Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

IEEE International Conference on Quantum Computing and Engineering (QCE)

A Heuristic Error Analysis Framework for Error Bottleneck Identification in Gate-Based Quantum Algorithms

Anika Zaman, Hiu Yung Wong

Published Sep 15, 2024• 1 citation
Publisher

Abstract

In this work, we present an automatic Python framework designed to perform heuristic error analysis of gate-based model algorithms running on a given quantum computer, to identify the source, the nature, and the bottleneck of errors. The information will allow quantum hardware-algorithm co-optimization. This is particularly useful for novel algorithms and hardware. By analyzing the relative contribution of the gate error, propagation error, bit-flip error, and measurement error at each node, one can then use the information to optimize the circuit in terms of the choice of gates and physical qubits. Since it is a model based on the probability of a state being measured, it cannot capture the crossterms and interference. However, it still can be used to deduce the node/stage that has a big error due to failure in interference. In this paper, the Harrow-Hassidim-Lloyd (HHL) quantum algorithm running on the IBM superconducting qubit platform is used as a demonstration of the framework. The bottleneck of the error in the HHL circuit is identified. It should also be noted that this framework can only be used for small problems because simulation is required on a classical computer.

DOI
10.1109/qce60285.2024.10367

Related papers

A Simulation Framework to Understand the Error Generation and Propagation of Quantum Algorithms

Anika Zaman

In this work, we present a Python framework designed to demonstrate various error types within quantum circuits through the utilization of probabilistic data obtained from quantum computers. The framework serves as a valuable tool for monitoring and mitigating errors across all stages of quantum circuits involving multiple qubits and gates. Leveraging the Harrow-Hassidim-Lloyd (HHL) quantum circuit, we conduct an analysis of errors on an IBM quantum computer and subsequently optimize the circuit. The paper introduces an automated methodology for computing single bit-flip errors and propagation errors, and gate errors offering insights into opportunities for mitigating errors in the context of the HHL quantum circuit.

•Aug 9, 2024•0 citations

Hybrid Quantum–Classical Framework for Quantum Complexity

Kiran Siripuri, Shashank Thota, Prasanna Mandala

This paper examines quantum algorithms and their computational complexity through a unified framework combining mathematical modeling, system architecture, and empirical evaluation. Key complexity measures circuit depth, gate count, and query complexity are analyzed under NISQ constraints. A hybrid quantum classical optimization framework is introduced to improve efficiency and stability. Results show the full model achieves 94.2% accuracy with baseline runtime, while removing optimization lowers accuracy to 85.6% and increases runtime by 30%. Reducing qubits decreases cost but drops accuracy to 78.3%, and disabling error mitigation causes unstable performance at 70.1%. Comparative analysis indicates strong advantages of quantum algorithms for structured problems, especially in scalability and asymptotic complexity. However, performance remains sensitive to noise, limited qubits, and circuit depth, emphasizing the need for hardware–algorithm co-design.

International Conference on Inventive Computation and Information Technologies (ICICIT)•Jul 1, 2026•0 citations

Study of Error Propagation and Generation in Harrow-Hassidim-Lloyd (HHL) Quantum Algorithm

Anika Zaman, Hiu Yung Wong

In this paper, we study the error propagation and generation in the Harrow-Hassidim-Lloyd (HHL) quantum algorithm runs on IBM-Q hardware with the help of a MATLAB simulator. HHL is a quantum algorithm that can provide exponential speedup over the fastest classical algorithm (conjugate gradient method) in solving systems of linear equations (SLE). However, without error correction, it cannot give correct results even in a 2-variable system due to its complexity. In this study, an HHL quantum circuit for a 2-variable SLE is implemented in IBM-Q and the error is extracted after each stage of the circuit and compared to a MATLAB simulator. We identified three major sources of errors, namely single-qubit flipping, gate infidelity, and error propagation. We also found that at the ancillary bit rotation stage, the error becomes large but the encoded solution still has high fidelity. However, the solution is mostly lost after the inverse quantum phase estimation which is necessary to extract the solution efficiently. Therefore, it is suggested that error correction resources, if limited, should be added to the second half of the circuit.

IEEE Latin American Electron Devices Conference (LAEDC)•Jul 4, 2022•16 citations

Characterizing Physical Error Contributions of Quantum Gates

Miha Papič, Adrian Auer, Inés de Vega

Large-scale quantum computation requires a reliable assessment of the main sources of error in the implemented quantum gates. To this aim, we provide a learning-based framework that extracts the contribution of each physical error source to the infidelity of a series of gates, together with an uncertainty estimate for every contribution. Crucially, the uncertainties provided by the underlying Gaussian Process Regression serve as a diagnostic of the assumed noise model itself: if the physical model does not fully explain the experimental observations, the framework signals this instead of returning a falsely precise error budget. We demonstrate the proposed budget learning procedure on a pair of qubits in a transmon array architecture, where we compute the error budgets of the native single- and two-qubit gates. For this purpose, we have also developed an advanced noise model based on the first-principles understanding of the error processes in current superconducting processors, including complex (e.g. non-Markovian) error sources. While the single-qubit budgets are reconstructed with high confidence, the same diagnostic reveals that even this detailed noise model does not fully capture the error dynamics of a state-of-the-art two-qubit gate --- quantitative evidence that uncertainty-aware error budgeting is necessary for the characterization of current quantum hardware.

arXiv:2305.08916•May 15, 2023•24 citations

Towards automatic evaluation of circuit fault-tolerance

Ayman Mondol

Quantum error correction codes are essential for fault-tolerant quantum computing. They are a method of detecting and correcting errors in a quantum computer by encoding logical qubits across multiple physical qubits. Several prominent error correction codes have been developed and larger and more complex codes are being developed continuously. However, evaluating the fault-tolerance of these larger codes is becoming exponentially more complicated. While conventional methods of proving and evaluating the fault-tolerance of these circuits have worked thus far, they are soon to be obsolete. The aim of this thesis is to develop a framework that automatically evaluates the fault-tolerance of a quantum error correction circuit across different hardware architectures. The framework works as follows: it takes a noiseless quantum error correction code; injects hardware-realistic noise into it; and evaluates the fault-tolerance of the resulting noisy circuit by estimating its logical error rate through Monte Carlo sampling. For the injection of hardware-realistic noise, this thesis considers noise stemming from five different quantum computing hardware architectures: superconducting qubits, neutral atoms, trapped ions, photonic qubits, and spin qubits. The noise model was constructed by extracting single-qubit gate, two-qubit gate and measurement error fidelities from current experimental literature. The noise model and circuit generation is implemented in Python, circuit representation and noise injection is executed in Stim and decoding and estimating the logical error rate is achieved through PyMatching. The framework is evaluated on the repetition code, the surface code, and the color code; the logical error rate is estimated across all five hardware architectures under the noise model; and the results are discussed in the context of hardware compatibility for the given codes.

•May 9, 2026•0 citations

Two variations of quantum phase estimation for reducing circuit error rates: Application to the Harrow-Hassidim-Lloyd algorithm

Yonghae Lee, Minjin Choi, Youngho Min +2 more

We introduce two variations of the quantum phase estimation algorithm: quantum shifted phase estimation and quantum punctured phase estimation. The shifted method employs a bit-string left shift to discard the most significant bit and focus on lower-order phase components, and the punctured method removes qubits corresponding to known phase bits, thereby streamlining the circuit. To demonstrate the effectiveness of the two variations, we integrate them into a hybrid quantum-classical implementation of the Harrow--Hassidim--Lloyd algorithm for solving linear systems. The hybrid method leverages both quantum and classical processors to identify and remove unnecessary qubits and gates. As a result, for small-scale linear systems, our method reduces qubit and gate counts relative to previous implementations, yielding lower overall circuit error rates on current hardware. Experimental demonstrations on IBM superconducting hardware confirm the error-mitigation effectiveness on small problem instances.

arXiv:2507.06711•Physical Review A•Nov 19, 2025•3 citations
In this work, we present an automatic Python framework designed to perform heuristic error analysis of gate-based model algorithms running on a given quantum computer, to identify the source, the nature, and the bottleneck of errors. The information will allow quantum hardware-algorithm co-optimization. This is particularly useful for novel algorithms and hardware. By analyzing the relative contribution of the gate error, propagation error, bit-flip error, and measurement error at each node, one can then use the information to optimize the circuit in terms of the choice of gates and physical qubits. Since it is a model based on the probability of a state being measured, it cannot capture the crossterms and interference. However, it still can be used to deduce the node/stage that has a big error due to failure in interference. In this paper, the Harrow-Hassidim-Lloyd (HHL) quantum algorithm running on the IBM superconducting qubit platform is used as a demonstration of the framework. The bottleneck of the error in the HHL circuit is identified. It should also be noted that this framework can only be used for small problems because simulation is required on a classical computer.
In this work, we present a Python framework designed to demonstrate various error types within quantum circuits through the utilization of probabilistic data obtained from quantum computers. The framework serves as a valuable tool for monitoring and mitigating errors across all stages of quantum circuits involving multiple qubits and gates. Leveraging the Harrow-Hassidim-Lloyd (HHL) quantum circuit, we conduct an analysis of errors on an IBM quantum computer and subsequently optimize the circuit. The paper introduces an automated methodology for computing single bit-flip errors and propagation errors, and gate errors offering insights into opportunities for mitigating errors in the context of the HHL quantum circuit.
This paper examines quantum algorithms and their computational complexity through a unified framework combining mathematical modeling, system architecture, and empirical evaluation. Key complexity measures circuit depth, gate count, and query complexity are analyzed under NISQ constraints. A hybrid quantum classical optimization framework is introduced to improve efficiency and stability. Results show the full model achieves 94.2% accuracy with baseline runtime, while removing optimization lowers accuracy to 85.6% and increases runtime by 30%. Reducing qubits decreases cost but drops accuracy to 78.3%, and disabling error mitigation causes unstable performance at 70.1%. Comparative analysis indicates strong advantages of quantum algorithms for structured problems, especially in scalability and asymptotic complexity. However, performance remains sensitive to noise, limited qubits, and circuit depth, emphasizing the need for hardware–algorithm co-design.
In this paper, we study the error propagation and generation in the Harrow-Hassidim-Lloyd (HHL) quantum algorithm runs on IBM-Q hardware with the help of a MATLAB simulator. HHL is a quantum algorithm that can provide exponential speedup over the fastest classical algorithm (conjugate gradient method) in solving systems of linear equations (SLE). However, without error correction, it cannot give correct results even in a 2-variable system due to its complexity. In this study, an HHL quantum circuit for a 2-variable SLE is implemented in IBM-Q and the error is extracted after each stage of the circuit and compared to a MATLAB simulator. We identified three major sources of errors, namely single-qubit flipping, gate infidelity, and error propagation. We also found that at the ancillary bit rotation stage, the error becomes large but the encoded solution still has high fidelity. However, the solution is mostly lost after the inverse quantum phase estimation which is necessary to extract the solution efficiently. Therefore, it is suggested that error correction resources, if limited, should be added to the second half of the circuit.
Large-scale quantum computation requires a reliable assessment of the main sources of error in the implemented quantum gates. To this aim, we provide a learning-based framework that extracts the contribution of each physical error source to the infidelity of a series of gates, together with an uncertainty estimate for every contribution. Crucially, the uncertainties provided by the underlying Gaussian Process Regression serve as a diagnostic of the assumed noise model itself: if the physical model does not fully explain the experimental observations, the framework signals this instead of returning a falsely precise error budget. We demonstrate the proposed budget learning procedure on a pair of qubits in a transmon array architecture, where we compute the error budgets of the native single- and two-qubit gates. For this purpose, we have also developed an advanced noise model based on the first-principles understanding of the error processes in current superconducting processors, including complex (e.g. non-Markovian) error sources. While the single-qubit budgets are reconstructed with high confidence, the same diagnostic reveals that even this detailed noise model does not fully capture the error dynamics of a state-of-the-art two-qubit gate --- quantitative evidence that uncertainty-aware error budgeting is necessary for the characterization of current quantum hardware.
Quantum error correction codes are essential for fault-tolerant quantum computing. They are a method of detecting and correcting errors in a quantum computer by encoding logical qubits across multiple physical qubits. Several prominent error correction codes have been developed and larger and more complex codes are being developed continuously. However, evaluating the fault-tolerance of these larger codes is becoming exponentially more complicated. While conventional methods of proving and evaluating the fault-tolerance of these circuits have worked thus far, they are soon to be obsolete. The aim of this thesis is to develop a framework that automatically evaluates the fault-tolerance of a quantum error correction circuit across different hardware architectures. The framework works as follows: it takes a noiseless quantum error correction code; injects hardware-realistic noise into it; and evaluates the fault-tolerance of the resulting noisy circuit by estimating its logical error rate through Monte Carlo sampling. For the injection of hardware-realistic noise, this thesis considers noise stemming from five different quantum computing hardware architectures: superconducting qubits, neutral atoms, trapped ions, photonic qubits, and spin qubits. The noise model was constructed by extracting single-qubit gate, two-qubit gate and measurement error fidelities from current experimental literature. The noise model and circuit generation is implemented in Python, circuit representation and noise injection is executed in Stim and decoding and estimating the logical error rate is achieved through PyMatching. The framework is evaluated on the repetition code, the surface code, and the color code; the logical error rate is estimated across all five hardware architectures under the noise model; and the results are discussed in the context of hardware compatibility for the given codes.
We introduce two variations of the quantum phase estimation algorithm: quantum shifted phase estimation and quantum punctured phase estimation. The shifted method employs a bit-string left shift to discard the most significant bit and focus on lower-order phase components, and the punctured method removes qubits corresponding to known phase bits, thereby streamlining the circuit. To demonstrate the effectiveness of the two variations, we integrate them into a hybrid quantum-classical implementation of the Harrow--Hassidim--Lloyd algorithm for solving linear systems. The hybrid method leverages both quantum and classical processors to identify and remove unnecessary qubits and gates. As a result, for small-scale linear systems, our method reduces qubit and gate counts relative to previous implementations, yielding lower overall circuit error rates on current hardware. Experimental demonstrations on IBM superconducting hardware confirm the error-mitigation effectiveness on small problem instances.