A Multi-Level Integrity Evaluation Framework for Quantum Circuits under Controlled Anomaly Injection

This paper proposes a multi-level integrity evaluation framework for quantum circuits that combines Structural, Operational, and Interaction Graph metrics to overcome the limitations of single-aspect validation, demonstrating through controlled anomaly injection that a composite approach is essential for reliably detecting deviations that structural analysis alone misses.

The Gist

Imagine you are sending a very delicate, complex origami bird to a friend. In the world of quantum computing, this "bird" is a quantum circuit—a set of instructions that tells a quantum computer how to solve a problem.

The problem is that before the bird reaches your friend, it might get folded, unfolded, or even secretly altered by the mail carrier (the software compiler) or a sneaky thief (an adversary). The authors of this paper are worried: How do we know the bird we receive is the exact same one we sent, and that it will still fly the way we intended?

Here is a simple breakdown of their solution, using everyday analogies.

The Problem: One Look Isn't Enough

Traditionally, people checked these "birds" in only two ways:

1. The "Count the Folds" Check (Structural): They looked at the paper to see if the number of folds and the general shape looked right.
2. The "Let It Fly" Check (Behavioral): They actually launched the bird to see if it flew correctly.

The paper argues that neither method is enough on its own.

• The Trap: You can have a bird that looks exactly the same as the original (same number of folds, same shape) but has been secretly re-folded so that it crashes instead of flying. The "Count the Folds" check would say, "Looks good!" while the bird fails.
• The Cost: The "Let It Fly" check is perfect for catching errors, but it's expensive and slow because you have to actually launch the bird every time.

The Solution: A Three-Layer Security System

The authors propose a new framework that uses three different lenses to check the integrity of the circuit. They call this a "Multi-Level Integrity Evaluation Framework."

Think of it like a security team inspecting a package:

1. The Structural Integrity Score (SIS) – "The Blueprint Check"

• What it does: This looks at the global shape of the circuit. It counts the gates (folds), measures the depth (how tall the stack is), and checks the connections.
• The Analogy: It's like checking if the package has the right number of boxes and if the tape looks normal.
• The Weakness: It's fast and easy, but it has a "blind spot." If someone swaps two identical-looking folds or rearranges the order of folds without changing the total count, this check misses it completely.

2. The Interaction Graph Score (IGS) – "The Relationship Map"

• What it does: This looks at how the different parts of the circuit talk to each other. It maps out the dependencies (who needs to act before whom) and the specific types of operations.
• The Analogy: Imagine a map showing who is holding hands with whom in a dance line. If two dancers swap places but the line looks the same length, the "Blueprint Check" (SIS) might miss it. But the "Relationship Map" (IGS) sees that Person A is now holding hands with Person B instead of Person C.
• The Benefit: It catches those sneaky rearrangements that the Blueprint Check misses, but it doesn't require actually launching the bird. It's a "pre-flight" check that is smarter than just counting folds.

3. The Operational Integrity Score (OIS) – "The Flight Test"

• What it does: This actually runs the circuit (or simulates it) and compares the results to the original. It uses a mathematical tool called Jensen-Shannon distance to measure how different the output "cloud" is from the expected one.
• The Analogy: This is the actual flight test. Does the bird fly? Does it land where it should?
• The Benefit: It is the ultimate truth-teller. If the bird flies wrong, this check catches it 100% of the time.
• The Downside: It is slow and expensive, especially for big birds (large circuits).

The Big Discovery: The "Blind Spot"

The researchers tested these three methods by injecting "anomalies" (deliberate mistakes) into 133 different quantum circuits. They found a shocking truth:

• The Structural Blind Spot: In many cases, the "Blueprint Check" (SIS) said the circuit was 95% perfect. It looked structurally identical to the original.
• The Reality: However, the "Flight Test" (OIS) revealed that 93.85% of those "perfect-looking" circuits were actually broken or behaving differently.
• The Middle Ground: The "Relationship Map" (IGS) caught 72.58% of these hidden errors without needing to run the expensive flight test.

The Takeaway

You cannot trust just one way of checking a quantum circuit.

• If you only check the structure, you might miss hidden sabotage.
• If you only check the behavior, it costs too much time and money.

The Best Strategy: Use a layered approach.

1. Use the Blueprint Check (SIS) for a quick, cheap first look.
2. If it passes, use the Relationship Map (IGS) to catch sneaky rearrangements.
3. Only for the most critical checks, use the Flight Test (OIS) to confirm the final result.

This paper proves that to ensure a quantum circuit is safe and correct, you need to look at it from three different angles simultaneously, because a circuit can look perfect on paper but fail in reality.

Technical Summary

1. Problem Statement

In the Noisy Intermediate-Scale Quantum (NISQ) era, ensuring the integrity of quantum circuits is critical due to complex software toolchains, compilation transformations, hardware constraints, and potential adversarial modifications. Existing validation approaches suffer from a fundamental limitation: they rely on a single perspective, either structural (analyzing gate counts, depth, topology) or behavioral (analyzing output distributions via simulation/execution).

The core problem identified is the "structural-behavioral gap." Structural similarity does not guarantee behavioral equivalence. Transformations such as gate reordering, substitution, or the insertion of "Trojan" operations on idle qubits can preserve global structural descriptors (making the circuit look identical structurally) while significantly altering the computational behavior. Relying solely on one metric leads to incomplete assessments and "blind spots" where integrity violations go undetected.

2. Methodology

The authors propose a three-layer metric framework to evaluate circuit integrity across structural, interaction-level, and behavioral dimensions. The framework compares a test circuit ($C$) against a reference circuit ($C_{ref}$) using three distinct scores:

A. Structural Integrity Score (SIS)

• Type: Pre-execution (Static).
• Mechanism: Measures global structural deviation using normalized differences in four components: gate count, circuit depth, two-qubit gate usage, and interaction topology (DAG).
• Formula: $SIS = 1 - \Delta_{struct}$, where $\Delta_{struct}$ is a weighted sum of relative differences.
• Limitation: Efficient but insensitive to structure-preserving semantic changes.

B. Operational Integrity Score (OIS)

• Type: Execution-based (Dynamic).
• Mechanism: Measures behavioral divergence by comparing output probability distributions of the reference and test circuits.
• Metric: Uses Jensen-Shannon Distance (JSD) to quantify the difference between distributions $p$ and $q$.
• Formula: $OIS = 1 - JSD(p, q)$.
• Limitation: Highly accurate for functional correctness but computationally expensive (exponential scaling with qubit count) and requires simulation or hardware execution.

C. Interaction Graph Semantic-Logical Score (IGS)

• Type: Pre-execution (Static/Intermediate).
• Mechanism: Represents the circuit as a labeled Directed Acyclic Graph (DAG) to model dependencies, ordering, and gate-level semantics without execution.
• Components: Evaluates edge differences (topology), node semantics (gate types/parameters via unitary fingerprints), execution ordering, multi-qubit interactions, and qubit usage patterns (to detect idle-qubit anomalies).
• Role: Acts as a bridge between structural and behavioral analysis, capturing interaction-level inconsistencies that global structure misses.

Experimental Setup

• Dataset: 133 circuits from the QASMBench suite (filtered to $\le$ 40 qubits, $\le$ 2000 gates).
• Anomaly Injection: Controlled perturbations were introduced at three severity levels (0.1, 0.3, 0.6). Types included gate deletion/insertion, gate substitution, reordering, qubit swaps, and "Trojan" operations (hidden activity on idle qubits).
• Comparison: The three metrics were evaluated independently on the same dataset to isolate their specific sensitivities.

3. Key Contributions

1. Empirical Demonstration of the Structural-Behavioral Gap: The study provides concrete evidence that structural similarity (high SIS) does not ensure behavioral equivalence, particularly under transformations like gate reordering or substitution.
2. Multi-Layer Integrity Framework: Introduction of a unified framework combining SIS, OIS, and IGS to provide complementary insights rather than relying on a single metric.
3. Identification of "Structural Blind Spots": The authors define and analyze scenarios where $SIS \ge 0.95$ (structurally indistinguishable) but anomalies exist.
4. Correlation Analysis: The paper investigates the relationship between interaction-level similarity (IGS) and behavioral similarity (OIS), finding they are not strongly correlated.

4. Key Results

• Structural Blind Spots: In cases where the Structural Integrity Score (SIS) remained high ($\ge 0.95$), indicating no structural change:
  • OIS detected anomalies in 93.85% of instances.
  • IGS detected anomalies in 72.58% of instances.
  • This confirms that structural analysis alone is insufficient for reliable validation.
• Metric Sensitivity:
  • SIS: Highly sensitive to gate insertion/deletion but fails to detect gate reordering or substitution.
  • OIS: Consistently detects all anomaly types but incurs high computational cost and variance, especially as qubit count increases.
  • IGS: Successfully detects interaction-level deviations (e.g., reordering, Trojans) with low computational overhead, acting as an efficient pre-execution filter.
• Correlation Weakness: The correlation between IGS and OIS is weak (Pearson $r \approx 0.28$) and decreases as anomaly severity increases. This proves that interaction-level similarity does not guarantee behavioral equivalence; both layers are necessary.
• Efficiency: IGS maintains stable, low runtime across qubit counts, whereas OIS runtime increases exponentially and becomes unstable beyond 10–14 qubits.

5. Significance and Implications

• Security: The framework addresses critical security concerns in cloud-based quantum computing. Adversaries can introduce "Trojan" circuits or malicious modifications that preserve structural metrics but alter execution behavior. A multi-layer approach is essential to detect these subtle threats.
• Validation Workflow Optimization: The results suggest a staged validation pipeline:
  1. SIS for rapid, coarse structural screening.
  2. IGS for efficient, pre-execution analysis of interaction-level and semantic inconsistencies.
  3. OIS for selective, high-confidence behavioral verification of critical circuits.
• Future Directions: The authors propose combining these metrics into a unified "weighted integrity index" to automate circuit monitoring and plan to extend the framework to handle noise models and larger-scale circuits.

In conclusion, the paper argues that no single metric is sufficient for quantum circuit integrity. A comprehensive evaluation requires a multi-dimensional approach that simultaneously analyzes structure, interaction dependencies, and behavioral outcomes to ensure correctness in complex NISQ workflows.