Quantum Software Engineering

I presented the work that we have been carrying on to develop a methodology for distributing the shots of a quantum computation across multiple, heterogeneous Quantum Processing Units.

The proposed methodology features different policies for shot distribution as well as a calibration technique to pre-evaluate the accuracy and reliability of target QPUs.

I discussed the potential advantages of such a methodology both quantitatively (average/maximal error and deviation) and qualitatively (robustness to noise and resilience to QPU failures).

Finally, I briefly pointed to our most recent work, devoted to exploring the potential advantages of combining circuit-cutting and shot-wise distribution techniques.

This talk has 3 parts: Part 1 explores 9 foundational challenges for applying software engineering principles to quantum computing. Part 2 discusses Federico Faggin’s OTP Theory in the light of principled challenges for Quantum Software. Part 3 delevops several baselines for utilizing OTP theory as an inspiration for the emerging field of Quantum Software.

Quantum algorithms, represented as quantum circuits, can be used as benchmarks for assessing the performance of quantum systems [1]. Existing datasets, widely utilized in the field, suffer from limitations in size and versatility, leading researchers to employ randomly generated circuits. Random circuits are, however, not representative benchmarks as they lack the inherent properties of real quantum algorithms for which the quantum systems are manufactured [2]. This shortage of “useful” quantum benchmarks poses a challenge to advancing the development and comparison of quantum compilers and hardware, as also highlighted by recent studies on full-stack quantum computing systems [3]. Our goal is to enhance existing quantum circuit datasets by generating what we refer to as “realistic-looking” circuits by employing the Transformer machine learning architecture [4]. For this purpose, we introduce KetGPT [5], a tool that generates synthetic circuits in OpenQASM language [6], whose structure is based on quantum circuits derived from existing quantum algorithms and follows the typical patterns of human-written algorithm-based code (e.g., order of gates and qubits). Our three-fold verification process – comprising manual inspection and Qiskit framework execution, transformer-based classification, and structural analysis – demonstrates the efficacy of KetGPT in producing large amounts of additional circuits that closely align with algorithm-based structures.

The rapid advancements in quantum computing necessitate a rigorous approach to the construction of a corresponding software ecosystem that combines knowledge and expertise from quantum computing, software engineering and computer science. The German Aerospace Center (DLR) is currently developing a quantum software ecosystem integrating software and hardware from various academic and industrial stakeholders. This talk gives an overview of these activities, shares experiences and highlight different research perspectives in the context of quantum software ecosystem design. It discusses considerations essential for building a quantum software ecosystem that makes quantum computing available for scientific and industrial problem-solving. At the heart of this discourse is the concept of hardware–software co-design, which creates a bidirectional feedback loop from the application layer at the top of the software stack down to the hardware. This approach begins with compilers and low-level software that are specifically designed to align with the unique specifications and constraints of the quantum processor, proceeds with algorithms developed with a clear understanding of underlying hardware and computational model features, and extends to applications that effectively leverage the capabilities to achieve a quantum advantage. For this purpose, a suitable benchmarking framework must be developed and integrated at all levels of the software stack. We discuss the ecosystem from two critical perspectives: the conceptual view, focusing on theoretical foundations, and the software infrastructure view, addressing practical implementations around real quantum devices necessary for a functional ecosystem. The integration of these two perspectives raises novel research challenges for the quantum software engineering community that are highlighted. Following this approach ensures that the focus is toward promising applications with optimized algorithm–circuit synergy, while ensuring a user-friendly design, an effective data management, an overall orchestration strategy, suitable benchmarking for quantum readiness as well as a clean software and services architecture.

In this talk we explored different approaches to improve the usage of QPUs inspired by classical service-oriented computing techniques.

First, we discussed a Quantum Task Manager [1] that integrates load balancing and resource allocation for efficient quantum task execution across multiple quantum providers. This solution aims to simplify the resource selection process for developers, making it easier for them to take full advantage of the resources offered by different quantum service providers. The Task Manager implementation adheres to the REST API architectural pattern, and it dynamically allocates tasks based on factors like the load of quantum resources, the number of pending tasks, and the availability of quantum machines. Its main goal is to improve resource availability and performance, delivering a higher quality of service for quantum task execution.

And then, the QCRAFT Scheduler [2] was reviewed. This tool reduces waiting times and execution costs while making greater use of quantum computer resources. To do that, circuit from different users are scheduled into combined circuits that can be executed together. This strategy provides a substantial improvement for the developers in terms of reducing queueing times and costs. Furthermore, the noise suffered by the execution of the combined circuits does not notably affect the obtained results. . These works underscore the potential of service-oriented computing methodologies and tools to improve resource utilization in quantum computing, facilitating the way for more efficient and accessible quantum software development.

We cannot think about quantum software without acknowledging that we know only a handful of quantum algorithms – and these are almost trivial from a software engineering point of view. Based on empirical analyses of open source quantum software, it is known that little of “quantum software” is actually “quantum”, and core quantum aspects are interleaved with large amounts of classical code. However, this is not necessarily a bad thing if we slightly rethink what “software” means in this context: I argue that by properly distinguishing between formal representations of (computational or problem) models and the underlying physical process that performs the actual work, it can be seen that transformation processes and the choice of appropriate model representations are at the core of quantum computation, and should receive appropriate attention as “software”. This leads to important unsolved questions that must be addressed by future research: Which models do perform useful computational tasks, how can we leverage their computational power, and how can we devise and automate the required model transformations from representations that have proved useful for traditional computation.

When it comes to applying software engineering principles to programs for quantum computers, the path forward is well-defined, with a clear vision for the next five to ten years. In contrast, using quantum computers to address software engineering problems presents a more uncertain and complex trajectory. This talk explores the challenges we face in this area and highlight some open questions, offering insights that may be of interest to the broader community.

The Canadian Quantum Software Consortium (QSC) research team, with funding from a five-year NSERC Alliance Quantum Consortium Grant, explores distributed quantum solutions for Canada.

The QSC team will pioneer distributed quantum computing software methodologies by adapting known quantum algorithms, developing new distributed quantum algorithms, investigating quantum software engineering methods, and establishing communication programming abstractions to connect disparate quantum processors. The team will also develop software for several socially and economically relevant distributed quantum applications, including practical chemistry, drug discovery, quantum materials, and quantum machine learning.

Distributed quantum computing (DQC) is a rapidly evolving field with its own unique challenges and opportunities. DQC represents a significant step in evolving hybrid quantum-classical computing. While hybrid systems tightly couple classical and quantum processors, DQC systems provide classical and quantum network services to connect and entangle logical qubits across quantum chips. DQC offers ways to build scalable platforms beyond current limitations for exploring quantum architectures, networks, algorithms, software, and applications.

Experimental platforms for distributed quantum computing are critical in demonstrating quantum utility at scale. We are developing a software framework to automate the deployment of DQC experiments, thereby accelerating the proliferation of distributed quantum algorithms and solutions.

I will claim that the right way to create complex, scalable quantum programs is through electronic design automation (EDA) synthesis methods. I will present Classiq’s mature synthesis engine and related aspects. I will show results backing this claim, in particular orders of magnitude improvements in program parameters compared to common compilation techniques for quantum software. The talk is based on https://arxiv.org/abs/2412.07372

This talk introduces a Software Product Line (SPL) approach for developing hybrid quantum-classical software systems, addressing the challenges of variability, complexity, and reuse in Quantum Software Engineering (QSE). As quantum computing (QC) increasingly integrates with classical software, systematic engineering techniques are essential to manage this hybrid paradigm. The proposed approach leverages feature models (FMs) to structure software variability, enabling modular, reusable components that adapt to evolving quantum and classical computing landscapes. The methodology follows a multi-level abstraction process, encompassing computing-independent, platform-independent, and platform-specific models to facilitate domain-driven and technology-agnostic software development. The preliminary findings highlight SPLs as a powerful mechanism for automating hybrid software development, enhancing reuse, improving testing efficiency, and managing scalability. However, challenges remain in tool support, runtime variability (Dynamic SPLs), and quantum-software-hardware co-design. This approach establishes the foundation for Quantum Software Product Lines (QSPLs), providing a structured framework to advance QSE and address the complexities of hybrid quantum applications.

Fixed-margin binary matrices widely used in fields like ecology and software engineering serve as essential tools for tasks such as hypothesis testing and fault localization. Generating such matrices with fixed row and column sums is critical for null model analysis but computationally challenging.This talk presents a novel approach using quantum annealing formulating the problem as a Quadratic Unconstrained Binary Optimization (QUBO) task. We share experimental results from the D-Wave Advantage quantum computer and Fixstars Amplify Annealing Engine showcasing the potential of quantum technologies to solve these problems efficiently.

This talk is supported by the [Bergerault].

While quantum computers have attracted much attention, dealing with computational errors due to noise caused by the external environment is a significant challenge. The current state of quantum computers is unstable, therefore. Users remain concerned about incorporating them into their businesses. We propose a new system architecture for reliable quantum computing. It has two features: redundancy and self-adaptation. By integrating classical software engineering techniques (i.e., software redundancy and self-adaptive techniques), the proposed architecture contributes to improving the reliability of the output of the quantum software systems. It consists of three layers: 1) Quantum computing application, 2) MAPE-QK (Monitor, Analysis, Plan, Execute, and Quantum Knowledge), and 3) NVQS (N-version Quantum Software Systems). While MAPE-QK is a quantum software managing system, NVQS is a managed quantum software system. In NVQS, multiple quantum systems that perform the same calculation are run independently to improve the reliability of the quantum system output. On the other hand, the MAPE-QK system monitors and analyzes the execution status of multiple quantum systems. Then, the quantum systems are automatically reconfigured to maintain and improve reliability. Through this architecture, we aim to create a society where users can operate quantum applications safely and securely.

Quantum computing is an interdisciplinary field that relies on the expertise of many different stakeholders. The views of various stakeholders on the subject of quantum computing may differ, thereby complicating communication. To address this, we propose a view-based quantum development approach based on a Single Underlying Model (SUM) and a supporting quantum Integrated Development Environment (IDE). Realizing this View-based Quantum Development approach with a supporting IDE will require solving the following research challenges: The conceptual challenge is the design of the Q-SUM that manages the consistency of different views of quantum software based on existing view- and model-based technologies. To design such a model, it is necessary to identify and analyze the various possible views, and their respective benefits and drawbacks. The design has to be extensible to integrate existing and future QPLs and support design patterns, best practices, modularity, and compositionality. Implementation challenges are the design and implementation of the IDE using a selection of state-of-the-art tooling, and the integration of external quantum simulators and interfaces to quantum hardware. For the evaluation of the Q-SUM, use case scenarios have to be defined and the capabilities of the approach have to be evaluated against them. Finally, a user study with domain experts should be conducted to rate the usability of our approach and its supporting IDE.

From the last few years running a QC department in an HPC center, we’ve developed thoughts on what roles an HPCQC software stack needs to have for users, developers, administrators, facility team and the systems themselves. This would be an overview talk based on experience that is driving some of the requirements we’re baking into our Munich Quantum Software Stack. I’d also posed some open questions based on data we’re getting from the systems that may influence design decisions for the software.

Our group is developing hybrid quantum-classical approaches for solving constrained combinatorial optimization problems for gate-based quantum computing hardware – using the quantum approximate approximation algorithm (QAOA), or quantum annealing. Both approaches take as input format quadratic unconstrained binary optimization (QUBO) problems. To describe a constrained combinatorial optimization problems as QUBO, one typical introduces penalty terms to the objective function. While this introduces infeasible solution to the solution space, it maintains optimality. However, when interested in not only optimal solutions but high quality solutions, setting the penalties for the terms is a hard problem. Tackle this issues using two approaches: (1) by transforming the constrained problem to an unconstrained one while maintaining the solution quality and (2) by a systematic investigation of the solution landscape wrt different encodings of the QUBO (ie, one-hot and domain-wall encodings).

We also survey our tools in optimization (QPLEX), quantum machine learning (piQture) and in the quantum computing education space, including QWalkViz, QGrover, QNotation and QuantumCrypto.

With physical realizations of quantum computing becoming accessible to a broader audience and several potential applications on the horizon, the efficient design of quantum computing solutions is now a key focus. As with classical systems, software plays a crucial role. But can we simply repurpose established software from the classical realm, or must we start from scratch for quantum computing? Additionally, how do we build bridges between computer scientists, who can develop efficient tools, and platform providers, who possess deep technological knowledge? This talk aims to provide answers to these questions, illustrated by current developments from the Munich Quantum Toolkit (https://www.cda.cit.tum.de/research/quantum/).

Today, the processing of quantum information is mostly defined by quantum circuits. However, the design of such quantum circuits is a challenging task which requires significant knowledge in quantum information theory. On top of that, finding an accurate solution (correct functionality) with low computational cost requires to reason about trade-offs between conflicting goals. This talk summarizes an ongoing series of works [1, 2] we perform to provide dedicated automation support for the synthesis, optimization, and debugging of quantum operators and circuits by using multi-objective optimization. More specifically, we use a meta-heuristic search approach by utilizing genetic programming in combination with numerical parameter optimizers as well as techniques from quantum information theory. The evaluation of the current framework on a set of quantum programs collected from literature and open-source projects shows that the approach is able to synthesize quantum operators as well as to correct and optimize existing quantum circuits.

The working group discussed the different types of adaptation [1] that hybrid [2], distributed quantum systems [3] should feature and classified them into three main dimensions: cost-driven, resource-driven, and quality-driven.

The working group highlighted the important need to trade off the aforementioned three dimensions (cost, resources, and quality) in order to realize valuable adaptations of quantum systems.

The working group then focused on identifying the new specific parameters to be taken into account for adapting quantum systems, such as circuit depth and height, coherence, entanglement, measurement, and noise.

The working group discussed two possible use cases for adaptive quantum systems: the travelling salesperson problem and the shot-wise distribution of quantum computations.

Hybrid quantum-classical and distributed quantum computing require dynamic adaptation due to evolving hardware, quantum networks, runtime system software, and problem constraints. Continuous monitoring and automated adaptation are essential for the long-term evolution of hybrid quantum systems. One promising avenue is to develop model-based frameworks [4] to explore, evaluate, and track different design choices systematically using autonomic computing techniques.[5]

Quantum computing is promised to redefine a variety of application domains. However, its practical realization remains hindered by the complex interplay between hardware limitations and software intricacies. At the Dagstuhl Seminar, our working group concentrated on the question how software abstraction can effectively bridge this gap and make quantum computing both accessible and scalable. Building upon the principles of Model-Driven Architecture (MDA) [1], we discussed methods to structure quantum software development into distinct layers that align high-level requirements with hardware-specific constraints.

In our discussions, we focused on a three-tiered abstraction approach. At the highest level, the computation-independent model (CIM) is used to capture essential requirements and business objectives without engaging with technical details. This model is then refined into a platform-independent model (PIM) that defines core functionalities, which can be applied uniformly across different quantum architectures. Finally, the platform-specific model (PSM) adapts these functionalities to the particular characteristics and limitations of individual quantum hardware systems. We see this layered approach as a practical method to manage complexity and to support a gradual evolution of quantum systems in line with hardware advances.

Another central topic was the potential use of domain-specific languages (DSLs) [2] for quantum computing. We discussed how DSLs could provide an intuitive syntax and semantic framework tailored to quantum operations, offering more expressive tools than conventional programming languages. However, we also recognized key challenges, such as ensuring long-term maintainability, achieving compatibility with existing systems, and adapting to rapid technological progress.

Furthermore, our stakeholder analysis revealed that different user groups – ranging from quantum researchers and algorithm developers to business application engineers – have distinct requirements. Researchers demand high-fidelity abstractions to model quantum phenomena accurately, while industry practitioners need interfaces that integrate seamlessly with traditional computing environments. We therefore recommend a stakeholder-centric approach, supported by iterative feedback through user studies and workshops.