⚛️ quantum physics

End-to-End Fidelity Analysis of Quantum Circuit Optimization: From Gate-Level Transformations to Pulse-Level Control

This paper presents an open-source framework that links a C++ circuit optimizer to a validated Lindblad fidelity model, demonstrating through extensive benchmarking and real hardware execution that two-qubit gate count is the primary predictor of process fidelity and that while the model accurately ranks circuit difficulty, it systematically overestimates absolute fidelity due to unmodeled error sources like crosstalk and leakage.

Original authors: Rylan Malarchick

Published 2026-06-23

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Rylan Malarchick

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

Imagine you are trying to send a delicate message across a stormy ocean. The message is written on a fragile piece of paper (the quantum circuit), and the ocean is full of waves and wind that want to tear it apart (noise and decoherence).

This paper is about building the best possible boat and navigation system to get that message to the other side without it getting ruined. The author, Rylan Malarchick, built a "simulator" to test different boat designs and then actually sailed a few of them on a real ship to see if the simulator was telling the truth.

Here is the breakdown of what they found, using simple analogies:

1. The Problem: The "Garbage Truck" vs. The "Sports Car"

When you write a quantum program, it often comes with a lot of unnecessary baggage. It's like packing a suitcase with heavy rocks you don't need.

The Simulator: The author built a computer program that acts like a "physics lab." It takes a quantum circuit, strips away the unnecessary parts, and then calculates exactly how much the "storm" (noise) will damage the message based on how long the trip takes and how many heavy turns the boat has to make.
The Real World Check: To make sure the simulator wasn't just guessing, they actually ran 8 specific trips on a real quantum computer (the IQM Garnet processor) and compared the results to what the simulator predicted.

2. The Big Discovery: "Canceling" is King

The author tested four different ways to clean up the circuit (optimization passes).

The Analogy: Imagine you are walking a path.
- Pass A: You walk forward, then immediately walk backward. (This is a "Gate Cancellation").
- Pass B: You swap the order of two things that don't affect each other.
- Pass C: You combine two small steps into one big step.
- Pass D: You remove steps that do nothing.
The Result: The study found that Pass A (Canceling) does almost all the heavy lifting. It removed 72% of the unnecessary steps and provided nearly all the improvement. The other three passes were like trying to polish a car that still has a flat tire; they helped a tiny bit, but they weren't the game-changer.
The Lesson: If you want to fix a quantum program, just look for steps that undo each other and delete them. That's the most important thing to do.

3. The Metric Trap: Counting "Total Steps" vs. "Heavy Steps"

Many people compare quantum computers by counting the total number of steps (gates) in a program. The author says this is misleading.

The Analogy: Imagine a delivery truck.
- Single-qubit gates are like delivering a letter. They are fast and light.
- Two-qubit gates are like delivering a grand piano. They are slow, heavy, and much more likely to break or get damaged.
The Finding: One popular software (Qiskit) claimed to cut the total number of steps by 47%. That sounds amazing! But when the author looked closer, they saw that Qiskit mostly removed the "letters" (light steps) and left almost all the "pianos" (heavy steps) alone.
The Reality: The author's tool didn't cut as many total steps, but it removed way more "pianos" (two-qubit gates). Since the "pianos" are what actually break the message, the author's tool produced a much better result for the real machine, even if the total step count looked lower on the other tool.

4. Time is the Enemy

The study found that the longer the boat stays in the storm, the more likely the message is to get wet.

The Finding: The duration of the trip (pulse duration) and the size of the circuit were the strongest predictors of failure.
The Analogy: If you have to cross a river, it doesn't matter if you take a shortcut that saves you 5 seconds if the bridge is shaky. But if you take a route that is 10 seconds longer, the water has 10 more seconds to splash you. The study showed that reducing the total time on the water is the single most effective way to keep the message safe.

5. The Order Doesn't Matter (Much)

The author wondered if the order in which they applied the cleaning steps mattered.

The Finding: It didn't. Whether you cleaned the "letters" first or the "pianos" first, the result was the same.
The Lesson: You don't need to be a genius to figure out the perfect order of operations. As long as you have the "Cancel" tool in your kit, you can use it whenever you want.

6. The "Optimism Gap"

When they compared the simulator's predictions to the real ship (the IQM hardware), the simulator was always too optimistic.

The Analogy: The simulator predicted the message would arrive 90% intact. In reality, it arrived only 40% intact.
The Reason: The simulator was very good at calculating the "waves" (standard noise), but it didn't account for "leaks" in the hull, "crosstalk" (waves hitting the wrong part of the boat), or "reading errors" (the receiver misreading the message).
The Value: Even though the simulator wasn't perfect, it was consistent. It correctly predicted which trips would be harder than others. It's like a weather forecast that is always 10 degrees too warm, but still correctly tells you that Tuesday will be hotter than Monday.

Summary

The paper tells us three main things for anyone building or using quantum computers:

Just Cancel: The most effective way to improve a quantum program is to find and delete steps that cancel each other out.
Count the Heavy Stuff: Don't just count how many steps a program has; count how many "heavy" (two-qubit) steps it has. That's what really matters.
Speed Matters: The faster you can get the program done, the less likely it is to fail.

The author has released all their tools and data for free, so anyone can use this "physics lab" to test their own quantum programs.

Technical Summary: End-to-End Fidelity Analysis of Quantum Circuit Optimization

Problem Statement

The fidelity of quantum computations on Near-Term Noisy Intermediate-Scale Quantum (NISQ) devices is constrained by gate errors, decoherence, and compilation overhead. While significant research has focused on gate-level optimization passes (e.g., peephole optimization, global rewriting), the end-to-end impact of these transformations on physical, pulse-level fidelity remains inadequately characterized. Current compiler comparisons often rely on misleading metrics, such as total gate counts, which fail to distinguish between single-qubit and two-qubit operations. Since two-qubit gates dominate the error budget on superconducting processors, reductions in total gate count do not necessarily translate to improved hardware performance. Furthermore, optimization strategies are frequently evaluated in isolation, ignoring the interplay between gate-level decisions and physical execution fidelity.

Methodology

The authors present qco-integration, an end-to-end framework connecting a high-performance C++ circuit optimizer to a per-gate Lindblad fidelity model. The system operates through a five-stage pipeline:

Parse and Validate: Input circuits in OpenQASM 3.0 are parsed and validated.
Optimize: A C++ optimizer applies a configurable sequence of four passes: Gate Cancellation, Commutation Analysis, Rotation Merging, and Identity Elimination.
Route: The SABRE algorithm maps logical qubits to physical hardware topologies (specifically the IQM Garnet heavy-hex layout), inserting SWAP gates as necessary.
Pulse Compile: Native gates (PRX, CZ) are compiled into microwave pulse sequences with calibrated durations (20 ns for single-qubit, 40 ns for two-qubit).
Simulate: A per-gate Lindblad master equation model computes noisy channels. Unlike full-circuit simulations, this approach solves the equation on one- or two-qubit subspaces for each gate, composing the results. The model includes $T_1/T_2$ relaxation, pure dephasing, and a calibrated depolarizing channel.

The framework was evaluated across 371 benchmark circuits (GHZ, QFT, QAOA, and Random) totaling 4,452 experiment runs. The study included:

Ablation Studies: Individual pass evaluation, leave-one-out analysis, and pass ordering sensitivity tests.
Compiler Comparison: Benchmarking the custom optimizer (QCO) against Qiskit transpilation levels (L0–L3) targeting both virtual and IQM-native basis gates.
Hardware Validation: Execution of eight representative circuits on the IQM Resonance Garnet 20-qubit processor to compare simulated predictions against measured fidelity.

Key Contributions

Modular Integration Architecture: A decoupled system connecting C++ optimization with Python-based pulse-level analysis via OpenQASM and JSON.
Per-Gate Lindblad Fidelity Model: A scalable model that cross-validates against qiskit-dynamics and scales linearly with gate count, enabling analysis of large circuit corpora.
Systematic Ablation Study: A formal evaluation of optimization passes using Cohen's $d$ effect sizes and Kruskal–Wallis tests to isolate contributions and ordering effects.
Hardware-Relevant Metrics: A demonstration that two-qubit gate count, rather than total gate count, is the appropriate metric for comparing compiler efficacy on superconducting hardware.
Hardware Benchmarking: A provenanced benchmark on IQM Garnet (8/8 jobs completed) that quantifies the gap between simulation and reality.

Results

Optimization Effectiveness

Dominance of Cancellation: Gate cancellation is the primary driver of improvement, removing 3,780 gates across the corpus and improving 72.0% of circuits. It accounts for a large effect size ( $d=1.66$ ).
Marginal Role of Other Passes: Rotation merging, commutation, and identity elimination showed negligible effects in isolation ( $d < 0.2$ ).
Pass Ordering: The order of the four passes has no statistically significant effect on optimization outcomes (Kruskal–Wallis $p=0.302$ ).

Fidelity Predictors

Negative Correlations: Circuit size (input gates, $r=-0.78$ ) and pulse duration ( $r=-0.73$ ) are the strongest negative predictors of process fidelity ( $R^2=0.53$ ).
Noise Sensitivity: The relative benefit of optimization increases with noise severity, providing a 50% relative fidelity improvement in very high noise regimes compared to 8% in low noise.

Compiler Comparison (QCO vs. Qiskit)

Two-Qubit Reduction: QCO achieved superior two-qubit gate reduction on structured circuits: 100% for QAOA and 87.8% for QFT. In contrast, Qiskit (L3) achieved only 1.5% and 12.2% respectively.
Total Gate Count Misleading: Qiskit L2/L3 showed high total gate reduction (47.7%), but this was driven by single-qubit consolidation ( $u_3$ ), resulting in only 9.3% two-qubit reduction.
Random Circuits: For unstructured random circuits, Qiskit-L3-IQM outperformed QCO (16.0% vs. 3.2% two-qubit reduction), highlighting the value of general-purpose optimization strategies for non-structured workloads.

Hardware Validation

Model as Upper Bound: The Lindblad model consistently overestimated absolute fidelity on real hardware by a mean of 0.49.
Preserved Ordering: Despite the absolute offset, the model correctly preserved the relative difficulty ordering of circuits (e.g., shallow GHZ circuits maintained higher fidelity than deep QFT circuits).
Error Budget: The gap quantifies unmodeled error sources, including crosstalk, leakage, and readout/SPAM errors.

Significance and Claims

The paper claims to provide concrete guidance for quantum compiler design in the NISQ era by bridging the gap between abstract gate optimization and physical pulse-level fidelity.

Practical Guidance: The authors conclude that compiler designers should prioritize gate cancellation (which carries nearly all optimization value), report two-qubit gate counts instead of total gate counts, and avoid over-engineering pass ordering.
Domain Specificity: The results suggest that production compilers should incorporate both general-purpose passes (effective for random circuits) and domain-specific strategies (essential for structured algorithms like QFT and QAOA).
Model Limitations: The authors explicitly state that their model is a scalable approximation that omits inter-gate correlations and crosstalk. The hardware benchmark serves to quantify this "optimism gap" rather than to validate absolute fidelity values.
Future Work: The paper notes that establishing optimization improvements on hardware with sufficient statistical power requires future work with more shots and repetitions, and that extending the framework to additional devices and unstructured circuit optimizers is a logical next step.

The work is released as open-source to facilitate reproducible quantum compilation benchmarking.