Pith. sign in

REVIEW 4 major objections 4 minor 75 references

An experience-based classification of quantum bugs in quantum software

T0 review · 4 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Many quantum bugs are compound failures at the intersection of several bug classes, and no single debugging strategy wins per class.

desk verdict A useful, candid experience report; the compound-bug claim is real but overstated because the category scheme conflates root cause with detection context. read the letter →

arxiv 2509.03280 v1 pith:7QDYOC6U submitted 2025-09-03 quant-ph cs.SE

Nils Quetschlich , Olivia Di Matteo This is my paper · ORCID
classification quant-phcs.SE
keywords quantumcomputingsoftwaredebuggingbugsbugclassificationcompoundengineering
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that many bugs in quantum programs are compound: they arise only when several independent parts of an algorithm or workflow go wrong at once. Drawing on 14 real bugs, mostly from the authors' own implementation work and supplemented by open-source issue reports, it proposes a six-category classification of quantum bugs (initialization, algorithm, measurement, transpilation, framework plumbing, and general quantum-related) and emphasizes that most bugs sit at the intersection of several categories. The paper also reports the unexpected finding that no debugging strategy is reliably best for a given bug class, with equivalence checking and visual inspection emerging as the most broadly useful. This matters because current debugging guidance and tools assume single-class, single-cause failures, and the compound nature of quantum bugs explains why quantum debugging consumes disproportionate developer time.

What carries the argument

The central object is the six-category classification scheme (INIT, ALG, MEAS, TRNS, PLUMB, GEN) together with the explicit claim that these categories are not disjoint: the scheme's distinguishing feature is the Venn-diagram view where each bug is placed at the intersection of every category it touches. This machinery does the work of converting a handful of anecdotes into a structural claim—that most quantum bugs require more than one thing to go wrong—and it directly motivates the paper's debugging flowchart, which branches on whether transpilation is involved and then on method availability rather than on bug class.

What would settle it

Collect a larger sample of quantum bugs, have independent annotators classify each bug with the paper's six categories, and record which debugging strategy actually resolved each one. If most bugs are consistently assigned to a single category, or if one strategy dominates within a category, the central claims would be weakened.

Watch

Extended reading notes

Core claim

The paper's central claim is that quantum bugs are frequently compound: they arise from the interaction of multiple root causes, so they fall at the intersection of any reasonable bug classification rather than in a single category. Analyzing 14 real bugs—most encountered first-hand in implementing Shor's algorithm and a variational eigensolver, supplemented by a selection of publicly reported issues—the authors found that 11 of the 14 span two or more of the six proposed categories (initialization, algorithm, measurement, transpilation, framework plumbing, and general quantum-related). Even the three single-category bugs (GPHASE, SP, XGATE) were only detected through interaction with another class. A second, unexpected finding is that debugging strategy effectiveness does not track bug class: equivalence checking and visual inspection were the most broadly useful, but the same class of bugs was successfully debugged by very different methods, and no class had a single best strategy. The authors accordingly propose a flowchart as a starting point rather than a rule.

Load-bearing premise

The central finding depends on the authors' six-category scheme being the right grain of analysis: with coarser categories the same bugs look single-class, and with finer categories they look even more multi-class.

Editorial extensions

If this is right

  • Debugging guidance for quantum software should be organized around compound failure scenarios, such as transpiler-plus-measurement-basis interactions or mid-circuit reset plus qubit reuse, rather than single root-cause categories.
  • Equivalence checking and visual inspection of circuits and states are the most accessible and frequently effective strategies, so improving their integration into quantum development kits would have the broadest payoff.
  • Bugs at the intersection of transpilation and measurement, such as gates being optimized away before non-basis measurement, need tooling that checks whether a transpiler change preserves measurement semantics, not just circuit equivalence.
  • Dynamic circuits with mid-circuit measurement and reset need dedicated debugging support; the reset and qubit-ordering bugs were caught only through a combination of unit tests and visualization, not by any single tool.
  • The absence of pure initialization-only or measurement-only bugs in the sample should not be read as evidence that they do not exist; the authors explicitly note that they simply have not encountered them.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the compound-bug pattern generalizes, automated repair tools, including large-language-model-based debuggers, should be benchmarked on multi-class bugs, since single-class benchmarks would understate the difficulty.
  • The 'no single best method' result may be partly an artifact of the small sample of 14 bugs and the coarse strategy categories; a larger corpus recording which strategy actually resolved each bug could either confirm or overturn it.
  • The compound-bug rate is sensitive to category granularity: refining the categories would likely increase the measured compound rate, while merging them would reduce it, so the finding is a property of the scheme as much as of the bugs.
  • A testable extension would be to have independent developers debug a fixed set of seeded quantum bugs, with half following the paper's flowchart and half debugging freely, and compare time-to-fix.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper presents an experience-based analysis of 14 quantum bugs collected from the authors' own development work and from GitHub issues of popular quantum frameworks. It proposes a six-category classification (INIT, ALG, MEAS, TRNS, PLUMB, GEN) and argues that a distinguishing feature of many quantum bugs is that they are 'compound', i.e., they span multiple categories because more than one thing must go wrong. Based on the 14 bugs, the paper also concludes that there is no clear relationship between debugging strategies and bug classes, and offers a flowchart suggesting when to use equivalence checking, visual inspection, assertions, and formal verification.

Significance. If the compound-bug claim holds, it would redirect quantum debugging tooling toward failures that straddle multiple workflow stages rather than single-category recipes. The paper's strengths are its concrete bug descriptions with named IDs, its candid acknowledgment of its own limitations in Section 5, and its useful survey of existing debugging methods. It also makes a falsifiable, if not yet statistically tested, prediction that strategy effectiveness is not class-specific. However, the central empirical generalization rests on a non-random, small sample and on a classification scheme whose granularity and category boundaries were derived from the same 14 bugs. The paper is best read as a well-documented experience report rather than an empirical study.

major comments (4)
  1. [Section 4, definition of 'compound' and Figure 3] The third disjunct of the definition ('identifying them requires more than one debugging approach') makes compoundness depend on the debugging process rather than on the bug itself. More importantly, several multi-class assignments in Figure 3 appear to be driven by the context in which a symptom is detected rather than by a genuinely compound root cause. For example, VRZ has a single root cause (a transpiler removing terminal RZ gates), yet is labeled ALG, MEAS, TRNS, and PLUMB because the removal is harmful only for non-Z-basis measurements and arose when crossing frameworks. RESET is similarly labeled INIT, ALG, and MEAS because a mid-circuit measurement reuses the qubit, even though the root cause is a single missed reset. Under this labeling rule, almost any bug whose symptom surfaces in a measurement or a transpiled circuit will appear compound, so the reported 11/14 majority does not establish that multiple things 'must go wrong' in the sense the paper claims. I recommend either re-analyzing the bugs with a root-cause/symptom-context distinction or explicitly reframing the claim as 'compound in manifestation' throughout the abstract and conclusions.
  2. [Section 4, Table 2 and Figure 3] The six-category scheme was explicitly constructed after inspecting the 14 bugs ('we initially proposed a new scheme'), so the observation that most bugs fall into multiple categories is partly entailed by the chosen granularity and category boundaries. Coarser categories (e.g., merging TRNS and PLUMB, or using the existing schemes reviewed in Section 2.1) would likely make more bugs look single-class; finer categories would make them look even more compound. The paper acknowledges this circularity in Section 5, but the abstract and conclusions still present the compound finding as a property of quantum bugs. Adding a sensitivity analysis with at least one alternative (coarser) category set, or explicitly labeling the conclusion as a hypothesis for future inter-annotator testing, would make the central claim proportionate to the evidence.
  3. [Section 3.2 and Table 1] The text states that 'DECOMP, VRZ, and VQEM are all related to transpilation, in addition to the algorithm and measurement', but Table 1 classifies DECOMP as TRANS only. This inconsistency suggests the category assignments were not applied with a consistent rule, and it is not a purely cosmetic issue because the count of compound bugs depends on exactly these assignments.
  4. [Section 5 and Table 1] The claim that 'there is no clear relationship between debugging strategies and bug classes' is derived from a strategy column that records which methods the authors happened to find useful on a set of 14 non-random bugs, not from a controlled comparison. The authors themselves note that the prevalence of equivalence checking and visualization may reflect their ease of use rather than effectiveness. As stated, the claim is too strong for the evidence; it should be narrowed to 'no single strategy was effective across all bugs in our sample' unless additional data are supplied.
minor comments (4)
  1. [Figure 4 caption and Section 5] The flowchart is described as based on 'effectiveness and usage frequency' in the caption, but the text says the authors 'noticed differences in the frequency in which the debugging methods proved helpful'; please align the wording to avoid implying a controlled effectiveness measurement.
  2. [References] Reference [12] lists the first author as 'aoun, M.R.E.'; the capitalization should be corrected to 'Aoun, M.R.E.'.
  3. [Figure 3] The Venn diagram is difficult to parse because TRNS and PLUMB are encoded by icon shape rather than shown as explicit regions; a legend with explicit category names or an alternative layout would improve readability.
  4. [Table 1] The inclusion of MATRIX, a quantum-related framework bug, in the same table as quantum algorithm bugs could confuse readers; consider separating the two sets or adding a clearer label in the table.

Circularity Check

2 steps flagged · score 4.0 of 10

The compound-bug finding is partly a definitional artifact of the authors' own multi-category scheme, though the paper's concrete bug data and explicit experience-based caveats keep most of the content independent.

  1. self definitional [Section 6 Conclusions, supported by Section 4 and Figure 3]
    "Many quantum bugs sit at the intersection of more than one category. In other words, more than one thing must go wrong."

    The paper equates 'intersection of more than one category' with 'more than one thing must go wrong.' The evidence for this is Figure 3's multi-class assignment under the authors' Table 2 scheme, whose classes are location/context categories (INIT, ALG, MEAS, TRNS, PLUMB), not independent counts of failure causes. Section 4 states that even single-root-cause bugs were labelled across classes because of detection context: 'we only detect this bug if a qubit is re-used later in an algorithm... and measured again.' VRZ, for example, has one transpiler root cause but is labelled ALG, MEAS, TRNS, PLUMB because its symptom appears in measurement and cross-framework contexts.

  2. self definitional [Section 4, definition of 'compound'; Section 5, strategy analysis]
    "We thus argue that a hallmark feature of many quantum bugs is that they are 'compound', in the sense that more than one thing must be done incorrectly, more than one conceptual misconception occurs, or that identifying them requires more than one debugging approach."

    The third disjunct defines compoundness partly in terms of the debugging process (multiple debugging approaches), and Section 5 then draws the strategic conclusion 'there is no single best debugging method for a given class of bugs' from the same Table 1 strategy lists that support the compound-bug discussion. Because the definition already folds process into the bug property, the later observation about strategy diversity is not fully independent evidence; it is partly a restatement of one of the definitional criteria, even though GPHASE shows the criterion was not applied mechanically.

full rationale

This is a descriptive, experience-based taxonomy paper rather than a derivation with equations or fitted parameters. The main circularity concern is the construction of the compound-bug claim: the categories in Table 2 were chosen after inspecting the bugs, and the conclusion equates multi-category membership with multiple things going wrong, even though the categories are location/context classes and Section 4 openly admits that detection context drove many multi-class labels. The paper mitigates this by first trying existing schemes, by marking the scheme as experience-based, and by explicitly disclaiming generality: 'The classification, investigated example bugs, and suggested debugging strategies come with a significant personal and experience-based flavor, and no generality is claimed.' The self-citation to Ref. [3] is used mainly for detailed bug descriptions and is not load-bearing for the central taxonomy claim. Overall, the central claim still has independent content in the concrete bug case studies and the retrospective strategy analysis, so the circularity is partial rather than total.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

No free parameters or fitted quantities appear; this is a qualitative classification paper. The load-bearing inputs are the category definitions, the bug sample, and the reported debugging strategies, all of which are the authors' own construction and are acknowledged as experience-based in Section 5.

assumptions (3)
  • domain assumption Quantum bugs are defined as bugs that occur precisely because an algorithm is a quantum algorithm and require domain-specific knowledge to fix.
    Used in Section 1 to delineate the scope; excludes framework misuse bugs (called quantum-related) and hardware noise, which the paper explicitly sets aside.
  • ad hoc to paper The six categories INIT, ALG, MEAS, TRNS, PLUMB, GEN are sufficient and at the right granularity to describe quantum bugs.
    The categories are derived from the authors' 14 observed bugs (Section 4); the compound-bug finding depends on this granularity.
  • domain assumption Self-reported debugging strategies in Table 1 reflect the strategies that actually identified or fixed each bug.
    The strategy-effectiveness discussion in Section 5 treats the listed strategies as effective without controlled evaluation or inter-annotator agreement.

how reviews work

0 comments
Cite this review

Pith. "Pith review of An experience-based classification of quantum bugs in quantum software." pith.science (2026). https://pith.science/paper/7QDYOC6U

@misc{pith2026250903280,
  author       = {Pith},
  title        = {Pith review of: An experience-based classification of quantum bugs in quantum software},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7QDYOC6U}},
  note         = {Machine review of arXiv:2509.03280}
}
read the original abstract

As quantum computers continue to improve in quality and scale, there is a growing need for accessible software frameworks for programming them. However, the unique behavior of quantum systems means specialized approaches, beyond traditional software development, are required. This is particularly true for debugging due to quantum bugs, i.e., bugs that occur precisely because an algorithm is a quantum algorithm. Pinpointing a quantum bug's root cause often requires significant developer time, as there is little established guidance for quantum debugging techniques. Developing such guidance is the main challenge we sought to address. In this work, we describe a set of 14 quantum bugs, sourced primarily from our experience as quantum software developers, and supplemented by analysis of open-source GitHub repositories. We detail their context, symptoms, and the techniques applied to identify and fix them. While classifying these bugs based on existing schemes, we observed that most emerged due to unique interactions between multiple aspects of an algorithm or workflow. In other words, they occurred because more than one thing went wrong, which provided important insight into why quantum debugging is more challenging. Furthermore, based on this clustering, we found that - unexpectedly - there is no clear relationship between debugging strategies and bug classes. Further research is needed to develop effective and systematic quantum debugging strategies.

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

75 extracted references · 32 canonical work pages

  1. [1]

    Zhao, J.: Quantum Software Engineering: Landscapes and Horizons (2021)

    work page 2021

  2. [2]

    From Quantum Mechanics to Quantum Software Engineering: A Historical Review

    Bisicchia, G., Garcia-Alonso, J., Murillo, J.M., Brogi, A.: From Quantum Mechan- ics to Quantum Software Engineering: A Historical Review (2024). https://arxiv. org/abs/2404.19428

    work page Pith review arXiv 2024

  3. [3]

    In: Proceedings of the 5th ACM/IEEE International Workshop on Quantum Software Engineering

    Di Matteo, O.: On the need for effective tools for debugging quantum programs. In: Proceedings of the 5th ACM/IEEE International Workshop on Quantum Software Engineering. Q-SE 2024, pp. 17–20. Association for Computing Machin- ery, New York, NY, USA (2024). https://doi.org/10.1145/3643667.3648226 . https://doi.org/10.1145/3643667.3648226

    arXiv 2024

  4. [4]

    In: Proceedings of the 36th IEEE/ACM Interna- tional Conference on Automated Software Engineering

    Zhao, P., Zhao, J., Miao, Z., Lan, S.: Bugs4Q: a benchmark of real bugs for quantum programs. In: Proceedings of the 36th IEEE/ACM Interna- tional Conference on Automated Software Engineering. ASE ’21, pp. 1373–

    work page

  5. [5]

    Proceedings of the ACM on Programming Languages 6(OOPSLA1), 1–27 (2022) https://doi.org/10.1145/3527330

    Paltenghi, M., Pradel, M.: Bugs in Quantum computing platforms: an empirical study. Proceedings of the ACM on Programming Languages 6(OOPSLA1), 1–27 (2022) https://doi.org/10.1145/3527330

    doi:10.1145/3527330 2022

  6. [7]

    In: 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp

    Luo, J., Zhao, P., Miao, Z., Lan, S., Zhao, J.: A comprehensive study of bug fixes in quantum programs. In: 2022 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp. 1239–1246 (2022). https: //doi.org/10.1109/SANER53432.2022.00147

    arXiv 2022

  7. [8]

    In: Proceedings of the 46th International Symposium on Computer Architecture

    Huang, Y., Martonosi, M.: Statistical assertions for validating patterns and 19 finding bugs in quantum programs. In: Proceedings of the 46th International Symposium on Computer Architecture. ISCA ’19, pp. 541–553. Association for Computing Machinery, New York, NY, USA (2019). https://doi.org/10.1145/ 3307650.3322213 . https://doi.org/10.1145/3307650.3322213

    arXiv 2019

  8. [9]

    In: Barik, T., Sunshine, J., Chasins, S

    Huang, Y., Martonosi, M.: QDB: From Quantum Algorithms Towards Cor- rect Quantum Programs. In: Barik, T., Sunshine, J., Chasins, S. (eds.) 9th Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU 2018). Open Access Series in Informatics (OASIcs), vol. 67, pp. 4–1414. Schloss Dagstuhl – Leibniz-Zentrum f¨ ur Informatik, Dagstuhl...

    work page doi:10.4230/oasics.plateau.2018.4 2019

Show all 75 references
  1. [10]

    In: 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE), pp

    Zhao, P., Zhao, J., Ma, L.: Identifying Bug Patterns in Quantum Programs. In: 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE), pp. 16–21 (2021). https://doi.org/10.1109/Q-SE52541.2021.00011

    2021

  2. [11]

    https://arxiv.org/abs/2410.00650

    Paltenghi, M., Pradel, M.: A Survey on Testing and Analysis of Quantum Software (2024). https://arxiv.org/abs/2410.00650

    2024 arXiv

  3. [12]

    https://arxiv.org/abs/2204.11965

    aoun, M.R.E., Li, H., Khomh, F., Tidjon, L.: Bug Characteristics in Quantum Software Ecosystem (2022). https://arxiv.org/abs/2204.11965

    2022 arXiv

  4. [13]

    https://doi.org/10.48550/arXiv

    Javadi-Abhari, A., Treinish, M., Krsulich, K., Wood, C.J., Lishman, J., Gacon, J., Martiel, S., Nation, P.D., Bishop, L.S., Cross, A.W., Johnson, B.R., Gambetta, J.M.: Quantum computing with Qiskit (2024). https://doi.org/10.48550/arXiv. 2405.08810

    2024 doi arXiv

  5. [14]

    Journal of Software: Evolution and Process 35(4), 2419 (2023) https://doi.org/10.1002/smr.2419 https://onlinelibrary.wiley.com/doi/pdf/10.1002/smr.2419

    Barrera, A., Guzm´ an, I., Polo, M., Piattini, M.: Quantum soft- ware testing: State of the art. Journal of Software: Evolution and Process 35(4), 2419 (2023) https://doi.org/10.1002/smr.2419 https://onlinelibrary.wiley.com/doi/pdf/10.1002/smr.2419

    2023 doi

  6. [15]

    Long, P., Zhao, J.: Testing multi-subroutine quantum programs: From unit testing to integration testing 33(6) (2024) https://doi.org/10.1145/3656339

    2024 doi

  7. [16]

    ICSE-NIER ’20, pp

    Miranskyy, A., Zhang, L., Doliskani, J.: Is your quantum program bug-free? In: Proceedings of the ACM/IEEE 42nd International Conference on Software Engi- neering: New Ideas and Emerging Results. ICSE-NIER ’20, pp. 29–32. Association for Computing Machinery, New York, NY, USA ...

    2020

  8. [17]

    https://arxiv.org/abs/2103.09172

    Miranskyy, A., Zhang, L., Doliskani, J.: On Testing and Debugging Quantum Software (2021). https://arxiv.org/abs/2103.09172

    2021 arXiv

  9. [18]

    In: Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory 20 of Computing

    Grover, L.K.: A fast quantum mechanical algorithm for database search. In: Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory 20 of Computing. STOC ’96, pp. 212–219. Association for Computing Machin- ery, New York, NY, USA (1996). https://doi.org/10.1145/237814.23...

    1996

  10. [19]

    Abhari, A.J., Faruque, A.I., Dousti, M.J., Svec, L., Catu, O., Chakrabati, A., Chi- ang, C.-F., Vanderwilt, S., Black, J., Chong, F.: Scaffold: Quantum Programming Language. (2012). https://api.semanticscholar.org/CorpusID:18354908

    2012

  11. [20]

    https://doi.org/10.2139/ssrn.4511772

    Jiang, N., Wang, Z., Wang, J.: Debugging Quantum Programs Using Probabilistic Quantum Cloning (2023). https://doi.org/10.2139/ssrn.4511772

    2023 doi

  12. [21]

    Li, G., Zhou, L., Yu, N., Ding, Y., Ying, M., Xie, Y.: Projection-based runtime assertions for testing and debugging quantum programs. Proc. ACM Program. Lang. 4(OOPSLA) (2020) https://doi.org/10.1145/3428218

    2020 doi

  13. [22]

    In: Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems

    Liu, J., Byrd, G.T., Zhou, H.: Quantum Circuits for Dynamic Runtime Assertions in Quantum Computation. In: Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems. ASPLOS ’20, pp. 1017–1030. Association ...

    2020

  14. [23]

    https://arxiv.org/abs/2412.12269

    Rovara, D., Burgholzer, L., Wille, R.: A Framework for Debugging Quantum Programs (2024). https://arxiv.org/abs/2412.12269

    2024 arXiv

  15. [24]

    https://arxiv.org/abs/2412

    Rovara, D., Burgholzer, L., Wille, R.: Automatically Refining Assertions for Efficient Debugging of Quantum Programs (2024). https://arxiv.org/abs/2412. 14252

    2024

  16. [25]

    IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 38(5), 848–859 (2019) https://doi.org/10.1109/TCAD.2018.2834427

    Zulehner, A., Wille, R.: Advanced simulation of quantum computations. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 38(5), 848–859 (2019) https://doi.org/10.1109/TCAD.2018.2834427

    2019

  17. [26]

    Quantum Information Processing 2(5), 347–380 (2003)

    Viamontes, G.F., Markov, I.L., Hayes, J.P.: Improving gate-level simulation of quantum circuits. Quantum Information Processing 2(5), 347–380 (2003)

    2003

  18. [27]

    Bergholm, V., et al.: PennyLane: Automatic differentiation of hybrid quantum- classical computations (2022)

    2022

  19. [28]

    https://algassert.com/quirk

  20. [29]

    In: IEEE International Conference on Quantum Computing and Engineering (QCE) (2024)

    Khan, M., Nair, P., Di Matteo, O.: CircInspect: Integrating Visual Circuit Anal- ysis, Abstraction, and Real-Time Development in Quantum Debugging. In: IEEE International Conference on Quantum Computing and Engineering (QCE) (2024)

    2024

  21. [30]

    https://docs.classiq.io/

  22. [31]

    In: 2022 21 IEEE International Conference on Quantum Computing and Engineering (QCE), pp

    Metwalli, S.A., Van Meter, R.: A tool for debugging quantum circuits. In: 2022 21 IEEE International Conference on Quantum Computing and Engineering (QCE), pp. 624–634 (2022). https://doi.org/10.1109/QCE53715.2022.00085

    2022

  23. [32]

    IEEE Transactions on Quantum Engineering 5, 1–15 (2024) https://doi.org/10.1109/ TQE.2024.3374879

    Metwalli, S.A., Van Meter, R.: Testing and debugging quantum circuits. IEEE Transactions on Quantum Engineering 5, 1–15 (2024) https://doi.org/10.1109/ TQE.2024.3374879

    2024

  24. [33]

    IEEE Transactions on Visualization & Computer Graphics 30(01), 573–583 (2024) https://doi.org/10.1109/TVCG.2023.3327148

    Wen, Z., Liu, Y., Tan, S., Chen, J., Zhu, M., Han, D., Yin, J., Xu, M., Chen, W.: Quantivine: A Visualization Approach for Large-Scale Quantum Circuit Representation and Analysis . IEEE Transactions on Visualization & Computer Graphics 30(01), 573–583 (2024) https://doi.org/10...

    2024

  25. [34]

    https://github.com/TheGupta2012/ qiskit-timeline-debugger

    Foda, A., Gupta, H. https://github.com/TheGupta2012/ qiskit-timeline-debugger

  26. [35]

    Ying, M.: Toward Automatic Verification of Quantum Programs. Form. Asp. Comput. 31(1), 3–25 (2019) https://doi.org/10.1007/s00165-018-0465-3

    2019 doi

  27. [36]

    https://arxiv.org/abs/2109

    Chareton, C., Bardin, S., Lee, D., Valiron, B., Vilmart, R., Xu, Z.: Formal Methods for Quantum Programs: A Survey (2022). https://arxiv.org/abs/2109. 06493

    2022

  28. [37]

    ACM Transactions on Quantum Computing (2023) https://doi.org/10.1145/3624483

    Lewis, M., Soudjani, S., Zuliani, P.: Formal Verification of Quantum Programs: Theory, Tools and Challenges. ACM Transactions on Quantum Computing (2023) https://doi.org/10.1145/3624483

    2023 doi

  29. [38]

    https: //arxiv.org/abs/quant-ph/0305050

    Janzing, D., Wocjan, P., Beth, T.: Identity check is QMA-complete (2003). https: //arxiv.org/abs/quant-ph/0305050

    2003 arXiv

  30. [39]

    Electronic Proceedings in Theoretical Computer Science 287, 1–21 (2019) https://doi.org/10.4204/eptcs.287.1

    Amy, M.: Towards Large-scale Functional Verification of Universal Quantum Cir- cuits. Electronic Proceedings in Theoretical Computer Science 287, 1–21 (2019) https://doi.org/10.4204/eptcs.287.1

    2019 doi

  31. [40]

    Software Impacts 7, 100051 (2021) https://doi.org/10.1016/j.simpa

    Burgholzer, L., Wille, R.: QCEC: A JKQ tool for quantum circuit equivalence checking. Software Impacts 7, 100051 (2021) https://doi.org/10.1016/j.simpa. 2020.100051

    2021

  32. [41]

    In: Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design

    Hong, X., Feng, Y., Li, S., Ying, M.: Equivalence Checking of Dynamic Quan- tum Circuits. In: Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design. ICCAD ’22. Association for Computing Machin- ery, New York, NY, USA (2022). https://doi.org/10.1145...

    2022

  33. [43]

    IEEE Journal on Emerging and Selected Topics in Circuits and Systems 12(3), 662–675 (2022) https://doi.org/10.1109/jetcas.2022.3202204

    Peham, T., Burgholzer, L., Wille, R.: Equivalence Checking of Quantum Circuits With the ZX-Calculus. IEEE Journal on Emerging and Selected Topics in Circuits and Systems 12(3), 662–675 (2022) https://doi.org/10.1109/jetcas.2022.3202204

    2022

  34. [44]

    In: Asia and South Pacific Design Automation Conference, pp

    Peham, T., Burgholzer, L., Wille, R.: Equivalence Checking of Parameterized Quantum Circuits: Verifying the Compilation of Variational Quantum Algo- rithms. In: Asia and South Pacific Design Automation Conference, pp. 702–708. Association for Computing Machinery, New York, NY,...

    2023

  35. [45]

    Asia and South Pacific Design Automation Conference (ASP-DAC) (2021) https://doi.org/10.1145/3394885.3431590

    Burgholzer, L., Kueng, R., Wille, R.: Random Stimuli Generation for the Verifica- tion of Quantum Circuits. Asia and South Pacific Design Automation Conference (ASP-DAC) (2021) https://doi.org/10.1145/3394885.3431590

    2021

  36. [46]

    Proceedings of the ACM on Programming Languages 5(POPL), 1–29 (2021) https://doi.org/10.1145/3434318

    Hietala, K., Rand, R., Hung, S.-H., Wu, X., Hicks, M.: A verified optimizer for Quantum circuits. Proceedings of the ACM on Programming Languages 5(POPL), 1–29 (2021) https://doi.org/10.1145/3434318

    2021 doi

  37. [47]

    https://arxiv.org/abs/1908.08963

    Shi, Y., Tao, R., Li, X., Javadi-Abhari, A., Cross, A.W., Chong, F.T., Gu, R.: Cer- tiQ: A Mostly-automated Verification of a Realistic Quantum Compiler (2020). https://arxiv.org/abs/1908.08963

    2020 arXiv

  38. [48]

    In: Cohen, L., Kaliszyk, C

    Hietala, K., Rand, R., Hung, S.-H., Li, L., Hicks, M.: Proving Quantum Pro- grams Correct. In: Cohen, L., Kaliszyk, C. (eds.) 12th International Conference on Interactive Theorem Proving (ITP 2021). Leibniz International Proceedings in Informatics (LIPIcs), vol. 193, pp. 21–12...

    2021 doi

  39. [49]

    Electronic Proceedings in Theoretical Computer Science 266, 119–132 (2018) https://doi.org/10.4204/eptcs.266.8

    Rand, R., Paykin, J., Zdancewic, S.: QWIRE Practice: Formal Verification of Quantum Circuits in Coq. Electronic Proceedings in Theoretical Computer Science 266, 119–132 (2018) https://doi.org/10.4204/eptcs.266.8

    2018 doi

  40. [50]

    In: Programming Languages and Systems, pp

    Chareton, C., Bardin, S., Bobot, F., Perrelle, V., Valiron, B.: An automated deductive verification framework for circuit-building quantum programs. In: Programming Languages and Systems, pp. 148–177. Springer, Cham (2021)

    2021

  41. [51]

    PhD thesis, University of Waterloo (2019)

    Amy, Matthew: Formal Methods in Quantum Circuit Design. PhD thesis, University of Waterloo (2019). http://hdl.handle.net/10012/14480

    2019

  42. [52]

    arXiv (2022)

    Peng, Y., Hietala, K., Tao, R., Li, L., Rand, R., Hicks, M., Wu, X.: A Formally Certified End-to-End Implementation of Shor’s Factorization Algorithm. arXiv (2022). https://arxiv.org/abs/2204.07112

    2022 arXiv

  43. [53]

    https://github.com/PennyLaneAI/catalyst 23

    Catalyst. https://github.com/PennyLaneAI/catalyst 23

  44. [54]

    SIAM Journal on Computing 26(5), 1484–1509 (1997) https://doi.org/10.1137/S0097539795293172

    Shor, P.W.: Polynomial-time algorithms for prime factorization and discrete log- arithms on a quantum computer. SIAM Journal on Computing 26(5), 1484–1509 (1997) https://doi.org/10.1137/S0097539795293172

    1997 doi

  45. [55]

    Physical Review Letters 85(14), 3049–3052 (2000) https: //doi.org/10.1103/physrevlett.85.3049

    Parker, S., Plenio, M.B.: Efficient Factorization with a Single Pure Qubit and logn Mixed Qubits. Physical Review Letters 85(14), 3049–3052 (2000) https: //doi.org/10.1103/physrevlett.85.3049

    2000 doi

  46. [56]

    Physical Review Letters 127(10) (2021) https: //doi.org/10.1103/physrevlett.127.100501

    C´ orcoles, A.D., Takita, M., Inoue, K., Lekuch, S., Minev, Z.K., Chow, J.M., Gambetta, J.M.: Exploiting Dynamic Quantum Circuits in a Quantum Algorithm with Superconducting Qubits. Physical Review Letters 127(10) (2021) https: //doi.org/10.1103/physrevlett.127.100501

    2021 doi

  47. [57]

    Moses, S.A., Baldwin, C.H., Allman, M.S., Ancona, R., Ascarrunz, L., Barnes, C., Bartolotta, J., Bjork, B., Blanchard, P., Bohn, M., Bohnet, J.G., Brown, N.C., Burdick, N.Q., Burton, W.C., Campbell, S.L., Campora, J.P., Carron, C., Chambers, J., Chan, J.W., Chen, Y.H., Chernog...

    2023

  48. [58]

    arXiv (2022)

    Lubinski, T., Granade, C., Anderson, A., Geller, A., Roetteler, M., Petrenko, A., Heim, B.: Advancing Hybrid Quantum-Classical Computation with Real-Time Execution. arXiv (2022). https://arxiv.org/abs/2206.12950

    2022 arXiv

  49. [59]

    Quantum Info

    Beauregard, S.: Circuit for Shor’s algorithm using 2 n + 3 qubits. Quantum Info. Comput. 3(2), 175–185 (2003)

    2003

  50. [60]

    In: ACM/IEEE Design Automation Confer- ence, pp

    Burgholzer, L., Wille, R.: Handling non-unitaries in quantum circuit equivalence checking. In: ACM/IEEE Design Automation Confer- ence, pp. 529–534 (2022). https://doi.org/10.1145/3489517.3530482 . https://doi.org/10.1145/3489517.3530482

    2022

  51. [61]

    Zenodo (2023)

    Developers, C.: Cirq. Zenodo (2023). https://doi.org/10.5281/zenodo.10247207 . https://doi.org/10.5281/zenodo.10247207

    2023 doi

  52. [62]

    Quantum Science and Technology 6(1), 014003 (2020) https://doi.org/10.1088/2058-9565/ab8e92

    Sivirajah, S., Dilkes, S., Cowtan, A., Simmons, W., Edgington, A., Duncan, 24 R.: TKET: A Retargetable Compiler for NISQ devices. Quantum Science and Technology 6(1), 014003 (2020) https://doi.org/10.1088/2058-9565/ab8e92

    2020 doi

  53. [63]

    Quantum Science and Technology 5 (2020) https://doi.org/10.1088/2058-9565/ab9359

    Amy, M., Gheorghiu, V.: staq - a full-stack quantum processing toolkit. Quantum Science and Technology 5 (2020) https://doi.org/10.1088/2058-9565/ab9359

    2020 doi

  54. [64]

    https://www.osti.gov/biblio/ 1785933 (2021)

    Younis, E., Iancu, C.C., Lavrijsen, W., Davis, M., Smith, E., USDOE: Berke- ley Quantum Synthesis Toolkit (BQSKit) v1. https://www.osti.gov/biblio/ 1785933 (2021). https://doi.org/10.11578/dc.20210603.2 . https://www.osti.gov/ /servlets/purl/1785933

    2021

  55. [65]

    Quantum 5, 497 (2021) https: //doi.org/10.22331/q-2021-07-06-497

    Gidney, C.: Stim: a fast stabilizer circuit simulator. Quantum 5, 497 (2021) https: //doi.org/10.22331/q-2021-07-06-497

    2021 doi

  56. [66]

    Quantum 6, 774 (2022) https://doi.org/10.22331/q-2022-08-11-774

    LaRose, R., Mari, A., Kaiser, S., Karalekas, P.J., Alves, A.A., Czarnik, P., Man- douh, M.E., Gordon, M.H., Hindy, Y., Robertson, A., Thakre, P., Wahl, M., Samuel, D., Mistri, R., Tremblay, M., Gardner, N., Stemen, N.T., Shammah, N., Zeng, W.J.: Mitiq: A software package for e...

    2022 doi

  57. [67]

    In: IEEE International Conference on Quantum Software (QSW)

    Wille, R., Berent, L., Forster, T., Kunasaikaran, J., Mato, K., Peham, T., Quetschlich, N., Rovara, D., Sander, A., Schmid, L., Schoenberger, D., Stade, Y., Burgholzer, L.: The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing. In: IEEE Inte...

  58. [68]

    https://github.com/PennyLaneAI/pennylane/issues/5099

  59. [69]

    https://arxiv.org/ abs/quant-ph/0407010

    Mottonen, M., Vartiainen, J.J., Bergholm, V., Salomaa, M.M.: Transformation of quantum states using uniformly controlled rotations (2004). https://arxiv.org/ abs/quant-ph/0407010

    2004 arXiv

  60. [70]

    https://github.com/CQCL/pytket-qiskit/issues/123

  61. [71]

    https://github.com/Qiskit/qiskit/pull/13118

  62. [72]

    https://github.com/Qiskit/qiskit/pull/10457

  63. [73]

    https://github.com/cda-tum/mqt-qcec/issues/251

  64. [74]

    https://github.com/cda-tum/mqt-qcec/issues/346

  65. [75]

    https://github.com/Qiskit/qiskit/pull/4849

  66. [76]

    In: IEEE/ACM International Workshop on Quantum Software Engineering (Q- SE), pp

    Guo, X., Zhao, J., Zhao, P.: On Repairing Quantum Programs Using ChatGPT. In: IEEE/ACM International Workshop on Quantum Software Engineering (Q- SE), pp. 9–16 (2024) 25

    2024

  67. [1376]

    https://doi.org/10.1109/ASE51524.2021.9678908

    IEEE Press, ??? (2022). https://doi.org/10.1109/ASE51524.2021.9678908 . https://doi.org/10.1109/ASE51524.2021.9678908

    2022

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.