⚛️ quantum physics

Real-time measurement error mitigation for one-way quantum computation

This paper proposes and validates a real-time quantum error mitigation scheme for one-way quantum computation that utilizes an entangled ancillary register and a voting protocol to detect and correct single-qubit measurement errors during processing, significantly reducing errors with minimal hardware overhead on both simulations and IBM quantum devices.

Original authors: Tobias Hartung, Stephan Schuster, Joachim von Zanthier, Karl Jansen

Published 2026-09-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Tobias Hartung, Stephan Schuster, Joachim von Zanthier, Karl Jansen

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

In the current era of quantum computing, scientists are working with machines that are powerful but imperfect. These devices, often called noisy intermediate-scale quantum processors, can perform calculations that classical computers cannot, yet they are plagued by errors. One of the most persistent sources of these errors is the act of measurement itself. In a standard quantum computer, information is processed through a series of steps, and at the end, the machine is asked to read out the result. However, in a specific and promising approach known as one-way quantum computing, the calculation happens entirely through a sequence of measurements. The computer starts with a large, entangled web of particles, and as researchers measure them one by one, the computation unfolds. The outcome of each measurement dictates what happens next. If a measurement is read incorrectly, the entire chain of logic can collapse, leading to a wrong answer. Because the process moves forward in real-time, there is no opportunity to stop, re-run the calculation, and average the results later, which is how errors are usually fixed in other types of quantum computing.

A team of researchers has developed a new method to fix these measurement mistakes as they happen, without stopping the computation. Instead of trying to correct the error after the fact, their approach uses extra helper particles, known as ancillary qubits, to verify the state of the particle being measured. Imagine a group of people trying to decide on a single answer; if one person is unsure or makes a mistake, the group can look to the others to find the truth. In this quantum system, the researchers entangle the target particle with a small register of these helper particles. When the measurement occurs, the system reads the target particle and all the helpers simultaneously. By comparing the results, a voting protocol determines the correct state. If the target particle's reading disagrees with the majority of the helpers, the system knows an error occurred and can apply the necessary correction immediately, allowing the computation to continue on the right path.

The researchers distinguished between two types of errors that can happen during this process. The first is a projection error, where the act of measuring physically disturbs the particle, flipping its state before the reading is even taken. The second is a readout error, where the particle remains in the correct state, but the machine's sensors misreport the result. In many other fields, these two are often treated as the same problem, but in one-way quantum computing, they behave differently and require different handling. The team showed that for readout errors, simply repeating the measurement a few times and taking a vote is enough to find the truth. However, for projection errors, repeating the measurement is impossible because the first measurement has already changed the particle. To solve this, they entangled the target with a group of helper particles before the measurement took place. This way, even though the target is measured only once, the helpers provide a backup record of what the state was supposed to be, allowing the voting system to work effectively.

To test their idea, the team first ran detailed computer simulations. They modeled the behavior of these quantum systems with varying numbers of helper particles and different rates of error. The simulations confirmed that as they added more helper particles, the chance of misidentifying the state dropped dramatically. For instance, with a small number of helpers, they could reduce the likelihood of a mistake to a very low level, even when the underlying error rate was relatively high. They then took the next step and moved from simulation to reality, running their protocol on a real quantum computer located in Brussels. They built a circuit that performed the basic step of a one-way computation, entangling a target particle with two and then four helper particles. When they measured the results, they found that the method worked exactly as predicted. The relative error in their results was nearly cut in half each time they added more helper particles to the voting group.

The study also examined a potential pitfall: the errors that might occur while creating the entanglement between the target and the helpers. If the process of linking these particles is flawed, it could introduce new mistakes that cancel out the benefits of the voting system. The researchers found that the design of the entanglement process matters greatly. If the helpers are linked in a simple, straight line, errors can pile up quickly as the group gets larger. However, by using a more efficient, tree-like structure to link the particles, they could keep the error accumulation low. Their analysis showed that even with imperfect hardware, this optimized approach allows the voting system to improve accuracy significantly, provided the number of helper particles is chosen carefully.

Ultimately, this work demonstrates that it is possible to verify and correct measurement errors in real-time within a one-way quantum computation. The method does not require the massive overhead of full-scale error correction codes, which would demand thousands of extra particles for a single logical calculation. Instead, it uses a small, constant number of helper particles that can be reused after each measurement step. The researchers showed that with just a handful of these extra particles, the system can reliably identify the correct state and apply the right fix, keeping the computation on track. This achievement suggests a practical path forward for making one-way quantum computers more robust and reliable, turning a fragile process into one that can withstand the noise of real-world hardware.

Technical Summary: Real-time Measurement Error Mitigation for One-Way Quantum Computation

1. Problem Statement

The paper addresses the critical challenge of measurement errors in One-Way Quantum Computation (OWQC), also known as Measurement-Based Quantum Computation (MBQC). Unlike gate-based models where errors can often be mitigated via post-processing after multiple circuit runs, OWQC relies on a sequence of measurements to drive feedforward operations. In this paradigm, the outcome of a measurement on an "upstream" qubit determines the corrective operation applied to a "downstream" qubit.

The authors identify two fundamental obstacles to applying standard error mitigation techniques to OWQC:

Irreversibility of Compute Steps: OWQC does not end with a measurement; the computation continues based on the outcome. Therefore, repeating the circuit to gather statistics for post-processing is impossible for individual compute steps.
Sensitivity to Misidentification: A single misidentification of a measurement outcome leads to the application of an incorrect corrective operation (e.g., applying a Pauli $X$ or $Z$ gate when it is not needed, or vice versa). Theoretical analysis shows that for a system with $Q$ qubits, a single misidentification can result in a state orthogonal to the intended state, causing a near-total loss of fidelity ( $E[\text{fidelity}] \approx 0$ for large $Q$ ).

Furthermore, the paper distinguishes between two types of measurement errors often conflated in literature:

Readout Errors: The qubit is correctly projected into a state, but the classical readout apparatus records the wrong value.
Projection Errors: The measurement process itself (due to backaction or energy transfer) causes the qubit to flip into the wrong state before the readout occurs.

Standard post-processing methods fail because they cannot correct the state of the downstream qubit in real-time, which is the primary requirement for OWQC to proceed correctly.

2. Methodology

The authors propose a real-time error mitigation scheme utilizing an ancillary verification register and a majority voting protocol. The method is designed to be compatible with the compute steps of OWQC without requiring the computation to halt or be repeated.

2.1 Distinguishing Error Types

The model separates errors into:

Readout Errors ( $r_{\neg b, b}$ ): Occur after projection. These can be mitigated by repeated readouts of the same projected state.
Projection Errors ( $p_{\neg b, b}$ ): Occur during the projection. These change the underlying state, making repeated readouts of the same qubit ineffective.

2.2 Mitigation of Readout Errors

For scenarios where readout can be separated from projection (e.g., via non-demolition measurements), the authors propose performing $N$ successive readouts of the projected qubit. A majority voting protocol determines the final outcome. The probability of misidentification ( $\epsilon$ ) decreases rapidly as $N$ increases, governed by the regularized incomplete beta function:
$\epsilon = I_{r_{\neg b, b}}(N - \lfloor N/2 \rfloor, 1 + \lfloor N/2 \rfloor)$
An analytical approximation is derived to estimate the required number of readouts $N$ for a target error rate.

2.3 Mitigation of Projection and Combined Errors

Since projection errors alter the qubit state, the authors propose entangling the target qubit ( $T$ ) with a verification register ( $V$ ) of $k$ ancillary qubits before the measurement.

State Preparation: The target qubit and the verification register are initialized in a specific entangled state (effectively a GHZ-like state) where the state of the register mirrors the state of the target.
Measurement: The target qubit $T$ and all qubits in register $V$ are measured.
Voting: A majority vote is taken over the $N = k + 1$ measurement outcomes (target + ancillas).
Feedforward: The result of the vote determines the corrective operation for the downstream qubit.

Crucially, the verification qubits are reused after each measurement cycle, requiring only a constant number of ancillas regardless of the total number of compute steps, unlike full quantum error correction codes which scale linearly with operations.

2.4 Handling CNOT Gate Errors

The paper analyzes the impact of errors in the CNOT gates used to entangle the target with the verification register.

Linear Protocol: CNOTs are applied sequentially between the target and each ancilla. Errors accumulate linearly with the register size ( $N-1$ ).
Log-Depth Protocol: CNOTs are applied in a tree-like structure, limiting error accumulation to $\log_2 N$ .
The authors derive that for small CNOT error rates ( $\gamma$ ), the log-depth protocol offers a significant advantage, keeping the effective error rate low even for larger registers. However, if CNOT errors are too large, the voting protocol can degrade performance rather than improve it.

3. Key Contributions

Real-Time Mitigation Framework: A novel protocol that mitigates measurement errors during the execution of an OWQC, avoiding the need for post-processing or circuit repetition.
Error Model Distinction: A clear theoretical separation of readout and projection errors, demonstrating why standard post-processing fails for OWQC and how the proposed method addresses both (treating combined errors similarly to projection errors).
Analytical Derivations:
- An exact expression for the misidentification probability based on the number of readouts/ancillas and the error rate.
- An analytical estimate for the required register size ( $N$ ) to achieve a specific success probability.
- Analysis of error propagation in CNOT gates for both linear and log-depth entanglement protocols.
Resource Efficiency: The method requires only a constant number of verification qubits (reused after each step), making it more feasible for near-term OWQC than full error-correcting codes.

4. Results

The paper validates the method through both numerical simulations and hardware experiments on IBM's ibm_bruce quantum processor.

Simulations: Numerical simulations of the elementary OWQC compute step (applying $HR_z(\alpha)$ ) showed excellent agreement with theoretical predictions. The misidentification rate decreased rapidly as the verification register size increased from $N=3$ to $N=7$ , even with projection error rates up to 5%.
Hardware Experiments: Experiments on IBM hardware (where readout and projection errors are inseparable and treated as a combined error) confirmed the theoretical model.
- The relative error ( $\eta$ ) of the outcome distribution was observed to decrease significantly with larger verification registers.
- Specifically, the relative error was nearly halved for each increase in the verification register size.
- The method successfully shifted the erroneous outcome distribution back toward the ideal uniform distribution ( $P(0) \approx P(1) \approx 0.5$ ).

5. Significance and Claims

The authors claim that this work provides a practical, real-time solution for measurement errors in one-way quantum computation, a critical bottleneck for scaling MBQC on NISQ devices.

Feasibility: By reusing verification qubits, the method avoids the prohibitive overhead of traditional quantum error correction, making it suitable for near-term devices.
Applicability: The protocol is applicable to any OWQC step and can be extended to dynamic circuits that utilize mid-circuit measurements and feedforward.
Robustness: The method remains effective even when projection and readout errors are inseparable, provided the combined error rate is below a critical threshold determined by the CNOT gate fidelity.

The paper concludes modestly, noting that while the proof-of-principle results are promising, future work is needed to analyze the impact of correlated measurement errors (which violate the independence assumption of the binomial model) and to extend the protocol to more complex multi-qubit logical gates and algorithms. The authors emphasize that their method is a step toward harnessing the full potential of noisy intermediate-scale quantum devices for measurement-based architectures.