Beyond Logical Circuits: Hardware-Aware Analysis of Expressibility and Trainability in Variational Quantum Algorithms

This paper demonstrates that hardware-aware transpilation significantly alters the expressibility and trainability of variational quantum algorithms compared to logical-level predictions, revealing that structural modifications during execution can disrupt the assumed expressibility-trainability trade-off and necessitate hardware-inclusive evaluation for accurate characterization.

The Gist

Imagine you are an architect designing a magnificent, complex house. You draw up perfect blueprints (the Logical Circuit) showing exactly how every room connects, where the windows go, and how the electricity flows. You assume that once you hand these blueprints to the construction crew, the house will be built exactly as you designed it.

However, in the real world of quantum computing, the "construction crew" (the Hardware) has very strict rules. They can't build a bridge between two rooms if there's a wall in the way, and they only have specific types of bricks (gates) available. To make your perfect blueprint fit these constraints, a middleman called a Transpiler steps in. They rearrange the rooms, add extra hallways, and swap out your fancy bricks for the ones the crew has. This process is called Transpilation.

This paper argues that most scientists have been studying the "perfect blueprints" and assuming the final house looks the same. The authors say: "Wait a minute! The construction crew changes the house so much that it might not even be the same house anymore."

Here is a breakdown of their findings using simple analogies:

1. The Two Things That Matter: "Flexibility" and "Ease of Driving"

To judge if a quantum algorithm (a program for a quantum computer) is good, scientists look at two main things:

• Expressibility (Flexibility): How many different shapes can the house take? A highly flexible house can turn into a castle, a cottage, or a skyscraper. In quantum terms, this means the circuit can create a wide variety of complex states.
• Trainability (Ease of Driving): How easy is it to steer the car to the right destination? If the car is stuck in a deep valley (a "barren plateau"), you can't steer it up the hill to find the best solution. If the car is on a flat plain, it's easy to drive.

2. The Big Surprise: The Construction Crew Changes the Rules

The authors took several different "blueprints" (called Ansatzes) and ran them through the construction crew (the Transpiler) on a simulated IBM quantum chip. They compared the original design to the final built house.

The Result: The construction crew didn't just add a few extra bricks; they fundamentally changed the nature of the house.

• The "Flexibility" Shock: For some designs, the transpilation process made the house less flexible. In one case (the "HEA Ring" design), the flexibility dropped by as much as 125% (meaning the final house could do far fewer things than the blueprint promised).
• The "Steering" Shock: For other designs, the ability to steer the car changed. Sometimes it got easier, sometimes harder. In some cases, the steering changed by 25%.

3. Not All Blueprints React the Same Way

The authors found that some designs are "tougher" than others when facing the construction crew:

• The "Structured" Houses (TTN and MPS): These are like houses built with a strict, logical grid system. They are very robust. When the construction crew rearranged them, the house stayed mostly the same. They didn't lose much flexibility, and they were still easy to drive.
• The "Dense" Houses (EfficientSU2): These are like houses with walls everywhere and no clear paths. They were already very flexible, so the construction crew couldn't make them much more flexible, but they also didn't break them easily.
• The "Ring" Houses (HEA Ring): These designs tried to connect rooms in a circle. Because the construction crew couldn't build a perfect circle with their limited tools, they had to add so many extra hallways that the house became a maze. This destroyed the original design's flexibility.

4. The Broken Promise: The "Trade-Off" Myth

For a long time, scientists believed in a simple rule: "If you make a house super flexible, it becomes impossible to drive (train)." They thought you had to choose between having a versatile house or an easy-to-drive one.

The paper says this rule is broken once you build the actual house.
The construction crew (transpilation) can mess with flexibility and steering independently.

• Sometimes, the crew makes the house less flexible but easier to drive.
• Sometimes, they make it more flexible but harder to drive.
• Sometimes, they change one but leave the other alone.

This means you cannot predict how a quantum computer will perform just by looking at the blueprints. The "construction process" itself changes the game.

The Bottom Line

If you design a quantum algorithm on paper, you are only seeing half the story. The moment you try to run it on real hardware, the "construction crew" (transpilation) rewrites the script.

The authors conclude that we need to stop just looking at the blueprints. We must test the actual built house (the transpiled circuit) to know if it will actually work. Relying only on the theoretical design is like judging a car's performance by looking at a sketch, ignoring the fact that the factory will have to weld the parts together in a very different way.

Technical Summary

Problem Statement

Variational Quantum Algorithms (VQAs) rely on Parameterized Quantum Circuits (PQCs), where performance is governed by two critical properties: expressibility (the ability to approximate Haar-random states) and trainability (the ease of optimizing parameters, often hindered by barren plateaus). Existing research typically evaluates these properties at the logical circuit level, implicitly assuming that the designed circuit remains structurally identical during hardware execution.

However, in practice, PQCs must undergo hardware-aware transpilation (compilation) to satisfy physical constraints such as limited qubit connectivity, native gate sets, and device topology. This process modifies the circuit structure through qubit mapping, routing (inserting SWAP gates), and basis decomposition. The paper argues that these structural modifications may fundamentally alter the PQC's expressibility and trainability, rendering logical-level analyses unreliable predictors of actual hardware behavior. While prior work has studied transpilation's impact on resource costs (depth, gate count) and noise, its effect on the fundamental functional properties of VQAs remains largely unexplored.

Methodology

The authors present a systematic, hardware-aware evaluation framework comparing logical circuits against their transpiled counterparts.

• Ansatz Families: The study evaluates six diverse ansatz families spanning different structural inductive biases:
  • Hardware-efficient: EfficientSU2, HEA Ring.
  • Tensor-network-inspired: Tree Tensor Network (TTN), Matrix Product State (MPS Brick).
  • Problem-specific/General: RealAmplitudes, TwoLocalRYRZ.
• Experimental Setup:
  • Logical Circuits: Constructed with varying qubit counts ($n \in \{2, 4, 6, 8, 10\}$) and repetition depths ($L \in \{2, 4, 6, 8, 10\}$).
  • Transpilation: Circuits are compiled using Qiskit's transpiler with the IBM FakeBrooklynV2 backend (65 qubits, heavy-hex connectivity) to simulate realistic hardware constraints without introducing stochastic noise.
  • Optimization Levels: Transpilation is performed across optimization levels 0 through 3 to assess the impact of compiler aggressiveness.
  • Simulation: Both logical and transpiled circuits are converted to PennyLane for noiseless statevector simulation. Crucially, the parameter count is kept fixed between logical and transpiled versions to isolate structural effects.
• Metrics:
  • Expressibility: Measured via the Kullback–Leibler (KL) divergence between the fidelity distribution of the circuit's output states and the theoretical Haar-random distribution. Lower KL divergence indicates higher expressibility.
  • Trainability: Quantified by the variance of the cost function gradients. Higher gradient variance indicates better trainability, while low variance suggests barren plateaus.
  • Overhead: Defined as the difference between the metric of the transpiled circuit and the logical circuit ($\Delta = \text{Metric}_{\text{transpiled}} - \text{Metric}_{\text{logical}}$).

Key Contributions

1. Limitations of Logical-Level Evaluations: The paper demonstrates that logical-level metrics are not always reliable predictors of hardware-level behavior. PQCs can exhibit substantially different characteristics after hardware-aware compilation.
2. Hardware-Aware Evaluation Framework: This work provides the first systematic study comparing PQC expressibility and trainability at both logical and transpiled levels, moving beyond conventional resource metrics like depth and gate count.
3. Systematic Multi-Ansatz Benchmarking: A comprehensive evaluation across multiple ansatz families, qubit counts, and circuit depths reveals how transpilation affects functional properties differently depending on the architecture.
4. Transpilation as an Active Transformation: The results show that transpilation is not merely a passive resource optimization but an active transformation that can non-monotonically reshape expressibility and trainability landscapes.
5. Breakdown of the Expressibility–Trainability Trade-off: The study challenges the commonly assumed inverse relationship between expressibility and trainability in hardware-aware settings, showing that transpilation can alter these properties in a decoupled, ansatz-dependent manner.

Key Results

• Qubit Overhead: Most ansatzes (EfficientSU2, TTN, RealAmplitudes, MPS Brick, TwoLocalRYRZ) maintained the same qubit count after transpilation. However, the HEA Ring ansatz required additional physical qubits (expansion from 8/10 to 12) at higher optimization levels to facilitate ring entanglement routing on the heavy-hex topology.
• Depth Overhead: Transpilation consistently increased circuit depth, with the magnitude heavily dependent on the ansatz structure and optimization level. EfficientSU2 (dense entanglement) showed the largest depth overhead, while structured ansatzes like TTN and MPS Brick remained relatively insensitive due to their locality-preserving nature.
• Expressibility Overhead:
  • HEA Ring exhibited the largest degradation (up to ~1.25 increase in KL divergence), particularly at larger qubit counts and higher optimization levels.
  • EfficientSU2 showed minimal overhead, likely because it was already highly expressive.
  • Structured Ansätze (TTN, MPS Brick) demonstrated high robustness, with overheads generally confined to small ranges ($\pm 0.04$).
  • RealAmplitudes showed a trend toward slight improvement in expressibility at higher optimization levels.
• Trainability Overhead:
  • TTN and HEA Ring showed localized improvements (positive overhead) in trainability, particularly at lower qubit counts.
  • RealAmplitudes exhibited a consistent negative bias (degradation) at higher optimization levels.
  • MPS Brick and TwoLocalRYRZ remained highly stable with near-zero overhead.
  • Overall, trainability variations were smaller (up to ~25%) compared to expressibility variations (up to ~125%).
• Decoupling of Properties: The study found that changes in expressibility do not necessarily correlate with changes in trainability. For instance, EfficientSU2 remained stable in both metrics despite significant depth overhead, while RealAmplitudes suffered trainability degradation without consistent expressibility gains.

Significance and Claims

The paper claims that the standard practice of evaluating VQAs solely at the logical design level is insufficient for characterizing their performance on NISQ devices. The authors argue that:

• Transpilation is an active transformation: It fundamentally alters the representational capacity and optimization landscape of VQAs, not just the resource cost.
• Logical-level trade-offs may not hold: The assumed trade-off between expressibility and trainability does not uniformly apply after hardware-aware compilation; these properties can be modified independently and in ansatz-dependent ways.
• Need for Hardware-Aware Design: Conclusions drawn from abstract circuit designs may not translate to practical implementations. Therefore, accurate characterization of VQAs requires evaluation frameworks that explicitly account for transpilation-induced structural transformations.

The authors conclude that hardware-aware evaluation is essential for the reliable design and deployment of variational quantum algorithms, as the "passive" compilation step can act as a significant architectural perturbation.