Modern quantum computers rely heavily on real-time control systems for operation. Software for these systems is becoming increasingly more complex due to the demand for more features and more real-time devices to control. Unfortunately, testing real-time control software is often a complex process, and existing simulation software is not usable or practical for software testing. For this purpose, we implemented an interactive simulator that simulates signals at the application programming interface level. We show that our simulation infrastructure simulates kernels 6.9 times faster on average compared to execution on hardware, while the position of the timeline cursor is simulated with an average accuracy of 97.9% when choosing the appropriate configuration.
Modern quantum computers rely heavily on real-time control systems for operation. Software for these systems is becoming increasingly more complex due to the demand for more features and more real-time devices to control. Unfortunately, testing real-time control software is often a complex process, and existing simulation software is not usable or practical for software testing. For this purpose, we implemented an interactive simulator that simulates signals at the application programming interface level. We show that our simulation infrastructure simulates kernels 6.9 times faster on average compared to execution on hardware, while the position of the timeline cursor is simulated with an average accuracy of 97.9% when choosing the appropriate configuration.
Real-time control software and hardware is essential for operating quantum computers. In particular, the software plays a crucial role in bridging the gap between quantum programs and the quantum system. Unfortunately, current control software is often optimized for a specific system at the cost of flexibility and portability. We propose a systematic design strategy for modular real-time quantum control software and demonstrate that modular control software can reduce the execution time overhead of kernels by 63.3% on average while not increasing the binary size. Our analysis shows that modular control software for two distinctly different systems can share between 49.8% and 91.0% of covered code statements. To demonstrate the modularity and portability of our software architecture, we run a portable randomized benchmarking experiment on two different ion-trap quantum systems.
Quantum computer is the key to controlling complex processes. If its hardware, in general is successfully created on the basis of the physical baggage of the 20th century, the mathematical software is fundamentally lagging behind. Feynman's user interface in the form of quantum gate arrays, cannot be used for the control because it gives the solution of the Schrödinger equation with quadratic slowdown compared to the real process. The software must then imitate the real process using appropriate program primitives written as the programs for classical supercomputer. The decoherence will be reflected by some constant - the number of basic states that can fit into the limited of memory available to software. The real value of this constant can be found in the experimental realization of Grover search algorithm. Rough estimates of this constant are given based on the simplest processes of quantum electrodynamics and nuclear decay.
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.
Abstract Quantum computing proposes a revolutionary paradigm that can radically transform numerous scientific and industrial application domains. To realize this promise, these new capabilities need software solutions that are able to effectively harness its power. However, developers may face significant challenges when developing and executing quantum software due to the limited availability of quantum computer hardware, high computational demands of simulating quantum computers on classical systems, and complicated technology stack to enable currently available accelerators into development environments. These limitations make it difficult for the developer to create an efficient workflow for quantum software development. In this paper, we investigate the potential of using remote computational capabilities in an efficient manner to improve the workflow of quantum software developers, by lowering the barrier of moving between local execution and computationally more efficient remote hardware and offering speedup in execution with simulator surroundings. The goal is to allow the development of more complex circuits and to support an iterative software development approach. In our experiment, with the solution presented in this paper, we have obtained up to 5 times faster circuit execution runtime, and enabled qubit ranges from 21 to 29 qubits with a simple plug-and-play kernel for the Jupyter notebook.
This paper describes the verification of the classical software and hardware stack that is used to control cold atom- and superconducting-based quantum computing hardware. The paper serves both as an introduction to quantum computing and to how classical device verification techniques can be employed there. Two main challenges in building a quantum control stack are generating precise deterministic-timing operations at the edge and scaled-out processing in the middle layer. Both challenges are to do with a certain kind of functional performance correctness. And, as usual, the design lives under tight power, memory and latency constraints. The quantum control stack is a complex interaction of algorithms, software runtimes and digital hardware. We take inspiration from modern software approaches to engineering, such as continuous integration and hardware automation, to quickly ship experimental features to customers in the field.
As the scientific community is increasing the coverage of the quantum computing domain ranging from theoretical physics to financial applications, so does the number of quantum computing applications being developed for quantum computing hardware that is available today. As this hardware evolves towards increased capacity in terms of qubit number and increased fidelity, so does the complexity of quantum computing applications that implement the state-of-the-art of (hybrid) quantum algorithms. With this comes an increased demand for quantum software engineering practices where testing is a crucial part of the development process. Hence, a robust approach that addresses certain challenges and peculiarities related to the quantum computing domain is needed for the testing process. This paper proposes a standard-ready testing pipeline that covers the requirements of testing in a continuous development cycle as part of a modern quantum software engineering lifecycle.