🧬 biology

Average Quantum Relative Entropy and Transpilation Depth as Indicators of Noise Robustness in Quantum Binary Classification

This paper proposes and validates a practical pre-hardware assessment method that combines average quantum relative entropy and backend-specific transpilation depth to predict and explain the noise robustness of quantum binary classifiers, addressing the limitations of using ideal accuracy or circuit depth alone.

Original authors: Aakash Ravindra Shinde, Arianne Meijer - van de Griend, Jukka K. Nurminen

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Aakash Ravindra Shinde, Arianne Meijer - van de Griend, Jukka K. Nurminen

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

Imagine you have built a very clever robot chef. You trained this chef in a perfect, sterile kitchen with no distractions, no broken knives, and no power outages. In this perfect world, the chef can make a delicious meal 95% of the time.

Now, you want to send this chef to work in a real, chaotic restaurant kitchen. This real kitchen has flickering lights, slippery floors, and ovens that run a bit too hot. You might expect the chef's performance to drop because the kitchen is messy. But here is the puzzle: Why do some chefs drop to 60% success in the messy kitchen, while others (who looked just as good in the perfect kitchen) only drop to 85%?

This paper, written by researchers from the University of Helsinki, tries to solve that mystery for Quantum Machine Learning. They are studying "Quantum Classifiers"—algorithms that sort data into two groups (like sorting emails into "Spam" or "Not Spam").

Here is the breakdown of their discovery using simple analogies:

1. The Problem: The "Perfect vs. Messy" Gap

In the world of quantum computers, we often train our models on classical computers (simulators) where everything is perfect. But when we run them on real quantum hardware (which is currently "noisy" and error-prone), they often fail.

The researchers noticed that two quantum models could look identical on paper:

They had the same "logical" design.
They had the same number of steps (circuit depth).
They both got 95% accuracy in the perfect simulation.

Yet, when put on real hardware, one might crash to 60% accuracy, while the other stays strong at 85%. The old rule of thumb—"shorter circuits are better"—didn't fully explain this difference.

2. The Two New Indicators (The "Secret Sauce")

The authors propose that to predict how well a model will survive in the "messy kitchen," you need to look at two specific things before you even run it on the real machine.

Indicator A: The "Distance Between Groups" (Average Quantum Relative Entropy)

Imagine you are teaching a dog to distinguish between a Cat and a Dog.

Model 1 learns to recognize them by looking at tiny, blurry details. In the real world, a little bit of fog (noise) makes it impossible to tell them apart.
Model 2 learns to recognize them by looking at huge, obvious differences (ears vs. snout). Even if there is fog, the dog can still tell them apart.

In quantum terms, this "difference" is called Quantum Relative Entropy.

High Entropy: The two groups of data (Cats and Dogs) are very far apart in the quantum world. They are easy to tell apart.
Low Entropy: The groups are huddled close together. Noise can easily push a "Cat" into the "Dog" pile.

The Finding: Models that learn to keep the two groups far apart (High Entropy) are much more robust against noise.

Indicator B: The "Travel Distance" (Transpilation Depth)

Quantum computers are like foreign countries with their own languages and road rules. When you write a program (circuit), you have to translate it (transpile) for the specific machine you are using.

Sometimes, a simple instruction like "turn left" has to be translated into a complex series of "turn right, spin, then turn left" because the machine doesn't have a "left" button.
This translation process adds extra steps. The Transpilation Depth is the count of these actual steps the machine has to take.

The Finding: The more steps the machine has to take, the more likely it is to trip and fall (accumulate errors). A model that looks short on paper might become very long and messy after translation.

3. The Big Discovery: You Need Both

The researchers found that looking at just one of these factors isn't enough.

Scenario A: A model has a "long travel distance" (High Depth) but the groups are "very far apart" (High Entropy). It might still survive because the groups are so distinct that the noise can't confuse them easily.
Scenario B: A model has a "short travel distance" (Low Depth) but the groups are "huddled together" (Low Entropy). It will likely fail because even a tiny bit of noise pushes the groups into each other.

The Analogy:
Think of it like walking across a frozen lake.

Transpilation Depth is how far you have to walk.
Relative Entropy is how thick the ice is under your feet.
If you have to walk a long way (High Depth), you need very thick ice (High Entropy) to survive.
If the ice is thin (Low Entropy), even a short walk (Low Depth) is dangerous.

4. Why This Matters (The "Pre-Flight Check")

The most practical part of this paper is that you can calculate both of these numbers classically (on a normal computer) before you ever touch the expensive, noisy quantum hardware.

The researchers created a method to look at a trained model and say:

"This model looks great in simulation, but based on its 'distance between groups' and its 'translation steps,' it is likely to fail on the real machine."

This allows scientists to screen their models. They can throw away the ones that are likely to fail and only send the robust ones to the real quantum computer, saving time and money.

Summary

The paper argues that to predict if a quantum classifier will survive the noisy real world, you cannot just look at how accurate it is in a perfect simulation or how "short" its code looks. You must check:

How distinct are the categories? (Are they far apart or huddled together?)
How many translation steps does it take? (How many extra moves does the machine have to make?)

By combining these two numbers, you get a reliable "weather forecast" for how your quantum model will perform before you even launch it.

Technical Summary: Average Quantum Relative Entropy and Transpilation Depth as Indicators of Noise Robustness in Quantum Binary Classification

Problem Statement
Quantum Machine Learning (QML) models, specifically Variational Quantum Algorithms (VQAs) like Quantum Parameterized Binary Classification (QPBC), often achieve high accuracy in ideal, noiseless simulations but suffer significant performance degradation when executed on Noisy Intermediate-Scale Quantum (NISQ) hardware. Current explanations for this discrepancy rely heavily on circuit depth or the intuition that shallower circuits are more resilient. However, empirical evidence shows that models with similar logical structures and comparable transpilation depths can exhibit markedly different robustness to noise. The central problem addressed is the lack of a practical, classical pre-hardware indicator that can anticipate this degradation, allowing for the screening of trained models before costly hardware execution.

Methodology
The authors propose a theoretical and empirical framework combining two complementary factors to predict noisy-execution robustness:

Average Quantum Relative Entropy ( $D_{avg}$ ): A measure of the distinguishability between learned quantum states of different classes. Based on the property that quantum relative entropy is contractive under noisy channels, the authors hypothesize that models with higher initial class-state distinguishability will retain more accuracy under noise.
Backend-Specific Transpilation Depth ( $L_{tr}$ ): A practical indicator of cumulative noise exposure. Unlike logical circuit depth, transpilation depth accounts for hardware-specific constraints, including qubit routing, basis-gate decomposition, and connectivity, which directly influence the number of noisy operations.

Theoretical Framework
The paper derives a relationship linking accuracy degradation ( $\Delta Acc$ ) to the contraction of quantum relative entropy over a noisy channel of depth $L$ . Using the Strong Data Processing Inequality (SDPI), the authors model the reduction in distinguishability as a product of contraction coefficients ( $\eta_i$ ) across layers. They formulate an accuracy indicator that incorporates:

The initial average quantum relative entropy between classes.
The cumulative contraction factor determined by transpilation depth.
Practical calibration coefficients ( $c, c_n$ ) accounting for measurement thresholds and finite-shot effects.
A residual drift coefficient ( $\delta_u$ ) to capture backend-specific deviations (e.g., calibration drift, crosstalk).

Experimental Design
The study validates these indicators through a comprehensive experimental setup involving:

Scope: Fixed 8-qubit systems to ensure comparability and avoid barren plateaus.
Variability: Over 2,750 trained models across diverse architectures (PQC/VQC, QNN, Data Reupload), ansatz families (>20 types), encoding methods (Angle, Amplitude, IQP), and measurement strategies (probabilistic and expectation value).
Datasets: Five synthetic binary classification datasets with varying linear and non-linear properties.
Backends: Simulations on noise models from IBM (e.g., Fez, Marrakesh), IQM (Apollo, Aphrodite), and IonQ (Aria 1), with consistency checks performed on actual hardware (IBM Marrakesh, Fez, Torino; IQM Garnet, Emerald; VTT Q50).
Selection Criteria: Only models achieving >85% accuracy in ideal simulations were analyzed to focus on post-training degradation rather than training failure.

Key Results

Insufficiency of Single Metrics: The study demonstrates that neither ideal simulation accuracy nor transpilation depth alone can reliably predict noisy execution outcomes. Models with similar depths and ideal accuracies showed substantial variance in degradation.
Joint Predictive Power: The combination of average quantum relative entropy and transpilation depth provides a more consistent interpretation of robustness. Specifically:
- Higher average quantum relative entropy correlates with lower accuracy degradation.
- Higher transpilation depth correlates with higher degradation.
- The joint behavior of these two metrics explains the variance in noisy performance better than either metric in isolation.
Classical Pre-Assessment: The proposed indicators can be computed classically using the trained model parameters and the target backend's noise profile, enabling a pre-hardware screening process.

Significance and Claims
The paper claims to provide a practical methodology for assessing the reliability of trained QPBC models in realistic noisy environments without requiring immediate hardware execution. By shifting the focus from "circuit depth" to "class-state distinguishability" and "backend-specific compilation overhead," the authors offer a more nuanced understanding of noise robustness.

The authors explicitly state modesty regarding their claims:

They do not assert a quantum advantage over classical machine learning.
They do not propose new error mitigation or correction techniques.
The derived equations (e.g., Eq. 30) are presented as degradation indicators rather than exact accuracy predictors or strict mathematical bounds, acknowledging the presence of residual backend effects.
The study is constrained to binary classification and 8-qubit systems, focusing on the "train-classical, deploy-quantum" paradigm where hardware access is limited.

The primary contribution is the identification of average quantum relative entropy and transpilation depth as actionable, pre-execution metrics for filtering quantum classifiers likely to survive the transition from ideal simulation to noisy hardware.