Despite significant progress in quantum computing in recent years, executing quantum circuits for practical problems remains challenging due to error-prone quantum hardware. Hence, quantum error correction becomes essential but induces significant overheads in qubits and execution time, often by orders of magnitude. Obviously, these overheads must be reduced. Since many quantum applications can tolerate some noise, end users can provide a maximum tolerated error, the error budget, to be considered during compilation and execution. This error budget, or, more precisely, its distribution, can be a key factor in achieving the overhead reduction. Conceptually, an errorcorrected quantum circuit can be divided into different parts that each have a specific purpose. Errors can happen in any of these parts and their errors sum up to the mentioned error budget-but how to distribute it among them actually constitutes a degree of freedom. This work is based on the idea that some of the circuit parts can compensate for errors more efficiently than others. Consequently, these parts should contribute more to satisfy the total error budget than the parts where it is more costly. However, this poses the challenge of finding optimal distributions. We address this challenge not only by providing general guidelines on distributing the error budget, but also a method that automatically determines resource-efficient distributions for arbitrary circuits by training a machine learning model on an accumulated dataset. The approach is evaluated by analyzing the machine learning model's predictions on so far unseen data, reducing the estimated space-time costs for more than 75% of the considered quantum circuits, with an average reduction of$\mathbf{1 5. 6 \%}$, including cases without improvement, and a maximum reduction of$\mathbf{7 7. 7 \%}$.
Despite significant progress in quantum computing in recent years, executing quantum circuits for practical problems remains challenging due to error-prone quantum hardware. Hence, quantum error correction becomes essential but induces significant overheads in qubits and execution time, often by orders of magnitude. Obviously, these overheads must be reduced. Since many quantum applications can tolerate some noise, end users can provide a maximum tolerated error, the error budget, to be considered during compilation and execution. This error budget, or, more precisely, its distribution, can be a key factor in achieving the overhead reduction. Conceptually, an errorcorrected quantum circuit can be divided into different parts that each have a specific purpose. Errors can happen in any of these parts and their errors sum up to the mentioned error budget-but how to distribute it among them actually constitutes a degree of freedom. This work is based on the idea that some of the circuit parts can compensate for errors more efficiently than others. Consequently, these parts should contribute more to satisfy the total error budget than the parts where it is more costly. However, this poses the challenge of finding optimal distributions. We address this challenge not only by providing general guidelines on distributing the error budget, but also a method that automatically determines resource-efficient distributions for arbitrary circuits by training a machine learning model on an accumulated dataset. The approach is evaluated by analyzing the machine learning model's predictions on so far unseen data, reducing the estimated space-time costs for more than 75% of the considered quantum circuits, with an average reduction of15.6%, including cases without improvement, and a maximum reduction of77.7%.
System-level resource estimation is a key component of fault-tolerant quantum computing (FTQC) toolchains. Its efficiency depends on how global error tolerance is allocated across logical operations, T-state distillation, and rotation synthesis to minimize physical resource overhead. The commonly used uniform-allocation strategy ignores circuit-specific structure and can overprovision inactive or less critical subsystems, leading to inflated space-time estimates. Prior work aims to address this limitation using supervised models trained on offline-generated datasets. However, this approach incurs additional data-generation costs and limits deployment flexibility. To overcome these drawbacks, we propose a training-free optimization framework that performs derivative-free search directly on the Azure Quantum Resource Estimator (AQRE), enabling instance-specific error budget allocation for previously unseen circuits without requiring offline training data. To evaluate robustness to optimizer choice, we instantiate the framework with two structurally distinct metaheuristics, simulated annealing and quantum particle swarm optimization. We evaluate our framework across 433 circuits spanning 2 to 91 qubits from 31 families in the MQT Bench suite. Across the benchmark suite, both methods reduce space-time cost by more than 33\% on average and agree within 1.34\% points, indicating that the gains are stable across different metaheuristic search strategies. Our analysis further finds that the optimization benefit is driven primarily by error-profile asymmetry rather than circuit scale, and the metric, Gini coefficient of optimized allocation, provides an interpretable diagnostic of expected improvement. Together, these results position adaptive error budget allocation as a system-software optimization layer for FTQC resource estimation pipeline.
Quantum computing has made significant advancements in the last years in both hardware and software. Unfortunately, the currently available Noisy Intermediate-Scale Quantum (NISQ) hardware is still heavily affected by noise. Many optimization techniques have been developed to reduce the negative effects thereof, which, however, only works up to a certain point. Therefore, scaling quantum applications from currently considered small research examples to industrial applications requires error-correction techniques to execute quantum circuits in a fault-tolerant fashion and enter the Fault-Tolerant Quantum Computing (FTQC) era. These error-correction techniques introduce dramatic qubit overheads, leading to the requirement of tens of thousands of qubits already for toy-sized examples. Hence, quantum circuit optimization that reduces qubit overheads when shifting from the NISQ to the FTQC era is essential. This raises the question, whether we need to start from scratch, or whether current state-of-the-art optimization techniques can be used as a basis for this. To approach this question, this work investigates the effects of different optimization passes on a representative selection of quantum circuits. Since hardly any tools to automatically design and evaluate FTQC quantum circuits exist yet, we utilize resource estimation to compare the (potential) benefits gained by applying NISQ quantum circuit optimization to estimated FTQC resource requirements. The Results indicate that, indeed, the estimated resource requirements for FTQC can be improved by applying NISQ quantum circuit optimization techniques. At the same time, more detailed investigations show what techniques lead to more benefits for FTQC compared to others, providing guidelines for the transfer of NISQ optimization techniques to the FTQC era.
Hybridizing machine learning (ML) with quantum computing has become an attractive strategy to increase computational power on Noisy Intermediate Scale Quantum (NISQ) devices. Although these can be potentially quantum advantage devices, their qubit numbers and noise are bounded and there are challenges when it comes to practical quantum circuit realization. This work concentrates on the creation of optimized quantum circuits via ML-based strategies, to enhance the performance of the circuits, to reduce the error rate and to accommodate the particular noise profile of the hardware of NISQ devices. The resulting suboptimal mappings with little or no consideration of noise and hardware topology in traditional quantum compilers can ruin the fidelity of quantum algorithm. Leveraging machine learning, and specifically reinforcement and supervised learning methods, our method learns to optimize compilation strategy for specific quantum hardware architecture. The paper proposes a framework that uses machine learning models to predict qubit mappings, gate decompositions, and transpilation paths that minimize gate depth and error accumulation. We also investigate transfer learning methods for propagating the learned compilation strategies to novel NISQ machines. Such methods are empirically validated on both simulated and real quantum hardware backends, providing evidence of circuit depth, execution time and error reductions. The results show that ML-assisted compilation can achieve better success probabilities for benchmark quantum algorithms like VQE and QAOA than conventional compilers. Furthermore, the work examines the interpretability of ML models providing hardware-aware optimization recommendations and understanding the noise patterns and methods of error correction. Our work highlights the key role of ML for transferring between theoretical quantum algorithms and their practical NISQ implementations. This integration boosts the immediate applicability of existing quantum devices and provides a basis for adaptive and scalable likelihood-based compilation for the era of fault-tolerant quantum computation. Our results motivate further investigation of hybrid classical-quantum workflows, in which ML iteratively improves compilation in accordance with changing hardware noise and capabilities. By improving quantum circuit compilation onNISQ computers, this work is taking steps toward the realization of quantum advantage in application scenarios such as optimization, cryptography, and quantum simulation without needing to wait for fully fault-tolerant large-scale quantum computers.
Any potential application of quantum computing, once encoded as a quantum circuit, needs to be compiled in order to be executed on a quantum computer. Deciding which qubit technology, which device, which compiler, and which corresponding settings are best for the considered problem—according to a measure of goodness—requires expert knowledge and is overwhelming for end-users from different domains trying to use quantum computing to their advantage. In this work, we treat the problem as a statistical classification task and explore the utilization of supervised machine learning techniques to optimize the compilation of quantum circuits. Based on that, we propose a framework that, given a quantum circuit, predicts the best combination of these options and, therefore, automatically makes these decisions for end-users. Experimental evaluations show that, considering a prototypical setting with 3000 quantum circuits, the proposed framework yields promising results: for more than three quarters of all unseen test circuits, the best combination of compilation options is determined. Moreover, for more than 95% of the circuits, a combination of compilation options within the top-three is determined—while the median compilation time is reduced by more than one order of magnitude. Furthermore, the resulting methodology not only provides end-users with a prediction of the best compilation options, but also provides means to extract explicit knowledge from the machine learning technique. This knowledge helps in two ways: it lays the foundation for further applications of machine learning in this domain and, also, allows one to quickly verify whether a machine learning algorithm is reasonably trained. The corresponding framework and the pre-trained classifier are publicly available on GitHub (https://github.com/cda-tum/MQTPredictor) as part of the Munich Quantum Toolkit (MQT).
Abstract Errors in the current generation of quantum processors pose a significant challenge towards practical-scale implementations of quantum machine learning (QML) as they lead to trainability issues arising from noise-induced barren plateaus, as well as performance degradations due to the noise accumulation in deep circuits even when QML models are free from barren plateaus. Quantum error correction (QEC) protocols are being developed to overcome hardware noise, but their extremely high spacetime overheads, mainly due to magic state distillation, make them infeasible for near-term practical implementation. This work proposes the idea of partial QEC for QML models and identifies a sweet spot where distillations are omitted to significantly reduce overhead. By assuming error-corrected two-qubit Controlled- Z s (Clifford operations), we demonstrate that the QML models remain trainable even when single-qubit gates are subjected to ≈ 0.2 % depolarizing noise, corresponding to a gate error rate of ≈ 0.13 % under randomized benchmarking. Further analysis based on various noise models, such as phase-damping and thermal-dissipation channels at low temperature, indicates that the QML models are trainable independent of the mean angle of over-rotation, or can even be improved by thermal damping that purifies a quantum state away from depolarizations. While it may take several years to build quantum processors capable of fully fault-tolerant QML, our work proposes a resource-efficient solution for trainable and high-accuracy QML implementations in noisy environments.
Quantum computation has the promise to solve problems that are not efficiently solvable by classical means. Yet, due to the fragile nature of quantum states, it is unavoidable that quantum systems are subject to decoherence, gate imperfections, and measurement errors. These problems stand as a major roadblock to the construction of large-scale fault-tolerant quantum computers. Conventional quantum error correction (QEC) codes, such as the surface code or Shor code, need to use an extensive amount of redundancy and classical control, which can be both computationally expensive and challenging to scale. In this context, we propose to investigate the use of machine learning (ML) techniques by realizing on-line identification, localization and correction of these quantum errors for fault-tolerant quantum computation by means of fault-tolerant quantum computing processes. Our model introduces a hybrids ML-QEC architecture that combines classical neural networks and decision-tree classifiers with quantum syndrome decoding. These models are trained on error syndromes produced using the approximation of common noise models (for example, depolarizing noise, dephasing and amplitude damping), simulated under different QEC schemes. The machine learning methods are trained with quantum error patterns and have a capability to rapidly infer where errors are likely to occur, as well as recommend correction operations with high confidence. As a result, the system reduces dramatically the delay and computational costs when compared to conventional decoding methods. There is also a self-adaptive learning module in the work, which recommences training on fresh quantum error distributions, meaning the system can adapt to changes in the environment (and also the decay of the hardware) as time progresses. The study further carries out ML predictions inside a real-time loop and cross-checks them with quantum state tomography and entanglement fidelity such as indicators. Experimental characterization on dedicated devices as well as noise models show that our ML-enhanced decoders reach higher fidelity and lower logical error rates compared to baseline decoders, especially in non-uniform or time-dependent noise. This work is a significant stride towards realizing practical fault-tolerant quantum computation by combining quantum error correction with the versatility and scalability of machine learning. With intelligent models to dictate learning, our proposed framework is able to eliminate a lot of trial-and-error manual processes in the conventional heuristic-based approach, and points to a potential path to achieve scalable quantum information processing platforms.