The continuous growth of quantum computing and the increasingly complex quantum programs resulting from it lead to unprecedented obstacles in ensuring program correctness. Runtime assertions are, therefore, becoming a crucial tool in the development of quantum programs. They assist developers in the debugging process and help to test and verify the program. However, while assertions can be implemented in a straightforward manner on classical computers, physical limitations of quantum computers pose considerable challenges for the evaluation of quantum assertions. Access to the quantum state of a program is limited, execution time is expensive and noise can significantly distort measurement outcomes. To address these problems, this work proposes a framework that assists developers in the evaluation of runtime assertions on real quantum computers. It translates a variety of assertions into sets of measurements, reduces execution overhead where possible and evaluates the measurement results after the execution even in the presence of noise. This approach substantially aids developers in the debugging process, enabling efficient assertion-driven debugging even in large programs. The proposed framework is available as an open-source implementation at https://github.com/munich-quantum-toolkit/debugger
The continuous growth of quantum computing and the increasingly complex quantum programs resulting from it lead to unprecedented obstacles in ensuring program correctness. Runtime assertions are, therefore, becoming a crucial tool in the development of quantum programs. They assist developers in the debugging process and help to test and verify the program. However, while assertions can be implemented in a straightforward manner on classical computers, physical limitations of quantum computers pose considerable challenges for the evaluation of quantum assertions. Access to the quantum state of a program is limited, execution time is expensive and noise can significantly distort measurement outcomes. To address these problems, this work proposes a framework that assists developers in the evaluation of runtime assertions on real quantum computers. It translates a variety of assertions into sets of measurements, reduces execution overhead where possible and evaluates the measurement results after the execution even in the presence of noise. This approach substantially aids developers in the debugging process, enabling efficient assertion-driven debugging even in large programs. The proposed framework is available as an open-source implementation at https://github.com/munich-quantum-toolkit/debugger
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.
As new advancements in the field of quantum computing lead to the development of increasingly complex programs, approaches to validate and debug these programs are becoming more important. To this end, methods employed in classical debugging, such as assertions for testing specific properties of a program's state, have been adapted for quantum programs. However, to efficiently debug quantum programs, it is key to properly place these assertions. This usually requires a deep understanding of the program's underlying mathematical properties, constituting a time-consuming manual task for developers. To address this problem, this work proposes methods for automatically refining assertions in quantum programs by moving them to more favorable positions in the program or by placing new assertions that help to further narrow down potential error locations. This allows developers to take advantage of rich and expressive assertions that greatly improve the debugging experience without requiring them to place these assertions manually in an otherwise tedious manner. An opensource implementation of the proposed methods is available at https://github.com/cda-tum/mqt-debugger.
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 quantum circuits grow beyond small toy examples, preparing them for execution on physical devices becomes increasingly complex. Design automation is therefore essential for scalable quantum computing: Compilation procedures optimize resource requirements and transform circuits to a format compatible with specific hardware; resource estimation evaluates execution cost; verification methods prove circuit correctness. However, these concepts present a steep learning curve for novices, particularly when quantum circuits are introduced through low-level textual representations. To address this, we present a block-based programming framework for quantum design automation, implemented as an extension to the Scratch programming platform. This system allows users to build quantum circuits as a sequence of blocks and embed them in classical control logic to perform evaluations, compare simulation results, and directly apply different design automation techniques. We evaluated the approach in a user study with computer science students, who completed guided exercises using the platform and provided structured feedback in the form of self-reports and short knowledge assessments. Results demonstrate strong understanding and confidence in quantum design automation concepts, suggesting that the block-based approach successfully lowers the entry barrier to quantum design automation. The implemented framework is open-source and available at https://github.com/munich-quantum-toolkit/scratch-quantum.
With the applications of quantum computing becoming more and more widespread, finding ways that allow end users without experience in the field to apply quantum computers to solve their individual problems is becoming a crucial task. However, current optimization algorithms require problem instances to be posed in complex formats that are challenging to formulate, even for experts. In particular, the Quadratic Unconstrained Binary Optimization (QUBO) formalism employed by many quantum optimization algorithms, such as the Quantum Approximate Optimization Algorithm (QAOA), involves the mathematical rewriting of constraints under strict conditions. To facilitate this process, we propose a framework to automatically generate QUBO formulations for pathfinding problems. This framework allows users to translate their specific problem instances into formulations that can be passed directly to quantum algorithms for optimization without requiring any expertise in the field of quantum computing. It supports three different encoding schemes that can easily be compared without requiring manual reformulation efforts. The resulting QUBO formulations are robust and efficient, reducing the previously tedious and error-prone reformulation process to a task that can be completed in a matter of seconds. In addition to an open-source Python package available on https://github.com/munich-quantum-toolkit/problemsolver, we also provide a graphical user interface accessible through the web (https://munich-quantum-toolkit.github.io/problemsolver/), which can be used to operate the framework without requiring the end user to write any code.
With the rapid advancement of quantum computing technology, there is a growing need for new debugging tools for quantum programs. Recent research has highlighted the potential of assertions for debugging quantum programs. In this paper, we investigate assertions in quantum ternary systems, which are more challenging than those in quantum binary systems due to the complexity of ternary logic. We propose quantum ternary circuit designs to assert classical, entanglement, and superposition states, specifically geared toward debugging quantum ternary programs.