Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.
Kai: We're looking at the paper: "Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation".
Mira: Here's the gist of the paper. Predicting noisy-simulator runtime is important for scheduling, resource allocation, and performance optimization <ref:2609.12980#pg5> The overall model setting, the transpiled GNN provides the strongest and most consistent results across all optimization levels, outperforming both the Source and Hybrid GNNs as well as ML models <ref:2609.12980#pg6> These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level <ref:2609.12980#pg2> Circuit Representation and Modeling The study formulates and evaluates three GNN graph representations (source, hybrid, and transpiled), alongside five ML regression methods to quantify the effects of feature representations and model choices on noisy-simulator runtime prediction <ref:2609.12980#pg5> Specifically, the source setting uses a source-level directed acyclic graph (DAG) extracted from the original circuit before transpilation, while the hybrid setting augments this with 13 post-transpilation global features <ref:2609.12980#pg5> The transpiled setting builds both its graph and global feature vector entirely from the backend-specific transpiled circuit <ref:2609.12980#pg5> Evaluation Methodology The evaluation methodology involves constructing a circuit dataset consisting of source-level and transpiled graphs for four optimization levels and two simulation backends using Qiskit Aer simulator <ref:2609.12980#pg5> The evaluation uses two standard regression metrics: root mean squared error (RMSE) and the coefficient of determination (R2) to measure prediction performance <ref:2609.12980#pg6> Data splitting is performed by generating 1,000 candidate 80/20 train-test splits and selecting the one that minimizes a distribution-matching score based on backend, circuit family, and execution-time distributions <ref:2609.12980#pg6> Performance Comparison Among Models The Transpiled GNN provides the strongest and most consistent results across all optimization levels, outperforming both the Source and Hybrid GNNs as well as the baseline winner <ref:2609.12980#pg5> The gain of the Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations such as more intensive layout, routing, cancellation and resynthesis passes <ref:2609.12980#pg6> However, R2 generally decreases as the optimization level increases because the Opt 3 dataset has a much tighter runtime distribution <ref:2609.12980#pg6> Backend-Specific Predictions Washington shows a clear benefit from backend-stratified results across all optimization levels and representations, with the overall Transpiled GNN being the best-performing model <ref:2609.12980#pg6> Sherbrooke shows that backend-specific training can improve prediction in selected settings, particularly for the Transpiled GNN at some optimization levels <ref:2609.12980#pg6> This suggests that separate training is not necessary for Washington <ref:2609.12980#pg6> Optimization Level Impact on Transpilation The benefit of additional optimization depends on the circuit characteristics, as deeper and slower circuits are much more likely to benefit from additional optimization <ref:2609.12980#pg6> On Washington, the percentage of circuits benefiting from Opt 1 increases significantly between fastest and slowest circuits <ref:2609.12980#pg6> Conversely, on Sherbrooke, there is almost no benefit for the slowest circuits with Opt 3 <ref:2609.12980#pg6> This suggests that additional transpilation overhead of Opt 3 generally outweighs its execution time savings <ref:2609.12980#pg6> Accuracy and Inference Cost The Transpiled GNN achieves the strongest predictive performance among the GNN representations in most evaluated settings <ref:2609.12980#pg6> The Transpiled GNN processes graphs that are approximately 34.9× larger on average and requires about 7.4× more inference time than other representations <ref:2609.12980#pg6> Despite the increased graph cost, its inference time is still in milliseconds, 2.35 ms per circuit, while achieving the highest mean R2 <ref:2609.12980#pg6> The Transpiled GNN's advantage is due to the post-transpilation representation rather than differences in dataset composition <ref:2609.12980#pg6> The paper proposes two GNN circuit representations (hybrid and transpiled) and evaluates their prediction accuracy and overhead with a circuit dataset collected on two backends with four transpilation optimization levels <ref:2609.12980#pg5> The results demonstrate that the transpiled GNN generally provides the strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features <ref:2609.12980#pg6> However, conventional ML regression models using transpilation-aware circuit features remain competitive with or outperform GNNs in several settings <ref:2609.12980#pg6> These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors <ref:2609.12980#pg6> Such predictors are essential for future quantum operating systems and schedulers, where runtime estimates can guide job placement and resource allocation <ref:2609.12980#pg6> Acknowledgments This work is supported in part by NSF Grant 2426940 and a high-performance computing system acquired through NSF MRI grant DMS-1337943 to WPI <ref:2609.12980#pg6> The paper's references include Bisicchia et al.
Kai: 2025, Chen and Guestrin 2016, Dam et al.
Mira: 2024, and Ma and Li 2026 The paper also cites Quetschlich et al.
Kai: 2023a, Quetschlich et al.
Paper summary: Kai: So to wrap up, the paper "Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation" looked at how different ways of representing a circuit—source, hybrid, or fully transpiled—affect our ability to predict runtime on noisy simulators.
Mira: They found that the fully transpiled GNN generally gives the best prediction accuracy among the graph-based methods, suggesting that knowing what's happening after transpilation is important for understanding circuit structure and features.
Lev: But they also showed that standard machine learning models using features aware of transpilation can still be just as good or even better than those graph neural networks in some settings.
Kai: The implications are that post-transpilation information is a key piece of the puzzle for building reliable predictors for quantum execution times.
Mira: For people who listen to this show, this means these runtime estimates are going to be crucial when we start building quantum operating systems and schedulers so they can decide where jobs go and how resources are used on real hardware.
Conclusion: Kai: So we're wrapping up this look at how circuit representations affect predicting noisy simulator runtime, focusing on the work by Bisicchia and his team.
Mira: They put forward two main GNN models for representing circuits—one hybrid and one fully transpiled—and they show that the latter, the transpiled one, is generally the strongest predictor.
Kai: But they also point out that standard machine learning models using features derived from that transpilation are still quite competitive with those graph neural networks.
Mira: That suggests post-transpilation information is genuinely useful for building these quantum execution time predictors.
Kai: It means these estimates become more reliable, which is important for the future of scheduling and resource allocation in quantum computing systems.
Mira: Exactly, because if we can predict how long a circuit will actually take to run on hardware after all that transpilation work is done, we can place jobs much better on real quantum machines.
Kai: It seems like the main thing here is that the structure of the circuit *after* it’s been prepared for a specific machine matters for accurate runtime guessing.
Mira: Right, and while they show this works well across different optimization levels and backends, we still have to look at how much extra computation that transpilation itself adds to the overall process.
Davud Azizov, Javier Vela-Tambo, Tian Guo
Worcester Polytechnic Institute
quant-ph, cs.PF
Submitted: 2026-09-11
Updated: 2026-11-09
Comments: Published in the Proceedings of the 2026 AAAI Fall Symposium Series (Second AAAI Symposium on Quantum Information & Machine Learning)
Journal ref: Proceedings of the AAAI Symposium Series, Vol. 10, No. 1, pp. 709-716 (2026)
DOI: 10.1609/aaaiss.v10i1.43479
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 83/100
The gist: Predicting noisy-simulator runtime is important for scheduling, resource allocation, and performance optimization <ref:2609.12980#pg5> The overall model setting…
Key concepts
- Circuit Representations
- The paper tests three ways to model a quantum circuit: source-level (before changes), hybrid (source plus post-transpilation features), and transpiled (built entirely from the backend-specific, optimized circuit). These representations are fed into Graph Neural Networks (GNNs) to predict how long the simulation will take.
- Transpilation
- Transpilation is the process of rewriting a quantum circuit to be compatible with a specific quantum hardware's native gate set and coupling map. It involves decomposing unsupported gates and inserting routing operations like SWAPs. The paper examines how different optimization levels of this process affect prediction accuracy.
- Transpiled GNN
- This is the GNN model that uses the circuit structure *after* it has been fully transpiled for a target backend. It consistently outperformed other models because it captures crucial information about the final, optimized circuit structure, proving that post-transpilation details are important for reliable runtime estimation.
Terminology
Summary
Predicting noisy-simulator runtime is important for scheduling, resource allocation, and performance optimization <ref:2609. p. 0 edu
Abstract
Predicting the runtime of noisy quantum circuit simulations
is important for scheduling, resource allocation, and performance optimization. However, accurate prediction is challenging because backend-aware transpilation can substantially alter the original circuit structure, while the backendderived noise model and simulator execution behavior can
introduce additional runtime variation. To
evaluate these predictors, we construct a circuit dataset that
consists of source-level and transpiled graphs for four transpilation optimization levels and two simulation backends
using Qiskit Aer simulator (Javadi-Abhari et al. In
the overall-model setting, the transpiled GNN provides the
strongest and most consistent results across all optimization
levels, outperforming both source and hybrid GNNs, as well
as ML models. However, under backend-specific evaluation, the
advantage of GNN decreases, with conventional regression
models matching or outperforming the GNNs in several settings. These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level.Where the paper says it
Where the paper says it
Where the paper says it
Circuit Representation and Modeling
The study formulates and evaluates three GNN graph representations (source, hybrid, and transpiled), alongside five ML regression methods to quantify the effects of feature representations and model choices on noisy-simulator runtime prediction <ref:2609.12980#pg5> Specifically, the source setting uses a source-level directed acyclic graph (DAG) extracted from the original circuit before transpilation, while the hybrid setting augments this with 13 post-transpilation global features <ref:2609. p. 2 Circuit Representation and Feature Extraction
We use three complementary representations for each circuit. In the source setting, which follows the representation
used by Ma and Li (2026), the graph branch uses a sourcelevel directed acyclic graph (DAG) extracted from the original circuit before transpilation. In the transpiled setting, the graph branch is built directly
from the backend-specific circuit rather than the original circuit. The global feature vector is also computed from the
transpiled circuit itself, using the same 41-feature setting.Where the paper says it
Where the paper says it
Evaluation Methodology
The evaluation methodology involves constructing a circuit dataset consisting of source-level and transpiled graphs for four optimization levels and two simulation backends using Qiskit Aer simulator <ref:2609.12980#pg5> The evaluation uses two standard regression metrics: root mean squared error (RMSE) and the coefficient of determination (R2) to measure prediction performance <ref:2609. p. 4 Evaluation Metrics. We evaluate prediction performance
using two standard regression metrics: root mean squared
error (RMSE) and the coefficient of determination (R2
). Data Splitting and Model Selection. We generate 1,000
candidate 80/20 train-test splits and select the one that minimizes a distribution-matching score based on backend, circuit family, and execution-time distributions.Where the paper says it
Where the paper says it
Performance Comparison Among Models
The Transpiled GNN provides the strongest and most consistent results across all optimization levels, outperforming both the Source and Hybrid GNNs as well as the baseline winner <ref:2609.12980#pg5> The gain of the Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations such as more intensive layout, routing, cancellation and resynthesis passes <ref:2609. p. 4 This
shows that the original representation can still retain much of
the information needed for the prediction. The benefit of the
Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations, such as more intensive layout, routing, cancellation and resynthesis passes (IBM Quantum 2026). 3, the Opt 3 dataset has a much tighter runtime distribution, with many circuits having similar execution times. Because R2 measures prediction error relative to the variance of actual runtimes, smaller variance makes it harder to
achieve a high R2
even with low absolute errors.Where the paper says it
Where the paper says it
Backend-Specific Predictions
Washington shows a clear benefit from backend-stratified results across all optimization levels and representations, with the overall Transpiled GNN being the best-performing model <ref:2609.12980#pg6> Sherbrooke shows that backend-specific training can improve prediction in selected settings, particularly for the Transpiled GNN at some optimization levels <ref:2609. p. 5 25 s in all settings. Overall, Sherbrooke shows that backend-specific training
can improve prediction in selected settings, including for
the Transpiled GNN at some optimization levels, although
no representation consistently benefits from separate training across all settings. 9, indicating the importance of optimization in prediction. Overall, these results
suggest that separate training is not necessary for Washington.Where the paper says it
Where the paper says it
Optimization Level Impact on Transpilation
The benefit of additional optimization depends on the circuit characteristics, as deeper and slower circuits are much more likely to benefit from additional optimization <ref:2609.12980#pg6> On Washington, the percentage of circuits benefiting from Opt 1 increases significantly between fastest and slowest circuits <ref:2609. p. 5 For example, on
Washington, the percentage of circuits benefiting from Opt
1 increases from 15. 7% between fastest and slowest circuits. The remaining cases perform poorly, with fewer than half
of the circuits in group 4 benefiting from Opt 3. On Sherbrooke, there is almost no benefit, reaching only 5% for
the slowest circuits and 0% for the deepest. On Sherbrooke, there is almost no benefit, reaching only 5% for
the slowest circuits and 0% for the deepest. This suggests
that the additional transpilation overhead of Opt 3 generally outweighs its execution time savings. On Sherbrooke, there is almost no benefit, reaching only 5% for
the slowest circuits and 0% for the deepest. This suggests
that the additional transpilation overhead of Opt 3 generally outweighs its execution time savings.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Accuracy and Inference Cost
The Transpiled GNN achieves the strongest predictive performance among the GNN representations in most evaluated settings <ref:2609.12980#pg6> The Transpiled GNN processes graphs that are approximately 34. p. 6 Graph-construction time is reported as a one-time preprocessing cost and averaged across both backends and optimization levels. The Transpiled GNN processes graphs that are approximately 34. Graph-construction time is reported as a one-time preprocessing cost and averaged across both backends and optimization levels. The Transpiled GNN processes graphs that are approximately 34. The Transpiled GNN processes graphs that are approximately 34. 9× larger on average and requires about 7. The Transpiled GNN processes graphs that are approximately 34. 9× larger on average and requires about 7. 9× larger on average and requires about 7. 4×
more inference time than other representations. 9× larger on average and requires about 7. 4×
more inference time than other representations. 4×
more inference time than other representations. However,
its inference time is still in milliseconds, 2. However,
its inference time is still in milliseconds, 2. 35 ms per circuit, while achieving the highest mean R2
. However,
its inference time is still in milliseconds, 2. 35 ms per circuit, while achieving the highest mean R2
.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Conclusion
The paper proposes two GNN circuit representations (hybrid and transpiled) and evaluates their prediction accuracy and overhead with a circuit dataset collected on two backends with four transpilation optimization levels <ref:2609.12980#pg5> The results demonstrate that the transpiled GNN generally provides the strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features <ref:2609. p. 6 Conclusion
This paper proposed two GNN circuit representations (hybrid and transpiled) and evaluated their prediction accuracy
and overhead with a circuit dataset collected on two backends with four transpilation optimization levels. Our results
demonstrate that the transpiled GNN generally provides the
strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features. Conclusion
This paper proposed two GNN circuit representations (hybrid and transpiled) and evaluated their prediction accuracy
and overhead with a circuit dataset collected on two backends with four transpilation optimization levels. Our results
demonstrate that the transpiled GNN generally provides the
strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features. Our results
demonstrate that the transpiled GNN generally provides the
strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features. However, conventional ML regression models using transpilation-aware circuit features
remain competitive with or outperform GNNs in several settings. However, conventional ML regression models using transpilation-aware circuit features
remain competitive with or outperform GNNs in several settings. These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors, but explicit graph modeling is not always necessary. These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors, but explicit graph modeling is not always necessary. Such predictors are essential for future quantum operating
systems and schedulers, where runtime estimates can guide
job placement and resource allocation.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Acknowledgments
This work is supported in part by NSF Grant 2426940 and a high-performance computing system acquired through NSF MRI grant DMS-1337943 to WPI <ref:2609.12980#pg6> The paper's references include Bisicchia et al. 2025, Chen and Guestrin 2016, Dam et al. p. 4 We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. p. 0 2022), resource estimation (Suchara et al. p. 0 Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. p. 0 Consequently, the relationship between source-level circuit
properties and simulator runtime is indirect, nonlinear, and
backend-dependent. Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. Consequently, the relationship between source-level circuit
properties and simulator runtime is indirect, nonlinear, and
backend-dependent. Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. MQT Predictor (Quetschlich, Burgholzer,
and Wille 2025) extends this direction by selecting a suitable quantum device and performs device-specific compilation for a given quantum algorithm. Compiler configuration selection has also been formulated as a supervised
prediction problem to select promising combinations of devices, compilers, and compiler settings for a given circuit (Quetschlich, Burgholzer, and Wille 2023b). It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. This work
provides a standardized foundation for evaluating Quantum
Software Engineering (QSE) tools. It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. This work
provides a standardized foundation for evaluating Quantum
Software Engineering (QSE) tools. It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. This work
provides a standardized foundation for evaluating Quantum
Software Engineering (QSE) tools. It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. This work
provides a standardized foundation for evaluating Quantum
Software Engineering (QSE) tools.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
References
The references include Bisicchia et al. 2025, Chen and Guestrin 2016, Dam et al. 2024, Giortamis et al. p. 0 However,
these simulations can themselves be computationally expensive, and their runtimes can vary substantially across circuits and backend configurations. Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. However,
these simulations can themselves be computationally expensive, and their runtimes can vary substantially across circuits and backend configurations. Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. However,
these simulations can themselves be computationally expensive, and their runtimes can vary substantially across circuits and backend configurations. Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. 2025a,b; Ravi et al. Higher optimization levels
may reduce circuit depth or gate count, but they can also increase compilation time. Compilation latency can itself be a
substantial component of end-to-end processing time, motivating both high-performance transpilation frameworks and
techniques that amortize or avoid repeated compilation (Hua
et al. 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). With
the growing availability of cloud-accessible quantum hardware (Ravi et al. 2021a), noisy simulators play a complementary role in developing and evaluating quantum workloads before hardware execution. With
the growing availability of cloud-accessible quantum hardware (Ravi et al. 2021a), noisy simulators play a complementary role in developing and evaluating quantum workloads before hardware execution. With
the growing availability of cloud-accessible quantum hardware (Ravi et al. 2021a), noisy simulators play a complementary role in developing and evaluating quantum workloads before hardware execution. Consequently, the relationship between source-level circuit
properties and simulator runtime is indirect, nonlinear, and
backend-dependent. Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. Consequently, the relationship between source-level circuit
properties and simulator runtime is indirect, nonlinear, and
backend-dependent. Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. Consequently, the relationship between source-level circuit
properties and simulator runtime is indirect, nonlinear, and
backend-dependent. Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer,
and Wille 2023a; Tomesh et al. These metrics
are useful because circuit execution cost is not determined
only by the number of qubits or gates, but also by circuit
structure, connectivity, depth, and parallelism. Recent work
further shows that circuit depth alone is not an accurate
proxy for runtime prediction because operations may have
different execution costs (Tremba, Hovland, and Liu 2025),
motivating richer gate- and backend-aware representation
and metrics. These metrics
are useful because circuit execution cost is not determined
only by the number of qubits or gates, but also by circuit
structure, connectivity, depth, and parallelism. Recent work
further shows that circuit depth alone is not an accurate
proxy for runtime prediction because operations may have
different execution costs (Tremba, Hovland, and Liu 2025),
motivating richer gate- and backend-aware representation
and metrics. These metrics
are useful because circuit execution cost is not determined
only by the number of qubits or gates, but also by circuit
structure, connectivity, depth, and parallelism. Recent work
further shows that circuit depth alone is not an accurate
proxy for runtime prediction because operations may have
different execution costs (Tremba, Hovland, and Liu 2025),
motivating richer gate- and backend-aware representation
and metrics. More recently, Villar et al. (2025) applied reinforcement learning
to permutation-circuit synthesis across different hardware
topologies, demonstrating generalization to previously unseen topologies. More recently, Villar et al. (2025) applied reinforcement learning
to permutation-circuit synthesis across different hardware
topologies, demonstrating generalization to previously unseen topologies. More recently, Villar et al. (2025) applied reinforcement learning
to permutation-circuit synthesis across different hardware
topologies, demonstrating generalization to previously unseen topologies. Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and
backend settings. arXiv:2609. Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and
backend settings. arXiv:2609. Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and
backend settings. arXiv:2609. We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)). We compare the proposed graphbased predictors against five ML regression baselines using the same global feature vector. These models cover linear methods (linear and ridge regression), kernel-based regression (support vector regression (SVR) with an RBF kernel (Smola and Scholkopf 2004)), and tree-based methods ¨
(random forest and XGBoost (Chen and Guestrin 2016)).Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Quantum Circuit Simulation
Classical simulation plays an important part in quantum computing because given the limited resources and availability of current quantum hardware, classical simulators remain one of the most practical ways to develop and test quantum algorithms <ref:2609.12980#pg3> Simulation cost, however, depends strongly on backend, simulation method and circuit characteristics <ref:2609. p. 2 (2025)
emphasize that, given the limited resources and availability
of current quantum hardware, classical simulators remain
one of the most practical ways to develop and test quantum algorithms. Simulation cost, however, depends strongly
on backend, simulation method and circuit characteristics. Simulation cost, however, depends strongly
on backend, simulation method and circuit characteristics. Vallero, Rech, and Vella (2026) show that circuit structure
can considerably affect the relative performance of some
simulators, and circuit-level analysis can help choose the
right simulation. Simulation cost, however, depends strongly
on backend, simulation method and circuit characteristics. Vallero, Rech, and Vella (2026) show that circuit structure
can considerably affect the relative performance of some
simulators, and circuit-level analysis can help choose the
right simulation.Where the paper says it
Where the paper says it
Where the paper says it
Quantum Circuit Execution Predictor Design
The goal of this study is to predict the Qiskit Aer simulation runtime (Javadi-Abhari et al. 2024) of a quantum circuit after it has been transpiled for a target backend, using a fixed shot count <ref:2609. p. 2 Quantum Circuit Execution Predictor Design
The goal of this study is to predict the Qiskit Aer simulation runtime (Javadi-Abhari et al. 2024) of a quantum circuit after it has been transpiled for a target backend, using a
fixed shot count. 2024) of a quantum circuit after it has been transpiled for a target backend, using a
fixed shot count. We formulate this as a supervised regression problem, where each training example consists of a circuit and its measured simulator runtime.Where the paper says it
Where the paper says it
Quantum Circuit Runtime Analysis
QSimBench (Bisicchia et al. 2025) provides an execution-level benchmark suite for noisy quantum simulation, offering over 20 million shot-level execution traces across different algorithms and multiple circuit sizes <ref:2609. p. 2 2025) provides an execution-level benchmark
suite for noisy quantum simulation. It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. It provides a comprehensive suite of over 20 million shot-level execution traces
across different algorithms and multiple circuit sizes, using both ideal and noisy simulation backends. This work
provides a standardized foundation for evaluating Quantum
Software Engineering (QSE) tools.Where the paper says it
Where the paper says it
Circuit Compilation
Transpilation rewrites the circuit using the backend’s native gate set, maps logical qubits to physical qubits, and adapts two-qubit operations to the backend coupling map <ref:2609.12980#pg5> Because hardware devices support only specific native gate sets, any gates that are not supported by the backend are decomposed <ref:2609. p. 1 Transpilation rewrites the circuit using the backend’s native
gate set, maps logical qubits to physical qubits, and adapts
two-qubit operations to the backend coupling map. Because
hardware devices support only specific native gate sets, any
gates that are not supported by the backend are decomposed
Original circuit
High-level circuit:
CX(q0,q3)
q0
q1
q2
q3
q0 q1 q2
q3
no direct edge
q0 and q3 are not directly connected
Backend Coupling map Transpiled circuit
q0
q1
q2
q3
Additional SWAP gates increase
depth and gate count
Original features Backend-aware
transpilation
Transpiled
features
Noisy simulator
runtime
Figure 1: Transpilation transforms a source-level circuit into
a backend-compatible form by decomposing gates and inserting SWAP operations. Transpilation rewrites the circuit using the backend’s native
gate set, maps logical qubits to physical qubits, and adapts
two-qubit operations to the backend coupling map. Because
hardware devices support only specific native gate sets, any
gates that are not supported by the backend are decomposed
Original circuit
High-level circuit:
CX(q0,q3)
q0
q1
q2
q3
q0 q1 q2
q3
no direct edge
q0 and q3 are not directly connected
Backend Coupling map Transpiled circuit
q0
q1
q2
q3
Additional SWAP gates increase
depth and gate count
Original features Backend-aware
transpilation
Transpiled
features
Noisy simulator
runtime
Figure 1: Transpilation transforms a source-level circuit into
a backend-compatible form by decomposing gates and inserting SWAP operations.Where the paper says it
Where the paper says it
Related Work
Prior work has examined quantum circuit performance through benchmarking (Quetschlich et al. 2023a; Tomesh et al. 2022), resource estimation (Suchara et al. 2013; Dam et al. p. 0 2022), resource estimation (Suchara et al. 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2013; Dam, Mykhailova, and Soeken
2024), and backend-aware compilation (Murali et al. 2019;
Quetschlich, Burgholzer, and Wille 2025). Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and
backend settings. arXiv:2609. Most closely related, Ma and Li (2026) propose a graph-transformer model (Velickovi ˇ c et al. 2018) for ´
execution-time prediction on simulators and real hardware. 2018) for ´
execution-time prediction on simulators and real hardware. Their approach primarily uses source-level, pre-transpilation
circuit representations and does not explicitly examine either the predictive value of backend-specific features extracted after transpilation or the transpiled circuit graph itself.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Circuit Compilation Details
Transpilation can be performed with different optimization levels, which control how much effort the transpiler spends on rewriting and simplifying the circuit <ref:2609.12980#pg5> Higher optimization levels may reduce circuit depth or gate count, but they can also increase compilation time <ref:2609. p. 1 2024), transpilation
can be performed with different optimization levels, which
control how much effort the transpiler spends on rewriting and simplifying the circuit. Higher optimization levels
may reduce circuit depth or gate count, but they can also increase compilation time. Higher optimization levels
may reduce circuit depth or gate count, but they can also increase compilation time. Compilation latency can itself be a
substantial component of end-to-end processing time, motivating both high-performance transpilation frameworks and
techniques that amortize or avoid repeated compilation (Hua
et al.Where the paper says it
Where the paper says it
Transpilation Process
Figure 1 illustrates the transpilation process at a high level, showing how Transpilation transforms a source-level circuit into a backend-compatible form by decomposing gates and inserting SWAP operations <ref:2609.12980#pg5> Additionally, two-qubit gates between logical qubits that are physically unconnected, as defined by the coupling map of the device, are resolved by inserting SWAP operations, a step known as routing <ref:2609. p. 1 into equivalent sequences of native operations (Quetschlich,
Burgholzer, and Wille 2023a). Additionally, two-qubit gates
between logical qubits that are physically unconnected, as
defined by the coupling map of the device, are resolved by
inserting SWAP operations, a step known as routing. Additionally, two-qubit gates
between logical qubits that are physically unconnected, as
defined by the coupling map of the device, are resolved by
inserting SWAP operations, a step known as routing. This
process produces a backend-compatible circuit that is functionally equivalent to the source-level circuit but structurally
different.Where the paper says it
Where the paper says it
Circuit Representation and Feature Extraction
The study uses three complementary representations for each circuit: the graph branch uses a source-level directed acyclic graph (DAG) extracted from the original circuit before transpilation <ref:2609.12980#pg4> The accompanying global feature vector for the MLP branch contains 41 source-level features, including 36 features following Ma and Li (2026) and five SupermarQ metrics <ref:2609. p. 3 feature vector for the MLP branch contains 41 source-level
features. The source-level features include 36 features following Ma and Li (2026), together with five SupermarQ
metrics (Tomesh et al.Where the paper says it
Two-Branch Graph Regression Model
The GNN-based predictor follows a two-branch graph regression design similar to that of Ma and Li (2026), where the graph branch encodes the circuit DAG while the MLP branch encodes the global feature vector <ref:2609.12980#pg4> Their embeddings are concatenated and passed through fully connected layers to predict the noisy-simulator runtime <ref:2609. p. 3 The
graph branch encodes the circuit DAG, while the MLP
branch encodes the global feature vector. Their embeddings
are concatenated and passed through fully connected layers
to predict the noisy-simulator runtime.Where the paper says it
Evaluation Metrics
The evaluation uses two standard regression metrics: root mean squared error (RMSE) and the coefficient of determination (R2) to evaluate prediction performance <ref:2609.12980#pg6> RMSE measures prediction error in the same units as simulator runtime, with lower values indicating greater accuracy <ref:2609. p. 4 We evaluate prediction performance
using two standard regression metrics: root mean squared
error (RMSE) and the coefficient of determination (R2
). RMSE measures prediction error in the same units as simulator runtime, with lower values indicating greater accuracy. RMSE measures prediction error in the same units as simulator runtime, with lower values indicating greater accuracy. R2 measures the proportion of runtime variance explained
by the model, with higher values indicating a better fit.Where the paper says it
Where the paper says it
Experimental Results
Fig. 4 evaluates the three GNN representations across four optimization levels using R2 and RMSE on the overall model prediction setting <ref:2609. p. 4 Prediction Comparison Among Models. 4 evaluates
the three GNN representations across four optimization levels using R2
and RMSE on the overall model prediction setting. To
evaluate these predictors, we construct a circuit dataset that
consists of source-level and transpiled graphs for four transpilation optimization levels and two simulation backends
using Qiskit Aer simulator (Javadi-Abhari et al. In
the overall-model setting, the transpiled GNN provides the
strongest and most consistent results across all optimization
levels, outperforming both source and hybrid GNNs, as well
as ML models. This
shows that the original representation can still retain much of
the information needed for the prediction. The benefit of the
Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations, such as more intensive layout, routing, cancellation and resynthesis passes (IBM Quantum 2026).Where the paper says it
Where the paper says it
Where the paper says it
Fig. 5 compares the separately trained backend-specific models with the backend-stratified results of the overall model <ref:2609. p. 5 Backend-Specific Predictions Fig. 5 compares the separately trained backend-specific models (solid bars) with
the backend-stratified results of the overall model (hatched
bars). Washington shows a clear benefit from
backend-stratified results. Across optimization levels and
all three representations, the overall Transpiled GNN is the
best-performing model for both R2
and RMSE, outperforming the backend-specific GNNs and the best ML models. 25 s in all settings. Overall, Sherbrooke shows that backend-specific training
can improve prediction in selected settings, including for
the Transpiled GNN at some optimization levels, although
no representation consistently benefits from separate training across all settings.Where the paper says it
Where the paper says it
Where the paper says it
The benefit of additional optimization depends on circuit characteristics, as deeper and slower circuits are much more likely to benefit from additional optimization <ref:2609.12980#pg6> On Washington, the percentage of circuits benefiting from Opt 1 increases from 15. p. 5 It shows that the benefit of additional optimization depends on the circuit characteristics. For example, on
Washington, the percentage of circuits benefiting from Opt
1 increases from 15. For each characteristic, circuits are ranked
separately and divided into four approximately equal-sized
groups. Thus, for depth, group 1 contains the shallowest circuits, while group 4 contains the deepest; while for Opt 0
execution time, group 1 contains the fastest executions, and
group 4 the slowest. The remaining cases perform poorly, with fewer than half
of the circuits in group 4 benefiting from Opt 3. On Sherbrooke, there is almost no benefit, reaching only 5% for
the slowest circuits and 0% for the deepest.Where the paper says it
Where the paper says it
Where the paper says it
The Transpiled GNN achieves the strongest predictive performance among the GNN representations in most evaluated settings <ref:2609.12980#pg6> The Transpiled GNN processes graphs that are approximately 34.9× larger on average and requires about 7.4× more inference time than other representations <ref:2609.12980#pg6> However, its inference time is still in milliseconds, 2. p. 6 4×
more inference time than other representations. However,
its inference time is still in milliseconds, 2.Where the paper says it
The paper proposes two GNN circuit representations (hybrid and transpiled) and evaluates their prediction accuracy and overhead with a circuit dataset collected on two backends with four transpilation optimization levels <ref:2609.12980#pg5> The results demonstrate that the transpiled GNN generally provides the strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features <ref:2609.12980#pg5> However, conventional ML regression models using transpilation-aware circuit features remain competitive with or outperform GNNs in several settings <ref:2609. p. 6 Our results
demonstrate that the transpiled GNN generally provides the
strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features. However, conventional ML regression models using transpilation-aware circuit features
remain competitive with or outperform GNNs in several settings. However, conventional ML regression models using transpilation-aware circuit features
remain competitive with or outperform GNNs in several settings. These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors, but explicit graph modeling is not always necessary. These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors, but explicit graph modeling is not always necessary. Such predictors are essential for future quantum operating
systems and schedulers, where runtime estimates can guide
job placement and resource allocation.Where the paper says it
Where the paper says it
Where the paper says it
This work is supported in part by NSF Grant 2426940 and a high-performance computing system acquired through NSF MRI grant DMS-1337943 to WPI <ref:2609.12980#pg2> The paper's references include Bisicchia et al. 2025, Chen and Guestrin 2016, Dam et al. 2024, Giortamis et al. 2025a/b, Guerreschi and Hua et al. p. 0 Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. 2025a,b; Ravi et al. Runtime and resource estimates support job scheduling, resource allocation, and performance optimization in quantum operating systems and
schedulers (Giortamis et al. 2025a,b; Ravi et al.Where the paper says it
Where the paper says it
The references include Bisicchia et al. 2025, Chen and Guestrin 2016, Dam et al. 2024, Giortamis et al. 2025a/b, Guerreschi and Hua et al. 2019, Murali et al. 2019, Quetschlich and Muraili and Wille 2023a/b/c, Ravi et al. 2021a/b, Suchara et al. 2013, Tomesh et al. 2022, Tremba et al. 2025, Villar et al. 2019 and Ma and Li 2016 <ref:2609.12980#pg2> The references also include Smola and Scholkopf 2004, Wilkens 2023, Zhou and Feng and Li 2023 <ref:2609.12980#pg2> The references cover various aspects of quantum circuit analysis and simulation tools <ref:2609.12980#pg2>
The GNN-based predictor follows a two-branch graph regression design similar to that of Ma and Li (2026), where the graph branch encodes …
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Data-driven circuit representation selection can be automated by using a distribution-matching score to select train-test splits based on backend, circuit family, and execution-time distributions before model training. This ensures that
all source circuits in the test set are completely unseen during training.
-
The hybrid GNN representation can be used when the advantage of explicit graph modeling depends on the backend and optimization level, as it
retains the source-level circuit graph but augments the source-level feature vector with 13 post-transpilation global features.
-
For deeper and slower circuits, dynamic selection of transpilation optimization levels can be implemented by comparing optimization levels 1 to 3 against 0 for the same circuits and reporting
the percentage for which the higher optimization level produces a lower total runtime.
Abstract
Predicting the runtime of noisy quantum circuit simulations is important for scheduling, resource allocation, and performance optimization. However, accurate prediction is challenging because backend-aware transpilation can substantially alter the original circuit structure, while the backend-derived noise model and simulator execution behavior can introduce additional runtime variation. We study the effectiveness of graph neural networks (GNNs) and conventional regression methods in predicting Qiskit Aer simulation runtime measured after transpilation. We construct a dataset from a benchmark pool of 1,402 unique circuits spanning 22 circuit families, two Qiskit fake-backend configurations, and four transpiler optimization levels. Specifically, we compare a source GNN using original circuit information, hybrid GNN combining source-level graph with post-transpilation features, and transpiled GNN using only transpiled circuit information, along with five regression models. In the overall-model setting, the transpiled GNN achieves the strongest performance among the graph-based representations at all four optimization levels, obtaining R squared values of 0.974, 0.713, 0.745, and 0.605 for optimization levels 0 through 3, respectively. However, under backend-specific evaluation, the advantage of GNN decreases, with conventional regression models matching or outperforming the GNNs in several settings. These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level.
Related papers
- Computational regimes in matrix-product-state-based quantum trajectory simulations
- Toward chemically accurate quantum simulations on quantum hardware: A quantum-HPC hybrid approach
- Transversal surface-code game with reconfigurable qubits
- Fulqrum: a generalized framework for quantum subspace diagonalization
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements