The ability to incorporate quantum phenomena in computing unlocks a host of new ways to make mistakes. This work surveys existing studies and approaches to debugging quantum programs. It then presents a set of examples that stem from first-hand experience, intended to motivate future research on the subject and the development of novel tools and techniques.
The ability to incorporate quantum phenomena in computing unlocks a host of new ways to make mistakes. This work surveys existing studies and approaches to debugging quantum programs. It then presents a set of examples that stem from first-hand experience, intended to motivate future research on the subject and the development of novel tools and techniques.
Recent advancements in quantum computing software are gradually increasing the scope and size of quantum programs being developed. At the same time, however, these larger programs provide more possibilities for functional errors that are harder to detect and resolve. Meanwhile, debugging tools that could aid developers in resolving these errors are still barely existent and far from what we take for granted in classical design automation and software engineering. As a result, even if one manages to identify the incorrect behavior of a developed quantum program, detecting and resolving the underlying errors in the program remains a time-consuming and tedious task. Moreover, the exponential growth of the state space in quantum programs makes the efficient manual investigation of errors radically difficult even for respectively simple algorithms, and almost impossible as the number of qubits increases. To address this problem, this work proposes a debugging framework, available as an open-source implementation at https://github.com/cda-tum/mqt-debugger. It assists developers in debugging errors in quantum programs, allowing them to efficiently identify the existence of errors and diagnose their causes. Users are given the ability to place assertions in the code that test for the correctness of a given algorithm and are evaluated using classical simulations of the underlying quantum program. Once an assertion fails, the proposed framework employs different diagnostic methods to point towards possible error causes. This way, the debugging workload for quantum programs is drastically reduced.
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.
Quantum computers are becoming more mainstream. As more programmers are starting to look at writing quantum programs, they need to test and debug their code. In this paper, we discuss various use-cases for quantum computers, either standalone or as part of a System of Systems. Based on these use-cases, we discuss some testing and debugging tactics that one can leverage to ensure the quality of the quantum software. We also highlight quantum-computer-specific issues and list novel techniques that are needed to address these issues. The practitioners can readily apply some of these tactics to their process of writing quantum programs, while researchers can learn about opportunities for future work.
Abstract Quantum computing offers the potential for exponential speed-ups for classically intractable problems, yet quantum programming is still susceptible to bugs. Classical debugging methods are often inadequate, as quantum mechanical principles make state inspection disruptive and classical simulation has exponential time complexity. This survey explores the landscape of quantum assertions as a key technique for identifying and locating bugs in quantum programs. We classify these techniques into two primary categories based on their evaluation stage: classical runtime and quantum runtime assertions. For each category, we analyze the strengths, limitations, time complexity, and applicability of current methods. Our findings show that scalable quantum debugging remains an open problem—a challenge that will persist even with the advent of fault-tolerant hardware. Finally, this work highlights key challenges and proposes future directions for the development of novel quantum debugging techniques.
As the scale and capability of quantum hardware improves, there is a growing need for more expressive languages and frameworks that enable developers to write, optimize, and debug quantum programs beyond low-level quantum circuits. Motivated by ongoing collaborative work [1], this talk will showcase the role of abstraction in quantum software development. The characteristics of “good” abstractions will be described, and their importance highlighted by the examples of building an interactive quantum debugger [2], and optimizing quantum programs at multiple levels. Determining the “right” set of abstractions is a challenging open question that requires further research.
With the advent of small-scale prototype quantum computers, researchers can now code and run quantum algorithms that were previously proposed but not fully implemented. In support of this growing interest in quantum computing experimentation, programmers need new tools and techniques to write and debug QC code. In this work, we implement a range of QC algorithms and programs in order to discover what types of bugs occur and what defenses against those bugs are possible in QC programs. We conduct our study by running small-sized QC programs in QC simulators in order to replicate published results in QC implementations. Where possible, we cross-validate results from programs written in different QC languages for the same problems and inputs. Drawing on this experience, we provide a taxonomy for QC bugs, and we propose QC language features that would aid in writing correct code.