🔬 physics

Representation as a Variable: Cross-Framework Variance Decomposition for Quantum Compilation

This large-scale empirical study across four quantum compilation frameworks and six algorithms demonstrates that the interaction between framework and algorithm, along with internal configuration choices, explains the majority of circuit depth variance, establishing representation selection as a critical optimization variable that grows in importance with circuit scale.

Original authors: David Vesterlund

Published 2026-10-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: David Vesterlund

Original paper licensed under CC BY 4.0 (https://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

Before a quantum computer can solve a problem, the instructions it receives must be translated into a language the machine actually understands. A quantum algorithm is like a high-level plan, written in abstract terms that describe what should happen to the particles inside the processor. However, the physical hardware is limited; it can only perform specific types of moves, and its parts are connected in a fixed pattern that does not always allow direct communication between every pair of particles. To make the plan work, a compiler acts as a translator, breaking down the abstract instructions into a sequence of concrete steps that fit the machine's physical constraints. This process is not unique; different software tools, known as frameworks, can translate the same plan in vastly different ways. Some might take a direct route, while others might take a winding path that uses more steps or deeper layers of operations. For scientists trying to run complex calculations on today's imperfect quantum machines, the depth of this translated circuit—the number of steps required—is critical. If the path is too long, the fragile quantum state collapses before the calculation finishes, rendering the result useless.

A researcher recently set out to understand how much of the final quality of this translation depends on the choice of software tool versus the specific settings chosen within that tool. They treated the way a circuit is represented not as a fixed outcome, but as a variable that could be optimized. To do this, they conducted a massive experiment involving four different major software frameworks, six distinct types of quantum algorithms, and four different sizes of circuits, ranging from six to twelve particles. They did not simply run each algorithm once with the default settings. Instead, they systematically explored thousands of different configurations within each framework, testing how changes in the translation strategy affected the final result. By analyzing over four thousand separate observations, they were able to break down the differences in performance into specific causes: how much was due to the algorithm itself, how much to the software framework, how much to the interaction between the two, and how much to the specific configuration chosen within a framework.

The study revealed a surprising truth that challenges the common assumption that one software tool is simply better than the others. The researcher found that the most significant factor determining the quality of the translation was not the framework itself, nor the algorithm alone, but the specific combination of the two. In circuits with six to ten particles, the interaction between the chosen algorithm and the chosen framework explained nearly forty percent of the differences in performance. This means that no single software tool is universally optimal; a tool that excels at translating one type of problem might perform poorly on another. For instance, when translating a specific search algorithm, one framework produced a circuit with a depth of seven steps, while another framework produced a circuit with a depth of over six thousand steps for the exact same logical problem. This massive difference was not a bug or an error, but a result of how each framework fundamentally approaches the translation task.

Beyond the choice of software, the researcher discovered that the settings used within a single framework matter even more as the problems get larger. In the largest circuits tested, containing twelve particles, the specific configuration chosen inside a framework explained up to seventy-eight percent of the variation in performance. This suggests that simply picking a popular software tool is not enough; the way that tool is configured is equally, if not more, important. The study showed that searching through these different settings could reduce the number of steps required by a median of twenty-nine percent, with some cases showing a reduction of nearly one hundred percent compared to the average configuration. In practical terms, this difference often determines whether a calculation can be completed at all or if it fails due to the limitations of the hardware.

The researcher also found that the different software frameworks are not just different versions of the same thing; they explore fundamentally different landscapes of possibilities. One framework might focus on rearranging the order of operations, while another might focus on merging similar steps or changing the type of basic moves used. Because these search spaces are structurally different, a configuration that works perfectly in one framework has no direct equivalent in another. This structural difference means that the best approach for a scientist is not to stick with a single tool, but to systematically search across different frameworks and their various settings to find the best representation for their specific problem. The study concludes that the choice of how to compile an algorithm is a genuine optimization variable, one that grows in importance as quantum computers scale up. By treating the translation process as a search problem rather than a fixed transformation, researchers can unlock significant improvements in performance, turning circuits that would otherwise be too deep to run into ones that are feasible for today's technology.

Technical Summary: Representation as a Variable: Cross-Framework Variance Decomposition for Quantum Compilation

Problem Statement

The paper addresses a fundamental assumption in quantum computing: that a quantum algorithm, once specified as an abstract circuit, yields a unique or near-unique compiled circuit once a compilation framework is selected. The author challenges the conventional approach, where users select a framework (e.g., Qiskit, PyTKET) and accept its default configuration, implicitly treating the resulting "representation" (the specific compiled circuit) as a fixed transformation determined solely by the algorithm and framework choice.

The core problem is that compilation is not unique. Different frameworks implement distinct passes, heuristics, and gate decompositions. Furthermore, within a single framework, configuration choices (layout, routing, optimization levels) produce vastly different compiled circuits from the same input. The paper posits that the representation choice itself is an optimization variable that has been underutilized. The study seeks to quantify how much of the variance in compilation quality (specifically circuit depth) is attributable to:

The choice of framework.
The choice of configuration within a framework.
The interaction between the framework and the algorithm.
How these factors scale with circuit size (qubit count).

Methodology

The author conducted a large-scale empirical study involving 4,608 observations derived from a factorial experimental design.

Frameworks: Four major quantum compilation frameworks were evaluated: Qiskit (v2.5.2), PyTKET (v2.18.4), PennyLane (v0.45.1), and Cirq (v1.7.0).
Algorithms: Six benchmark algorithms with varying circuit structures were used: Quantum Fourier Transform (QFT), Grover's algorithm, Quantum Phase Estimation (QPE), GHZ state preparation, Bernstein–Vazirani (BV), and a Superposition circuit.
Scale: Experiments were run on circuits of 6, 8, 10, and 12 qubits.
Search Space: The study did not rely on default settings. Instead, it treated configuration as a search variable:
- Qiskit: Searched a 32-configuration subset of a 128-configuration grid (optimization level, layout, routing, translation).
- PyTKET: Explored 32 states via sequential beam search from a 108-configuration space (optimization, placement, routing, rebase).
- PennyLane: Explored 22 states from a 24-configuration space (commute, cancel, merge, cleanup).
- Cirq: Explored 9 states from a 6-configuration space (gate set, max passes).
Constraints: All experiments utilized a restrictive linear (nearest-neighbor) coupling map to force routing, thereby amplifying the impact of representation choices.
Analysis: The author applied a two-factor variance decomposition (ANOVA-style) to partition the variance of circuit depth into:
- $\eta^2_{algorithm}$ : Variance explained by the algorithm identity.
- $\eta^2_{framework}$ : Variance explained by the framework choice.
- $\eta^2_{interaction}$ : Variance explained by the interaction between algorithm and framework.
- $\eta^2_{residual}$ : Variance explained by configuration choices within cells (and stochasticity).

Key Contributions

Large-Scale Cross-Framework Benchmark: A dataset of 4,608 compilation observations across four frameworks, six algorithms, and four circuit sizes, with all data made publicly available via the WestQuant ecosystem.
Variance Decomposition Formalization: The paper formalizes the representation search problem by quantifying the variance decomposition, demonstrating that the framework $\times$ algorithm interaction is a dominant factor in compilation quality.
Structural Comparison of Search Spaces: The study reveals that frameworks expose structurally different representation search spaces (e.g., compiler configuration vs. gate-level transforms vs. gate set selection), rather than merely different parameterizations of the same space.
Quantification of Search Value: The paper provides empirical evidence that systematic representation search yields substantial improvements, with the best configurations reducing circuit depth by a median of 29% and up to 99% compared to mean configurations.

Key Results

1. Interaction is the Dominant Factor (6–10 Qubits)

The most significant finding is that the framework $\times$ algorithm interaction explains 32–42% of the circuit depth variance (mean 39%) for circuits between 6 and 10 qubits. This exceeds the main effect of the framework choice (10–14%) and approaches the main effect of the algorithm (23–34%).

Implication: No single framework is universally optimal. The "best" framework depends entirely on the specific algorithm being compiled.

2. Configuration Variance Grows with Scale

Within a single framework, the variance explained by configuration choice increases significantly as circuit size grows.

At 12 qubits, configuration choice explains up to 78% of the depth variance in PyTKET and 45% in Qiskit.
In contrast, at 6 qubits, these figures were 55% and 12%, respectively.
This indicates that as circuits scale, the choice of configuration within a framework becomes as important, or more important, than the choice of algorithm itself.

3. Extreme Variance in Specific Cases (Grover's Algorithm)

The study highlights extreme disparities in compilation quality for specific algorithms. For Grover's algorithm at 12 qubits:

PyTKET achieved a depth of 7.
PennyLane achieved a depth of 13.
Qiskit achieved a depth of 4,519.
Cirq achieved a depth of 6,610.
This represents a 944x difference in depth between the best and worst frameworks for the same logical circuit, attributed entirely to how different frameworks decompose multi-controlled gates.

4. Search Space Structure

The frameworks are not interchangeable.

Qiskit and PyTKET search compiler configuration spaces (which passes to apply).
PennyLane searches gate-level transform spaces (which gate rewrites to apply).
Cirq searches gate set and pass count spaces.
The size and nature of these spaces correlate with the variance they can explain; larger search spaces (e.g., PyTKET's 108 configs) offer more optimization room but require more search effort.

Significance and Claims

The paper claims that representation is a genuine optimization variable, not a fixed choice. The significance of this finding is threefold:

Rejection of Universal Optimality: The high interaction effect proves that researchers cannot rely on a single "best" framework for all tasks. A static compilation strategy is suboptimal.
Scaling Importance: The importance of representation search grows with circuit scale. At 12 qubits, configuration choice is the primary lever for optimization, suggesting that as quantum hardware scales to 20+ qubits, systematic search will become critical for fitting circuits onto devices.
Practical Impact: The improvements found are not marginal; they are often the difference between a circuit that fits on a device and one that does not. The median 29% depth reduction and maximum 99% reduction demonstrate that moving from default configurations to optimized representations yields tangible, substantial gains.

The author concludes that the field must shift from accepting default framework configurations to systematically searching the representation space across frameworks and configurations. They position the WestQuant open-source ecosystem as the necessary tooling to facilitate this search and enable future machine learning-guided approaches to representation selection.