⚛️ quantum physics

Mitigating Errors on Superconducting Quantum Processors through Fuzzy Clustering

This paper presents the first proof-of-principle validation of a Quantum Error Mitigation technique using Fuzzy C-Means clustering to identify measurement error patterns, demonstrating improved accuracy in expectation values for single- and two-qubit circuits on a real 5-qubit superconducting processor without requiring state-of-the-art hardware fidelities.

Original authors: Halima G. Ahmad, Roberto Schiattarella, Pasquale Mastrovito, Angela Chiatto, Anna Levochkina, Martina Esposito, Domenico Montemurro, Giovanni P. Pepe, Alessandro Bruno, Francesco Tafuri, Autilia Vitie

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Halima G. Ahmad, Roberto Schiattarella, Pasquale Mastrovito, Angela Chiatto, Anna Levochkina, Martina Esposito, Domenico Montemurro, Giovanni P. Pepe, Alessandro Bruno, Francesco Tafuri, Autilia Vitiello, Giovanni Acampora, Davide Massarotti

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

The Big Picture: Fixing a Noisy Quantum Computer

Imagine you have a very delicate, high-tech musical instrument (a quantum computer) that can play beautiful, complex songs (solve hard problems). However, this instrument is currently in a very noisy room. Every time you try to play a note, the wind blows, the floor vibrates, and the microphone picks up static. By the time the music reaches your ears, it sounds garbled and wrong.

This is the current state of Superconducting Quantum Processors. They are powerful, but they are "noisy." The errors happen because the machines are so sensitive that even the act of measuring them introduces mistakes.

The authors of this paper didn't try to build a quieter room (which is incredibly hard and expensive). Instead, they invented a new way to clean up the recording after the fact. They used a mathematical trick called Fuzzy Clustering to figure out exactly how the noise is messing up the music, and then corrected it.

The Problem: The "Messy" Measurement

In a perfect world, if you tell a quantum computer to prepare a specific state (like a light switch being "On"), it stays "On." But in the real world, the computer might accidentally flip the switch to "Off" just as you look at it.

The Analogy: Imagine you are taking a photo of a group of friends. Because the camera is shaky and the lighting is bad, sometimes the photo makes your friend look like they are wearing a hat when they aren't, or makes them look like they are smiling when they are frowning.
The Result: You get a "noisy" photo. You know what you tried to take, but the result is distorted.

The Solution: The "Fuzzy" Detective

The researchers used a technique called Fuzzy C-Means (FCM) Clustering.

The Analogy: Imagine you are a detective trying to figure out why your friends' photos keep looking weird. You take 100 photos of your friend in a "Smiling" pose and 100 photos in a "Frowning" pose.
- Some "Smiling" photos look like they are frowning (a mistake).
- Some "Frowning" photos look like they are smiling (a mistake).
- But most look correct.

Instead of saying, "This photo is definitely a mistake," the Fuzzy approach says, "This photo is 70% likely to be a smile and 30% likely to be a frown." It acknowledges that the error isn't black and white; it's a blur.

By analyzing thousands of these "blurry" photos (data points), the algorithm creates a Map of Errors (called a Mitigation Matrix). This map tells the computer: "Hey, whenever you see a result that looks like X, there's a 20% chance it was actually supposed to be Y."

Once they have this map, they can run the computer's raw, noisy results through a "cleaner" (a mathematical filter) to get the correct answer.

What They Actually Did

The team didn't just simulate this on a computer; they tested it on a real, physical quantum chip made by QuantWare.

The Hardware: They used a 5-qubit (5-bit) superconducting chip but focused on just 2 qubits (like testing a single piano key and the one next to it).
The Setup: They didn't use the most expensive, perfect equipment. Their chip had "average" performance—it wasn't the best in the world, and it had significant errors (readout errors were around 20-40% in some cases). This is important because it proves the technique works even when the hardware isn't perfect.
The Test: They ran simple quantum circuits (like flipping a switch or flipping two switches together).
- Without the fix: The results were often wrong.
- With the Fuzzy fix: They applied their "error map" to the results.

The Results: Cleaning Up the Signal

The paper reports that this method worked well, especially for the "messier" circuits:

Simple Circuits: For simple tasks, the results were already pretty good, and the fix gave a small boost (improving accuracy by about 3–10%).
Complex Circuits: For tasks involving two qubits working together (which are much noisier), the improvement was huge. In some cases, they improved the accuracy by 30% or more.
The "Magic" Number: They measured success using something called "Hellinger Fidelity" (a score of how close the result is to the truth).
- When the computer was doing terribly (score ~30%), the fix helped a little, but couldn't fix a total disaster.
- When the computer was doing okay (score ~60%), the fix turned it into a great result (score ~90%+).

The Bottom Line

The paper claims that Fuzzy Clustering is a powerful tool for cleaning up noisy quantum data.

It's Software, not Hardware: You don't need to build a better machine; you just need better math to process the data after the machine runs.
It Works on "Imperfect" Chips: It doesn't require a perfect, state-of-the-art quantum computer to work. It helps even the "rougher" machines perform better.
It's Fast: It happens on a regular computer after the quantum experiment is done, so it doesn't slow down the quantum machine itself.

In short, the researchers showed that even if your quantum computer is a bit "drunk" (noisy), you can use a smart mathematical filter to help it tell the truth.

Technical Summary: Mitigating Errors on Superconducting Quantum Processors through Fuzzy Clustering

Problem Statement
The practical utility of superconducting quantum hardware is currently constrained by the Noisy Intermediate Scale Quantum (NISQ) era limitations: a modest number of qubits and high levels of control and readout errors. These errors stem from intentional coupling with the external environment required for manipulation and readout, as well as state leakage and cross-coupling. While Quantum Error Correction (QEC) offers a long-term solution, it requires significant hardware overhead (thousands to hundreds of thousands of physical qubits) that is currently infeasible. Consequently, Quantum Error Mitigation (QEM) techniques are essential for improving the accuracy of expectation values in current devices. Existing QEM methods, such as Zero-Noise Extrapolation (ZNE) or Probabilistic Error Cancellation (PEC), often require high sampling costs or complex parameter adjustments. Furthermore, previous demonstrations of Fuzzy C-Means (FCM) based QEM were limited to noisy quantum simulators and had not been validated on real NISQ hardware.

Methodology
The authors propose and experimentally validate a QEM technique based on Fuzzy C-Means (FCM) clustering to identify and correct measurement error patterns. The workflow involves three primary steps:

Dataset Creation: The 2-qubit register is initialized in all four computational basis states ( $|00\rangle, |01\rangle, |10\rangle, |11\rangle$ ). For each state, $t$ experiments are run to collect probability vectors representing the readout outcomes. This generates four datasets ( $D_i$ ), each containing instances of measurement probabilities.
Fuzzy Clustering: The FCM algorithm is applied to each dataset to cluster the probability vectors into different error patterns. Unlike hard clustering, FCM assigns a membership degree to each instance for every cluster. The optimal number of clusters is determined by maximizing the fuzzy partition coefficient ( $f_{pc}$ ).
Mitigation Matrix Construction: The algorithm selects the "most appropriate" probability vectors—those with the most uncertain membership degrees in the fuzzy partition matrix, representing a trade-off among error patterns. These vectors are used to construct a calibration matrix $M$ . The mitigation matrix $S$ is then computed as the inverse of $M$ ( $S = M^{-1}$ ). This matrix is applied classically to noisy count vectors ( $C_{noisy}$ ) to estimate the ideal count vectors ( $C_{ideal} = S \cdot C_{noisy}$ ).

Experimental Setup
The technique was validated on a real 5-qubit superconducting quantum processor (QuantWare Soprano) based on transmon qubits. The experiment focused on a 2-qubit subset consisting of qubits Q0 (low-frequency) and Q2 (central medium-frequency).

Hardware Characteristics: The device exhibited moderate coherence times (e.g., $T_1 \approx 24 \mu s$ for Q0, $T_1 \approx 8 \mu s$ for Q2) and readout fidelities ranging from 60% to 80%, without the use of quantum-limited amplification or sophisticated readout techniques.
Gate Performance: Single-qubit gate fidelities were approximately 99.8% (Q0) and 99.43% (Q2). The two-qubit CZ gate fidelity was approximately 89%, which is lower than state-of-the-art benchmarks, providing a challenging testbed for error mitigation.
Circuits: The validation involved 16 test circuits (4 initial states $\times$ 4 circuit types) comprising single-qubit gates (Hadamard, X, Y rotations) and two-qubit gates (CNOT constructed via CZ).

Key Results
The performance of the FCM-QEM technique was evaluated using the Hellinger fidelity ($HF$), measuring the similarity between the ideal and the experimental (mitigated and unmitigated) probability distributions.

Single-Qubit Circuits: The technique provided a modest improvement. For "Single-qubit circuit 1," the average $HF$ improved by approximately +3% (e.g., from 93% to 96%). For "Single-qubit circuit 2," improvements ranged from +10% to +15%.
Two-Qubit Circuits: Significant improvements were observed for circuits with lower initial fidelities.
- For "Two-qubit circuit 1" (CNOT + H), the improvement ranged from +5% to +33%, with a maximum improvement of +33% for the $|00\rangle$ initial state (raising fidelity from 54% to 87%).
- For "Two-qubit circuit 2" (CNOT alone), improvements ranged from +0% to +30%.
Performance Limits: The authors observed that when the unmitigated Hellinger fidelity was very low (below 50%), the mitigation technique offered minimal correction (5–9% improvement). However, for initial fidelities around 60%, the technique could improve readout by up to 30%. In cases where the unmitigated circuit already showed high fidelity (90%), the technique could push the result to ~99%.

Significance and Claims
The paper claims to provide the first proof-of-principle validation of the FCM-QEM technique on a real NISQ device based on superconducting transmon qubits. The significance of this work lies in demonstrating that:

Hardware Independence: The FCM-based QEM technique can improve the accuracy of expectation values for single- and two-qubit gate circuits without requiring state-of-the-art coherence, gate, or readout fidelities. It is effective even on hardware with "modest" performance metrics.
Experimental Convenience: The method relies entirely on classical post-processing and an initialization routine, avoiding the need for additional hardware resources or complex in-circuit corrections (unlike ZNE or t-REx).
Stability: The technique demonstrates repeatability across multiple runs, effectively accounting for readout randomness and shot noise.
Scalability Caveat: The authors acknowledge that, like other matrix-based QEM techniques, the computational cost to build and invert the mitigation matrix scales exponentially with the number of qubits, a challenge to be addressed in future work.

The authors conclude that FCM-QEM is a suitable candidate for readout error mitigation on NISQ devices, particularly those with non-optimized readout characteristics, and can be integrated into software interfaces between hardware setups and quantum processors.