The Quantum Software Architecture (QSA) pursues to deliver architectural descriptions that include components, connections, and configurations to aid in the design and development of quantum software, while abstracting complicated and implementation-specific tasks.
The objective of QSA is to provide a complete view on quantum software-intensive systems, resembling a blueprint, by abstracting complex implementation specifics via architectural components and connectors. This method reflects the effective use of architectural descriptions and specifications in traditional software development, where they have been crucial in designing, developing, validating, and evolving systems at elevated levels of abstraction while maintaining system functionality and quality. Despite substantial financial and strategic investments by technology giants in quantum computing platforms and quantum programming languages (QPLs) like Q# from Microsoft, Qiskit from IBM, and Cirq from Google, the field of quantum software engineering and development remains emerging. Consequently, QSA is gaining significance in delivering a systematic and rational methodology for developing dependable quantum software. Current software engineering methodologies and modeling notations may be modified to extract architecting tasks and create modeling languages tailored for quantum software.
Building Blocks of Quantum Computing Systems
A quantum computing system can be abstracted in terms of three fundamental building blocks:
- Quantum Hardware
- Quantum Software
- Quantum Software Architecture(QSA)
In the figure, the relationship between these components is depicted. It highlights the correlation between quantum bits (Qubits) and quantum gates (Qugates) and quantum source code. Additionally, it emphasizes how software architecture components and connectors serve as a blueprint for the implementation of this code.
Quantum Hardware
Qubit: The qubit is crucial to quantum computing because, unlike a classical bit, which can either be 0 or 1, it can be situated in a superposition of both states at the same time. A qubit can be in two states: |0〉 or |1〉, or in a superposition state with a 50% likelihood of being |0〉 and a 50% probability of being |1〉. Furthermore, entanglement is a unique quantum feature in which two or more qubits get connected in such a way that the state of one immediately changes the state of the others, regardless of the distance between them. These quantum properties (Qubits, superposition, entanglement, and interference) are essential for quantum information processing.
Quantum Gates: To execute quantum algorithms and change their states, qubits undergo basic operations called quantum gates, or qugates. Quantum gates act on one or more qubits through unitary transformations, much like classical computing’s logic gates. Quantum software architecture (QSA) allows for the representation of qubits mapped to qugates as architectural components and connections. To operationalize quantum computers and take advantage of quantum information processing, software systems and applications are required, similar to how software controls bits and logic gates in classical computing systems.
Quantum Software Engineering (QSE)
Software Engineering (SE): The goal of software engineering (SE), as described by the ISO/IEC/IEEE 90003:2018 standard, is to efficiently design, develop, validate, deploy, and evolve software-intensive systems by utilizing ideas in engineering and methods. The issues of quantum computing, including quantum software models, their algorithmic specifications, and simulated assessments to capitalize on the benefits of quantum hardware for quantum information processing, have been addressed by SE-focused research and development in recent years.
Quantum Software Engineering (QSE): Applying SE concepts to the field of quantum computing is known as quantum software engineering, or QSE. A variety of engineering operations, such as requirements engineering, design, implementation, assessment, and deployment, are included in the software processes that must be followed. The QSA is essential throughout the design phase of the QSE lifecycle. Quantum Programming Languages (QPLs) are crucial for generating executable specifications for quantum hardware; yet, they frequently emphasize computation and implementation specifics, neglecting a comprehensive perspective of the software systems being designed. Implementation details based on source code might obscure the architectural perspective, which functions as a system blueprint and is essential for preserving the quality and operation of quantum software. Research indicates that quantum software initiatives emphasizing quantum source code implementation rather than design principles are susceptible to erroneous implementations and defects. Consequently, QSA addresses this deficiency by offering elevated abstractions and a structural viewpoint on quantum software systems. Established architectural methods and activities from classical software engineering provide focused expertise that may be modified to tackle the architectural issues inherent in quantum software systems.
Architectural Processes for Quantum Software
An architectural method for quantum software takes a step-by-step and incremental approach to generating architectural solutions, involving a variety of architecting tasks. These efforts contribute to the study, synthesis, and assessment of the architecture for quantum software systems and applications. During the system design and implementation phase, the architectural process simplifies what needs to be done and provides a framework for various architecting activities that indicate how it should be done. Key architecting activities identified for quantum software are:
- Architectural Requirements: Examining and identifying the design problems and challenges a given architecture must address is part of this process. The result is a list of architecturally significant requirements (ASRs) stressing the required functionality and intended quality of the system. An ASR might be the method of safely and efficiently distributing quantum information across a quantum network.
- Architectural Modeling: Specifying its components, connectors, and configurations, abstract high-level models (design artifacts) of the quantum software architecture is created. The system finds its blueprint in these models. Developing architectural models to generate quantum source code or designing network topologies for quantum information transfer are two instances of examples.
- Architectural Implementation: This stage of architectural implementation concentrates on turning the abstract high-level models into low-level executable specifications (source code artifacts). Model-driven architecting of quantum software allows one to enable this by means of model transformations creating high-level source code then compiled into quantum instruction sets. Among the activities are compiling and developing quantum codes.
- Architectural Validation: This exercise aims to guarantee that the applied architecture satisfies the architectural criteria and the intended quality traits. Simulating and testing the quantum software could help to find any inconsistencies between the design and execution.
- Architectural Deployment: Configuring the executable specification (architectural implementation) on a deployment node—usually an application server—on a last action helps to permit the operationalizing of the validated software.
Although current architectural methods for classical computing systems can be customized to assist the architecting process for quantum software systems, architectural modeling and implementation activities must clearly address needs particular to quantum software. Customized activities in the architectural process are required of quantum-specific challenges including co-design (the simultaneous design of quantum algorithms and the underlying quantum hardware), mapping quantum algorithms to Qubits and Qugates, compiling hybrid classical-quantum source code into a unified quantum instruction set, and configuring simulators for quantum code execution. The iterative nature of the architectural activities calls for maintenance or refactorings of the architectural model depending on comments from the implementation and validation stages to guarantee consistency between design and execution.
Modeling Notations for Quantum Software Architectures
Modeling representations are essential for visually depicting the detailed sequence of architecting activities and illustrating the relationships between the numerous units of a software system. Research indicates that modeling notations to specify quantum software architectures primarily rely on box and arrow notations (component diagrams) and graph-based models (state graphs) to represent the structures and behavior of quantum software under design. These notations help in visualizing the architectural components (e.g., Qubits, Qugates, quantum circuits, classical control units) and their interactions (e.g., quantum communication channels, control flow).
Unlike conventional software architectures, where the Unified Modeling Language (UML) is often considered a de facto standard for software design, there is considerably less evidence of UML-based modeling for quantum software architectures.Still, certain initiatives are starting in this line. For instance, one work shows a quantum-specific UML called Q-UML that uses class and sequence diagrams to depict the structure and behavior of quantum software systems. By means of the current tools, frameworks, and architectural knowledge within the software engineering community, the development of such quantum-specific extensions to existing modeling languages could be advantageous in leveraging the existing reusability and (semi-)automation to empower designers and architects in modeling, developing, and evolving quantum software. Dedicated architectural description languages and UML profiles able to properly reflect the special qualities and complexity of quantum software seem to be needed.
Architectural Patterns for Quantum Software
Architectural patterns are recommended practices for building and using software systems as they reflect reusable knowledge. Finding and recording architectural patterns for quantum computers can greatly help to address reoccurring architectural issues and support good design decisions. Several trends for quantum software architectures have been found by the systematic literature study including:
- Layered pattern: Usually segregating issues like the application logic, quantum algorithms, and hardware interface, this layered pattern arranges the system into hierarchical layers.
- Pipe and filter pattern: For quantum data processing pipelines, this pattern—which runs data through a series of independent processing steps (filters) linked by data streams—pipes—can be really helpful.
- Composite design pattern: This pattern can be used to the creation of quantum circuits and subsystems since it lets one create complicated constructions from simpler components.
- Prototypical design pattern: In some quantum simulation or state preparation situations, this pattern—which entails copying a prototype—may find use.
- Recursive containment: Possibly helpful for modular quantum designs, this pattern comprises elements of the same type that enclose other such components.
- Two-qubit gate patterns: Fundamental to quantum processing, two-qubit gate patterns reflect typical and effective configurations of two-qubit gates.
These trends reflect preliminary results; the subject of quantum software architecture is still developing and more specialized and efficient architectural patterns suited to the particular difficulties of quantum computing are probably to be revealed by continuous research.
Tools and Frameworks for Quantum Software Architecture
Support of the automation and customization of architectural solutions for quantum software depends much on tools and frameworks. These technologies can supplement architectural solutions, give user decision support, and help architecting operations to be automated. The examined literature notes numerous tools and frameworks pertinent to quantum software architecture:
- Simulation tools: LIQUi|>, qHiPSTER, Strawberry Fields, JKQ DDSim, Kwant, and QuNetSim are among the simulation tools that let one model quantum operations, track quantum states, and replicate the running of quantum algorithms on classical equipment. By concentrating on the degree of superposition and entanglement, the Ket Bitwise Simulator (KBW) is another tool meant to increase simulation efficiency.
- Quantum programming languages and frameworks: Frameworks include Qiskit (IBM), Q# (Microsoft), and Cirq (Google) offer tools and libraries for designing, running, and generating quantum programs on genuine quantum hardware as well as simulators and An other framework stressing hardware abstraction and a full-stack approach is OpenQL. ProjectQ is a modular compiler based open-source framework.
- Compilation tools: The translation of high-level quantum program descriptions into low-level instructions that can be performed on quantum hardware depends on compiler tools. One instrument aiming at several qubit technologies is the OpenQL compiler.
- Link layer protocols: Tools like the Link layer protocol for quantum networks help to manage and transmit quantum information across quantum networks.
- Domain-specific tools: Frameworks tailored to particular quantum computing paradigms or application domains include Strawberry Fields for photonic quantum computing and Kwant for quantum transport simulations.
These tools and frameworks support several human roles engaged in the development process, such quantum domain engineers who understand the physics and quantum algorithms, and quantum code developers who implement the software; they also often incorporate reusable knowledge about quantum algorithms and hardware. Automating and personalizing the design process for quantum software depends on constant development of such tools.
Quantum-Classical Co-design
The development of quantum software architectures presently entails a considerable extent of quantum-classical co-design. Owing to the nascent stage of quantum software research, it is typically impractical to construct a comprehensive quantum software architecture exclusively on quantum computing principles. It is essential to incorporate classical software development principles and methodologies, particularly at the interface level, to organize a comprehensive quantum software system. Research demonstrates that a substantial segment of current quantum software architectural solutions emphasizes the quantum-classical interface, wherein classical and quantum methodologies are employed collaboratively. This hybrid methodology is deemed essential in the short term for enhancing architectural efficiency and achieving requisite performance objectives. Effective co-design necessitates intimate collaboration between software and hardware developers to develop architectural models that align software components with the instruction set of the quantum computing processor.
Read more about the Quantum Computing Architecture Diagram
Read more about the What is Quantum Finite Automata in Quantum Computing?
Read more about the What is Quantum cellular automata in quantum computing?