⚛️ quantum physics

MERA: A Mid-Circuit-Measurement Error-Aware Compilation Framework for Quantum Circuits

MERA is a novel quantum compilation framework that integrates per-qubit mid-circuit measurement (MCM) error modeling and context-aware dynamic decoupling into layout, routing, and scheduling stages to significantly improve circuit fidelity without additional SWAP overhead, outperforming existing compilers like Qiskit and QR-Map in benchmarks with frequent MCM operations.

Original authors: Ming Zhong, Zhemin Zhang, Xiangyu Ren, Chenghong Zhu, Siyuan Niu, Zhiding Liang

Published 2026-10-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ming Zhong, Zhemin Zhang, Xiangyu Ren, Chenghong Zhu, Siyuan Niu, Zhiding Liang

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 ordinary machines thousands of years, but they currently face a significant hurdle: they are incredibly fragile. The tiny particles that carry information, known as qubits, are easily disturbed by their environment, causing them to lose their data before a calculation finishes. To make these machines useful, scientists have developed a technique called mid-circuit measurement. Instead of waiting until the very end of a calculation to read the result, this method allows the computer to check the state of a qubit in the middle of the process. If the measurement shows the qubit is in a certain state, the computer can reset it and use it again for a new part of the calculation. This is like having a limited number of workers on a construction site; instead of waiting for all of them to finish before starting a new task, you check their work, send them back to the starting line, and have them build something else immediately. This approach saves space and time, but it introduces a new problem: the act of measuring and resetting is not perfect. It can introduce errors, and these errors are not the same for every worker.

Researchers at The Chinese University of Hong Kong and other institutions have discovered that these errors vary wildly from one physical qubit to another within the same machine. Some qubits are nearly perfect, while others are prone to making mistakes up to forty-two percent of the time. Existing software used to program these computers, such as the widely used Qiskit compiler, treats all qubits as if they were identical. It assigns tasks to qubits without checking which ones are reliable and which ones are prone to failure. This is like assigning a delicate, high-precision task to a worker who is known to be clumsy, simply because that worker was available. The result is that the final calculation often fails, even if the logic of the program is correct. To fix this, the team developed a new framework called MERA, which acts as a smart traffic controller for quantum circuits.

MERA works by first taking a detailed inventory of the machine's health. The researchers ran a simple test on real quantum processors to measure how often each individual qubit failed when it was measured and reset. They found that this pattern of errors is surprisingly stable; once they mapped out which qubits were reliable and which were not, that map remained accurate for at least twenty-four hours. This stability meant they did not need to constantly re-check the machine, allowing them to build a reliable plan for running calculations. With this map in hand, MERA rewrites the instructions for the quantum computer. When it needs to decide which physical qubit should perform a specific task, it looks at the error map and deliberately avoids the unreliable ones. If a calculation requires a qubit to be measured and reset many times, MERA ensures that this qubit is placed on a physical part of the machine that rarely makes mistakes.

The system also manages the movement of information between qubits. In many quantum machines, qubits can only talk to their immediate neighbors. If two qubits that need to interact are far apart, the computer must swap their positions, a process that takes time and introduces more opportunities for errors. MERA is designed to find paths that not only shorten the distance between qubits but also keep the most error-prone operations away from the most error-prone physical locations. Furthermore, the system adds a layer of protection during the moments when a qubit is waiting. While a qubit is idle, it can lose its information due to natural decay. MERA inserts specific pulses of energy during these quiet moments to keep the qubit stable, but it does so carefully, ensuring these pulses do not interfere with the measurements happening on nearby qubits.

When the researchers tested this new framework against standard software, the results were significant. On a set of twenty-nine different test circuits, MERA improved the accuracy of the calculations by an average of nearly twenty-five percent compared to the standard software, and in some cases, the improvement was as high as eighty percent. These gains were achieved without adding extra steps that would slow the computer down. The team also tested MERA on circuits generated by another advanced tool designed to reuse qubits. Even when starting with these already optimized circuits, MERA was able to boost their accuracy by nearly thirty percent on average. When they ran these tests on actual quantum hardware from IBM, the improvements held true, though the gains were smaller on a newer, more reliable machine. This makes sense, as the newer machine already had fewer errors to begin with, leaving less room for improvement.

The study highlights that the future of quantum computing depends not just on building better hardware, but on writing smarter software that understands the unique weaknesses of each machine. By treating every qubit as a unique individual with its own history of reliability, MERA demonstrates that we can extract much more value from the machines we have today. The researchers found that their approach works best for circuits that rely heavily on measuring and resetting qubits, such as those used in advanced error correction or specific machine learning tasks. While the system does not fix every possible error, and it cannot prevent the physical limits of the hardware itself, it provides a crucial layer of intelligence that turns a collection of imperfect parts into a more reliable whole. This work suggests that as quantum computers grow larger and more complex, the ability to adapt to the specific quirks of the hardware will be just as important as the hardware itself.

Technical Summary: MERA – A Mid-Circuit-Measurement Error-Aware Compilation Framework

1. Problem Statement

Mid-circuit measurement (MCM) is a critical capability for modern quantum processors, enabling qubit reuse, dynamic control, and quantum error correction (e.g., in Repeat-Until-Success and fault-tolerant schemes). However, MCM operations introduce significant, non-negligible errors, including measurement-induced crosstalk, decoherence of idling qubits, readout errors, and reset infidelity.

A critical observation motivating this work is the spatial heterogeneity of MCM errors. Profiling on IBM Eagle (127 qubits) and Heron (156 qubits) processors reveals that MCM error rates vary drastically across physical qubits within the same device (ranging from <0.1% to >42% on Eagle). Furthermore, these error distributions exhibit strong temporal stability, remaining consistent for over 24 hours.

Despite this variability, existing mainstream compilers (e.g., Qiskit-compiler) and state-of-the-art qubit-reuse compilers (e.g., QR-Map, CaQR) ignore MCM error variations. They often map logical qubits with high MCM intensity to physical qubits with high error rates, leading to substantial fidelity loss in dynamic circuits.

2. Methodology: The MERA Framework

The authors propose MERA, a compilation framework that integrates MCM error modeling into the layout, routing, and scheduling stages. The workflow consists of three primary phases:

A. MCM Error Profiling

Before compilation, MERA employs a lightweight, device-agnostic profiling method.

Procedure: Each qubit is initialized to $|1\rangle$ via an X gate, subjected to a mid-circuit measurement with reset, and finally measured. This is repeated in parallel (1,024 shots) to estimate the success probability $P(|0\rangle)$ post-reset.
Stability: Temporal analysis confirms that the per-qubit error distribution remains stable for at least 24 hours, allowing a single profiling run to guide compilation without frequent re-calibration.

B. Layout Stage (MCM-Aware Mapping)

MERA constructs a logical interaction graph and assigns logical qubits to physical qubits using a cost function that balances connectivity and error rates.

MCM Cost Modeling: The cost for mapping a logical qubit $q_i$ to a physical qubit $p_j$ is defined as $MCM\_Cost = MCM\_Int(q_i) \times Err_{MCM}(p_j)$ , where $MCM\_Int$ is the intensity of MCM operations on the logical qubit.
Error Normalization: To prevent the compiler from over-optimizing for negligible error differences in low-error regions (which might force suboptimal connectivity), MERA normalizes MCM errors using a threshold $\tau_{MCM}$ . Errors below this threshold are capped, ensuring a balanced weighting between MCM errors and other hardware constraints (distance, 2Q/1Q gate errors).
Seed Selection & Expansion: Physical qubits are ranked by a composite score (incorporating normalized MCM error, gate errors, and connectivity). The top-ranked qubits serve as seeds for a Breadth-First Search (BFS) expansion to generate layout candidates. Variants are generated by reordering logical qubits to prioritize placing high-MCM-intensity qubits on low-error physical qubits.

C. Routing Stage (Two-Level Hierarchical Ranking)

To insert SWAPs for connectivity, MERA uses a two-level ranking strategy:

Level 1 (Distance): Prioritizes SWAPs that reduce the interaction distance for current and near-future two-qubit gates.
Level 2 (MCM Error): For candidates with similar distance scores (within a threshold $\Delta_{swap}$ ), MERA selects the SWAP that minimizes the product of the physical qubit's MCM error and the logical qubit's remaining MCM intensity. This prevents high-intensity MCM logical qubits from being moved to high-error physical qubits.

D. Scheduling Stage (ALAP + CADD)

ALAP Scheduling: Gates are scheduled as-late-as-possible to compact the circuit and expose idle intervals.
Context-Aware Dynamic Decoupling (CADD): Decoupling pulses are inserted only within the idle windows exposed by ALAP. Crucially, CADD is "context-aware": it avoids inserting pulses during MCM windows to prevent interference and coordinates pulse timing across coupled qubits to mitigate $ZZ$ crosstalk, which is prominent during MCM operations.

3. Key Contributions

MCM Error Characterization: The paper provides empirical evidence of significant spatial heterogeneity and temporal stability (24+ hours) in MCM errors on superconducting processors, motivating the need for error-aware compilation.
MERA Framework: A novel compiler integrating MCM error modeling into layout (via cost-guided seed selection and normalization), routing (via two-level hierarchical ranking), and scheduling (via CADD).
Comprehensive Evaluation: The framework is evaluated on 29 benchmarks, including 8 RUS circuits, 19 qubit-reuse circuits, and 2 QASM-Bench circuits.

4. Experimental Results

The evaluation compares MERA against Qiskit-compiler (optimization level 3) and QR-Map (SOTA qubit-reuse compiler) on IBM Eagle and Heron processors (simulated and real).

vs. Qiskit-compiler: MERA achieves average fidelity gains of 24.94% – 80.48% across different benchmark groups without introducing additional SWAP overhead. For RUS benchmarks, MERA reduces the number of "Attempts" (MCM operations required for success) significantly compared to Qiskit.
vs. QR-Map: When used as a post-processor for circuits generated by QR-Map, MERA improves fidelity by an average of 29.26% (up to 122.58% for specific benchmarks like SYM_9).
Real-Device Performance: On the IBM Eagle processor, MERA improves fidelity by an average of 40.55% over QR-Map. On the newer IBM Heron processor (which has lower baseline MCM errors), the gain is smaller (7.69%), confirming that MERA's benefits are most pronounced on devices with higher MCM error heterogeneity.
Overhead: Compilation runtime is modest (0.12–0.77 seconds), and the framework does not increase the critical path length or SWAP count compared to baselines.

5. Significance and Claims

The paper claims that MERA addresses a critical gap in current quantum compilation: the lack of awareness regarding MCM error heterogeneity. By explicitly modeling and mitigating these errors during the compilation process, MERA significantly enhances the reliability of dynamic quantum circuits.

The authors emphasize that MERA is orthogonal to existing compilation strategies (including those for distributed computing or error correction) and can serve as an add-on module to improve fidelity in any workflow involving MCM operations. The work demonstrates that leveraging the temporal stability of device characteristics allows for effective, low-overhead compilation strategies that adapt to the specific noise profile of the hardware.

Note: The paper acknowledges limitations, such as the current model focusing on $|1\rangle \to |0\rangle$ reset transitions and not explicitly modeling leakage to higher energy levels (which requires hardware solutions) or advanced readout error mitigation protocols.