Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation

arXiv:2609.12980 · quant-ph, cs.PF · Submitted 2026-09-11 · Read on arXiv

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

Where the paper says it

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.

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. p. 1
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

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. p. 2

Where the paper says it

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.

12980#pg5> The transpiled setting builds both its graph and global feature vector entirely from the backend-specific transpiled circuit <ref:2609. p. 3
Where the paper says it

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.

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. p. 4

Where the paper says it

Evaluation Metrics. We evaluate prediction performance using two standard regression metrics: root mean squared error (RMSE) and the coefficient of determination (R2 ).

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. p. 4
Where the paper says it

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.

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. p. 4

Where the paper says it

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).

12980#pg6> However, R2 generally decreases as the optimization level increases because the Opt 3 dataset has a much tighter runtime distribution <ref:2609. p. 5
Where the paper says it

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.

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. p. 5

Where the paper says it

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.

12980#pg6> This suggests that separate training is not necessary for Washington <ref:2609. p. 5
Where the paper says it

9, indicating the importance of optimization in prediction. Overall, these results suggest that separate training is not necessary for Washington.

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. p. 5

Where the paper says it

For example, on Washington, the percentage of circuits benefiting from Opt 1 increases from 15. 7% between fastest and slowest circuits.

12980#pg6> Conversely, on Sherbrooke, there is almost no benefit for the slowest circuits with Opt 3 <ref:2609. p. 5
Where the paper says it

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.

12980#pg6> This suggests that additional transpilation overhead of Opt 3 generally outweighs its execution time savings <ref:2609. p. 5
Where the paper says it

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.

p. 5
Where the paper says it

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.

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. p. 6

Where the paper says it

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.

p. 6
Where the paper says it

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.

9× larger on average and requires about 7. p. 6
Where the paper says it

The Transpiled GNN processes graphs that are approximately 34. 9× larger on average and requires about 7.

p. 6
Where the paper says it

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. p. 6
Where the paper says it

9× larger on average and requires about 7. 4× more inference time than other representations.

p. 6
Where the paper says it

9× larger on average and requires about 7. 4× more inference time than other representations.

12980#pg6> Despite the increased graph cost, its inference time is still in milliseconds, 2. p. 6
Where the paper says it

4× more inference time than other representations. However, its inference time is still in milliseconds, 2.

35 ms per circuit, while achieving the highest mean R2 <ref:2609. p. 6
Where the paper says it

However, its inference time is still in milliseconds, 2. 35 ms per circuit, while achieving the highest mean R2 .

p. 6
Where the paper says it

However, its inference time is still in milliseconds, 2. 35 ms per circuit, while achieving the highest mean R2 .

12980#pg6> The Transpiled GNN's advantage is due to the post-transpilation representation rather than differences in dataset composition <ref:2609.12980#pg6>

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

Where the paper says it

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.

p. 6
Where the paper says it

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.

12980#pg6> However, conventional ML regression models using transpilation-aware circuit features remain competitive with or outperform GNNs in several settings <ref:2609. p. 6
Where the paper says it

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.

12980#pg6> These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors <ref:2609. p. 6
Where the paper says it

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.

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. p. 6
Where the paper says it

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.

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. 2025, Chen and Guestrin 2016, Dam et al. p. 4

Where the paper says it

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)).

p. 4
Where the paper says it

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)).

p. 4
Where the paper says it

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)).

p. 4
Where the paper says it

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)).

2024, and Ma and Li 2026 The paper also cites Quetschlich et al. p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. p. 0

Where the paper says it

2022), resource estimation (Suchara et al. p. 0

Where the paper says it

Prior work has examined quantum circuit performance through benchmarking (Quetschlich, Burgholzer, and Wille 2023a; Tomesh et al. p. 0

Where the paper says it

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.

2022), resource estimation (Suchara et al.

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al.

2019; Quetschlich, Burgholzer, and Wille 2025).

2023a, Quetschlich et al. p. 0
Where the paper says it

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.

2023b, and IBM Quantum 2016 <ref:2609. p. 2
Where the paper says it

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).

12980#pg2> The references cover various aspects of quantum circuit analysis and simulation tools <ref:2609. p. 2
Where the paper says it

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.

p. 2
Where the paper says it

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.

p. 2
Where the paper says it

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.

p. 2
Where the paper says it

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.

12980#pg2>

References

The references include Bisicchia et al. 2025, Chen and Guestrin 2016, Dam et al. 2024, Giortamis et al. p. 0

Where the paper says it

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.

p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

2025a, Giortamis et al. p. 0
Where the paper says it

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.

2025b, Guerreschi and Hua et al. p. 1
Where the paper says it

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.

2019, Murali et al. p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

2019, Quetschlich and Muraili and Wille 2023a/b/c, Ravi et al. p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

2021a/b, Suchara et al. p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

2013, Tomesh et al. p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

2022, Tremba et al. p. 1
Where the paper says it

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.

p. 1
Where the paper says it

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.

p. 1
Where the paper says it

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.

2025, Villar et al. p. 2
Where the paper says it

More recently, Villar et al. (2025) applied reinforcement learning to permutation-circuit synthesis across different hardware topologies, demonstrating generalization to previously unseen topologies.

p. 2
Where the paper says it

More recently, Villar et al. (2025) applied reinforcement learning to permutation-circuit synthesis across different hardware topologies, demonstrating generalization to previously unseen topologies.

p. 2
Where the paper says it

More recently, Villar et al. (2025) applied reinforcement learning to permutation-circuit synthesis across different hardware topologies, demonstrating generalization to previously unseen topologies.

2019 and Ma and Li 2016 <ref:2609. p. 0
Where the paper says it

Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and backend settings. arXiv:2609.

p. 0
Where the paper says it

Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and backend settings. arXiv:2609.

p. 0
Where the paper says it

Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and backend settings. arXiv:2609.

12980#pg2> The references also include Smola and Scholkopf 2004, Wilkens 2023, Zhou and Feng and Li 2023 <ref:2609. p. 4
Where the paper says it

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)).

p. 4
Where the paper says it

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)).

p. 4
Where the paper says it

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)).

12980#pg2> The references cover various aspects of quantum circuit analysis and simulation tools <ref:2609.12980#pg2>

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

Where the paper says it

(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.

12980#pg3> Vallero et al. p. 2
Where the paper says it

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.

2026 show that circuit structure can considerably affect the relative performance of some simulators, and circuit-level analysis can help choose the right simulation <ref:2609. p. 2
Where the paper says it

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.

12980#pg3>

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

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.

12980#pg3> This is formulated as a supervised regression problem where each training example consists of a circuit and its measured simulator runtime <ref:2609. p. 2
Where the paper says it

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.

12980#pg3>

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

Where the paper says it

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.

12980#pg4> This work provides a standardized foundation for evaluating Quantum Software Engineering (QSE) tools <ref:2609. p. 2
Where the paper says it

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.

12980#pg4>

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

Where the paper says it

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.

12980#pg5> Original features Backend-aware transpilation Transpiled features Figure 1 illustrates the transpilation process at a high level <ref:2609. p. 1
Where the paper says it

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.

12980#pg5>

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

Where the paper says it

2022), resource estimation (Suchara et al. 2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al.

2024), and backend-aware compilation (Murali et al. 2019; Quetschlich et al. p. 0
Where the paper says it

2013; Dam, Mykhailova, and Soeken 2024), and backend-aware compilation (Murali et al. 2019; Quetschlich, Burgholzer, and Wille 2025).

2019) <ref:2609. p. 0
Where the paper says it

Therefore, it remains unclear how much transpilationaware information improves noisy-simulator runtime prediction across different transpiler optimization levels and backend settings. arXiv:2609.

12980#pg6> Most closely related, Ma and Li (2026) propose a graph-transformer model for execution-time prediction on simulators and real hardware <ref:2609. p. 0
Where the paper says it

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.

12980#pg6> Their approach primarily uses source-level, pretranspilation circuit representations and does not explicitly examine either the predictive value of backend-specific features extracted after transpilation or the transpiled circuit graph itself <ref:2609. p. 0
Where the paper says it

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.

12980#pg6>

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

Where the paper says it

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.

12980#pg5> Compilation latency can itself be a substantial component of end-to-end processing time <ref:2609. p. 1
Where the paper says it

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.

12980#pg5>

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

Where the paper says it

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.

12980#pg5> This process produces a backend-compatible circuit that is functionally equivalent to the source-level circuit but structurally different <ref:2609. p. 1
Where the paper says it

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.

12980#pg5>

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

Where the paper says it

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.

12980#pg4>

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

Where the paper says it

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.

12980#pg4>

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

Where the paper says it

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.

12980#pg6> R2 measures the proportion of runtime variance explained by the model, with higher values indicating a better fit <ref:2609. p. 4
Where the paper says it

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.

12980#pg6>

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

Where the paper says it

Prediction Comparison Among Models. 4 evaluates the three GNN representations across four optimization levels using R2 and RMSE on the overall model prediction setting.

12980#pg5> 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. p. 1
Where the paper says it

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.

12980#pg5> The benefit of the Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations <ref:2609. p. 4
Where the paper says it

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).

12980#pg5>

Fig. 5 compares the separately trained backend-specific models with the backend-stratified results of the overall model <ref:2609. p. 5

Where the paper says it

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).

12980#pg6> Washington shows a clear benefit from backend-stratified results across optimization levels and all three representations, outperforming the backend-specific GNNs and the best ML models <ref:2609. p. 5
Where the paper says it

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.

12980#pg6> Sherbrooke shows that backend-specific training can improve prediction in selected settings, including for the Transpiled GNN at some optimization levels <ref:2609. p. 5
Where the paper says it

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.

12980#pg6>

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

Where the paper says it

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.

2% to 95.7% between fastest and slowest circuits <ref:2609. p. 5
Where the paper says it

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.

12980#pg6> On Sherbrooke, there is almost no benefit for the slowest circuits with Opt 3 <ref:2609. p. 5
Where the paper says it

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.

12980#pg6> This suggests that additional transpilation overhead of Opt 3 generally outweighs its execution time savings <ref:2609.12980#pg6>

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

Where the paper says it

4× more inference time than other representations. However, 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#pg5> However, conventional ML regression models using transpilation-aware circuit features remain competitive with or outperform GNNs in several settings <ref:2609. p. 6

Where the paper says it

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.

12980#pg5> These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors <ref:2609. p. 6
Where the paper says it

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.

12980#pg5> Such predictors are essential for future quantum operating systems and schedulers, where runtime estimates can guide job placement and resource allocation <ref:2609. p. 6
Where the paper says it

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.

12980#pg5>

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

Where the paper says it

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.

p. 0
Where the paper says it

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.

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 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

  1. 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.

  2. 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.

  3. 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