The forty-year history of quantum computers has taken us through initial curiosity, naive optimism, then dismay at the scale of proposed error-corrected systems, and into today's excitement over the availability of real, but still small and error-prone, systems [1, 2, 3].Algorithms have followed a similar roller coaster, arriving at the point where a demonstration of the implementation of algorithms originally defined as abstract equations in theory papers are now commonly represented as circuit diagrams [4].The challenge now is, for both the hardware and software is scalability, how can we have more qubits and build larger and more sophisticated programs.This thesis introduces a collection of software functions (Cirquo), a packaged testing suite aiming to address the complex challenges of quantum circuit development as quantum programs scale up to the complexities of classical software.As the field of quantum software engineering evolves, the need for sophisticated tools that can handle the nuances of quantum computing becomes imperative.Cirquo stands out by offering tailored debugging strategies and comprehensive testing capabilities specifically designed to manage the unique aspects of quantum computation.In this thesis we discuss the three main types of quantum circuit blocks: Amplitude Permutation, Phase Modulation, and Amplitude Redistribution.Each type presents specific challenges that we proposed different approaches to address.For Amplitude Permutation Circuits, we provide techniques to correct amplitude permutations, effectively mimicking classical operations and ensuring circuit accuracy.In the realm of Phase Modulation Circuits, the suite offers precise calibration tools for phase alterations, which are critical for the successful execution of quantum algorithms.The most complex Amplitude Redistribution Circuits benefit from advanced methods that adjust probability amplitudes to maintain the integrity of quantum states.The suite enhances quantum circuit debugging by allowing developers to divide circuits into manageable slices, either vertically or horizontally, categorize these slices, ii iii and perform targeted tests.This slicing mechanism is vital for isolating problematic sections and applying focused debugging strategies without disrupting the circuit's overall functionality.Additionally, Cirquo facilitates gate tracking within each circuit slice, providing developers with detailed insights into gate behavior and interactions.One of the main features of Cirquo is its automated test generation, which supports six common subroutines used in quantum algorithms.This feature streamlines the testing process and enhances the efficiency of detecting and resolving bugs.Moreover, the suite's capability to simulate or execute tests on current quantum devices ensures that developers can optimize circuits for real-world applications.This thesis also offers strategic advice on creating efficient test cases for different circuit categories.These test cases are instrumental in pinpointing the location of bugs, thus significantly reducing debugging time and improving circuit reliability.In conclusion, this research significantly advances the field of quantum computing by providing a robust framework for debugging quantum circuits.The introduction of Cirquo is a pivotal step towards developing reliable quantum computing systems, which are expected to have profound implications across various domains.The empirical evidence confirms the effectiveness of Cirquo in optimizing quantum circuit performance, marking a significant milestone in the maturation of quantum software engineering.
The forty-year history of quantum computers has taken us through initial curiosity, naive optimism, then dismay at the scale of proposed error-corrected systems, and into today's excitement over the availability of real, but still small and error-prone, systems [1, 2, 3].Algorithms have followed a similar roller coaster, arriving at the point where a demonstration of the implementation of algorithms originally defined as abstract equations in theory papers are now commonly represented as circuit diagrams [4].The challenge now is, for both the hardware and software is scalability, how can we have more qubits and build larger and more sophisticated programs.This thesis introduces a collection of software functions (Cirquo), a packaged testing suite aiming to address the complex challenges of quantum circuit development as quantum programs scale up to the complexities of classical software.As the field of quantum software engineering evolves, the need for sophisticated tools that can handle the nuances of quantum computing becomes imperative.Cirquo stands out by offering tailored debugging strategies and comprehensive testing capabilities specifically designed to manage the unique aspects of quantum computation.In this thesis we discuss the three main types of quantum circuit blocks: Amplitude Permutation, Phase Modulation, and Amplitude Redistribution.Each type presents specific challenges that we proposed different approaches to address.For Amplitude Permutation Circuits, we provide techniques to correct amplitude permutations, effectively mimicking classical operations and ensuring circuit accuracy.In the realm of Phase Modulation Circuits, the suite offers precise calibration tools for phase alterations, which are critical for the successful execution of quantum algorithms.The most complex Amplitude Redistribution Circuits benefit from advanced methods that adjust probability amplitudes to maintain the integrity of quantum states.The suite enhances quantum circuit debugging by allowing developers to divide circuits into manageable slices, either vertically or horizontally, categorize these slices, ii iii and perform targeted tests.This slicing mechanism is vital for isolating problematic sections and applying focused debugging strategies without disrupting the circuit's overall functionality.Additionally, Cirquo facilitates gate tracking within each circuit slice, providing developers with detailed insights into gate behavior and interactions.One of the main features of Cirquo is its automated test generation, which supports six common subroutines used in quantum algorithms.This feature streamlines the testing process and enhances the efficiency of detecting and resolving bugs.Moreover, the suite's capability to simulate or execute tests on current quantum devices ensures that developers can optimize circuits for real-world applications.This thesis also offers strategic advice on creating efficient test cases for different circuit categories.These test cases are instrumental in pinpointing the location of bugs, thus significantly reducing debugging time and improving circuit reliability.In conclusion, this research significantly advances the field of quantum computing by providing a robust framework for debugging quantum circuits.The introduction of Cirquo is a pivotal step towards developing reliable quantum computing systems, which are expected to have profound implications across various domains.The empirical evidence confirms the effectiveness of Cirquo in optimizing quantum circuit performance, marking a significant milestone in the maturation of quantum software engineering.
This paper introduces a process framework for debugging quantum circuits, focusing on three distinct types of circuit blocks: Amplitude Permutation, Phase Modulation, and Amplitude Redistribution circuit blocks. Our research addresses the critical need for specialized debugging approaches tailored to the unique properties of each circuit type. For Amplitude Permutation Circuits, we propose techniques to correct amplitude permutations mimicking classical operations. In phase modulation circuits, our proposed strategy targets the precise calibration of phase alterations essential for quantum computations. The most complex Amplitude Redistribution Circuits demand advanced methods to adjust probability amplitudes. This research bridges a vital gap in current methodologies and lays the groundwork for future advancements in quantum circuit debugging. Our contributions are twofold: We present a comprehensive unit testing tool (Cirquo) and debugging approaches tailored to the unique demands of quantum computing, and we provide empirical evidence of its effectiveness in optimizing quantum circuit performance. This work is a crucial step toward realizing robust quantum computing systems and their applications in various domains.
As the scale of quantum programs grows to match that of classical software, the nascent field of quantum software engineering must mature and tools such as debuggers will become increasingly important. However, developing a quantum debugger is challenging due to the nature of a quantum computer; sneaking a peek at the value of a quantum state will cause either partial or complete collapse of the superposition and may destroy the necessary entanglement. As a first step to developing a full quantum circuit debugger, we have designed and implemented a quantum circuit debugging tool. The tool allows the user to divide the circuit vertically or horizontally into smaller chunks known as slices, and manage their simulation or execution for either interactive debugging or automated testing. The tool also enables developers to track gates within the overall circuit and each chunk to understand their behavior better. Feedback on usefulness and usability from early users shows that using the tool to slice and test their circuits has helped make the debugging process more time-efficient for them.
Quantum programming involves designing and constructing executable quantum programs to achieve specific computational results.Several quantum programming languages, such as Scaffold, Quipper, Qiskit, Q#, and Cirq, enable researchers and developers to implement and experiment with quantum computing techniques efficiently.However, ensuring the correctness of quantum programs is challenging due to unique features like superposition, entanglement, and no-cloning, which make bug detection difficult.Although some approaches for debugging and testing quantum software have been proposed, the research in identifying and detecting bugs in quantum programs is still in its early stages.Existing research has shortcomings in the following areas: (1) Redundancy in Bug Patterns: Many publicly reported bugs follow similar patterns, necessitating proper bug pattern classification metrics to assist developers in understanding and avoiding these bugs effectively.(2) Lack of Suitable Bug Benchmark Suites: The absence of comprehensive bug benchmark suites restricts the systematic evaluation of debugging and testing methods for quantum programs, hindering the progress of quantum software development.(3) Challenges of Dynamic Techniques and Classic Static Analysis: Dynamic techniques relying on the execution of quantum programs can be cumbersome and expensive, while classic static analysis tools designed for traditional programs are unsuitable for analyzing quantum programs due to their unique mechanisms.To address these challenges and improve the quality assurance of quantum software, this thesis primarily focuses on identifying and detecting bugs in quantum programs.The work is divided into three phases: (1) Identification and Categorization of Bug Patterns: The thesis identifies and categorizes bug patterns in the Qiskit quantum programming language.This provides researchers and programmers with a clear understanding of the types of bugs that can occur in quantum programs and how to detect them.The bug patterns cover quantum-related constructs, focusing on symptoms, root causes, cures, and preventions.(2) Bugs4Q Benchmark Suite: As an initial step towards evaluating debugging and testing tools for quantum software, the thesis introduces Bugs4Q.This benchmark suite consists of forty-two real Qiskit bugs obtained from popular platforms like GitHub, StackOverflow, and Stack Exchange.Bugs4Q includes a bug database and test cases to reproduce faulty behaviors.Researchers have access to the actual bugs and corresponding fixes for further study.The i I would like to express my sincere thanks to the members of the defense committee:
Advances in NISQ devices have allowed quantum researchers and enthusiasts to design and develop quantum programs for different applications. As the hardware progresses from noisy to fault-tolerant, the size of the programs implemented will increase. As the circuits get larger, testing and debugging these circuits will become more complex. To overcome the counterintuitive nature of quantum circuits and help developers better understand their programs and locate bugs during the development process's testing and debugging stages, we must understand the different types of bugs that occur in quantum circuits and how they affect the state of the qubits and propagate through the circuit. In this work, we categorize some bugs that could occur when implementing quantum circuits. This poster is part of a bigger work that aims to assist developers in debugging their circuits. This is done by bridging some testing and debugging techniques from the classical world, such as hypothesis and binary-like testing, and debugging-assistance functions, such as tracking gates and detecting qubits' light cones. In addition, we collected and studied bugs from Stack Exchange, Stack Overflow, and GitHub and categorized these bugs based on their source to provide developers with tools and information for an efficient and systematic debugging process for their programs.
A Suite for Testing and Debugging Quantum Programs", addresses an underdeveloped area of research in the current scope of quantum computing: testing and debugging quantum programs.This work makes a significant contribution not only to the future of quantum software development but also more broadly to the advancement of the field of quantum computing, as software tools are critical to maturing from the current NISQ (noisy intermediate-scale quantum) era to the FTQC (fault-tolerant quantum computation) era.Quantum technology has been rapidly evolving, as seen through the significant advances in quantum computing, sensing, cryptography, and communication.Quantum technology is transitioning from experimental prototypes to more practical, yet still limited, applications.These advances offer the prospect of unprecedented computational capabilities for specific tasks like optimization, chemical simulation, and cryptography but are hindered by challenges such as error rates, qubit coherence times, and scalability.All of these problems are being addressed by physicists and engineers.One area receiving far too little attention is the emerging field of quantum software engineering.
Quantum simulators are a foundational component of the quantum software ecosystem. They are widely used to develop and debug quantum programs, validate compiler transformations, and support empirical claims about correctness and performance. In the absence of large-scale quantum hardware, simulator outputs are often treated as ground truth for algorithm development and system evaluation. However, quantum simulators also introduce unique implementation challenges. They must faithfully emulate quantum behavior while executing on classical hardware, requiring complex representations of quantum state evolution, operator composition, and noise modeling. Yet, we still lack a large-scale and in-depth study of failures in quantum simulators.
To bridge this gap, this work presents a comprehensive empirical study of bugs in widely used open-source quantum simulators. We analyze 394 confirmed bugs from 12 simulators and manually categorize them based on root causes, failure manifestations, affected components, and discovery mechanisms. Our study reveals several key findings. First, bug discovery is largely user-driven, with most crashes, exceptions, and resource-related failures not detected by automated testing and identified after deployment. Second, logical correctness failures are widespread and often silent, producing plausible but incorrect outputs without triggering crashes or explicit error signals. Third, many critical failures originate in classical simulator infrastructure, such as memory management, indexing, configuration, and dependency compatibility, rather than in core quantum execution logic. These findings provide new insights into the reliability challenges of quantum simulators and highlight opportunities to improve testing and validation practices in the quantum software ecosystem.