Quantum Software Engineering

Landscapes and Horizons

Jianjun Zhao
Kyushu University
[email protected]

ABSTRACT application is the problems that require efficient and accurate sim-
Quantum software plays a critical role in exploiting the full po- ulation of quantum problems in nature [85, 307] from the areas,
tential of quantum computing systems. As a result, it is drawing such as physics [52], chemistry [182, 204, 231] and materials sci-
increasing attention recently. This paper defines the term "quantum ence [116, 299].
arXiv:2007.07047v1 [cs.SE] 14 Jul 2020

software engineering" and introduces a quantum software life cycle. With the rapid development of impressive quantum hardware
Based on these, the paper provides a comprehensive survey of the as well as the accessibility of universal quantum devices to the
current state of the art in the field and presents the challenges and researchers and professionals via Quantum-as-a-Service (QaaS) [17,
opportunities that we face. The survey summarizes the technology 167], it is high time to focus our attention on engineering quan-
available in the various phases of the quantum software life cycle, tum software systems to reap the benefits of quantum technol-
including quantum software requirements analysis, design, imple- ogy. Meanwhile, various application domains of quantum comput-
mentation, test, and maintenance. It also covers the crucial issue of ing [144, 275, 290, 291] urgently need quantum software engineer-
quantum software reuse. ing methodologies and techniques to solve their specific problems.
Therefore, we believe that there is an urgent need to build a com-
KEYWORDS munity for quantum software engineering that focuses on devising
methods, tools, and processes for developing quantum software
Quantum software engineering, quantum programming, quantum systems efficiently.
software life cycle, requirements analysis, design, testing and de- Quantum software development techniques aim at providing
bugging, maintenance, and reuse means for creating quantum software throughout the quantum
software life cycle (refer to Section 3.5). A number of quantum pro-
1 INTRODUCTION gramming approaches are available, for instance, Scaffold [1, 138],
Qiskit [232], Q# [269], ProjectQ [272], and Quipper[115]. Moreover,
"The challenge [of quantum software engineering] is to rework and the concepts are also being applied at the earlier stages of quantum
extend the whole of classical software engineering into the quantum software development. For example, at the quantum software de-
domain so that programmers can manipulate quantum programs with sign stage, [45, 46, 220] provides means for modeling and specifying
the same ease and confidence that they manipulate today’s classical quantum software systems, and [260] studied how the characteris-
programs." tics of quantum computing systems impact the quality attributes
of quantum software architectures. With a variety of techniques
Susan Stepney, in the 2004 report of Grand Challenges in available to a software engineer at each stage, the task of engineer-
Computing Research [130]. ing a quantum software system poses significant challenges. At
each development stage, the software engineer needs to employ
Quantum computing is a rapidly developing field that is expected
the most suitable quantum software technique for the application
to make breakthroughs in many areas [20, 25, 67, 161, 204, 205].
being developed. The choice of technique can be dictated by various
Quantum computing uses the principles of quantum mechanics
factors, including system requirements, organizational practices,
to process information and has the potential to perform specific
and constraints imposed by the tools or development environments,
tasks much faster than classical computing. The basis of quantum
and the nature of the quantum programming (mechanics). This im-
computing is the quantum bit (qubit). Unlike a classical computer
plies that multiple techniques may be employed at each stage in
bit that is assigned either 0 or 1, a qubit can be either assigned
conjunction with each other. As quantum software development
states that is the superposition of 0 and 1. Compared to classical
techniques mature, there is a need for guidelines supporting the
algorithms, quantum algorithms have the potential to solve specific
development of well-engineered quantum software systems.
problems with exponential acceleration. In the last two decades,
In this paper, we present a comprehensive survey of quantum
there has been a large amount of literature that contributed to the
software engineering. We summarize the aspects of previous work
development of quantum algorithms [70, 118, 192, 193, 249, 257].
that have focused mainly on quantum software engineering issues,
Just like classical computing, quantum computing is applicable to
while simultaneously covering various approaches across different
applications in many disciplines and will have a wide impact [108].
phases of the quantum software life cycle. We have organized the
There are two types of applications where quantum computers
literature according to five different aspects: requirements, design,
are expected to outperform classical computers [178]. The first
implementation, testing, and maintenance. Some papers may cover
application is the problems that require large amounts of paral-
more than one aspect. For such papers, we refer them to all the
lel computing, such as optimization [81, 121], encryption [194],
relevant sections to ensure completeness.
big data analysis [230], and machine learning [34, 76]. The other
 Additionally, we identify challenges and opportunities for the 2.1 Quantum Bit (Qubit)
emerging research community working at the intersection between A classical bit is a binary unit of information used in classical
methodologies and techniques for classical software engineering computation. It can take two possible values, 0 or 1. A quantum
and problems in engineering quantum software systems. To ensure bit (or qubit) is different from the classical bit in that its state is
that our survey is self-contained, we have tried to include enough theoretically represented by a linear combination of two bases in
materials to thoroughly guide the software engineering researchers the quantum state space (represented by a column vector of length
who are interested in techniques and methods for engineering 2). We can define two qubits |0⟩ and |1⟩, which can be described as
quantum software systems. We also seek to provide quantum com- follows:    
puting researchers with a complete survey of software engineering 1 0
|0⟩ = |1⟩ =
solutions to improve the development of quantum systems. 0 1
There have been surveys related to some aspects of quantum Qubits |0⟩ and |1⟩ are the computational basis state of the qubit. In
software engineering. For example, a number of surveys [54, 98, other words, they are a set of basis of quantum state space.
102, 125, 140, 186, 239, 244, 261, 263, 276, 280, 281, 302, 311] have Any qubit |e⟩ can be expressed as a linear combination of two
been proposed for quantum programming languages, which mainly basis as α|0⟩ + β|1⟩, where α and β are complex numbers, and |α | 2 +
focus on the language paradigms, implementations, semantics, and |β | 2 = 1. This restriction is also called normalization conditions.
tools. Surveys related to quantum software development environ- For example, 0.6|0⟩ + 0.8|1⟩ is a qubit state, and 1−i 1+i
2 |0⟩ + 2 |1⟩ is
ments [86, 163, 236, 253] have also been proposed, from various also a qubit state, but (1-i)|0⟩ + (1+i)|1⟩ is not a legitimate qubit state
points of view. However, as far as we know, no previous work has fo- because it does not satisfy the normalization condition. Intuitively,
cused on a comprehensive survey of the whole life cycle of quantum qubits can be viewed as a superposition of classical bits. For example,
software development, including quantum software requirements 0.6|0⟩ + 0.8|1⟩ can be considered as a superposition state of |0⟩ and
analysis, design, implementation, testing, and maintenance. |1⟩, where the probability for bit |0⟩ is 0.62 = 0.36 and for bit |1⟩ is
In summary, the main contributions of this paper are as follows: 0.82 = 0.64. Note that 0.62 + 0.82 = 1 .
• Definition. It defines the term "quantum software engineer- 2.2 Quantum Gate
ing" and introduces a quantum software life cycle model for
Just as a logic gate in a digital circuit that can modify the state of
supporting quantum software development.
a bit, a quantum gate can change the state of a qubit. A quantum
• Survey. It provides a comprehensive survey on quantum
gate can have only one input and one output (transition of a single
software engineering, which is across various phases of
quantum state), or it can have multiple inputs and multiple outputs
quantum software life cycle, including quantum software
(transition of multiple quantum states). The number of inputs and
requirements analysis, design, implementation, testing, and
outputs should be equal because the operators need to be reversible
maintenance.
which means no information can be lost in quantum computing.
• Horizons. It identifies challenges, opportunities, and promis-
Here, we describe two quantum gates with single input and output,
ing research directions for quantum software engineering,
and one quantum gate with multiple inputs and outputs.
intended to promote and stimulate further research.
2.2.1 NOT Gate. The NOT gate works on a single qubit. It can
The rest of this paper is organized as follows. The structure of this exchange the coefficients of two basis vectors:
paper is also depicted in Table 1. Section 2 reviews the fundamental
NOT (α |0⟩ + β |1⟩) = α |1⟩ + β |0⟩
terminology in quantum computing. Section 3 briefly introduces
the quantum software development which includes quantum pro- The quantum NOT gate is an extension of the NOT gate in classical
gramming, a definition of "quantum software engineering," and the digital circuits.
quantum software life cycle for quantum software development. A single input-output quantum gate can be represented by a
From Section 4 to Section 8, we survey the current state of the art on 2 × 2 matrix. The state of a quantum state after passing through
quantum software requirements analysis, design, implementation, the quantum gate is determined by the value of the quantum state
testing, and maintenance, respectively. Section 9 covers the current vector left-multiplied by the quantum gate matrix. The quantum
state of the art on quantum software reuse. Section 10 discusses the gate matrix corresponding to the NOT gate is
challenges and opportunities for quantum software engineering. 
0 1

Related works are discussed in Section 11, and concluding remarks X =
1 0
are given in Section 12. An extensive set of references is provided
Therefore, the result of a qubit passing a NOT gate is
for readers wishing to pursue the matter further.
α 0 1 α β
      
X = =
2 BACKGROUND β 1 0 β α
This section briefly introduces some basics of quantum mechanics, 2.2.2 Hadamard Gate. The Hadamard gate also works on a
which form the basis of quantum computing. More detailed reading single qubit, which can decompose existing quantum states accord-
materials can be found in the books by Gruska [120], Nielsen & ing to its coefficients:
Chuang [202], and Nakahara [198]. Preskill’s lecture notes [225] α +β α −β
are also a valuable resource. H (α |0⟩ + β |1⟩) = √ |0⟩ + √ |1⟩
2 2
2
 Table 1: A Table-like Structure for Paper Organization

Introduction [Sec.1]
Quantum bit (qubit) [Sec.2.1]
NOT gate [Sec.2.2.1]
Quantum gate [Sec.2.2] Hadamard gate [Sec.2.2.2]
Controlled NOT gate [Sec.2.2.3]
Background [Sec.2] Quantum circuit [Sec.2.3]
Superposition and entanglement [Sec.2.4]
Quantum measurement [Sec.2.5]
Quantum algorithm [Sec.2.6]
Quantum computing [Sec.2.7]
Concepts of quantum programming [Sec.3.1.1]
Quantum programming [Sec.3.1] Languages for quantum programming [Sec.3.1.2]
Semantics of quantum programming [Sec.3.1.3]
Quantum Software Engineering [Sec.3] Definition of quantum software engineering [Sec.3.2]
Quantum software engineering methods, tools, and processes [Sec.3.3]
Generic view of quantum software engineering [Sec.3.4]
Quantum software life cycle [Sec.3.5]
Quantum Requirements Analysis [Sec.4]
Quantum software modeling [Sec.5.1]
Quantum software specification [Sec.5.2]
Quantum Software Design [Sec.5]
Pattern language for quantum software [Sec.5.3]
Quality attributes [Sec.5.4]
Quantum Software Implementation [Sec.6]
Bug types in quantum software [Sec.7.1]
Invariant and inductive assertion [Sec.7.2.1]
Assertions for quantum software [Sec.7.2] Applied quantum Hoare logic [Sec.7.2.2]
Assertion library for quantum software [Sec.7.2.3]
Open problems on testing quantum software [Sec.7.3.1]
Fuzz testing [Sec.7.3.2]
Quantum software testing [Sec.7.3]
Quantum Software Testing [Sec.7] Property-based testing [Sec.7.3.3]
Functional, white-box, and model-based testing [Sec.7.3.4]
Debugging tactics [Sec.7.4.1]
Assertion-based debugging [Sec.7.4.2]
Quantum program debugging [Sec.7.4]
Debugging quantum processes [Sec.7.4.3]
Language support for debugging [Sec.7.4.4]
Quantum program analysis for bug detection [Sec.7.5]
Quantum Software Maintenance [Sec.8] Reengineering classical information system to quantum computing [Sec.8.1]
Quantum pattern reuse [Sec.9.1]
Quantum Software Reuse [Sec.9] Quantum circuit reuse [Sec.9.2]
Quantum state reuse [Sec.9.3]
Quantum software requirements analysis [Sec.10.1]
Quantum architectural design [Sec.10.2.1]
Quantum software design [Sec.10.2]
Detailed quantum design [Sec.10.2.2]
Design models for quantum software [Sec.10.2.3]
Quantum software implementation [Sec.10.3]
Fault model for quantum software [Sec.10.4.1]
Challenge and Opportunities [Sec.10]
Quantum software testing [Sec.10.4.2]
Quantum software reliability [Sec.10.4] Quantum program debugging [Sec.10.4.3]
Quantum software visualization [Sec.10.4.4]
Quantum program verification [Sec.10.4.5]
Quantum software maintenance [Sec.10.5]
Quantum software resue [Sec.10.6]
Quantum programming languages [Sec.11.1]
Related work [Sec.11] Quantum software engineering [Sec.11.2]
Quantum software development environments [Sec.11.3]
Concluding Remarks [Sec.12]

This can be represented by a matrix as: Although Hadamard gate is not directly related to the AND and
√  OR gates in classical digital circuits, it has important applications

2 1 1 in many quantum computing algorithms. Interested readers can
H= try to prove that after applying the Hadamard gate twice in a row,
2 1 −1
3
 |j 1 ⟩ H R2 R3 ··· Rn |y1 ⟩

|j 2 ⟩ • H R2 ··· Rn−1 |y2 ⟩

|j 3 ⟩ • • H ··· Rn−2 |y3 ⟩

.. .. .. .. ..
. . . . .
|jn ⟩ • • • H |yn ⟩

Figure 1: Quantum circuit for the quantum Fourier transform (QFT) algorithm.

the quantum state will return to its original state. This behavior is circuit. The result of a quantum circuit can be read out through
consistent with the NOT gate. quantum measurements.
There can be an infinite variety of single input and output quan- As an example, Figure 1 shows the quantum circuit for the quan-
tum gates, as long as the result of the left multiplication of the qubit tum Fourier transform (QFT) algorithm. The quantum gates used
state vector by the qubit state vector-matrix still satisfies the qubit in the circuit
" are# the Hadamard gate and the controlled phase gate
normalization conditions. 1 0
Rm = 2π i . The black dots present the control bits.
2.2.3 Controlled NOT Gate. Computer programs are full of 0 e 2m
conditional judgment statements: if so, what to do, otherwise, do
something else. In quantum computing, we also expect that the 2.4 Superposition and Entanglement
state of one qubit can be changed by another qubit, which requires Quantum computers use the laws of quantum mechanics to pro-
a quantum gate with multiple inputs and outputs. The following is vide a computation mechanism that is significantly different from
the controlled-NOT gate (CNOT gate). It has two inputs and two classical machines. The first distinguishing feature of a quantum
outputs. If the input and output are taken as a whole, this state can system is known as superposition [74, 308], or, more formally, the
be expressed by superposition principle of quantum mechanics. A quantum system
α |00⟩ + β |01⟩ + γ |10⟩ + θ |11⟩ is actually in all its possible states at a time, rather than existing in
one distinct state at the same time. For a quantum computer, this
where |00⟩, |01⟩, |10⟩, |11⟩ are column vectors of length 4, which means that a quantum register exists in the superposition of all its
can be generated by concatenating |0⟩ and |1⟩. This state also needs possible 0’s and 1’s configurations, which is different from a clas-
to satisfy the normalization conditions, that is sical system whose register contains only one value at any given
time. Until the system is observed, it collapses into an observable,
|α | 2 + |β | 2 + |γ | 2 + |θ | 2 = 1
deterministic classical state.
The CNOT gate is two-qubit operation, where the first qubit is Quantum systems may also exhibit entanglement [79, 242], which
usually referred to as the control qubit and the second qubit as the is a quantum mechanical phenomenon. A state is considered to be
target qubit. When the control qubit is in state |0⟩, it leaves the entangled if it cannot be broken down into its more basic parts.
target qubit unchanged, and when the control qubit is in state |1⟩, In other words, two distinct elements of the system are entangled
it leaves the control qubit unchanged and performs a Pauli-X gate if one part of a system cannot be described without considering
on the target qubit. It can be expressed in mathematical formulas the other. A particularly interesting feature of quantum entangle-
as follows: ment is that elements of a quantum system may be entangled even
if they are separated by considerable space. Thus, measurements
CNOT (α |00⟩ +β |01⟩ +γ |10⟩ +θ |11⟩) = α |00⟩ +β |01⟩ +γ |11⟩ +θ |10⟩
performed on one system can instantaneously influence other sys-
The action of the CNOT gate can be represented by the following tems entangled with it. Quantum entanglement has applications in
matrix: quantum computation [202, 257], quantum cryptography [26], and
1 0 0 0  quantum teleportation [112, 139].
 
0 1 0 0 
X =  
0 0 0 1  2.5 Quantum Measurement

0 0 1 0 
  From the introduction of the quantum gate above, we can see that
a qubit is the superposition state of two quantum states |0⟩ and |1⟩;
2.3 Quantum Circuit two qubits combined into a whole are in a superposition of four
Quantum circuits, also known as quantum logic circuits, are the quantum states |00⟩, |01⟩, |10⟩, and |11⟩. From this analogy, n qubits
most commonly used general-purpose quantum computing models, can be described by a superimposed state of 2n qubits, which is a
which represent circuits that operate on qubits under an abstract huge advantage over n classical bits that have only one fixed state.
concept. A quantum circuit is a collection of interconnected quan- However, the laws of physics also have their limitations-in order
tum gates. The actual structure of quantum circuits, the number to know the exact state of a qubit, a measurement is needed. But
and the type of gates, as well as the interconnection scheme, are the measurement can cause the superposition state to collapse into
all determined by the unitary transformation U , performed by the a deterministic state. The information contained in a qubit after
4
 Figure 2: The architecture of quantum computing system in [260].

measurement is similar to a classical bit, and its value can only be (1) Memory initialization: preparing the initial state (basis state)
0 or 1. A superposed state can collapse to 0 or 1, the probability of |x⟩ with x ∈ Bn (classical register),
which is determined by the coefficients α and β in the superposed (2) Operation of the quantum circuit: applying a quantum circuit
state. The probability that this superposed state collapses to |0⟩ or of polynomially many in n gates from some universal gate
|1⟩ is |α | 2 and |β | 2 , respectively. Similarly, for a two-qubit system, set, and
the probability that the measurement results in |00⟩, |01⟩, |10⟩, |11⟩ (3) Performing an elementary measurement: measuring the quan-
is |α | 2 , |β | 2 , |γ | 2 , and |θ | 2 , respectively. tum state to retrieve classic data.
Such physical law causes the result of quantum computing to
be non-deterministic. In actual applications, additional means are Quantum circuits are regarded as a predictive tool that can pro-
needed to verify the correctness of the output. For the algorithm vide some (classical) information probabilistically, from which the
used in quantum computing, if we can reduce the superposition target result can be inferred. The fact that the probability is high
state of qubits as much as possible in the previous step of measure- enough is a direct consequence of the mathematical properties of
ment, we can get correct results with a high probability. the unitary mapping described by the quantum circuit. The essence
of quantum algorithms (and the reason for their efficiency) is to
describe an effective circuit that implements this unitary mapping.
Therefore, it is crucial to describe an efficient circuit that can re-
2.6 Quantum Algorithm alize the unitary mapping in order to obtain the efficiency of the
Quantum algorithms are designed to solve classical problems in quantum algorithm.
a probabilistic manner [192]. For example, the phase estimation
algorithm (QPE) [149] takes a matrix U , an eigenvector |ψ ⟩, as in-
puts, and calculates the eigenvector value of U corresponding to 2.7 Quantum Computing
|ψ ⟩. Another example is Grover’s search algorithm [118]: given a The necessary procedure of quantum computing is as follows:
sparse non-zero function f : {0, . . . , 2n−1 } → {0, 1}, Grover’s
algorithm outputs a value x such that the probability of f (x) = 1 • Start with a set of calculated ground states (each qubit is
is high enough to beat brute force search, which is true in gen- initialized to |0⟩ or |1⟩ as input to the calculation);
eral. Quantum algorithms are usually designed to solve (classical) • Pass the qubits through a series of quantum gates according
problems more efficiently than existing classical algorithms. to a predetermined algorithm;
A quantum algorithm is generally realized on a quantum circuit • A series of bits is obtained as a result of quantum measure-
designed according to the parameters of the problem (such as the ment.
size of the instance), usually through the following three steps of
Note that the realization of each quantum gate requires manual
iteration:
manipulation of quantum gates.
5
 Table 2: A Brief and Historical Summary of Quantum Programming Languages

Year Language Reference(s) Semantics Host Language Paradigm

1996 Quantum Lambda Calculi [181] Denotational lambda Calculus Functional
1998 QCL [206–209] C Imperative
2000 qGCL [241, 312–314] Operational Pascal Imperative
2003 λq [282, 283] Operational Lambda Calculus Functional
2003 Q language [32, 33] C++ Imperative
2004 QFC (QPL) [245–247] Denotational Flowchart syntax (Textual syntax) Functional
2005 QPAlg [141, 160] Process calculus Other
2005 QML [10, 11, 113] Denotational Syntax similar to Haskell Functional
2004 CQP [102–104] Operational Process calculus Other
2005 cQPL [180] Denotational Functional
2006 LanQ [188–191] Operational C Imperative
2008 NDQJava [298] Java Imperative
2009 Cove [227] C# Imperative
2011 QuECT [48] Java Circuit
2012 Scaffold [1, 138] C (C++) Imperative
2013 QuaFL [162] Haskell Functional
2013 Quipper [114, 115] Operational Haskell Functional
2013 Chisel-Q [175] Scala Imperative, functional
2014 LIQUi|⟩ [292] Denotational F# Functional
2015 Proto-Quipper [234, 237] Haskell Functional
2016 QASM [212] Assembly language Imperative
2016 FJQuantum [82] Feather-weight Java Imperative
2016 ProjectQ [122, 266, 272] Python Imperative, functional
2016 pyQuil (Quil) [259] Python Imperative
2017 Forest [61, 259] Python Declarative
2017 OpenQASM [66] Assembly language Imperative
2017 qPCF [213, 215] Lambda calculus Functional
2017 QWIRE [217] Coq proof assistant Circuit
2017 cQASM [146] Assembly language Imperative
2017 Qiskit [4, 232] Python Imperative, functional
2018 IQu [214] Idealized Algol Imperative
2018 Strawberry Fields [147, 148] Python Imperative, functional
2018 Blackbird [147, 148] Python Imperative, functional
2018 QuantumOptics.jl [157] Julia Imperative
2018 Cirq [271] Python Imperative, functional
2018 Q# [269] C# Imperative
2018 Q |S I ⟩ [174] .Net language Imperative
2020 Silq [35] Python Imperative, functional
∗ Year: The invented year of the language,
∗ Language: The name of the language,
∗ Reference(s): The main reference paper(s) of the language,
∗ Semantics: The type(s) of semantics for the language the authors described in the reference(s),
∗ Host language: The classical language on (or to) which the language is based (or extended),
∗ Paradigm: We consider each language to belong to three types of paradigms: imperative language, Functional language, and circuit
design language.

In [260], a general architecture of a quantum computing system circuitry and other elements that are needed for qubit ad-
has been proposed. As shown in Figure 2, the architecture com- dressing and control operations.
prises of two parts: quantum layer and classical layer. The quantum • Quantum logic gates contain physical circuitry that makes
layer contains purely quantum hardware and circuitry, and can be up quantum logic gates.
considered as comprising the quantum processing unit (QPU). The • Quantum-classical interface includes the hardware and soft-
detailed composition of this layer is listed as follows. ware which provides the interfacing between classical com-
puters and a QPU.
• Physical building blocks include quantum hardware that typ-
ically makes use of superconducting loops for the physical re- The classical layer consists of classical hardware and software,
alization of qubits, and the physical qubit coupler/interconnect as shown in the following:
6
 • Quantum programming environment provides the quantum by a classical computer. This model influenced the design of sub-
assembly language that is necessary for instructing a QPU, sequent quantum programming languages. Ömer [206–209] de-
the programming abstractions for writing quantum pro- veloped the first practical quantum programming language QCL
grams in a high-level programming language, and the simu- with a C-like syntax in 1998. Since then, many quantum program-
lator support, as well as IDEs. ming languages have been designed and implemented in terms
• Business applications include quantum software applications of different types of language paradigms for programming quan-
that are written to cater to business requirements. tum computers, including qGCL [241, 312–314], LanQ [188, 191],
Scaffold [1, 138], Q language [32, 33], NDQJava [298], Q# [269],
3 QUANTUM SOFTWARE ENGINEERING Q |SI ⟩ [174], ProjectQ [122, 266], and Qiskit [4] for imperative
quantum programming languages. Quantum lambda calculi [181],
Quantum computing is not only a technological advancement, but
QFC (QPL) [244, 245, 247], QML [10, 11, 113], cQPL [180], [286],
can also be considered as a new general-purpose paradigm for soft-
QuaFL [162], Quipper [114, 115], LIQUi|> [292], qPCF [213, 215],
ware development, which can radically influence the way a software
and IQu [214] for functional quantum programming languages, and
system is conceived and developed. This calls for new, quantum-
QPAlg [141], qASM [212], QuECT [48], QWire [217], Quil [259]
specific, software engineering approaches. In this section, we first
for other quantum programming languages paradigms. Table 2
introduce quantum programming and define quantum software
gives a summary of quantum programming languages since it first
engineering. This will be followed by an introduction of a quantum
emerged in 1996. In the table, we summarize each quantum pro-
software life cycle for quantum software development, which will
gramming language according to six categories: year, language,
be a baseline for discussing the state of the art of quantum software
reference, semantics, host language, and language paradigm. For
engineering activities in the rest of the paper.
more information regarding quantum programming languages, one
can also refer to survey papers discussed in Section 11.
3.1 Quantum Programming
Quantum programming is the process of designing and building 3.1.3 Semantics for Quantum Programming. Semantics for
executable quantum computer programs to achieve a particular quantum programming have also been studied extensively, and re-
computing result [187, 301]. Since the quantum programming ef- cently many approaches [43, 53, 56, 83, 101, 123, 180, 189, 190, 211,
forts predate the other quantum software development techniques, 245, 301, 302] have been proposed for describing the semantics
we will focus first on quantum programming. Here, we briefly of quantum programming languages. These approaches can be
introduce the concepts, languages, and semantics of quantum pro- classified into three categories: operational semantics, denotational
gramming. An excellent book written by Ying [301] covers similar semantics, and axiomatic semantics. Although there is no survey
material to this section, with more detailed discussions of the fun- for the semantics of quantum programming languages, readers can
damentals of quantum programming. also refer to some survey papers [100, 140, 244, 302] on quantum
programming languages for the detailed discussions of the quantum
3.1.1 Concepts of Quantum programming. A quantum pro- language semantics issues.
gram consists of blocks of code, each of which contains classical
and quantum components. Quantum operations can be divided 3.2 Definition of Quantum Software
into unitary operations (reversible and preserve the norm of the Engineering
operands), and non-unitary operations (not reversible and have While quantum programming languages are exciting developments,
probabilistic implementations). A quantum program executed on a coding is not the primary source of problems in quantum software
quantum computer uses a quantum register of qubits to perform development. Requirements and design problems are much more
quantum operations, and a classical register of classic bits to record common and costly to correct. Therefore, the focus on quantum
the measurements of the qubits’ states and apply quantum oper- software development techniques should not be limited to quan-
ators conditionally [66]. Therefore, a typical quantum program tum programming issues, but should also focus on other aspects of
usually consists of two types of instructions. One is called classical quantum software engineering. The promise quantum software de-
instructions that operate on the state of classical bits and apply velopment methodologies hold for overcoming complexity during
conditional statements. Another is called quantum instructions that analysis and design and accomplishing analysis and design reuse
operate on the state of qubits and measure the qubit values. is really significant. If it is accepted that quantum software devel-
opment is more than quantum programming, then a whole new
3.1.2 Languages for Quantum Programming. Early quan-
approach, including life cycle, must be adopted to address other
tum programming language development efforts focused on ex-
aspects of quantum software development.
ploring the quantum Turing Machine (QTM) model proposed by
Software engineering is a problem-solving process with roots in
Deutsch [70], but did not result in practical tools for program-
behavioral, engineering, project management, computer science,
ming quantum computers. This situation made the quantum cir-
programming, cost management, and mathematical science. Ac-
cuit models quickly become the driving force for quantum pro-
cording to [96], the software engineering process can be defined as
gramming. To build it as a practical language (rather than just
follows:
designing circuits), Knill [152, 154] proposed a pseudocode notion
for quantum programming and the model of a quantum random- "A software process can be defined as the coherent set of policies,
access machine (QRAM) in which the quantum system is controlled organizational structures, technologies, procedures, and artifacts that
7
are needed to conceive, develop, deploy, and maintain a software would be applied: the deliverables, the controls that help quality
product." assurance and change coordination, as well as the milestones that
enable quantum software managers to access the progress.
For the definition of software engineering, the IEEE has developed
Different ways of combining these three elements of quantum
a ’standard’ definition [60] for classical software engineering as
software engineering would lead to different quantum software
follows:
engineering models. The selection of a suitable model should be
"(1) The application of a systematic, disciplined, quantifiable approach based on the nature of the project and the application, the methods
to the development, operation, and maintenance of software; that is, and tools to be used, and the controls and deliverables that are
the application of engineering to software. (2) The study of approaches required. Three typical examples discussed in [226] for classical
as in (1)." software engineering are the classical life cycle (or waterfall model),
the prototyping model, and the evolutionary model. Each of these
Fritz Bauer [201] first stated the definition of software engineer-
models could be extended to the domain of quantum computing
ing as following:
for supporting the development of quantum software systems. In
"The establishment and use of sound engineering principles in order Section 3.5, we will introduce a life cycle for quantum software,
to obtain economically software that is reliable and works efficiently which is inspired by the idea of the waterfall model from classical
on real machines." software engineering.
Although many definitions of software engineering [13, 38, 60, 88,
3.4 A Generic View of Quantum Software
262, 297] have been developed since then, Bauer’s definition is still
the widely accepted one [226], and can serve as the basis for our Engineering
definition of quantum software engineering in this paper. Pressman [226] introduced a generic view of classic software engi-
In this paper, we define quantum software to include not only a neering, which can be extended to the field of quantum software
set of executable quantum programs but also associated supporting engineering. Quantum software engineering can be regarded as a
libraries and documents needed to develop, operate, and maintain branch of systems engineering [50, 80], which involves the devel-
quantum software. By defining quantum software in this broader opment of large and complex quantum software systems. To this
perspective, we hope to emphasize the necessity of considering end, the following issues must be discussed.
timely documentation as an integral part of the quantum software • What is the problem to be solved by quantum software?
development process. Inspired by the definitions of classical soft- • What characteristics of the quantum software are used to solve
ware engineering, we define quantum software engineering as the problem?
following: • How will the quantum software (and the solution) be imple-
"Quantum software engineering is the use of sound engineering princi- mented?
ples for the development, operation, and maintenance of quantum soft- • What method will be used to detect errors made in the design
ware and the associated document to obtain economically quantum and construction of the quantum software?
software that is reliable and works efficiently on quantum computers." • How will the quantum software be supported in a long period,
when the users request corrections, adaptations, and enhance-
In this definition, we would like to highlight three important issues ments?
in quantum software engineering. First, it is important to apply the To adequately engineering quantum software, a quantum soft-
"sound engineering principles" to quantum software development. ware engineering process must be defined. In this section, we con-
Second, the quantum software should be built "economically." Fi- sider the generic characteristics of the quantum software process.
nally, the quantum software should be "reliable" and needs to work The work related to quantum software engineering can be catego-
"efficiently" on quantum computers. rized into three generic phases: definition, development, and support
phases. These phases are independent of the application domain,
3.3 Quantum Software Engineering Methods, project size, or complexity.
Tools, and Processes The definition phase focuses on what, dealing with the problems
Quantum software engineering, as its classical counterpart [75], that quantum software developers try to determine. These issues
can also be considered as a layered technology, which contains include topics such as what information to process, what functions
three elements: methods, tools, and processes. and performance are required, what interfaces to build, what design
Quantum software engineering methods provide the techniques constraints exist, and what verification standards are needed to
for constructing the quantum software. They consist of a wide define a successful quantum software system. At this stage, there
range of tasks, including the design of data structures, program ar- may be three sub-processes, including quantum software system
chitecture, algorithm procedure, coding, testing, and maintenance. analysis, quantum software project planning, and quantum software
Quantum software engineering tools provide automated or semi- requirements analysis.
automated support for these methods. Quantum software engi- The development phase focuses on how, which deals with the
neering processes are the foundation for the quantum software problems that quantum software developers try to describe. These
engineering. The process provides the glue that holds the methods issues include how to design quantum software architecture and
and tools together and enables the rational and timely development related data structures, how to implement quantum program de-
of quantum software. They define the sequence in which methods tails, how to translate quantum software design into a quantum
8
 Figure 3: A quantum software life cycle.

programming language, and how to conduct quantum software In the following, we briefly introduce each phase of the life cycle
testing. This phase may also contain some sub-processes, including model from the perspective of quantum software development.
quantum software design, quantum software implementation, and
quantum software testing. 3.5.1 Quantum Software Requirements Analysis. The quan-
The maintenance phase focuses on change, which is related to tum software life cycle model begins with the requirements analysis
error correction, adaptions required as the quantum software envi- phase, where the stakeholders discuss the requirements of the soft-
ronment evolves, and modifications due to enhancements brought ware that needs to be developed to achieve a goal. The requirements
about by changes in customer requirements. The maintenance analysis phase aims to capture the detail of each requirement and
phase reapplies the definition and development phases, but it is to make sure everyone understands the scope of the work and how
carried out in the context of existing quantum software. each requirement is going to be fulfilled. The analysis creates a set
of measurable quantum software requirements that specify, from
the supplier’s perspective, what characteristics, attributes, and func-
3.5 Quantum Software Life Cycle tional and performance requirements the quantum software system
A software life cycle model can be defined as a reference model is to possess, to satisfy stakeholder requirements. Later life cycle
for a software development process that supports the design and phases, including design, implementation, testing, maintenance for
construction of high-quality software [105]. A software life cycle quantum software, assume that requirements analysis continues
provides a well-structured flow of phases that can help an organi- through the quantum software life cycle.
zation to quickly produce high-quality software that is well-tested
and ready for production use. Several software life cycle models 3.5.2 Quantum Software Design. Quantum software design
have been proposed for classical software development, including is the second phase in the life cycle, which is a process to transform
the waterfall model [238], evolutionary model [128], and the Spiral user requirements into a suitable form that helps the programmer
model [39]. Among them, the most widely accepted life cycle model in quantum software implementation (coding).
for classical software development is the waterfall life cycle model, As classical software design [75], quantum software design may
which is sometimes called the classical model. Other models are also involve two stages: architectural design and detailed design.
often improved upon it. Architectural design defines a collection of quantum software com-
As the first step, this paper introduces a systemic, sequential ponents, their functions, and their interactions (interfaces) to es-
life cycle model for the quantum software development process to tablish a framework for the development of a quantum software
support the design and construction of quantum software systems. system. Detailed design refines and expends the architectural design
A quantum software life cycle model begins at the system level and to describe the internals of the quantum software components (the
progresses through requirements analysis, design, implementation, algorithms, processing logic, data structures, and data definitions).
testing, and maintenance. The model, however, is extensible in the Detailed design is complete when the description is sufficient for
sense that one can add more phases into it if necessary. Figure 3 implementation (coding).
shows the life cycle, which encompasses the following phases, each
one is flowing into the next. 3.5.3 Quantum Software Implementation. After complet-
ing the requirements and design activities, the next phase of the life
• Quantum software requirements analysis cycle is the implementation or development of quantum software.
• Quantum software design At this phase, developers start coding based on the requirements
• Quantum software implementation and design discussed in the previous phases. Developers also per-
• Quantum software testing form the unit testing for each component to test the new code they
• Quantum software maintenance write, review the code for each other, create builds, and deploy
9
 Table 3: Brief Summary of the Patterns for Quantum Algorithms in [166]

Pattern Type Description

(1) Initialization (aka state preparation) Initializing the input of a quantum register in a straightforward manner
Creating an equally weighted superposition of all possible states of the qubits
(2) Uniform superposition
of a quantum register
(3) Creating entanglement Creating an entangled state
(4) Function table Computing a function table of a finite Boolean function
(5) Oracle (aka black box) Reusing the computation of another quantum algorithm
(6) Uncompute (aka unentangling aka copy-uncompute) Removing entanglement that resulted from a computation
(7) Phase shift Distinguishing important aspects of a state efficiently
(8) Amplitude amplification Increasing the probability of finding a solution
(9) Speedup via verifying Achieving a speedup when verifying a solution is simple
(10) Quantum-classic split Splitting a solution between a quantum computer and a classical computer

quantum software to the environment. This development cycle is design of the classical software development life cycle. It seems rea-
repeated until the requirements are met. sonable to extend the UML approach to support quantum system de-
sign. Recently, Pérez-Delgado and Perez-Gonzalez [220] presented
3.5.4 Quantum Software Testing. Testing is the last phase of
an approach to extending the UML to model quantum software
the quantum software life cycle before the software is delivered to
systems. The extension covers two types of UML diagrams: class
customers. During testing, testers start to test the quantum software
diagram and sequence diagram. Extension for the other three com-
according to the requirements. The aim is to find defects within
ponents (i.e., composite structure diagrams, activity diagrams, and
the software as well as to verify whether the software behaves as
state machine diagrams) still needs to be studied. They also shared
expected based on the documentation from the quantum software
three fundamental observations from their work, including:
requirements analysis phase.
• The nature of quantum computation, leading to the intrinsic
3.5.5 Quantum Software Maintenance. Quantum software difference between quantum and classical computation is in
maintenance is the last phase of the quantum software life cycle, how it achieves its goal,
which represents all the modifications and updates made after the • Quantum computation changes the very nature of informa-
delivery of quantum software products. tion itself, and is much more productive and powerful than
classical computation, and
4 QUANTUM SOFTWARE REQUIREMENTS • The classical vs. quantum nature of the information used
ANALYSIS by a module is an important consideration when discussing
To the best of our knowledge, until recently, no research work about its internal implementation and interface.
has been proposed to address the issues on quantum software re- Their observations, though not complete, can serve as a base for
quirements analysis. However, as quantum software development further studying the design methodologies of quantum software
resources are going to be accumulated, we believe that the develop- systems.
ment of methodologies, techniques, and tools to support quantum
software requirements analysis will become a critical and inevitable 5.2 Quantum Software Specification
issue.
Quantum computing relies on quantum mechanics, which is a
subject more familiar to physicists rather than computer scientists
5 QUANTUM SOFTWARE DESIGN and software engineers. Thus, we must be aware of the underlying
Developing quantum algorithms is considered extremely difficult theory before we reason about quantum computers. Even though
comparing to classical counterparts due to some intrinsic features delivering the principles of quantum mechanics is not an easy task,
of quantum computing, such as superposition and entanglement. due to their counter-intuitive nature.
Hence, new design principles for quantum algorithms are strongly Recently, the method for reasoning about quantum computing
demanded. Although software design is recognized as a critical is a mixture of linear algebra and Dirac representation, which is a
phase in classical software engineering, researches [46, 220, 274] subject more suitable for physicists than computer scientists (soft-
on the principle and methodology for quantum software design are ware engineers) [46]. Therefore, it is necessary to provide a more
just starting. This section gives an overview of state of the art on "intuitive" way to think and write quantum algorithms, thereby
quantum software design. simplifying the design and implementation of quantum software.
This can be achieved, for example, by introducing a specification
5.1 Quantum Software Modelling language, which adopts the symbolism and reasoning principle of
The Unified Modeling Language (UML) [40, 135, 240] is a general- software engineering and will take on the role of Hilbert space
purpose, well-known modeling language in the field of classical algebra, allowing us to describe quantum structures and design
software engineering. It provides a standard way to visualize the quantum algorithms in a more natural way [113].
10
 Table 4: The Effects of QCS characteristics on Quality Attributes [260]

Interoperability

Maintainability

Manageability

Performance
Availability
Attributes

Testability
Scalability
Reliability

Usability
Quality

Security
QCS Characteristics
Platform heterogeneity U − U U − U − − U −
Special physical environment U − − U − U U U U −
Large form factor − − − − − − U − − −
Higher energy efficiency − − − − F − F − − −
Lower level of the programming abstractions U − U − − U − − U −
Remote software development and deployment − − U − − − − − U −
Dependency on quantum algorithms − U U − F − F − U −
Limited portability of software U U U − − − U − − −
Limited quantum networking U − − − U U U − − −
Lack of native quantum operating system − − − U U U U U − −
Fundamentally different programming model − U U − − U − U U −
Dependency on classical storage − − − U U U U − − −
∗ Cell value indicates an impact on quality attributes: "F": Favorable, "U": Unfavorable, "−": Unknown/Neutral.

To this end, Cartiere [45, 46] presented some work on defining summarized some basic "tricks" used in quantum algorithms. The
a formal specification language for quantum algorithms. The goal main contribution of this work is to systematize this to become a
is to introduce a formal specification language that can be used subject of a software engineering discipline for quantum algorithms.
to represent the basic notations of quantum computing, which In [166], Leymann identified ten types of basic patterns derived
are more suitable for quantum computing scientists and quantum from existing quantum algorithms that mainly based on gate mod-
software engineers. The language is based on Z [2, 296], a well- els. Each pattern is described through eight elements, including
studied formal specification language for classical software systems. name, intend, icon, problem statement, context, solution, know uses,
The language can represent some elementary quantum gates such as and next. The summary of these ten types of patterns is listed in
Identity gate, Pauli-X gate, Phase Shift gate, Pauli-Z gate, Hadamard Table 3.
gate, and C-NOT gate, which perform unitary transformations to Additionally, Leymann also discussed some issues on the using of
support writing quantum programs. Cartiere also showed how to these patterns regarding software engineering, and mentioned that
use the language to specify some simple quantum algorithms, such the pattern language proposed can be stored as a pattern repository.
as the Deutsch-Jozsa algorithm [70, 71]. It is, however, unclear In the repository, each pattern could be linked with the correspond-
if the language can be used to represent more complex quantum ing implementation in a concrete quantum programming language
algorithms such as Shor’s integer factoring quantum algorithm [257] to support the programming of the pattern. Note that the patterns
and Grover’s database search quantum algorithm [118]. identified in [166] is in no way meant to be exhaustive, and more
patterns should be identified in the future to make the patterns and
the pattern language practical useful.
5.3 Pattern Language for Quantum Software
In classical computing, software engineers have long noticed that
specific patterns recur and persist across different applications 5.4 Quality Attributes
and systems. A pattern is a systematic design that can capture With practical quantum computing systems (QCSs) becoming a
the experiences of experts on good designs or best practices, and reality rapidly, it is desirable to make use of their real potential
record the essence of this wisdom in an easy-to-understand way for in software applications. Therefore, it is crucial to determine the
peers to use [12]. Patterns can be used to describe and reason about implications of QCSs for quantum software architecture, and some
the relationship between a specific context, and a problem and its questions must be answered, like "What are the key characteristics
solutions in that context. A pattern language is a network of related of QCSs, which are efficacious for quantum software development?"
patterns that may jointly contribute to an encompassing solution and "In what way does a QCS affect the quality attributes (and non-
of a complex problem [5, 23]. Patterns and pattern languages are functional requirements) of quantum software applications?"
used in multiple design and engineering disciplines, especially for To answer these questions, Sodhi [260] presented an in-depth
software architecture design [44, 93, 95, 287]. study on the state-of-the-art QCSs for identifying all such charac-
Leymann [166] proposed a pattern language for supporting the teristics of a QCS that are relevant from a software architecture
development of quantum algorithms. There is a need for document- perspective, and performed an investigation on how these char-
ing solutions for problems recurred in quantum software develop- acteristics may affect the architecture of a quantum software ap-
ment, as observed and mentioned in [171, 202], which informally plication. As the first step, Sodhi sought and investigated related
11
papers and software artifacts of QCSs and identified thirteen criti- (Quiper). Therefore, the first natural step in the choice of a suit-
cal characteristics of QCSs. This includes platform heterogeneity, able technique is to reduce the available set of techniques to those
physical environment, large form factor, energy efficiency, lower that support the base programming language to be employed in
level of the programming abstractions, remote software develop- application development. If no suitable technique is available for
ment and deployment, dependency on quantum algorithms, limited the base programming language, a custom language needs to be
portability of software, limited quantum networking, lack of native implemented.
quantum operating system, limited multitasking and multiprocess-
ing, fundamentally different programming model, and dependency 7 QUANTUM SOFTWARE TESTING
on classical storage. These key characteristics of QCSs form a base Quantum computers are powerful. However, since the human intu-
for further studies on how they could affect the quality attributes ition is much better adapted to the classical world than the quantum
of the software architecture of a QCS. world, programmers might make mistakes more frequently when
Quality attributes (QAs) are measurable or testable properties of designing programs on quantum computers compared to program-
a system that is used to indicate how well the system satisfies the ming on classical counterparts [300]. Furthermore, compared to
needs of its stakeholders [21]. They, therefore, have a system-wide the classical computers, quantum computers have very different
impact on the architecture, implementation as well as the operation properties, such as quantum superposition, entanglement, and no-
of the system. QAs are usually categorized in various specialized cloning [202]. Therefore, the prediction of the behavior of quantum
areas, such as design qualities, runtime qualities, system qualities, software is difficult [54, 300]. As a result, new quantum software
user qualities, non-runtime qualities, architecture qualities, and testing and debugging techniques are needed to discover [268].
business qualities [41, 216]. It is recognized that when software Recently, researches are emerging for identifying bugs, and for
applications have at least a reasonable level of quality attributes testing and debugging of quantum software. This section gives
such as performance, reliability, scalability, security, and usability, an overview of state of the art on quantum software testing, in a
the overall design and quality of the applications can be considered broader sense, according to quantum software bug type, assertion,
good [21, 22]. testing, debugging, and analysis.
For investigating the impact of QCS characteristics on the QAs,
Sodhi [260] adapted a slightly expanded list of QAs, which include 7.1 Bug Types in Quantum Software
availability, interoperability, maintainability, manageability, per- A software bug is regarded as the abnormal program behaviors
formance, reliability, scalability, security, testability, and usability. which deviate from its specification [6]. Fault models are a com-
He only discussed the parts of a QA that are related to determine mon concept in the software and hardware testing field. To debug-
how this QA is affected by the characteristics of QCSs. To do so, ging and testing quantum software, it is essential to define some
one may take each characteristic of QSC and considers how it af- fault model which can help deeply understanding the behavior
fects the various QAs. The impact of each characteristic on QAs of bugs in quantum programs. Several researches considered this
is classified as favorable, unfavorable, or neutral. The summary of issue recently. To support quantum software debugging, Huang
the impact of various characteristics of QCSs on QAs is shown and Martonosi [132, 133] studied the bug types for special quan-
in Table 4, and the detailed discussions on those impacts can be tum programs. Based on the experiences of implementing some
referred to the paper [260]. Additionally, several issues should be quantum algorithms, they identified several types of bugs specific
further studied, such as identifying more characteristics of QCSs to to quantum computing. These bug types include incorrect quantum
enhance the current list and investigating more QAs for obtaining initial values, incorrect operations and transformations, incorrect
more complete findings (insights) for the problem studied in the composition of operations using iteration, incorrect composition
paper. In conclusion, Sodhi [260] argued that the evolution of the of operations using recursion, incorrect composition of operations
technology would likely introduce additional concerns and factors using mirroring, incorrect classical input parameters, and incorrect
that may affect the architecture of quantum software application, deallocation of qubits. They also proposed some defense strategies
as quantum computing is undergoing rapid development. for each type of bugs. The detailed summary of these bugs and their
corresponding strategies can be found in Table 5.

6 QUANTUM SOFTWARE IMPLEMENTATION 7.2 Assertions for Quantum Software

This section will be brief, as much of the material has been cov- An assertion is a statement about the expected behavior of a soft-
ered in the survey (or overview) papers of quantum programming ware component that must be verified during execution [92]. In
languages [54, 98, 102, 186, 244, 261, 263, 280, 281, 301, 302, 311]. software development, a programmer defines an assertion to ensure
The initial focus of quantum software development on the im- a specific program state at run time. Assertions have been used
plementation level has resulted in a range of quantum program- extensively for detecting runtime faults, documenting programmer
ming approaches. It is crucial to identify a suitable quantum pro- intent, and formally reasoning about the correctness of classical pro-
gramming technique when implementing a quantum application. grams [58]. Recently, several researches have been carried out for
Most quantum programming techniques support one or more base defining and identifying assertions in quantum software systems.
programming languages. For example, languages are available for
quantum programming in C (QCL), C++ (Scafflod), C# (Q#), Python 7.2.1 Invariant and Inductive Assertions. Ying et al. [303]
(ProjectQ, Qiskit, Forest), F# (LIQUi|⟩), Scala (Chisel-Q), and Haskell studied the issue of how to define the notion of invariant and in-
ductive assertion [91] for quantum programs. They considered this
12
 Table 5: Bug types and their corresponding defense types for quantum software in [132, 133]

Bug Type Defense Strategy

(1) Incorrect quantum initial values Assertion checks for classical and superposition preconditions
(2) Incorrect operations and transformations Assertion checks for unit testing
(3) Incorrect composition of operations using iteration Assertion checks for classical intermediate states
(4) Incorrect composition of operations using recursion Assertion checks for entangled intermediate states
(5) Incorrect composition of operations using mirroring Assertion checks for product state postconditions
(6) Incorrect classical input parameters Assertion checks for classical postconditions
(7) Incorrect deallocation of qubits Assertions on algorithm postconditions

issue in two different ways – from the perspectives of additive and uses a robust statistical method to test the probability of observing a
multiplication. They proved that both additive and multiplication qubit in a given state. AssertEntangled takes two qubits as its argu-
invariants could be used to prove the partial correctness of quan- ments to test whether or not they are entangled. AssertEqual tests
tum programs. They also showed that additive invariants could be the equality of two states in quantum programs. AssertTeleported
derived from additively inductive assertions, and can be generated tests quantum teleportation as it is a significant protocol in the quan-
through an SDP (Semidefinite Programming [284]) solver. How- tum realm. AssertTransformed tests the validity of any unitary
ever, how to generate the multiplication invariants is still an open transformation. The detailed description of each assertion method
problem that has not been addressed in [303], and therefore still is summarized in Table 6. Although those assertion methods are
needs to be explored. used initially for testing, they also have the potential to be used in
quantum program debugging and runtime error checking.
7.2.2 Applied Quantum Hoare Logic. Hoare logic (also known
as Floyd-Hoare logic) [90, 129] is a formalism with a set of logic
rules used for rigorous reasoning on the correctness of computer 7.3 Quantum Software Testing
programs. Hoare logic has been extensively used for the verifica- Testing [24, 196] is the process that executes a program with the
tion, debugging, and testing of classical software [3, 14]. Recently, intent to find errors, which is a very critical process for supporting
researchers have extended Hoare logic to the quantum domain quality assurance during software development. In this section, we
to support the formal verification of quantum programs [18, 43, review state of the art for testing quantum software.
73, 143, 277, 300, 310]. Among them, Li et al. [310] introduced ap-
plied quantum Hoare logic (aQHL), which is a simplified version 7.3.1 Open Problems on Testing Quantum Software. Mi-
of quantum Hoare logic (QHL) [300], with particular emphasis on ranskyy and Zhang [184] proposed some challenges associated
supporting debugging and testing of the quantum programs. aQHL with white-box and black-box testings as well as verification and
simplified two issues of QHL through: (1) binding QHL to a particu- validation of quantum programs. They have shown that some of
lar class of pre- and post-conditions (assertions), that is, projections, the existing software engineering practices are readily transferable
to reduce the complexity of quantum program verification and to to the quantum computing domain (e.g., code review). Others are
provide a convenient way used for debugging and testing of quan- difficult to transfer (e.g., interactive debugging). And the rest have
tum software. (2) providing additional rules for reasoning about the to be introduced (e.g., complexity-dependent placement of a valida-
robustness of quantum programs. As aQHL can be used to specify tion program). Rather than proposing a particular testing method
assertions such as pre- and post-conditions, and invariants for quan- (or strategy) for quantum software, they tried to define the software
tum software, hopefully, it could provide a very efficient way to engineering practices for quantum software. With this definition
support assertion-based quantum software debugging and testing. at hand, software engineering specialists in academia and industry
Although no detail [310] was given on how aQHL could be used to can start exploring this fascinating area of quantum computing and
debug and test quantum software, we believe it could be a promising expand their work to other areas of testing as well as the remaining
way for tracking errors in quantum software, similar to its classical phases of the quantum software life cycle.
counterpart. Moreover, besides aQHL, similar approaches that use
other types of (dynamic) quantum logic [18, 43, 143] for specifying 7.3.2 Fuzz Testing. Fuzz testing (or fuzzing) [270] is a software
assertions for supporting debugging of quantum software should testing technique that inputs invalid or random data called fuzz
also be investigated. into the software system to discover coding errors and security
7.2.3 Assertion Library for Quantum Software. As we will loopholes. Wang et al. [289] adapted an existing technique from
discuss in Section 7.3, Honarvar and Nagarajan [131] proposed a classical software testing called coverage-guided fuzzing (CGF) [65,
property-based approach to testing quantum programs in Q# (de- 248, 306] to test quantum software. They proposed QuanFuzz, a
veloped by Microsoft) [269]. To this end, they developed a library search-based test input generator for quantum software. The basic
of assertion methods that can be used to specify various properties idea of QuanFuzz is to define some quantum sensitive information
(assertions) in Q# programs for testing. These assertion methods to evaluate the test inputs for quantum software and use a matrix
include AssertProbability, AssertEntangled, AssertEqual, generator to generate test cases with higher coverage. The testing
AssertTeleported and AssertTransformed. AssertProbability process of QuanFuzz consists of two steps:
13
 Table 6: Brief Summary and Comparison of Assertion Methods in [131] and Assertion Functions in [172]

Assertion Methods [131] Description

AssertProbability(q0,state,probability) To take three arguments to test the expected probability of observing a qubit q0 in a
given state after measurement.
AssertEntangled(q0,q1) To take two qubits q0 and q1 as its arguments to test whether or not they are entangled.
AssertEqual(q0,q1) To take two qubits q0 and q1 as its arguments to compare the equality of these two states.
AssertTeleported(q0,q1) To take the sent and received qubits q0, q1 as its arguments to test quantum teleportation.
AssertTransformed(q0,(θ interval)(ϕ interval)) To test the validity of any unitary transformation.
Assertion Functions [172] Description
classical_assertion(circuit,qubitList,value) To take three arguments to specify the quantum circuit under test, the list of qubits for
assertion, and a particular classical value to assert for.
entanglement_assertion(circuit,qubitList,flag) To take three arguments specifying the quantum circuit under test, the list of qubits for
assertion, and the type of entanglement.
superposition_assertion(circuit,qubitList,phaseDict,flag) To take four arguments specifying the quantum circuit under test, the list of qubits for
assertion, the quantum state dictionary for the qubits, and a flag.

(1) Extracts quantum sensitive information from the quantum when applying classical software testing to the quantum comput-
source code. Such information includes the measurement op- ing domain. He discussed how some prevalent strategies of classical
erations on the quantum registers and the sensitive branches software testing, such as functional testing, white-box testing, and
associated with the measurement results. model-based testing, can be applied to test quantum software. Func-
(2) Uses the sensitive information guided algorithm to mutate tional testing [197] is a type of software testing that validates the
the initial input matrix and selects those matrices which software system against the functional requirements/specifications.
improve the probability weight for a value of the quantum Usaola discussed some basic concepts regarding functional testing
register to trigger the sensitive branch. (such as test case and test suite) and showed that a process of func-
This process keeps iterating until the sensitive branch is triggered. tional testing for quantum software might consist of the following
They also implemented QuanFuzz based on Q |SI ⟩ [174] and Nrefac- three steps:
tory for quantum software simulation and code instrumentation (1) The initial situation of a quantum test case sets up the initial
respectively, and evaluated QuanFuzz on seven quantum programs status of the qubits.
with different registers (containing 2 to 8 qubits), which are build-in (2) Similar to classical testing, the quantum circuit is executed.
benchmark programs from Q |SI ⟩. The experimental result showed (3) The test suite saves the obtained result to calculate the most
that QuanFuzz can obtain 20%∼60% more branch coverage than the probable result.
classical test input generation method. White-boxing testing [197] is a method that tests a software
solution’s internal structure, design, and coding. Among differ-
7.3.3 Property-Based Testing. Property-based testing [55, 87]
ent white-box testing methods, Usaola specially studied mutation
uses specifications of essential properties to produce testing criteria
testing, which might be a good candidate technique for quantum
and procedures which focus on these properties in a systematic
software testing. He also gave a simple example program of adding
manner. Honarvar and Nagarajan [131] presented QSharpCheck,
two integer numbers using IBM’s Qiskit simulator to show how the
a property-based testing approach for quantum software written
mutation testing can be applied for testing. However, how to define
in Q#. To this end, they defined a testing specification language
suitable quantum mutant operators to support quantum mutation
to specify the properties of Q# programs. The whole design of the
testing has not been discussed. Model-based testing [279] is a soft-
language is inspired by several ideas, such as the syntax of Q#,
ware testing technique where run time behavior of the software
quantum predicates and predicate transformers by D’Hondt and
during the test is checked against predictions made by a model. To
Panangaden [73], and quantum Hoare logic by Ying [300]. In the
apply model-based testing to the quantum software, one should
language, a test is represented by four parts: test property name and
first use some modeling language, for example, UML, to model the
parameters, allocation and setup, function call, and asset and de-
behavior of the quantum software. Then, based on the model, one
allocate. They also identified several types of assertions that formed
can generate test cases for the software under test to perform the
the basis of post-conditions and assertion types associated with
testing. As we discussed in Section 5, one may use the Q-UML [220],
the test specification language. Based on these specified properties,
an extension of UML to the quantum domain, to model a quantum
one can generate various types of test cases, run the test cases to
software system to support the test case generation of the system.
test Q# programs, and check the output results to see if there are
Q# [269] is a quantum programming environment developed
any problems within the programs. Moreover, they also showed
by Microsoft that supports quantum programming and quantum
some basic considerations on the design and implementation of
software development. Q# offers tools for testing and debugging
QSharpCheck tool and carried out two case studies to demonstrate
quantum programs [273]. The tools can be used to verify that quan-
the effectiveness of QSharpCheck through mutation analysis of Q#
tum programs act as intended as well as to diagnose an incorrect
programs.
quantum program.
7.3.4 Functional, White-box, and Model-based Testing. Us- Although testing is a widely used technique to guarantee the
aola [278] proposed some ideas and identified some challenges reliability of a software system, as Dijkstra stated in [68], testing
14
can be used to show the presence of bugs, but never to show their some potential solutions to solve these problems. Those solutions,
absence. Therefore, after testing, systematical techniques such as however, might still be immature, thus may be infeasible in prac-
debugging is still needed to localize the bugs in the system. tice. Therefore, much work remains to be done to work out some
solutions to support quantum program debugging.
7.4 Quantum Program Debugging
7.4.2 Assertion-based Debugging. Several assertion-based
The process of finding and fixing bugs is called debugging, which
approaches have been proposed recently for debugging quantum
is the activity of analyzing the program to locate and correct errors
programs. As we described previously, Huang and martonosi [132,
in a program by reasoning about causal relations between bugs and
133] summarized several types of bugs in quantum programs based
the error detected in the program [28, 42]. Program debugging tools
on their experiences of implementation of a set of quantum pro-
are essential for any programming environment [15, 165]. In the life
grams (or algorithms [118, 182, 204, 257]). They also proposed some
cycle of software development, almost 25% of maintenance is carried
corresponding defense strategies in terms of programming and
out for debugging [170]. Debugging methodologies and techniques
assertion to prevent such bugs during programming to develop
are also crucial for quantum programming [54]. This section gives
bug-free quantum programs. This study is preliminary, and fur-
an overview of quantum program debugging techniques from four
ther, Huang and Martonosi [133] presented the statistical assertions
aspects: debugging tactics, debugging quantum processes, assertion-
for quantum programs based on statistical tests on some classical
based debugging, and language support for debugging.
observations. These allow the programmers to decide if a quan-
7.4.1 Debugging Tactics. For classical program debugging, tum program state matches its expected value in one of classical,
some well-established common tactics including backtracking, cause superposition, or entangled types of states. Based on this, they
elimination, and brute force [197, 226] are widely used. These de- classified possible assertions in quantum software into three types:
bugging tactics can also be used to support the quantum program classical assertion, superposition assertion, and entanglement asser-
debugging. tion. They extended an existing quantum programming language
Miranskyy et al. [185] analyzed the debugging tactics for quan- called Scaffold [1, 138] with the ability to specify quantum asser-
tum programs and discussed the possibility of applying some well- tions, and developed a tool to check these assertions in a quantum
established classical debugging techniques to the quantum domain. program simulator called QX [145]. To demonstrate the effective-
They mainly considered three types of debugging tactics in classical ness of their assertion-based approach, they performed three case
debugging, as mentioned above, and concluded that backtracking studies on three benchmark quantum programs: factoring integers,
tactics, especially those based on code reviews and inspections, database search, and quantum chemistry, each of which represents
could probably be applied for quantum debugging. This is also a different class of quantum algorithms. They also showed some
confirmed by the discussions with practical quantum software de- results on what types of bugs are possible and laid out a strategy
velopers who usually use code reviews and inspections for their for using quantum programming patterns to place assertions and
daily programming tasks [185]. prevent bugs. Moreover, to validate the proposed approach, they
For cause elimination tactics, they pointed out that it could be cross-validated the quantum programs and the simulation results
naturally extended to the domain of quantum computing. First, one through the functional equivalent programs implemented in dif-
can set a hypothesis and specify a root cause for a bug understudy ferent quantum programming languages, including LIQUi|⟩ [236],
during quantum debugging, and then collect data and perform some ProjectQ [122, 266], and Q#[269]. Through this validation, they
experiments based on the data to prove the hypothesis. However, found and shared some results and insights on how language fea-
considering the probabilistic nature of the quantum program’s be- tures of different quantum programming languages can help insert
havior [184, 202], the final result of the quantum program should the quantum assertions in a suitable place in the program, or other-
be assessed based on the distribution of the results obtained from wise prevent bugs in the first place.
multiple executions of the program. To solve the problem, Miran- Zhou and Byrd [309] and Liu et al. [172] observed that the
skyy et al. [185] suggested to apply classical testing techniques of critical limitation of Huang and Martonosi’s assertion-based ap-
probabilistic programs [77, 78] to the quantum computing domain. proach [133] is that each measurement during debugging has to
For brute force tactics, the most common tactic for classical de- stop the execution of the program, and the assertions require ag-
bugging, its applicability to quantum debugging might depend on gregates of runs when the actual computation results are to be
two situations. If we regard the quantum program as a black box, measured. To overcome this limitation, motivated by quantum er-
one could follow the classical debugging process: (1) First, trace ror correction (QEC) [110, 202] and nondestructive discrimination
the input and the output of the program (2) Then, record the input (NDD) [136], they proposed an approach to constructing suitable
and output data in a log file. (3) Finally, analyze and compare these quantum circuits to support runtime assertion check of quantum
data against expected values to see if they are consistent. If we treat software [172, 309]. The key idea of this approach is to use ancilla
the quantum program as a white box, one has to consider how to qubits (some additional quantum bits) to collect the information of
capture the execution traces during the execution of the program to the qubits under test indirectly and to measure those ancilla qubits,
perform interactive debugging. However, considering the specific rather than the original qubits under test directly. This can avoid
features such as superposition, entanglement, and no-cloning, in disrupting the program execution during the assertion check at run-
quantum computing, it is almost impossible. Miranskyy et al. [185] time. To this end, they identified three types of dynamic assertions,
discussed some scenarios regarding those specific quantum features respectively, for classical values, entanglement, and superposition.
for which the classical debugging cannot be applied, and suggested Assertion for classical value is to ensure that the qubits are initialized
15
to the correct value, or some intermediate classical results should A Hoare type, similar to the Hoare triples and is represented as
satisfy some condition such as (|ψ ⟩==|0⟩). Assertion for entangle- {P }x : A{Q },
ment is to assert two or more qubits are in entangled states based
on checking the parity of two qubits. Assertion for superposition can be ascribed to a stateful computation if when executed in a
is to assert that the use of Hadamard gates to set the input qubits heap satisfying the precondition P, the computation diverges or
in the uniform superposition state, and also to assert arbitrary results in a heap satisfying the postcondition Q and returns a value
superposition state represented as |ψ ⟩ = sin( θ2 )|0⟩ + e iφ cos( θ2 )|1⟩. of type A [199]. To support quantum circuits, the Hoare type is
The implementation of the idea of assertion circuits is also dis- extended with its syntax augmented with that of QWire, a quantum
cussed. This is based on Qiskit developed by IBM [232], an open- circuit language that supports quantum circuit programming and
source framework for quantum computing, through integrating verification. Through this way, the host language HTT can be
three types of assertion functions into the Qiskit development en- augmented with a wire type W in QWire, so that to treat quantum
vironment. Programmers can use these functions to instrument the circuits as data, it can be used to specify properties in quantum
necessary assertion circuits for classical, entanglement, and super- programs as well. Here, W and A can be described as:
position states, and therefore can check the corresponding ancilla W = 1 | bit | qbit | W 1 ⊗ W 2
qubits for error detection. These three kinds of assertion func-
and
tions include classical_assertion, entanglement_assertion,
and superposition_assertion. Table 6 summarises and com- A ::= ... | U nit | Bool | A × A | Circuit(W 1,W 2),
pares these assertion functions, with the assertion methods pro- respectively. This work aims to build a unified system eventually for
posed in [131]. The experimental results for several case studies supporting quantum programming, specification, and verification,
have confirmed the effectiveness of the proposed approach on de- but it is still preliminary recently, and more work remains to be
bugging as well as on improving the success rate for quantum done to realize the goal.
algorithms such as Quantum Fourier Transform (QFT) [64], Quan-
tum Phase Estimation (QPE) [149], and Bernstein-Vazirani algo- 7.4.3 Debugging Quantum Processes. Since the measure-
rithm [29, 30]. ment of a quantum system may cause its state to collapse, it is
The assertion schemes proposed by Huang and Martonosi [132], challenging to debug quantum programs through the monitoring
Zhou and Byrd [309], and Liu et al. [172], however, still have some of the program. To solve this problem, Li and Ying [169] proposed
limitations that they can only handle limited quantum states related an approach to debugging quantum processes through monitor-
assertions and limited assertion locations, which may increase the ing measurements. The basic idea of the approach is to develop a
difficulty in debugging based on the assertions. To overcome this protocol to support the debugging of quantum processes through
problem, Li et al. [168] proposed Poq, a projection-based runtime monitoring, which does not disturb the states of the processes.
assertion checker for debugging quantum programs. Poq uses pro- Informally, the approach can be described as following. Suppose
jection [37] to represent assertions, which, compared to classical that we have built a quantum system to execute some quantum
representation, has more expressive power. Moreover, since pro- processes. The system is set to an initial state |ψ ⟩, and then evolve
jection naturally matches the projective measurement, which may under the controlled Hamiltonian denoted by H (t). This guarantees
not affect the measured state when the state is in one of its basis that the trajectory {|ψ ⟩} of the system states is anticipated. Since
states [168], it may reduce the testing overhead. Poq can assert the time for the whole process is usually much longer than the time
sophisticated quantum algorithms. of a single quantum component (such as a gate) action, it may be
The above work on tackling bugs in quantum programs via as- considered as infinite. Here, we can see that if there is a bug of
sertion checking is promising, but it usually has to check assertions the system in the process at time t ′ , the system will not truly be
dynamically during runtime, which could waste the quantum com- H (t) for t ≥ t ′ during the execution, which may cause errors in
puting (or simulation) resources. To overcome this, inspired by the system state, so we write ρ t . For this situation, to debug the
previous work on the verification of quantum programs such as process, we should try to find a projection operator P = 0 of the
quantum weakest preconditions [73] and quantum Floyd-Hoare system as well as a sequence of time points t 1 , t 2 , . . . (tn → ∞),
logic [300], Singhal [258] proposed to encode assertions into a static such that P |ψtn ⟩ = 0 for all n. Here, P |ψt ⟩ = 0 means that nothing
type system of a quantum programming language to support pro- can be detected by P if the system state is |ψt ⟩ as anticipated. So, to
grammers to write correct programs from the start. In this way, it perform debugging, we can monitor the process at time t 1 , t 2 , . . . ,
is hopeful that the programmers can encode some of the semantic by using a measurement apparatus formalized by P, which is called
properties that they intend for their programs as specifications a monitoring measurement, and together with probability tr (P ρ tn ),
in their code, so that a type checker could be used to ensure the the error state could be detected at time tn . If this really happened,
correctness of some of those properties during compilation time. an error would be detected in the state, and t ′ is more likely in
The basic idea, to this end, is to extend the Hoare Type presented in [tn−1 , tn ], and the relevant components should be carefully checked.
Hoare Type Theory (HTT) in [199] for classical programming lan- Practically, the time points t 1 , t 2 , . . . are determined by a classical
guages, to the quantum Hoare Types in the quantum domain which program S. The critical point for this debugging approach is to find
can be encoded into a quantum programming language to support the required projector P, and the condition P |ψt ⟩ = 0 guarantees
static checking, and even formal verification of quantum software. that the anticipated process is not disturbed by P. On the other
hand, it is also implied that the debugging procedure is conclusive
in the sense that if the process runs correctly, it would be no error
16
reported. Besides this, the authors also gave a formal definition debug. To perform entanglement analysis, ScaffCC explores data-
of the proposed debugging approach in the case of discrete-time flow analysis techniques to automatically track the entanglements
evolution. within the code through annotating the output of the QASM-HL
As mentioned in the conclusion of the paper, the proposed de- program, an intermediate representation of ScaffCC, to denote pos-
bugging approach can only handle the debugging of the quantum sibly entangled qubits. The analysis is conservative in the sense
processes with time-independent Hamiltonians, and the debugging that it assumes that if two qubits interact, they are likely to have
with time-dependent hamiltonians is still an open problem [169]. become entangled with each other. However, this might lead to
some false positive entangled qubit pairs when the number of the
7.4.4 Language Support for Debugging. Programming lan-
qubits is large. Moreover, entanglement analysis can also help to
guages with good design features, such as static type systems and
find the un-computing portions in the module, through analysis of
modular programming, can help prevent bugs. Hietala et al. [126]
un-entanglement, which can be created by applying inverse func-
proposed a type-based approach to tracking errors in quantum
tions such as CNOT and Toffoli operations to the same set of control
programs at the language level. The approach uses the principle of
and target qubits.
quantum error correction code [110] for encoding each logic qubit
QASM [212] is an open-source Python tool that allows program-
in the program with a block of physical qubits, and then uses fault-
mers to investigate how to map arbitrary computation onto a qua-
tolerant operations to manipulate those encoded qubits to track
dratic unconstrained binary optimization (QUBO) [288] that runs
and correct the errors in the programs. The goal is to determine
on a quantum annealing D-Wave 2X system [134]. QASM computes
whether the error correction operations added can successfully
a simple heuristic computation algorithm and present symbolic
offset potential errors. To achieve this goal, it needs to track how
variable names as well as assembly like code blocks that might be
errors propagate through the circuit and ensure that the cumulative
reusable. Developers may integrate the solution into the D-wave
number of errors in each encoded qubit does not exceed the thresh-
system directly or by using a local simulator, which raises questions
old. To support all these issues, the authors extended QWIRE [217]
about the reliability security of such a tool [8]. Alsaadi et al. [9]
quantum circuit language with new error types and an error correc-
proposed to use static code analysis techniques to investigate the
tion gate EC by interpreting QWIRE’s Qubit type as an encoded
security threats in QASM code written in Python. The result in-
qubit and assuming that all gates are fault-tolerant. Since QWIRE
dicates that the D-Wave system might be vulnerable to multiple
is seamlessly integrated into the Coq proof assistant [31, 72], the
security breaches. They used flow-sensitive, inter-procedural, and
language can utilize both QWIRE and Coq type system to check
context-sensitive data flow analysis to uncover vulnerable points
the errors in the circuits of the program.
in the program, and several security threats have been found. They
A simple case study for the implementation was carried out
found that most of the identified functions and modules, though
and showed that the proposed language system could type check
well structured, are either undefined or unused. Also, it is hard to
a teleport example correctly. This guaranteed that every function
apply fixes because QASM is highly dependent on D-WaveâĂŹs
produces the specified number of errors in the given number of
proprietary SAPI library (programmed in C++) and does not work
specified errors from the input, and the error threshold is never
correctly without it.
passed. Several issues are also discussed as the future work, in-
cluding (1) a possible extension of the current type system with
probabilities to check if all qubits have less than t (some thresh-
8 QUANTUM SOFTWARE MAINTENANCE
old) errors with probability at least p, and (2) the development of a Support for software maintenance is crucially important in the
type system which the qubit type representing the physical qubits, development of computer software. A motivation for this is the
rather than the encoded qubits, and the error is tracked through well-known fact that somewhere between 60% and 80% of the cost
fidelity. of software comes from the maintenance phase of software develop-
ment [285]. The primary purpose of quantum software maintenance
7.5 Quantum Program Analysis for Bug is to modify and update software applications after delivery to cor-
Detection rect faults and to improve performance. Research work on this
area [159, 218] is emerging recently, which mainly focuses on the
Program analysis utilizes static techniques for reliable computation reengineering of existing classical software systems to integrate
of the information about the dynamic behavior of programs [203]. with new quantum algorithms.
Example applications include compilers (for code improvement)
and software validation (for detecting errors). Several researches
have been carried out for program analysis of quantum programs
8.1 Reengineering Classical Information
recently, which can support bug detection for quantum programs. Systems to Quantum computing
ScaffCC [137, 138] is a scalable compiler framework developed Software Reengineering [51, 69] refers to the inspection and mod-
at Princeton University for the quantum programming language ification of the target software system with a series of activities
Scaffold [1]. ScaffCC supports both compilation and compiling-time such as design recovery, re-documentation, reverse engineering,
analysis for Scaffold programs to optimize and detect possible errors and forward engineering. It aims to reconstruct the existing system
in the code. One analysis that ScaffCC supports is called entangle- as a new form to develop higher quality and more maintainable
ment analysis, which can conservatively identify each possible pair software.
of qubits that might be entangled in the program. Such entangle Although significant progress has been made in the development
information can help a programmer to design algorithms and to of quantum computers, it is evident that quantum computers can
17
not be used for all things in the short term (due to its high initial The research also implies that the ability to easily and smoothly
cost, among other reasons). Instead, it is common to use quantum replace functional components of classical software architecture
computers to solve some important problems by making specific with quantum components, just like in classical component-based
calls from classical computers to remote quantum computers in the software engineering [124], is crucial for the success of the project.
cloud [268]. In this case, most enterprises require to integrate and
migrate their first quantum algorithm or future quantum algorithm 9 QUANTUM SOFTWARE REUSE
with their existing classical information systems. Therefore, reengi- Computer software can be systematically reused across the entire
neering must be revisited to deal with the problems associated with development life-cycle, i.e., requirement specification, design, and
the migrations of quantum computing and the next coexistence of implementation [94, 158]. It has its place even in the post-delivery
classical and quantum software. stages of development, e.g., its continuing quality assessment or
To solve this problem, Pérez-Castillo [218] proposed a software software maintenance. This section gives an overview of state of
modernization approach (model-driven reengineering) [243] to re- the art on quantum software reuse in several aspects, including
structuring classical systems together with existing or new quantum quantum pattern reuse, quantum circuit reuse, and quantum state
algorithms to provide target systems that combine both classical reuse.
and quantum information systems. The software modernization
method in classical software engineering has been proved to be 9.1 Quantum Pattern Reuse
an effective mechanism that can realize the migration and evolu-
tion of software while retaining business knowledge. The solution As we discussed in Section 5, Leymann [166] identified some quan-
proposed is systematic and based on existing, well-known stan- tum patterns which can help develop quantum algorithms from the
dards such as Unified Modelling Language (UML) [40, 135, 240] perspective of software reuse. They also plan to represent these
and Knowledge Discovery Metamodel (KDM) [219]. The solution quantum patterns in a pattern repository, which is a specialized
could benefit from reducing the development of new quantum in- database that stores pattern documents and manages the links be-
formation systems. Moreover, since it is based on international tween them. Such a quantum pattern repository allows a quantum
standards to represent the knowledge in an agnostic manner, it software developer to query the database to find appropriate quan-
would be independent of any quantum programming languages. tum patterns (e.g., to determine the entry pattern corresponding to
Besides, Pérez-Castillo also pointed out that quantum technologies a problem), supports browsing the content of each pattern docu-
and programming have not yet been addressed with techniques, ment, and enables navigating between patterns based on the links
good practices, and development methodologies of software engi- between them. In this way, a quantum software developer could
neering to meet quantum programs’needs. find suitable patterns from the repository, that may cross to several
Another issue regarding reengineering (maintenance) is how different domains, and compose them to solve a complex problem.
to integrate quantum computation primitives (for instance, quan-
tum software components) to an existing classical software system. 9.2 Quantum Circuit Reuse
Since quantum computer (QC) is very different from the previous The design of efficient quantum circuits is an essential problem in
technology and method, integrating QC into existing software sys- quantum computation [221, 293]. For a given unitary matrix, it is a
tems requires that it not only solves this problem at the level of difficult task to find a highly optimized quantum circuit. There are
algorithm implementation, but also involves many more extensive a few known methods of quantum circuit design, which are mainly
problems studied in software engineering [226]. Quantum anneal- based on heuristic search techniques such as genetic algorithm
ing [89, 142, 254] is a quantum-mechanical metaheuristic (generic and simulated annealing. However, these methods are limited to
and approximate method) to solve combinatorial optimization and a relatively small circuit size, and the solutions generated by the
sampling problems. Krüger and Mauerer [159] performed a case methods are usually difficult to explain. To solve these problems,
study on how to augment a quantum software component imple- Klappenecker and Rötteler [150] presented a new design principle
mented in a quantum annealer (QA) for the Boolean satisfiability for quantum circuits that is based exactly on the idea of reusing
problem (SAT) [63], to an existing software system. In this case some existing quantum circuits in the construction of other quan-
study, they discussed the related quality measures of quantum com- tum circuits. The unique characteristics of the design principle is:
ponents, and showed that the method of transforming the SAT into assuming that we have an effective set of quantum circuits avail-
a QA, which is mathematically equivalent but structurally different, able, we can systematically construct efficient quantum circuits
can lead to substantial differences in these qualities. Their research by reusing and combining a group of highly optimized quantum
also showed that defining and testing specific quality attributes of circuits. The sound mathematical basis of this design method al-
QC components, as studied in [260], is one of the key challenges. lows meaningful and natural explanations of the generated circuits.
Although these properties do not play a core role in classical engi- They also suggested that from a practical perspective, it would
neering, they must be considered in the software architecture with be interesting to build a database of medium-sized matrix groups
quantum components. Their study may help readers form a real- with effective quantum circuits. A given transformation can then
istic intuition about the ability, potential, and challenges of using be searched in this database by linear algebra, and automatically
quantum components to enhance classical software in the near and deriving quantum circuit implementations in this way could be an
medium term. They also claimed that in the current development attractive possibility.
stage, this problem must be considered at a much lower level than Allouche et al. [7] attempted to extend further the design-by-
the conventional abstraction level in classical software engineering. reuse method proposed by Klappenecker and Rötteler [150] to a
18
general framework to support circuit synthesis through reusing the and Chuang [111], and may be considered as commercial products
existing quantum circuits. In their extension, the approach needs that can be manufactured.
to find suitable groups for the implementation of new quantum
circuits. They also identified some critical points which are nec- 10 CHALLENGES AND OPPORTUNITIES
essary for constructing their extended method. For example, this Quantum computing is an emerging field where new engineering
method relies on the distribution of the information between the methodology needs to be developed to address issues such as un-
group and the coefficient matrix. When the group contains enough foreseen changes in requirements, lack of expertise in software
information, such as the Fourier transform power group, the coeffi- development and limited budgets that plague scientific software
cient matrix is easy to calculate, and the efficiency of the quantum projects [253]. The interdisciplinary nature of the quantum com-
Fourier transform synthesis is used to generate an effective circuit puting leads to the complexity of the field. This section discusses
on non-trivial operators. Besides, they also studied some potential the challenges and opportunities in the area of quantum software
group candidates, such as the projective Pauli group and the dihedral engineering.
group, for testing the proposed method.
10.1 Quantum Software Requirements
Analysis
9.3 Quantum State Reuse
Quantum software requirements analysis may include two stages:
"Some quantum state are hard to create and maintain, but are a
stakeholder requirements definition and system requirements defini-
valuable resource for computing. Twenty-first-century entrepreneurs
tion. A key issue for the stakeholder requirements definition is to
could make a fortune selling disposable quantum states [224]."
establish the critical performance requirements so that it is possi-
To make it real, Preskill presented an interesting idea called
ble to determine whether quantum technology provides enough
plug-in quantum software for probably reusing quantum states,
benefits over classical technology. Similarly, the acceptability (size,
which make up a quantum software program [224]. The basic idea
cost, capability) of the user system must be established as early as
is that manufacturers can design a valuable quantum state and use
possible to determine the feasibility of using quantum technology
a special-purpose device to make multiple copies of that quantum
in the application under consideration. Still, the types of benefits
state; these copies can be tested to ensure their quality and stored
that quantum systems may provide are not fully defined. Therefore,
until they are needed. Consumers can pay to download that state
if the existing technology can meet the needs, especially consider-
and plug it into their quantum computer for a performance boost.
ing that the technical risks of using quantum systems may be high,
A candidate application of plug-in quantum software is to en-
users may not consider quantum systems. However, research and
sure the reliable operation of quantum computers, which is usu-
expected efforts to utilize quantum systems in the coming years will
ally achieved by applying the principle of quantum error correc-
likely provide the knowledge needed to define the needs of quan-
tion [256, 265]. For each known quantum error correction scheme,
tum systems properly so that they can be considered in the solution
some quantum gates in the fault-tolerant universal set are easy to
space. Therefore, in the process of defining stakeholder needs, it is
implement, while others are difficult. The latter can be efficiently
necessary to ensure that quantum and non-quantum solutions can
executed with quantum software, which can be prepared in advance
be adequately distinguished so as not to ignore quantum benefits.
and then consumed during the execution of the quantum gate. The
The definition of system requirements is to transform the stake-
advantage of using software rather than hardware to implement
holder requirements into a set of (technical) system requirements
the gate is that one can verify that the software is ready according
that the proposed solution must meet. The resulting system require-
to specifications before use. If a problem is found with the software,
ments cover functional, non-functional, performance, process, and
it can be discarded or repaired. On the contrary, if the hardware
interface aspects, and include design constraints. However, due to
has a severe failure during the execution of the quantum gate, it
the limitations of the models, the definition of design constraints
may be difficult to recover.
due to quantum technology effects might also be problematic. There-
The idea for creating and preparing quantum states offline is not
fore, one of the main problems in the system requirements definition
new. Instead, several researches [111, 153, 255] have been carried
process is whether the models used to establish the relationship
out. Among them, Gottesman and Chuang [111] proposed an inter-
and correlation between different technical requirements are ade-
esting approach to preparing, using, and classifying quantum states.
quate and sufficient. This problem, however, can only be solved by
The goal of their approach is to make the design of fault-tolerant
developing better models and considering the effects of quantum
quantum computers more straightforward and methodical. The
technology adequately.
main idea is to use a generalized form of quantum teleportation,
a simple technique to reduce the required resources to construct
necessary quantum gates (states), such as Pauli gates (X , Y and Z ), 10.2 Quantum Software Design
Cliff group, Toffoli gate, the π /8 gate (rotation about the Z -axis by This section discusses challenges and opportunities regarding quan-
an angle π /4), and the phase gate. Their construction relies on the tum software design from the perspectives of architectural design
ability to create some ancilla states, which is independent of the and detailed design.
data being manipulated, and therefore can be prepared offline in
10.2.1 Quantum Architectural Design. The software archi-
advance. So they are valuable general-purpose quantum resources,
tecture of a system defines its high-level structure, revealing its
perhaps a kind of "quantum software," as mentioned by Gottesman
overall organization as a set of interacting components [179, 222].
19
A well-defined architecture allows an engineer to reason about validation of quantum software architectures.
system properties at a high level of abstraction. The incorporation
of quantum computing effects on software architectures may re- Software Quality Attributes. Software quality attributes [22] refer
quire new methods to define the attributes, features, functions, and to the non-functional requirements of software, which can have
constraints assigned to architectural elements. This will require a profound effect on the quality of a software product. The soft-
quantum software architects to reach a consensus and establish ware quality attributes of a system should be considered and evalu-
standard representations for quantum software components. The ated during the development of the software architecture. These
extent to which new types of components are introduced at the ar- attributes relate to how the architecture addresses important non-
chitecture level depends on the level of abstraction required, which functional requirements, such as performance, security, and main-
is yet unclear. The functional architecture is unlikely to be affected tainability. Other software quality attributes include modifiability,
by the introduction of quantum software components, though spe- testability, traceability, scalability, reusability, and availability. As
cific functions within the architecture may be new. we summarized in section 5, Sohdi [260] identified some critical
Quantum Architectural Patterns (Styles). The software architecture characteristics of quantum computing systems, and studied how
pattern provides a skeleton or template for the overall software these characteristics may affect the quality attributes of quantum
architecture or high-level design of software applications [109]. software architectures. A more significant issue worth investigating
Shaw and Garlan [179] mentioned the architectural style (or pattern) is how to use these quality attributes to evaluate the quality of the
of software architecture, which is the repetitive architecture used in quantum software architecture during the architectural design.
various software applications (see also [22]). Architectural patterns 10.2.2 Detailed Quantum Design. The detailed quantum de-
can be classified into two main categories: architectural structure sign provides information about the quantum software system as
patterns, which focus on the static structure of the architecture, and a whole and the individual quantum software components to en-
architectural communication patterns, which focus on the dynamic able implementation. An essential aspect of the detailed design is
communication among distributed components of the architecture. the selection of the technologies required for each quantum soft-
Currently, software architects do not have architectural patterns ware component. Substantially, the inclusion of quantum software
for quantum software systems, which can be used to adequately component increases the search space available to the quantum
deal with the quantum issues when specifying the architecture of software engineer in making technology selection, but may lead to
quantum software systems. The current repository for architectural a challenge. The development of suitable models and their incorpo-
patterns do not provide patterns which consider the quantum issues. ration into quantum software design frameworks should be an area
Therefore, to perform the architectural-level design of quantum of intensive research effort in the future. Another important con-
systems, it is necessary to identify some quantum architectural sideration is that at any particular stage in the quantum software
patterns, which are well-considered to model the quantum effect of life cycle, an appropriate level of quantum software modeling must
the system. be included. Moreover, it is crucial to recognize that the individual
Quantum Architectural Description Languages. Architectural de- quantum software components may be developed by several or
scription languages (ADLs) [59] are formal languages that can be many different organizations.
used to represent the architecture of a software system. They fo- Quantum Design Patterns. A design pattern describes a recurring
cus on the high-level structure of the overall application rather design problem to be solved, a solution to the problem, and the
than the implementation details of any specific source module. Sev- context in which that solution works [95, 97]. Design patterns have
eral ADLs have been proposed, such as Wright [235], Rapide [176], been evolved over a long period and provide the best solutions to
UniCon [252], Darwin [177], and ACME [99] to support formal specific problems faced during software development. Learning
representation and reasoning of classical software architectures. these patterns helps inexperienced developers to learn software
Recently, software architects do not have tools to adequately deal design in an easy and faster way. Design patterns have proved
with the quantum issues when specifying the architecture of quan- highly useful within the object-oriented field and have helped to
tum software systems. Current ADLs do not provide primitives achieve good design of applications through the reusability of val-
to specify quantum components and their connections with clas- idated components. These experiences tell us that it is crucial to
sical components. Using ADLs, software architects can specify identify the elements of good and reusable designs for quantum
the functionality of the system using components and the inter- software and to start formalizing peopleâĂŹs experience with these
action between components using connectors. It is necessary to designs through quantum design patterns. We hope that the quan-
extend current ADLs to quantum architectural description languages tum design patterns, if being identified, could benefit the quantum
(qADLs) to formally specify the architectures of quantum software software development, and a quantum pattern catalog for quantum
systems for architectural-level design of quantum systems. We be- software could be especially useful.
lieve that such a qADL should contain at least those mechanisms,
including specifications of classical components with interfaces 10.2.3 Design Models for Quantum Software. There is an
and connections between interfaces (already provided in classical absence of modeling techniques for quantum software system de-
ADLs), specifications of quantum components, and specifications sign. The current existing model of quantum software systems [220]
of connectors between classical and quantum components. Also, a is generally a simple extension of the classical modeling technique.
qADL should support the tasks of formal analysis, verification, and The lack of suitable models is probably one of the most significant
difficulties facing quantum software engineering, particularly as
20
this may impact design, testing, and possibly maintenance parts of selection techniques of quantum software. Although work on iden-
the quantum software life cycle. tifying bug types for quantum software is just beginning [132, 133],
Design models for classical software engineering have been ex- more study should be carried out to build a practical fault model
tensively studied from various perspectives. Among them, several for supporting quantum software testing and debugging.
notable design models are data flow diagrams (DFDs) [305], entity-
relationship diagrams (ERDs) [49] and unified modeling language 10.4.2 Quantum Software Testing. Systematic testing of quan-
(UML) [40]. We believe that the first natural step is to investigate tum software systems must be based on fault models that reflect
these well-established design models to see if they could be ex- the structural and behavioral characteristics of quantum software.
tended to the quantum computing domain to support quantum Criteria and strategies for testing quantum programs should be
software modeling by incorporating the quantum effects within developed in terms of the fault model. As its classical counterpart,
the models appropriately. quantum software testing must explore the following issues rigor-
ously and provide the answers for each of them to build effective
10.3 Quantum Software Implementation and efficient testing frameworks for quantum software.
Quantum software implementation refers to the development of (1) How to define testing coverage criteria of quantum software?
quantum software entities that meet the requirements, architecture, (2) How to automatically and efficiently generate test cases for
and design. It is not uncommon to introduce new constraints in quantum software?
the implementation. These constraints must be reflected back into (3) How to evaluate the test data quality for quantum software?
requirements. The essential design characteristics for achieving a (4) How to test quantum software regressively?
subtle quantum effect are likely not to be compromised. Therefore,
the process must include rules and tests to ensure that unwanted Although some of these issues, such as testing covering crite-
changes are not introduced. One can expect that reliability will ria [289] and test case generation [131], have been addressed in
become an important area of research in quantum software tech- current researches, it is far from practical uses for testing quantum
nologies. The principles derived from this research will provide a software.
basis for the implementation strategy formulated during the imple-
mentation process. In short, the implementation process will need 10.4.3 Quantum Program Debugging. A commonly used
to incorporate the principles of quantum software reliability engi- classical debugging technique is the one in which a developer exam-
neering. Testing the potential impact of implementation changes ines the program state through setting breakpoints [164]. This tech-
on the entire quantum software system requires modeling before nique, however, cannot be used to debug quantum software since
agreeing to the changes. any inspection of a quantum register can cause it to decohere [295].
On the other hand, it seems challenging to introduce new quan- A simple variant of this technique that entails making a copies of
tum programming languages into widespread practice. Perhaps a the quantum register is similarly foiled due to the physical impossi-
promising way is to define the requirements for the future high- bility of making copies of quantum objects. One possible way is to
level quantum programming, which may eventually lead to the use multiple quantum registers that are prepared in the same way.
development and widespread use of a more efficient quantum pro- However, the probabilistic nature of quantum computation should
gramming language. Another possible research direction could be serve as a constant reminder to the debugger of quantum software
to develop techniques and tools to generate quantum code from that no two quantum registers can be assumed to be identical. It is
quantum software design specifications automatically. evident here that more investigations are needed. Recently, several
pieces of research [132, 133, 168, 169, 172, 309] have been carried
10.4 Quantum Software Reliability out that showed some promising initial results on debugging quan-
tum software. However, it is still not clear what the appropriate
This section discusses the challenges and opportunities on quan- debugging techniques for quantum computing are [195]. As a result,
tum software reliability, including fault model, testing, debugging, new approaches still need to be developed. On the other hand, while
verification, and visualization. assertion-based debugging [132, 133, 168, 172] seems a promising
10.4.1 Fault Model for Quantum Software. In general, a way in debugging quantum software, different kinds of debugging
fault model refers to an engineering model that may cause problems techniques in classical computing, such as interactive debugging,
in the construction or operation of equipment, structures, or soft- static and dynamic analysis, code review and inspection, and post-
ware [36]. The unique features of quantum programming, such as mortem, are also worth further investigation [195]. A question that
superposition, entanglement, and no-cloning, do not occur in clas- naturally arises is: are these classical debugging techniques applicable
sical imperative, functional, or even multi-paradigm programming. to the quantum domain?
Each feature can manifest new fault types that ultimately lead to As an example, Whyline [155], a novel interactive debugging
quantum program failures. Therefore, to test quantum software, a paradigm for classical software, can reduce the debugging time by
fault model for quantum software is required. Such a fault model allowing programmers to select "why" and "why not" questions
should be based on the peculiarities of quantum programs, and to query the behavior of a program. We have not seen such a
defined through careful analysis of the unique constructs of quan- novel idea in the debugging of quantum software, but it would
tum programming languages and reflects an initial evaluation of be worth exploring. An in-depth understanding of how quantum
classes of potential faults. Such a fault model can be used to measure programmers perform debugging would provide an opportunity
the fault-detection effectiveness of automatic test generation and to develop new quantum debugging tools, and such work should
21
be based on previous research that demonstrates best practices in for classical software maintenance have been well studied and es-
scientific computing [16]. tablished [27, 75, 119, 262], but research on the maintenance of
Another example of classical debugging paradigms that should quantum software systems is just starting [218]. We believe that
be paid attention to is algorithmic debugging [250, 251]. Algorithmic any quantum software maintenance process should deal with at
debugging is an interactive process in which the debugging system least the following three main issues:
gains knowledge of the expected behavior of the program being • How to understand the existing quantum software?
debugged and uses this knowledge to locate errors. An algorithmic • How to modify the existing quantum software?
debugger can be invoked after noticing an externally visible symp- • How to re-validate the modified quantum software?
tom of a bug. Then, it executes the program and builds an execution Moreover, the maintenance process of quantum software systems
trace tree at the procedure level, while saving some useful trace in- likely needs to include the monitoring of the systems so that fault
formation such as the procedure name and input/output parameter diagnosis could be informed during the maintenance and evolution
values. After that, the debugger traverses the execution tree and of the systems.
interacts with the user by asking for the expected behavior of each
procedure. The user can answer "yes" or "no" to give an assertion 10.6 Quantum Software Reuse
about the predicted behavior of the procedure. Once some neces-
Component-based software engineering (CBSE) is an approach to
sary conditions are satisfied, the search ends, and the location of
software systems development based on reusing software com-
the bug is identified. Algorithmic debugging provides a declarative
ponents [124, 156]. Component here means a unit or a part of a
way of debugging. If applied to quantum software, it might offer
model. It is the process that emphasizes the design and construc-
abstractions that allow programmers to think at an algorithmic
tion of computer-based systems using reusable software compo-
level with less concern for details like control pulse generation,
nents or simply building software systems from pre-existing compo-
which may provide a possibility for overcoming the problems for
nents [262]. The maintenance of CBSE can be easily accomplished
which the quantum software debugging are facing [54].
by replacing or introducing a new component to the system [183].
As quantum software resources are getting accumulated, it is
10.4.4 Quantum Software Visualization. Understanding the
crucial to develop some methodologies, techniques, and tools for
behavior of quantum software is an important and nontrivial task,
reusing quantum software systems. One promising way, we be-
and software visualization [151, 264], a well-developed technique
lieve, might be the component-based quantum software engineer-
for understanding the behavior of classical software, may signifi-
ing (CBQSE), which focuses on the design and development of
cantly contribute to it. Visualization of qubit states is particularly
quantum computer-based systems with the use of reusable quan-
challenging since the number of achievable quantum states is ex-
tum (classical) software components. Such an approach can save
ponential [16]. Recently, several methods have been proposed for
the development time and also be easy for maintenance during
visualizing the state of qubits by using Bloch sphere [62, 106] and
the evolution of the quantum software system. Another possible
matrices of Pauli Expectation Value (PEVs) [117, 294], and for vi-
research direction, as we discussed in Section 10.2, is to build a
sualizing the transitions between qubit states by using two-qubit
quantum architectural (design) pattern catalog to support the reuse
representation [233]. However, the explosion of qubit state-space
of quantum software entities efficiently and effectively.
necessitates the development of scalable visualization that can in-
tuitively help quantum software developers understand the states
their systems are in, to facilitate the development, debugging, and
11 RELATED WORK
validation of quantum algorithms [16]. To the best of our knowledge, this work is the first comprehensive
survey on the research of quantum software engineering regarding
10.4.5 Quantum Program Verification. Verification plays various phases of its life cycle, including quantum software require-
an essential role in quantum programming, both in the short and ments analysis, design, implementation, testing, and maintenance.
long term. Quantum programs are difficult to debug and test due This section discusses some related work in quantum programming
to features such as superposition, entanglement, and no-cloning. languages, quantum software engineering, and quantum software
To build the confidence regarding the correctness of a quantum development environments.
program, we need to develop verification methods. There has been
substantial progress in verifying quantum programs [43, 47, 84, 11.1 Quantum Programming Languages
173, 228, 229, 300, 304]. However, as Rand et al. [229] pointed out, Software is a solution for solving a computational problem us-
novel verification methods are still needed to deal with errors and ing a formal programming language. The construction of the lan-
to verify error-prone quantum programs concerning the hardware guage and the tools that can be used to model, implement, and
we intend to run them on. Moreover, we need also approaches to test software systems affect the quality of the solution, including
verify quantum compilations [127]. correctness, reliability, readability, computational efficiency, and
efficiency of design and development. Therefore, the quantum pro-
gramming language plays a vital role in the life cycle of quantum
10.5 Quantum Software Maintenance
software development. Several comprehensive surveys on quan-
Software maintenance is an essential activity during software de- tum programming languages have been carried out from different
velopment. The objective is to modify the existing software product perspectives [54, 98, 102, 125, 140, 186, 239, 244, 261, 263, 276, 280,
while preserving its integrity [27]. Methods, techniques, and tools 281, 302, 311].
22
 Selinger [244] carried out the first survey on quantum program- languages are mentioned and compared, that is, QCL [206, 207]
ming language in 2004. His survey uses a similar classification and qGCL [241, 312–314] for imperative, the approaches by Ton-
scheme and offers a different perspective on some of the issues in der [282] and Girard [107] and QPL [244, 245, 247] by Selinger for
the field. functional, and CQP [103, 104] and QPAlg [160] for parallel and
Gay [102] published a comprehensive and detailed survey on distributed. The survey also discussed the semantics issues of quan-
quantum programming languages in 2006. He classified the cen- tum programming languages, from the perspectives of operational,
tral theme of each paper from the perspectives of programming axiomatic, and denotational aspects, respectively.
language design, semantics, and compilation. Regarding to program- Sofge [261] gave a brief survey on quantum programming lan-
ming language design, the paper considers imperative and func- guages from the perspective of history, method, and tools in 2008.
tional programming languages, and for semantics, it focuses on the He introduced a taxonomy of quantum programming languages,
denotational techniques. Besides the survey, Gay also maintained which divided into (1) imperative quantum programming languages,
an online bibliography as a resource for the community [100]. (2) functional quantum programming languages, and (3) other quan-
Unruh [276] also gave an overview of the state of the art on tum programming language paradigms, which include some types
the development of quantum programming languages in 2006. In of mathematical formalism that not intended for computer exe-
his overview, quantum programming languages are classified into cution. Based on the taxonomy, a brief survey is given to reflect
two types, i.e., practical programming language and formal pro- state of the art for quantum programming languages until 2007.
gramming language. Practical programming languages, such as Some challenges and a path forward for quantum programming
QCL [206, 207] and Q [33], aim at practical applications such as languages are also given in the survey.
simulation or the programming of actual quantum computers, while Ying et al. [302] presented a survey on the programming method-
formal programming languages, such as QFC (QPL) [244, 245, 247], ology for quantum computing in 2012. Their survey discussed those
Quantum lambda calculus [181], qGCL [241, 312–314], QPAlg [160], issues regarding the design of sequential and concurrent quantum
and CQP [103, 104], concentrate on how to model the semantics programming languages and their semantics and implementations,
of a quantum program. The survey also pointed out some open with more emphasis on the work conducted by the authors. Notably,
problems and challenges regarding the practical and formal pro- in addition to discussion on the quantum programming languages
gramming languages. For practical languages, the main challenges themselves, they also reviewed some formal verification approaches
are how to design some powerful language constructs to abstract for quantum programs and protocols, and discussed the potential ap-
from the low-level model of quantum circuits to lift towards the plications of these quantum languages and verification approaches
high-level programming, and how to develop compilers and opti- in quantum computing engineering.
mizers to obtain the best results out of the available resources. For One of the most recent surveys for quantum programming lan-
formal languages, the main challenges lay in how to design expres- guages is proposed by Garhwal et al. [98] in 2019, which gave an
sive, easy-to-read quantum languages with well-defined semantics, overview of state of the art in the field of quantum programming
and how to develop effective methods to verify quantum programs languages, focusing on actual high-level quantum programming
written by these languages. languages, their features and comparisons. They classified quantum
Rüdiger [239] presented a comprehensive survey for quantum programming languages into five categories: quantum imperative
programming languages from the pragmatic perspective in 2006. programming language, quantum functional language, quantum
He first gave some introduction on necessary notations of quan- circuit language, multi-paradigm language, and quantum object-
tum theory and quantum computation, and then discussed the oriented language. In the survey, they tried to answer the following
goals and design issues for quantum programming languages. He research questions [98]:
claimed that quantum programming languages should enable pro-
• What are the different types of quantum languages?
grammers to reason about the structures of quantum algorithms
• What are the recent trends in developing quantum languages?
and programs, and a well-designed quantum programming lan-
• What are the most popular publication venues for quantum
guage should help find new quantum algorithms. The survey also
programming?
discussed several concrete quantum programming languages such
• What are the most cited papers in the area of a quantum
as pseudocode [152, 154], QCL [206, 207], and Q language [32, 33]
language?
in detail, and gave a comparison of these three languages from
• Which major companies, groups, institutes, and universities
the perspective of language paradigms and semantics. The sur-
are working on the development of quantum languages?
vey also pointed out some research directions towards quantum
programming language design and implementation. They concluded the survey by pointing out some recent trends,
Jorrand’s survey [140] on the quantum computing paradigm results, and future work in the area.
started from a brief overview of the principles that underlay quan- Another recent survey [311] is presented by Zorzi, which focuses
tum computing and introduced the breakthroughs achieved by on the QRAM (Quantum Random Access Machine) architectural
the quantum computing field, which include quantum algorithms model. The survey is organized from the twofold perspectives,
and teleportation. The main focus of the survey is on the quan- i.e., theory and concrete, and identifies the main problems one
tum computation paradigm, that is, quantum programming lan- has to face in quantum language design. The survey tried to find
guages and their semantics. Three styles for quantum programming some evidences from current researches to answer the following
languages have been discussed in the survey, including impera- fundamental questions [311] regarding quantum language design
tive, functional, and parallel and distributed. For each style, several and provided some possible answers to these questions.
23
 • What is the architectural model the language refers to? debugging and testing techniques for quantum computing, as
• How to manage quantum data (which are no-duplicable to we know that quantum execution is in principle unobservable.
ensure the no-cloning property, so need a form of linear treat- • Novel quantum possibilities: how to extend quantum software
ment)? engineering to encompass those new issues from quantum
• What class of quantum functions one aim to program (expres- mechanics, which cannot be even simulated by discrete deter-
sive power)? ministic classical computers.
Besides those above, several other surveys are also given in [54, We believe that the software engineering and the quantum com-
125, 186, 263, 280, 281], on quantum programming languages from puting communities should pay more attention to the issues listed
different viewpoints. However, although these surveys on quantum above, to facilitate the construction of the overall picture for the
programming languages give very comprehensive pictures on the field of quantum software engineering.
state of the art of researches on quantum programming languages,
they lack the discussion of other phases of the life cycle of quantum 11.2.2 A landscape of Research Challenges for Quantum
software development, such as requirement, design, testing, and Software Engineering. Barbosa [19] presented a landscape of
maintenance. some research challenges to overcome for evolving the software
engineering application in quantum computing, along with poten-
11.2 Quantum Software Engineering tial research directions in several aspects of the problem, including
models, architectures, and properties. He believed that it is the time
The term quantum software engineering was originally coined by
to discuss an agenda for a solid, rigorous software engineering
John Clark and Susan Stepney [57] at the Workshop on Grand
discipline for quantum systems. He claimed that any roadmap for
Challenges for Computing Research organized by Tony Hoare and
such a discipline should contain three main aspects:
Malcolm Atkinson, in 2002. Since then, there have been exten-
sive research works on the different aspects of quantum software (1) How quantum software systems are modeled.
engineering as surveyed in this paper. Although no survey has (2) How the models of these systems are composed.
been presented for quantum software engineering until now, some (3) How the properties of these systems’ behaviors can be pre-
papers [19, 223] discussed the challenges of which quantum com- dicted, specified, and verified.
puting is facing on during quantum software development. He also pointed out some challenges and research directions in
terms of the models, architectures, and properties of the quantum
11.2.1 Journeys in Non-Classical Computation. In their sem-
systems, respectively. Among those directions, one particularly
inal papers titled "Journeys in non-classical computation I and
interesting issue, which is worth exploring, is how to extend the
II" [267, 268], Stepney et al. presented a grand challenge on quan-
contract-based design, a successful paradigm in classical software
tum software engineering, to develop a mature discipline of quan-
engineering, to the quantum domain. The paper is presented in
tum software engineering for fully exploiting commercial quantum
the form, of which the formal aspect of the quantum software
computer hardware. They claimed in [268] that "The whole of clas-
engineering principle is emphasized.
sical software engineering needs to be reworked and extended into
the quantum domain.", and introduced this challenge from different 11.2.3 The Talavera Manifesto for Quantum Software En-
perspectives of quantum software engineering, including founda- gineering and Programming. Piattini et al. [223] presented the
tions, quantum computational models, languages and compilers, Talavera Manifesto for quantum software engineering and program-
methods and tools, as well as novel quantum possibilities. Here, ming, which is the result obtaining from the discussions and differ-
we briefly list some challenge problems for each aspect mentioned ent viewpoints of academia and industry practitioners who joined
in [267, 268]: at the QANSWER, the 1st International Workshop on Quantum
• Foundations: how to develop metaphors and models of quan- Software Engineering & Programming, promoted by aQuantum at
tum computing, which one can use to design and reason about School of Computer Science, in the Campus of Talavera de la Reina
quantum algorithms without considering the details within of the University of Castilla-La Mancha. The manifesto collects
the quantum machine and unitary matrices, etc. some principles and commitments about the field of quantum soft-
• Quantum computational models: how to generalize various ware engineering and programming, as well as some calls for action.
classical formalisms to the quantum realm in different ways They believe that quantum software engineering should have a nec-
• Languages and compilers: how to determine the fundamen- essary contribution to the success of quantum computing, and it is
tal building blocks of quantum programming; how to design the time to develop quantum software by applying or adapting the
suitable assembly level and high-level quantum programming well-established principles and methodologies from classical soft-
languages and the compilers of these languages; how to de- ware engineering field, to the development of quantum software,
velop suitable reasoning systems and refinement calculi for which may include processes, methods, techniques, and practices.
these languages. Concretely, they listed some principles and commitments regarding
• Methods and tools: how to develop powerful simulation sys- quantum software engineering, such as quantum software process,
tems so that one can perform computational experiments and reengineering, requirement, evolution, testing and debugging, reuse,
validate the designs of the languages and algorithms; how to security and privacy, and management. They also call for actions
discover what high-level structuring techniques and architec- to the stakeholders, including software practitioners, researchers,
tures are suitable for quantum software; how to develop novel educators, government and funding agencies, quantum technology
24
vendors, professional associations, customers, and users, who may and discrete and continuous-variable gate-model quantum comput-
contribute to the field of quantum software engineering. ing [210]. For each project, the evaluation covers those features,
However, the manifesto contains no detailed discussion about including documentation, licensing, the choice of programming
the current status of research in the field of quantum software language, compliance with software engineering specifications, and
engineering. the culture of the project. Fingerhuth et al. also discussed some
of the findings that though the diversity of the projects is fasci-
nating, only a few projects attract external developers, and even
11.3 Quantum Software Development many commercially supported frameworks have flaws in software
Environments engineering. Based on these findings, the authors highlighted some
best practices that could foster a more active community around
Roetteler et al. [236] presented a survey on investigating recent
quantum computing software, welcome newcomers to the field,
progress in building a quantum software framework, which can
and also ensure high-quality, well-documented code.
compile quantum algorithms from the high-level descriptions to
Shaydulin et al. [253] surveyed open-source quantum computing
physical quantum gates, which can be implemented on fault-tolerant
projects from a different perspective, which mainly focused on the
quantum computers. In the survey, they discussed why tools such as
contributors of quantum software projects. They observed that one
compilation and design automation are essential to meet the enor-
of the main problems in quantum computing is the lack of under-
mous challenges of building scalable quantum computers. They also
standing of what training is required for success in the quantum
introduced a library developed with LIQUi|⟩ [292] programming
computing field. To answer this question, they collected data on
language, including reversible circuits for arithmetic and new real
148 contributors to three open-source quantum computing projects
quantum methods that rely on quantum computer architecture,
hosted on GitHub, including Qiskit [4] by IBM, PyQuil/Grove [259]
which allows the probability execution of quantum gates. This li-
by Rigetti, and Cirq [271] by Google. They studied the successful
brary, in some cases, can reduce time and space overhead. Also, the
contributors to these projects from the field as well as the wider
survey highlights why these libraries are useful for implementing
quantum computing community to understand the background and
many quantum algorithms. Finally, the tool Revs was investigated.
training that contributed to their success. These observations can
This tool can help to compile high-level irreversible programs into
help develop educational resources targeted at preparing a new gen-
low-level reversible circuits with resource efficiency, while trying to
eration of quantum computing researchers and practitioners. Their
optimize the memory footprint of the resulting reversible network.
study could have a positive effect on bringing software engineering
Construction of the tool is motivated by the fact that the availability
methodologies and techniques to the quantum domain.
of qubit is limited in the foreseeable future.
All these surveys focus specifically on the quantum software
LaRose [163] presented an overview and comparison of gate-
development environments, one of the essential aspects of quantum
level quantum software platforms. The overview mainly focuses
software development, but not on the whole life cycle of quantum
on four new software platforms in quantum computing, namely,
software development, as we presented in this paper.
Forest (pyQuil) from Rigetti [61, 259], Qiskit from IBM [232], Pro-
jectQ from ETH Zurich [266, 272], and Quantum Developer Kit (Q#)
from Microsoft [269]. Forest, Qiskit, and ProjectQ allow the users 12 CONCLUDING REMARKS
to access the real quantum computing devices, while Quantum This paper presented a comprehensive survey in the field of quan-
Developer Kit only allows access to the simulator. In the overview, tum software engineering, which is across all the phases of the quan-
each platform is discussed and summarized from six aspects: re- tum software life cycle, and covered the crucial issue on quantum
quirements and installation, documentation and tutorials, quantum software reuse as well. The paper also discussed some challenges
programming language syntax, quantum assembly/instruction lan- and opportunities in the field.
guage, quantum hardware, and simulator capabilities, with the links In its short history, quantum software development has been
to documents and tutorial sources of each package. The overview driven by the emergence of quantum programming languages [100,
also compares each platform with additional aspects, including 115, 206, 232, 269]. In other words, quantum software development
library support, quantum hardware, and quantum compilers, and has mostly been synonymous with quantum programming. While
lists some notable and useful features of each platform. The purpose such languages have helped popularise the subject, this is not a
of this overview is to provide users with essential information for healthy position in the longer term. In particular, it is vital that
each platform to help them select a suitable platform to start ex- a complete software engineering discipline emerges for quantum
ploring quantum computing programming. In addition to the four software development. This paper is aimed as a stepping stone in
platforms mentioned, the overview also briefly introduced several this direction. This paper has examined state of the art in engi-
quantum programming environments, including Quipper [114, 115], neering support for quantum software systems, looking at areas
Scaffold [1], and QCL [206]. such as requirements, design, implementation, testing, and main-
Fingerhuth et al. [86] presented an exhaustive review of open- tenance in the quantum software life cycle. The crucial issue of
source software projects in quantum computing. The review covers quantum software reuse has also been considered. The evidence
the whole stages in the quantum toolchain from quantum hard- presented suggests that rapid progress is being made in these areas.
ware interfaces through quantum compiler to implementations of It would be wrong though to claim maturity in the topics addressed
quantum algorithms and also the full spectrum of quantum com- by this paper; indeed, although many techniques have emerged,
puting paradigms, which include quantum annealing [89, 142, 254], further experience is required to appreciate their relative strengths
25
and indeed to consolidate proposals into a small number of critical [19] Luís S. Barbosa. 2020. Software engineering for ’quantum advantage’. In 2020
approaches. IEEE/ACM First International Workshop on Quantum Software Engineering (Q-SE).
IEEE.
[20] Rami Barends, Julian Kelly, Anthony Megrant, Andrzej Veitia, Daniel Sank,
Evan Jeffrey, Ted C White, Josh Mutus, Austin G Fowler, Brooks Campbell, et al.
REFERENCES 2014. Superconducting quantum circuits at the surface code threshold for fault
[1] Ali J Abhari, Arvin Faruque, Mohammad J Dousti, Lukas Svec, Oana Catu, tolerance. Nature 508, 7497 (2014), 500–503.
Amlan Chakrabati, Chen-Fu Chiang, Seth Vanderwilt, John Black, and Fred [21] Len Bass, Paul Clements, and Rick Kazman. 2012. Software architecture in
Chong. 2012. Scaffold: Quantum programming language. Technical Report. practice. Addison-Wesley Professional.
Department of Computer Science, Princeton University. [22] Len Bass, Mark Klein, and Felix Bachmann. 2000. Quality attribute design
[2] Jean-Raymond Abrial, SA Schuman, and Bertrand Meyer. 1980. A Specification primitives. Technical Report. CARNEGIE-MELLON UNIV PITTSBURGH PA
language. RM McK-eag and AM MacNaughten, editors7 On the Construction of SOFTWARE ENGINEERING INST.
Programs: An Advanced Course (1980). [23] K BECK. 1987. Using Pattern Languages for Object-Oriented Programs. In
[3] W Richards Adrion, Martha A Branstad, and John C Cherniavsky. 1982. Vali- OOPSLA-87.
dation, verification, and testing of computer software. Comput. Surveys 14, 2 [24] B Beiser. 1983. Software Testing Techniques. Van Nostrand Reinhold Company.
(1982), 159–192. [25] Marcello Benedetti, John Realpe-Gómez, Rupak Biswas, and Alejandro Perdomo-
[4] Gadi Aleksandrowicz, Thomas Alexander, Panagiotis Barkoutsos, Luciano Ortiz. 2016. Estimation of effective temperatures in quantum annealers for
Bello, Yael Ben-Haim, David Bucher, Francisco Jose Cabrera-HernÃąndez, Jorge sampling applications: A case study with possible applications in deep learning.
Carballo-Franquis, Adrian Chen, Chun-Fu Chen, Jerry M. Chow, Antonio D. Physical Review A 94, 2 (2016), 022308.
CÃşrcoles-Gonzales, Abigail J. Cross, Andrew Cross, Juan Cruz-Benito, Chris [26] Charles H Bennett and Gilles Brassard. 2014. Quantum cryptography: Public
Culver, Salvador De La Puente GonzÃąlez, Enrique De La Torre, Delton Ding, key distribution and coin tossing. Theoretical Computer Science 560 (2014), 7–11.
Eugene Dumitrescu, Ivan Duran, Pieter Eendebak, Mark Everitt, Ismael Faro [27] Keith H Bennett and Václav T Rajlich. 2000. Software maintenance and evolution:
Sertage, Albert Frisch, Andreas Fuhrer, Jay Gambetta, Borja Godoy Gago, Juan a roadmap. In Proceedings of the Conference on the Future of Software Engineering.
Gomez-Mosquera, Donny Greenberg, Ikko Hamamura, Vojtech Havlicek, Joe 73–87.
Hellmers, ÅĄukasz Herok, Hiroshi Horii, Shaohan Hu, Takashi Imamichi, Toshi- [28] Jon Bentley. 1985. Programming Pearls: Confessions of a Coder. Commun. ACM
nari Itoko, Ali Javadi-Abhari, Naoki Kanazawa, Anton Karazeev, Kevin Krsulich, 28, 7 (1985), 671–679.
Peng Liu, Yang Luh, Yunho Maeng, Manoel Marques, Francisco Jose MartÃŋn- [29] Ethan Bernstein and Umesh Vazirani. 1993. Quantum complexity theory. In
FernÃąndez, Douglas T. McClure, David McKay, Srujan Meesala, Antonio Mezza- Proceedings of the twenty-fifth annual ACM symposium on Theory of Computing.
11–20.
capo, Nikolaj Moll, Diego Moreda RodrÃŋguez, Giacomo Nannicini, Paul Nation,
[30] Ethan Bernstein and Umesh Vazirani. 1997. Quantum complexity theory. SIAM
Pauline Ollitrault, Lee James O’Riordan, Hanhee Paik, JesÞs PÃľrez, Anna Phan,
Journal on computing 26, 5 (1997), 1411–1473.
Marco Pistoia, Viktor Prutyanov, Max Reuter, Julia Rice, AbdÃşn RodrÃŋguez
[31] Yves Bertot and Pierre Castéran. 2013. Interactive theorem proving and program
Davila, Raymond Harry Putra Rudy, Mingi Ryu, Ninad Sathaye, Chris Schnabel,
development: CoqâĂŹArt: the calculus of inductive constructions. Springer Science
Eddie Schoute, Kanav Setia, Yunong Shi, Adenilton Silva, Yukio Siraichi, Seyon
& Business Media.
Sivarajah, John A. Smolin, Mathias Soeken, Hitomi Takahashi, Ivano Tavernelli,
[32] Stefano Bettelli. February 2002. Toward an architecture for quantum program-
Charles Taylor, Pete Taylour, Kenso Trabing, Matthew Treinish, Wes Turner,
ming. Ph.D. Dissertation. Università di Trento.
Desiree Vogt-Lee, Christophe Vuillot, Jonathan A. Wildstrom, Jessica Wilson, Er-
[33] Stefano Bettelli, Tommaso Calarco, and Luciano Serafini. 2003. Toward an
ick Winston, Christopher Wood, Stephen Wood, Stefan WÃűrner, Ismail Yunus
architecture for quantum programming. The European Physical Journal D-
Akhalwaya, and Christa Zoufal. 2019. Qiskit: An Open-source Framework for
Atomic, Molecular, Optical and Plasma Physics 25, 2 (2003), 181–200.
Quantum Computing. (jan 2019). https://doi.org/10.5281/zenodo.2562111
[34] Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan
[5] Christopher Alexander. 1977. A pattern language: towns, buildings, construction.
Wiebe, and Seth Lloyd. 2017. Quantum machine learning. Nature 549, 7671
Oxford university press.
(2017), 195–202.
[6] Eric Allen. 2002. Bug Patterns in Java. (2002).
[35] Benjamin Bichsel, Maximilian Baader, Timon Gehr, and Martin Vechev. 2020.
[7] Cyril Allouche, Marc Baboulin, T Goubault de Brugière, and Benoît Valiron.
Silq: A High-Level Quantum Language with Safe Uncomputation and Intuitive
2017. Reuse method for quantum circuit synthesis. In International Conference
Semantics. In Proceedings of the 41th ACM SIGPLAN Conference on Programming
on Applied Mathematics, Modeling and Computational Science. Springer, 3–12.
Language Design and Implementation.
[8] Khalifa AlRoum, Abdulhakim Alolama, Rami Kamel, May El Barachi, and Mon-
[36] Robert Binder. 2000. Testing object-oriented systems: models, patterns, and tools.
ther Aldwairi. 2017. Detecting malware domains: A cyber-threat alarm system.
Addison-Wesley Professional.
In International Conference on Emerging Technologies for Developing Countries.
[37] Garrett Birkhoff and John Von Neumann. 1936. The logic of quantum mechanics.
Springer, 181–191.
Annals of mathematics (1936), 823–843.
[9] Hesham H Alsaadi, Monther Aldwairi, and Eva-Marie Muller-Stuler. 2019. An-
[38] Barry W. Boehm. 1976. Software Engineering. IEEE transactions on computers
alyzing D-Wave Quantum Macro Assembler Security. In 16th International
25, 12 (1976), 1226–1240.
Conference on Information Technology-New Generations (ITNG 2019). Springer,
[39] Barry W Boehm. 1988. A spiral model of software development and enhance-
125–132.
ment. Computer 21, 5 (1988), 61–72.
[10] Thorsten Altenkirch and Jonathan Grattage. 2005. A functional quantum pro-
[40] Grady Booch, James Rumbaugh, and Ivar Jacobson. 1999. The Unified Modeling
gramming language. In 20th Annual IEEE Symposium on Logic in Computer
Language User Guide. addison-wesley.
Science (LICS’05). IEEE, 249–258.
[41] Pierre Bourque, Richard E Fairley, et al. 2014. Guide to the software engineering
[11] Thorsten Altenkirch and Jonathan Grattage. 2005. QML: Quantum data and
body of knowledge (SWEBOK (R)): Version 3.0. IEEE Computer Society Press.
control. Submitted for publication, Febuary (2005).
[42] JH Bradley. 1985. The Science and Art of Debugging. COMPUTERWORLD. 19,
[12] Deepak Alur, John Crupi, and Dan Malks. 2003. Core J2EE patterns: best practices
33 (1985), 35–38.
and design strategies. Prentice Hall Professional.
[43] Olivier Brunet and Philippe Jorrand. 2004. Dynamic quantum logic for quantum
[13] Stephen J Andriole and Peter A Freeman. 1993. Software systems engineering:
programs. International Journal of Quantum Information 2, 01 (2004), 45–54.
The case for a new discipline. Software Engineering Journal 8, 3 (1993), 165–179.
[44] Frank Buschmann, Kelvin Henney, and Douglas Schimdt. 2007. Pattern-Oriented
[14] Krzysztof R Apt and Ernst-Rüdiger Olderog. 2019. Fifty years of HoareâĂŹs
Software Architecture: On Patterns And Pattern Language, Volume 5. Vol. 5. John
logic. Formal Aspects of Computing 31, 6 (2019), 751–807.
wiley & sons.
[15] Keijiro Araki, Zengo Furukawa, and Jingde Cheng. 1991. A general framework
[45] Carmelo R. Cartiere. 2013. Quantum Software Engineering: Bringing the Classical
for debugging. IEEE software 8, 3 (1991), 14–20.
Software Engineering into the Quantum Domain. Master’s thesis. Department of
[16] Zahra Ashktorab, Justin D Weisz, and Maryam Ashoori. 2019. Thinking Too
Computer Science, University of Oxford.
Classically: Research Topics in Human-Quantum Computer Interaction. In
[46] Carmelo R. Cartiere. 2016. Quantum Software Engineering: Introducing Formal
Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems.
Methods into Quantum Computing.
1–12.
[47] Rohit Chadha, Paulo Mateus, and Amílcar Sernadas. 2006. Reasoning about
[17] Harrison Ball, Michael J Biercuk, Andre Carvalho, Rajib Chakravorty, Jiayin
imperative quantum programs. Electronic Notes in Theoretical Computer Science
Chen, Leonardo A de Castro, Steven Gore, David Hover, Michael Hush, Per J
158 (2006), 19–39.
Liebermann, et al. 2020. Software tools for quantum control: Improving quantum
[48] Arnab Chakraborty. 2011. QuECT: a new quantum programming paradigm.
computer performance through noise and error suppression. arXiv preprint
arXiv preprint arXiv:1104.0497 (2011).
arXiv:2001.04060 (2020).
[49] Peter Pin-Shan Chen. 1976. The entity-relationship modelâĂŤtoward a unified
[18] Alexandru Baltag and Sonja Smets. 2006. LQP: the dynamic logic of quantum
view of data. ACM transactions on database systems (TODS) 1, 1 (1976), 9–36.
information. Mathematical structures in computer science 16, 3 (2006), 491–525.

26
[50] Harold Chestnut. 1967. Systems Engineering Methods. (1967). of a quantum technology industry. In 2016 18th International Conference on
[51] Elliot J. Chikofsky and James H Cross. 1990. Reverse engineering and design Transparent Optical Networks (ICTON). IEEE, 1–4.
recovery: A taxonomy. IEEE software 7, 1 (1990), 13–17. [81] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. 2014. A quantum approxi-
[52] Andrew M Childs, Dmitri Maslov, Yunseong Nam, Neil J Ross, and Yuan Su. mate optimization algorithm. arXiv preprint arXiv:1411.4028 (2014).
2018. Toward the first quantum simulation with quantum speedup. Proceedings [82] Samuel S Feitosa, Juliana K Vizzotto, Eduardo K Piveta, and Andre R Du Bois.
of the National Academy of Sciences 115, 38 (2018), 9456–9461. 2016. FJQuantum–A Quantum Object Oriented Language. Electronic Notes in
[53] Kenta Cho. 2016. Semantics for a quantum programming language by operator Theoretical Computer Science 324 (2016), 67–77.
algebras. New Generation Computing 34, 1-2 (2016), 25–68. [83] Yuan Feng, Runyao Duan, Zhengfeng Ji, and Mingsheng Ying. 2005. Semantics
[54] Frederic T Chong, Diana Franklin, and Margaret Martonosi. 2017. Programming of a purely quantum programming language. arXiv preprint cs/0507043 (2005).
languages and compiler design for realistic quantum hardware. Nature 549, [84] Yuan Feng, Runyao Duan, Zhengfeng Ji, and Mingsheng Ying. 2007. Proof rules
7671 (2017), 180–187. for the correctness of quantum programs. Theoretical Computer Science 386, 1-2
[55] Koen Claessen and John Hughes. 2011. QuickCheck: a lightweight tool for (2007), 151–166.
random testing of Haskell programs. ACM SIGPLAN NOTICES 46, 4 (2011), [85] Richard P Feynman. 1982. Simulating physics with computers. Int. J. Theor.
53–64. Phys 21, 6/7 (1982).
[56] Pierre Clairambault, Marc De Visme, and Glynn Winskel. 2019. Game semantics [86] Mark Fingerhuth, Tomáš Babej, and Peter Wittek. 2018. Open source software
for quantum programming. Proceedings of the ACM on Programming Languages in quantum computing. arXiv preprint arXiv:1812.09167 (2018).
3, POPL (2019), 1–29. [87] George Fink and Matt Bishop. 1997. Property-based testing: a new approach to
[57] John Clark and Susan Stepney. 2002. Quantum Software Engineering. In Work- testing for assurance. ACM SIGSOFT Software Engineering Notes 22, 4 (1997),
shop on Grand Challenges for Computing Research. http://www.ukcrc.org.uk/ 74–80.
press/news/call/a5.cfm. [88] Anthony Finkelsteiin and Jeff Kramer. 2000. Software engineering: a roadmap.
[58] Lori A Clarke and David S Rosenblum. 2006. A historical perspective on runtime In Proceedings of the Conference on the Future of Software Engineering. 3–22.
assertion checking in software development. ACM SIGSOFT Software Engineering [89] Aleta Berk Finnila, MA Gomez, C Sebenik, Catherine Stenson, and Jimmie D
Notes 31, 3 (2006), 25–37. Doll. 1994. Quantum annealing: a new method for minimizing multidimensional
[59] Paul C Clements. 1996. A survey of architecture description languages. In functions. Chemical physics letters 219, 5-6 (1994), 343–348.
Proceedings of the 8th international workshop on software specification and design. [90] RW FLOYD. 1967. Assigning meanings to program. In Proc. Symposia in Applied
IEEE, 16–25. Mathematics, 1967, Vol. 19. 19–32.
[60] IEEE Computer Society. Software Engineering Technical Committee. 1990. IEEE [91] Robert W Floyd. 1993. Assigning meanings to programs. In Program Verification.
standard glossary of software engineering terminology. Institute of Electrical Springer, 65–81.
and Electronics Engineers. [92] Harry D Foster, Adam C Krolnik, and David J Lacey. 2006. Assertion-Based
[61] Regetti Computing. 2017. Forest SDK. Accessed on: April, 2020 (2017). http: Design. Springer Science & Business Media.
//docs.rigetti.com/en/stable/ [93] Martin Fowler. 2002. Patterns of enterprise application architecture. Addison-
[62] Wikipedia Contributors. 2017. Block sphere - Wikipedia. The Free Encyclopedia Wesley Longman Publishing Co., Inc.
[Accessed on April 26, 2020] (2017). https://en.wikipedia.org/wiki/Bloch_sphere [94] William B Frakes and Kyo Kang. 2005. Software reuse research: Status and
[63] Stephen A Cook and David G Mitchell. 1997. Finding hard instances of the future. IEEE transactions on Software Engineering 31, 7 (2005), 529–536.
satisfiability problem: A survey. Satisfiability Problem: Theory and Applications [95] Buschmann Frank, Meunier Regine, Rohnert Hans, Sommerlad Peter, and Stal
35 (1997), 1–17. Michael. 1996. Pattern-oriented software architecture: a system of patterns.
[64] Don Coppersmith. 2002. An approximate Fourier transform useful in quantum Wiley, ISBN 0 471, 95889 (1996), 7.
factoring. arXiv preprint quant-ph/0201067 (2002). [96] Alfonso Fuggetta. 2000. Software process: a roadmap. In Proceedings of the
[65] Rick David Craig and Stefan P Jaskiel. 2002. Systematic software testing. Artech Conference on the Future of Software Engineering. 25–34.
house. [97] Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. 1995. Design
[66] Andrew W Cross, Lev S Bishop, John A Smolin, and Jay M Gambetta. 2017. Patterns Elements of reusable object-oriented sofware. Addison Wesley.
Open quantum assembly language. arXiv preprint arXiv:1707.03429 (2017). [98] Sunita Garhwal, Maryam Ghorani, and Amir Ahmad. 2019. Quantum Pro-
[67] Andrew W Cross, Graeme Smith, and John A Smolin. 2015. Quantum learning gramming Language: A Systematic Review of Research Topic and Top Cited
robust against noise. Physical Review A 92, 1 (2015), 012327. Languages. Archives of Computational Methods in Engineering (2019), 1–22.
[68] Ole-Johan Dahl, Edsger Wybe Dijkstra, and Charles Antony Richard Hoare. [99] David Garlan, Robert Monroe, and David Wile. 1997. Acme: An Architecture
1972. Structured programming. Academic Press Ltd. Description Interchange Language. Proceedings of CASCON’97 (1997).
[69] Serge Demeyer, Stéphane Ducasse, and Oscar Nierstrasz. 2002. Object-oriented [100] Simon Gay. 2005. Bibliography on quantum programming languages. Bulletin
reengineering patterns. Elsevier. of the EATCS 6 (2005). http://www.dcs.gla.ac.uk/~simon/quantum/qplbibD.html
[70] David Deutsch. 1985. Quantum theory, the Church–Turing principle and the [101] Simon Gay and Ian Mackie. 2010. Semantic Techniques in Quantum Computation.
universal quantum computer. Proceedings of the Royal Society of London. A. Cambridge University Press.
Mathematical and Physical Sciences 400, 1818 (1985), 97–117. [102] Simon J Gay. 2006. Quantum programming languages: Survey and bibliography.
[71] David Deutsch and Richard Jozsa. 1992. Rapid solution of problems by quantum Mathematical Structures in Computer Science 16, 4 (2006), 581–600.
computation. Proceedings of the Royal Society of London. Series A: Mathematical [103] Simon J Gay and Rajagopal Nagarajan. 2004. Communicating quantum pro-
and Physical Sciences 439, 1907 (1992), 553–558. cesses. Proceedings of the 2nd International Workshop on Quantum Programming
[72] Coq Development Team. 2019. The Coq proof assistant reference manual, Languages (2004), 91–107.
version 8.11. https:// coq.inria.fr/ distrib/ current/ refman/ (2019). [104] Simon J Gay and Rajagopal Nagarajan. 2005. Communicating quantum processes.
[73] Ellie D’hondt and Prakash Panangaden. 2006. Quantum weakest preconditions. In Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of
Mathematical Structures in Computer Science 16, 3 (2006), 429–451. programming languages. 145–157.
[74] Paul Adrien Maurice Dirac. 1981. The principles of quantum mechanics. Num- [105] Carlo Ghezzi, Mehdi Jazayeri, and Dino Mandrioli. 2002. Fundamentals of
ber 27. Oxford university press. Software Engineering. (2002).
[75] Merlin Dorfman and Richard H. Thayer (eds.). 1997. Software Engineering. IEEE [106] Craig Gidney. 2017. Visualizing 2-Qubit Entanglement. [Accessed on: April 26,
Computer (1997). 2020] (2017). https://algassert.com/post/1716
[76] Vedran Dunjko, Jacob M Taylor, and Hans J Briegel. 2016. Quantum-enhanced [107] Jean-Yves Girard. 2004. Between logic and quantic: a tract. Linear logic in
machine learning. Physical review letters 117, 13 (2016), 130501. computer science 316 (2004), 346–381.
[77] Saikat Dutta, Owolabi Legunsen, Zixin Huang, and Sasa Misailovic. 2018. Testing [108] James Glanz. 1995. A quantum leap for computers? Science 269, 5220 (1995),
probabilistic programming systems. In Proceedings of the 2018 26th ACM Joint 28–30.
Meeting on European Software Engineering Conference and Symposium on the [109] Hassan Gomaa. 2011. Software modeling and design: UML, use cases, patterns,
Foundations of Software Engineering. 574–586. and software architectures. Cambridge University Press.
[78] Saikat Dutta, Wenxian Zhang, Zixin Huang, and Sasa Misailovic. 2019. Storm: [110] Daniel Gottesman. 2010. An introduction to quantum error correction and
program reduction for testing and debugging probabilistic programming sys- fault-tolerant quantum computation. In Quantum information science and its
tems. In Proceedings of the 2019 27th ACM Joint Meeting on European Software contributions to mathematics, Proceedings of Symposia in Applied Mathematics,
Engineering Conference and Symposium on the Foundations of Software Engineer- Vol. 68. 13–58.
ing. 729–739. [111] Daniel Gottesman and Isaac L Chuang. 1999. Demonstrating the viability of
[79] Albert Einstein, Boris Podolsky, and Nathan Rosen. 1935. Can quantum- universal quantum computation using teleportation and single-qubit operations.
mechanical description of physical reality be considered complete? Physical Nature 402, 6760 (1999), 390–393.
review 47, 10 (1935), 777. [112] Daniel Gottesman and Isaac L Chuang. 1999. Quantum teleportation is a uni-
[80] Mark J Everitt, Michael J de C Henshaw, and Vincent M Dwyer. 2016. Quantum versal computational primitive. arXiv preprint quant-ph/9908010 (1999).
Systems Engineering: A structured approach to accelerating the development
27
[113] Jonathan Grattage. 2006. QML: A functional quantum programming language. [142] Tadashi Kadowaki and Hidetoshi Nishimori. 1998. Quantum annealing in the
Ph.D. Dissertation. The University of Nottingham. transverse Ising model. Physical Review E 58, 5 (1998), 5355.
[114] Alexander S Green, Peter LeFanu Lumsdaine, Neil J Ross, Peter Selinger, and [143] Yoshihiko Kakutani. 2009. A logic for formal verification of quantum programs.
Benoît Valiron. 2013. An introduction to quantum programming in quipper. In In Annual Asian Computing Science Conference. Springer, 79–93.
International Conference on Reversible Computation. Springer, 110–124. [144] Peter J Karalekas, Nikolas A Tezak, Eric C Peterson, Colm A Ryan, Marcus P da
[115] Alexander S Green, Peter LeFanu Lumsdaine, Neil J Ross, Peter Selinger, and Silva, and Robert S Smith. 2020. A quantum-classical cloud platform optimized
Benoît Valiron. 2013. Quipper: a scalable quantum programming language. In for variational hybrid algorithms. arXiv preprint arXiv:2001.04449 (2020).
Proceedings of the 34th ACM SIGPLAN conference on Programming language [145] N Khammassi, I Ashraf, X Fu, CG Almudever, and K Bertels. 2017. QX: a
design and implementation. 333–342. high-performance quantum computer simulation platform. In Proceedings of the
[116] Harper R Grimsley, Sophia E Economou, Edwin Barnes, and Nicholas J Mayhall. Conference on Design, Automation & Test in Europe. 464–469.
2019. An adaptive variational algorithm for exact molecular simulations on a [146] Nader Khammassi, Gian G Guerreschi, Imran Ashraf, Justin W Hogaboam,
quantum computer. Nature communications 10, 1 (2019), 1–9. Carmen G Almudever, and Koen Bertels. 2018. cqasm v1. 0: Towards a common
[117] David Gross, Yi-Kai Liu, Steven T Flammia, Stephen Becker, and Jens Eisert. quantum assembly language. arXiv preprint arXiv:1805.09607 (2018).
2010. Quantum state tomography via compressed sensing. Physical review [147] Nathan Killoran, Josh Izaac, Nicolás Quesada, Ville Bergholm, Matthew Amy,
letters 105, 15 (2010), 150401. and Christian Weedbrook. 2018. Strawberry Fields: A Software Platform for
[118] Lov K Grover. 1996. A fast quantum mechanical algorithm for database search. In Photonic Quantum Computing. arXiv preprint arXiv:1804.03159 (2018).
Proceedings of the twenty-eighth annual ACM symposium on Theory of computing. [148] Nathan Killoran, Josh Izaac, Nicolás Quesada, Ville Bergholm, Matthew Amy,
212–219. and Christian Weedbrook. 2019. Strawberry fields: A software platform for
[119] Penny Grubb and Armstrong A Takang. 2003. Software maintenance: concepts photonic quantum computing. Quantum 3 (2019), 129.
and practice. World Scientific. [149] Alexei Yu Kitaev, Alexander Shen, Mikhail N Vyalyi, and Mikhail N Vyalyi. 2002.
[120] Jozef Gruska. 1999. Quantum computing. Vol. 2005. McGraw-Hill. Classical and quantum computation. Number 47. American Mathematical Soc.
[121] Gian Giacomo Guerreschi and Mikhail Smelyanskiy. 2017. Practical optimization [150] Andreas Klappenecker and Martin Rötteler. 2003. Quantum software reusability.
for hybrid quantum-classical algorithms. arXiv preprint arXiv:1701.01450 (2017). International Journal of Foundations of Computer Science 14, 05 (2003), 777–796.
[122] Thomas Häner, Damian S Steiger, Mikhail Smelyanskiy, and Matthias Troyer. [151] Claire Knight and Malcolm Munro. 1999. Comprehension with [in] virtual
2016. High performance emulation of quantum circuits. In SC’16: Proceedings environment visualisations. In Proceedings Seventh International Workshop on
of the International Conference for High Performance Computing, Networking, Program Comprehension. IEEE, 4–11.
Storage and Analysis. IEEE, 866–874. [152] Emmanuel Knill. 1996. Conventions for quantum pseudocode. Technical Report.
[123] Ichiro Hasuo and Naohiko Hoshino. 2017. Semantics of higher-order quantum Los Alamos National Lab., NM (United States).
computation via geometry of interaction. Annals of Pure and Applied Logic 168, [153] Emanuel Knill, Raymond Laflamme, and Wojciech H Zurek. 1998. Resilient
2 (2017), 404–469. quantum computation: error models and thresholds. Proceedings of the Royal
[124] George T Heineman and William T Councill. 2001. Component-based software Society of London. Series A: Mathematical, Physical and Engineering Sciences 454,
engineering. addison-westley (2001). 1969 (1998), 365–384.
[125] Kesha Hietala. 2016. Quantum Programming Languages. (2016). [154] EH Knill and MA Nielsen. 2000. Encyclopedia of Mathematics, Supplement III,
[126] Kesha Hietala, Robert Rand, and Michael Hicks. 2020. Tracking errors through chapter Theory of quantum computation. (2000).
types in quantum programs. In The First International Workshop on Programming [155] Andrew Ko and Brad Myers. 2008. Debugging reinvented: Asking and Answer-
Languages for Quantum Computing (PLanQC 2020). ing Why and Why Not Questions about Program Behavior. In 2008 ACM/IEEE
[127] Kesha Hietala, Robert Rand, Shih-Han Hung, Xiaodi Wu, and Michael Hicks. 30th International Conference on Software Engineering. IEEE, 301–310.
2019. Verified Optimization in a Quantum Intermediate Representation. arXiv [156] Wojtek Kozaczynski and Grady Booch. 1998. Component-based software engi-
preprint arXiv:1904.06319 (2019). neering. IEEE software 15, 5 (1998), 34.
[128] Edward Hirsch. 1985. Evolutionary acquisition of command and control systems. [157] Sebastian Krämer, David Plankensteiner, Laurin Ostermann, and Helmut Ritsch.
Program Manager (1985), 18–22. 2018. QuantumOptics. jl: A Julia framework for simulating open quantum
[129] Charles Antony Richard Hoare. 1969. An axiomatic basis for computer pro- systems. Computer Physics Communications 227 (2018), 109–116.
gramming. Commun. ACM 12, 10 (1969), 576–580. [158] Charles W Krueger. 1992. Software reuse. Comput. Surveys 24, 2 (1992), 131–183.
[130] T. Hoare and R. Milner (eds.). 2004. Grand Challenges in Computing Research. [159] Tom Krüger and Wolfgang Mauerer. 2020. Quantum Annealing-Based Software
organised by BCS, CPHC, EPSRC, IEE, etc. (2004). http://www.ukcrc.org.uk/press/ Components: An Experimental Case Study with SAT Solving. In International
news/report/gcresearch.cfm?type=pdf. Workshop on the Quantum Software Engineering & Programming.
[131] Shahin Honarvar, Mohammadreza Mousavi, and Rajagopal Nagarajan. 2020. [160] Marie Lalire and Philippe Jorrand. 2004. A process algebraic approach to concur-
Property-based testing of quantum programs in Q#. In First International Work- rent and distributed quantum computation: operational semantics. Proceedings
shop on Quantum Software Engineering (Q-SE 2020). of the 2nd International Workshop on Quantum Programming Languages (2004),
[132] Yipeng Huang and Margaret Martonosi. 2018. QDB: From quantum algorithms 109–126.
towards correct quantum programs. arXiv preprint arXiv:1811.05447 (2018). [161] Benjamin P Lanyon, James D Whitfield, Geoff G Gillett, Michael E Goggin,
[133] Yipeng Huang and Margaret Martonosi. 2019. Statistical assertions for validating Marcelo P Almeida, Ivan Kassal, Jacob D Biamonte, Masoud Mohseni, Ben J
patterns and finding bugs in quantum programs. In Proceedings of the 46th Powell, Marco Barbieri, et al. 2010. Towards quantum chemistry on a quantum
International Symposium on Computer Architecture. 541–553. computer. Nature chemistry 2, 2 (2010), 106–111.
[134] D-Wave Systems Inc. 2017. The D-Wave 2X quantum computer. Ac- [162] Andrei Lapets, Marcus P da Silva, Mike Thome, Aaron Adler, Jacob Beal, and
cessed on: May 11, 2020 (2017). https://www.dwavesys.com/blog/2015/08/ Martin Rötteler. 2013. QuaFL: a typed DSL for quantum programming. In
announcing-d-wave-2x-quantum-computer Proceedings of the 1st annual workshop on Functional programming concepts in
[135] Ivar Jacobson, Grady Booch, and James Rumbaugh. 1999. The unified software domain-specific languages. 19–26.
development process. Addison-wesley Reading. [163] Ryan LaRose. 2019. Overview and comparison of gate level quantum software
[136] Sakshi Jain, Sreraman Muralidharan, and Prasanta K Panigrahi. 2009. Secure platforms. Quantum 3 (2019), 130.
quantum conversation through non-destructive discrimination of highly entan- [164] Beatrice Lazzerini and Lanfranco Lopriore. 1992. Program Debugging Environ-
gled multipartite states. EPL (Europhysics Letters) 87, 6 (2009), 60008. ments, Design and Utilization. Ellis Horwood/Simon & Schuster.
[137] Ali JavadiAbhari, Shruti Patil, Daniel Kudrow, Jeff Heckey, Alexey Lvov, Fred- [165] Raimondas Lencevicius. 2000. Advanced debugging methods. Vol. 568. Springer
eric T Chong, and Margaret Martonosi. 2014. ScaffCC: a framework for compi- Science & Business Media.
lation and analysis of quantum computing programs. In Proceedings of the 11th [166] Frank Leymann. 2019. Towards a Pattern Language for Quantum Algorithms.
ACM Conference on Computing Frontiers. 1–10. In International Workshop on Quantum Technology and Optimization Problems.
[138] Ali JavadiAbhari, Shruti Patil, Daniel Kudrow, Jeff Heckey, Alexey Lvov, Fred- Springer, 218–230.
eric T Chong, and Margaret Martonosi. 2015. ScaffCC: Scalable compilation [167] Frank Leymann, Johanna Barzen, Michael Falkenthal, Daniel Vietz, Benjamin
and analysis of quantum programs. Parallel Comput. 45 (2015), 2–17. Weder, and Karoline Wild. 2020. Quantum in the Cloud: Application Potentials
[139] Xian-Min Jin, Ji-Gang Ren, Bin Yang, Zhen-Huan Yi, Fei Zhou, Xiao-Fan Xu, and Research Opportunities. arXiv preprint arXiv:2003.06256 (2020).
Shao-Kai Wang, Dong Yang, Yuan-Feng Hu, Shuo Jiang, et al. 2010. Experimental [168] Gushu Li, Li Zhou, Nengkun Yu, Yufei Ding, Mingsheng Ying, and Yuan Xie.
free-space quantum teleportation. Nature photonics 4, 6 (2010), 376–381. 2019. Poq: Projection-based Runtime Assertions for Debugging on a Quantum
[140] Philippe Jorrand. 2007. A Programmer’s Survey of the Quantum Computing Computer. arXiv preprint arXiv:1911.12855 (2019).
Paradigm. 34, 1-2 (2007). [169] Yangjia Li and Mingsheng Ying. 2014. Debugging quantum processes using
[141] Philippe Jorrand and Marie Lalire. 2004. From quantum physics to program- monitoring measurements. Physical Review A 89, 4 (2014), 042338.
ming languages: a process algebraic approach. In International Workshop on [170] Bennett P Lientz and E Burton Swanson. 1980. Software maintenance manage-
Unconventional Programming Paradigms. Springer, 1–16. ment. Addison-Wesley Longman Publishing Co., Inc.

28
[171] Richard J Lipton and Kenneth W Regan. 2014. Quantum algorithms via linear [203] Flemming Nielson, Hanne R Nielson, and Chris Hankin. 2015. Principles of
algebra: a primer. MIT Press. program analysis. Springer.
[172] Ji Liu, Gregory T Byrd, and Huiyang Zhou. 2020. Quantum circuits for dynamic [204] Jonathan Olson, Yudong Cao, Jonathan Romero, Peter Johnson, Pierre-Luc
runtime assertions in quantum computation. In Proceedings of the Twenty-Fifth Dallaire-Demers, Nicolas Sawaya, Prineha Narang, Ian Kivlichan, Michael
International Conference on Architectural Support for Programming Languages Wasielewski, and Alán Aspuru-Guzik. 2017. Quantum information and compu-
and Operating Systems. 1017–1030. tation for chemistry. arXiv preprint arXiv:1706.05413 (2017).
[173] Junyi Liu, Bohua Zhan, Shuling Wang, Shenggang Ying, Tao Liu, Yangjia Li, [205] Peter JJ O’Malley, Ryan Babbush, Ian D Kivlichan, Jonathan Romero, Jarrod R
Mingsheng Ying, and Naijun Zhan. 2019. Formal verification of quantum McClean, Rami Barends, Julian Kelly, Pedram Roushan, Andrew Tranter, Nan
algorithms using quantum Hoare logic. In International conference on computer Ding, et al. 2016. Scalable quantum simulation of molecular energies. Physical
aided verification. Springer, 187–207. Review X 6, 3 (2016), 031007.
[174] Shusen Liu, Xin Wang, Li Zhou, Ji Guan, Yinan Li, Yang He, Runyao Duan, [206] Bernhard Ömer. 1998. A procedural formalism for quantum computing. Master’s
and Mingsheng Ying. 2018. Q |S I ⟩ : A Quantum Programming Environment. In thesis. Department of Theoretical Physics, Technical University of Vienna.
Symposium on Real-Time and Hybrid Systems. Springer, 133–164. [207] Bernhard Ömer. 2000. Quantum programming in QCL. Master’s thesis. Institute
[175] Xiao Liu and John Kubiatowicz. 2013. Chisel-Q: Designing quantum circuits of Information Systems, Technical University of Vienna.
with a scala embedded language. In 2013 IEEE 31st International Conference on [208] Bernhard Ömer. 2003. Structured quantum programming. Ph.D. Dissertation.
Computer Design (ICCD). IEEE, 427–434. Institute for Theoretical Physics, Technical University of Vienna.
[176] David C. Luckham, John J. Kenney, Larry M. Augustin, James Vera, Doug Bryan, [209] Bernhard Ömer. 2005. Classical concepts in quantum programming. Interna-
and Walter Mann. 1995. Specification and analysis of system architecture using tional Journal of Theoretical Physics 44, 7 (2005), 943–955.
Rapide. IEEE Transactions on Software Engineering 21, 4 (1995), 336–354. [210] Luis Ortiz-Gutiérrez, Bruna Gabrielly, Luis F Muñoz, Kainã T Pereira, Jefferson G
[177] Jeff Magee and Jeff Kramer. 1996. Dynamic structure in software architectures. Filgueiras, and Alessandro S Villar. 2017. Continuous variables quantum compu-
ACM SIGSOFT Software Engineering Notes 21, 6 (1996), 3–14. tation over the vibrational modes of a single trapped ion. Optics Communications
[178] Margaret Martonosi and Martin Roetteler. 2019. Next Steps in Quantum Com- 397 (2017), 166–174.
puting: Computer Science’s Role. arXiv preprint arXiv:1903.10541 (2019). [211] Michele Pagani, Peter Selinger, and Benoît Valiron. 2014. Applying quantitative
[179] Shaw Mary and Garlan David. 1996. Software architecture: perspectives on an semantics to higher-order quantum computing. In Proceedings of the 41st ACM
emerging discipline. Prentice-Hall (1996). SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 647–658.
[180] Wolfgang Mauerer. 2005. Semantics and simulation of communication in quan- [212] Scott Pakin. 2016. A quantum macro assembler. In 2016 IEEE High Performance
tum programming. arXiv preprint quant-ph/0511145 (2005). Extreme Computing Conference (HPEC). IEEE, 1–8.
[181] Philip Maymin. 1996. Extending the lambda calculus to express randomized [213] Luca Paolini, Mauro Piccolo, and Margherita Zorzi. 2019. QPCF: Higher-Order
and quantumized algorithms. arXiv preprint quant-ph/9612052 (1996). Languages and Quantum Circuits. Journal of Automated Reasoning 63, 4 (2019),
[182] Sam McArdle, Suguru Endo, Alan Aspuru-Guzik, Simon Benjamin, and Xiao 941–966.
Yuan. 2018. Quantum computational chemistry. arXiv preprint arXiv:1808.10402 [214] Luca Paolini, Luca Roversi, and Margherita Zorzi. 2019. Quantum programming
(2018). made easy. In 2018 Joint International Workshop on Linearity and Trends in Linear
[183] Hefedh Mili, Ali Mili, Sherif Yacoub, and Edward Addy. 2001. Reuse-based Logic and Applications, Linearity-TLLA 2018, Vol. 292. 133–147.
software engineering: techniques, organization, and controls. Wiley-Interscience. [215] Luca Paolini and Margherita Zorzi. 2017. qPCF: A Language for Quantum
[184] Andriy Miranskyy and Lei Zhang. 2019. On testing quantum programs. In 2019 Circuit Computations. In International Conference on Theory and Applications of
IEEE/ACM 41st International Conference on Software Engineering: New Ideas and Models of Computation. Springer, 455–469.
Emerging Results (ICSE-NIER). IEEE, 57–60. [216] Microsoft Patterns. 2009. Microsoft application architecture guide. Microsoft
[185] Andriy Miranskyy, Lei Zhang, and Javad Doliskani. 2020. Is Your Quantum Press.
Program Bug-Free? arXiv preprint arXiv:2001.10870 (2020). [217] Jennifer Paykin, Robert Rand, and Steve Zdancewic. 2017. QWIRE: a core
[186] Jaroslaw Miszczak. 2011. Models of quantum computation and quantum pro- language for quantum circuits. ACM SIGPLAN Notices 52, 1 (2017), 846–858.
gramming languages. Bulletin of the Polish Academy of Sciences: Technical [218] Ricardo Pérez-Castillo. 2020. Reengineering of Information Systems toward
Sciences 59, 3 (2011), 305–324. Classical-Quantum Systems. In International Workshop on the Quantum Software
[187] Jarosław Adam Miszczak. 2012. High-level structures for quantum computing. Engineering & Programming.
Vol. 4. Morgan & Claypool Publishers. 1–129 pages. [219] Ricardo Pérez-Castillo, Ignacio Garcia-Rodriguez De Guzman, and Mario Piattini.
[188] Hynek MlnařÍk. 2006. Introduction to LanQ–an Imperative Quantum Program- 2011. Knowledge Discovery Metamodel-ISO/IEC 19506: A standard to modernize
ming Language. (2006). legacy systems. Computer Standards & Interfaces 33, 6 (2011), 519–532.
[189] Hynek MlnařÍk. 2007. Operational semantics and type soundness of quantum [220] Carlos A. Pérez-Delgado and Hector G. Perez-Gonzalez. 2020. Towards a Quan-
programming language LanQ. arXiv preprint arXiv:0708.0890 (2007). tum Software Modeling Language. In First International Workshop on Quantum
[190] Hynek MlnařÍk. 2008. Semantics of quantum programming language LanQ. Software Engineering (Q-SE 2020).
International Journal of Quantum Information 6, supp01 (2008), 733–738. [221] Marek Perkowski, Martin Lukac, Pawel Kerntopf, Mikhail Pivtoraiko, Michele
[191] Hynek Mlnarık. September, 2007. Quantum programming language LanQ. Ph.D. Folgheraiter, Yong Woo Choi, Jung-wook Kim, Dongsoo Lee, Woong Hwangbo,
Dissertation. Masaryk University, Faculty of Informatics. and Hyungock Kim. 2003. A hierarchical approach to computer-aided design
[192] Ashley Montanaro. 2016. Quantum algorithms: an overview. npj Quantum of quantum circuits. In 6th International Symposium on Representations and
Information 2, 1 (2016), 1–8. Methodology of Future Computing Technologies. 201–209.
[193] Michele Mosca. 2008. Quantum algorithms. arXiv preprint arXiv:0808.0369 [222] Dewayne E Perry and Alexander L Wolf. 1992. Foundations for the study of
(2008). software architecture. ACM SIGSOFT Software engineering notes 17, 4 (1992),
[194] Michele Mosca. 2018. Cybersecurity in an era with quantum computers: will 40–52.
we be ready? IEEE Security & Privacy 16, 5 (2018), 38–41. [223] Mario Piattini, Guido Peterssen, Ricardo Pérez-Castillo, Jose Luis Hevia,
[195] Michele Mosca, Martin Roetteler, and Peter Selinger. 2019. Quantum Program- Manuel A. Serrano, Guillermo Hernández, Ignacio García Rodríguez de Guzmán,
ming Languages (Dagstuhl Seminar 18381). Schloss Dagstuhl-Leibniz-Zentrum Claudio Andrés Paradela, Macario Polo, Ezequiel Murina, Luis Jiménez, Juan Car-
fuer Informatik. los Marqueño, Ramsés Gallego, Jordi Tura, Frank Phillipson, Juan M. Murillo,
[196] Glenford J Myers. 1979. The art of software testing. John Wiley & Sons. Alfonso Niño, and Moisés Rodríguez. 2020. The Talavera Manifesto for Quan-
[197] Glenford J Myers, Corey Sandler, and Tom Badgett. 2011. The art of software tum Software Engineering and Programming. In Short Papers Proceedings of
testing. John Wiley & Sons. the 1st International Workshop on the QuANtum SoftWare Engineering & pRo-
[198] Mikio Nakahara and Tetsuo Ohmi. 2008. Quantum computing: from linear algebra gramming, Talavera de la Reina, Spain, February 11-12, 2020 (CEUR Work-
to physical realizations. CRC press. shop Proceedings), Mario Piattini, Guido Peterssen, Ricardo Pérez-Castillo,
[199] Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal. 2008. Hoare type Jose Luis Hevia, and Manuel A. Serrano (Eds.), Vol. 2561. CEUR-WS.org, 1–
theory, polymorphism and separation. Journal of Functional Programming 18, 5. http://ceur-ws.org/Vol-2561/paper0.pdf
5-6 (2008), 865–911. [224] John Preskill. 1999. Plug-in quantum software. Nature 402, 6760 (1999), 357–358.
[200] Engineering National Academies of Sciences, Medicine, et al. 2019. Quantum [225] John Preskill. 2018. Lecture notes for physics 229: Quantum information and
computing: progress and prospects. National Academies Press. computation. California Institute of Technology 16 (2018). Availablefromhttp:
[201] Peter Naur and Brian Randell. 1969. Software Engineering: Report of a confer- //www.theory.caltech.edu/people/preskill/ph229/#lecture
ence sponsored by the NATO Science Committee, Garmisch, Germany, 7th-11th [226] Roger S Pressman. 2010. Software engineering: A Practitioner’s approach.
October 1968. (1969). McGraw-Hill.
[202] Michael A Nielsen and Isaac Chuang. 2002. Quantum computation and quantum [227] Matt Purkeypile. 2009. Cove: A practical quantum computer programming frame-
information. (2002). work. Ph.D. Dissertation. Colorado Technical University. https://arxiv.org/abs/
0911.2423

29
[228] Robert Rand. 2018. Formally verified quantum programming. Ph.D. Dissertation. [259] Robert S Smith, Michael J Curtis, and William J Zeng. 2016. A practical quantum
University of Pennsylvania. instruction set architecture. arXiv preprint arXiv:1608.03355 (2016).
[229] Robert Rand, Kesha Hietala, and Michael Hicks. 2019. Formal Verification vs. [260] Balwinder Sodhi. 2018. Quality Attributes on Quantum Computing Platforms.
Quantum Uncertainty. In 3rd Summit on Advances in Programming Languages arXiv preprint arXiv:1803.07407 (2018).
(SNAPL 2019). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik. [261] Donald A Sofge. 2008. A survey of quantum programming languages: History,
[230] Patrick Rebentrost, Masoud Mohseni, and Seth Lloyd. 2014. Quantum support methods, and tools. In Second International Conference on Quantum, Nano and
vector machine for big data classification. Physical review letters 113, 13 (2014), Micro Technologies (ICQNM 2008). IEEE, 66–71.
130503. [262] Ian Sommerville. 2011. Software engineering 9th Edition. ISBN-10 137035152
[231] Markus Reiher, Nathan Wiebe, Krysta M Svore, Dave Wecker, and Matthias (2011), 18.
Troyer. 2017. Elucidating reaction mechanisms on quantum computers. Pro- [263] Milan Spišiak and Ján Kollár. 2017. Quantum programming: A review. In 2017
ceedings of the National Academy of Sciences 114, 29 (2017), 7555–7560. IEEE 14th International Scientific Conference on Informatics. IEEE, 353–358.
[232] IBM Research. 2017. Qiskit. Accessed on: April, 2020 (2017). https://qiskit.org [264] John Stasko, John Domingue, Marc H Brown, and Blaine Price. 1998. Software
[233] IBM Research. 2020. Entanglion. [Accessed on: April 26, 2020] (2020). https: Visualization: Programming as a Multimedia Experience. (1998).
//entanglion.github.io/ [265] Andrew M Steane. 1996. Error correcting codes in quantum theory. Physical
[234] Francisco Rios and Peter Selinger. 2017. A categorical model for a quantum Review Letters 77, 5 (1996), 793.
circuit description language. In Proceedings 14th International Conference on [266] Damian S Steiger, Thomas Häner, and Matthias Troyer. 2018. ProjectQ: an open
Quantum Physics and Logic (QPL 2017). 164–178. source software framework for quantum computing. Quantum 2 (2018), 49.
[235] J ALLEN Robert. 1997. A formal approach to software architecture. Ph.D. Disser- [267] Susan Stepney, Samuel L Braunstein, John A Clark, Andy Tyrrell, Andrew
tation. School of Computer Science, Carnegie Mellon University. Adamatzky, Robert E Smith, Tom Addis, Colin Johnson, Jonathan Timmis, Peter
[236] Martin Roetteler, Krysta M Svore, Dave Wecker, and Nathan Wiebe. 2017. Design Welch, et al. 2005. Journeys in non-classical computation I: A grand challenge for
automation for quantum architectures. In Design, Automation & Test in Europe computing research. International Journal of Parallel, Emergent and Distributed
Conference & Exhibition (DATE), 2017. IEEE, 1312–1317. Systems 20, 1 (2005), 5–19.
[237] Neil Julien Ross. 2015. Algebraic and Logical Methods in Quantum Computa- [268] Susan Stepney, Samuel L Braunstein, John A Clark, Andy Tyrrell, Andrew
tion. Ph.D. Dissertation. Department of Mathematics and Statistics, Dalhousie Adamatzky, Robert E Smith, Tom Addis, Colin Johnson, Jonathan Timmis, Peter
University, 2015. Available from arXiv:1510.02198. Welch, et al. 2006. Journeys in non-classical computation II: initial journeys
[238] Winston W Royce. August, 1970. Managing the development of large software and way points. The International Journal of Parallel, Emergent and Distributed
systems: concepts and techniques. In Proceedings of the WESCON. Systems 21, 2 (2006), 97–125.
[239] Roland Rüdiger. 2007. Quantum Programming Languages: An Introductory [269] Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christopher Granade,
Overview. Comput. J. 50, 2 (2007), 134–150. Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and Martin
[240] James Rurnbaugh, Ivar Jacobson, and Grady Booch. 1999. The Unified Modeling Roetteler. 2018. Q#: Enabling Scalable Quantum Computing and Development
Language Reference Manual. addison-wesley. with a High-level DSL. In Proceedings of the Real World Domain Specific Lan-
[241] Jeff W Sanders and Paolo Zuliani. 2000. Quantum programming. In International guages Workshop 2018. 1–10.
Conference on Mathematics of Program Construction. Springer, 80–99. [270] Ari Takanen, Jared D Demott, Charles Miller, and Atte Kettunen. 2018. Fuzzing
[242] Erwin Schrödinger. 1935. Discussion of probability relations between separated for software security testing and quality assurance. Artech House.
systems. In Mathematical Proceedings of the Cambridge Philosophical Society, [271] Google AI Quantum team. 2018. Cirq. (2018). https://github.com/quantumlib/
Vol. 31. Cambridge University Press, 555–563. Cirq
[243] Robert C Seacord, Daniel Plakosh, and Grace A Lewis. 2003. Modernizing [272] ProjectQ Team. 2017. ProjectQ. Accessed on: April, 2020 (2017). https://projectq.
legacy systems: software technologies, engineering processes, and business practices. ch/
Addison-Wesley Professional. [273] Q# Team. 2017. Testing and debugging. Accessed on: April, 2020
[244] Peter Selinger. 2004. A brief survey of quantum programming languages. In (2017). https://docs.microsoft.com/en-us/quantum/techniques/
International Symposium on Functional and Logic Programming. Springer, 1–6. testing-and-debugging?view=qsharp-preview%5C&tabs=tabid-vs2019
[245] Peter Selinger. 2004. Towards a quantum programming language. Mathematical [274] Jayne Thompson, Kavan Modi, Vlatko Vedral, and Mile Gu. 2018. Quantum plug
Structures in Computer Science 14, 4 (2004), 527–586. n’play: modular computation in the quantum regime. New Journal of Physics
[246] Peter Selinger. 2004. Towards a semantics for higher-order quantum computa- 20, 1 (2018), 013004.
tion. In Proceedings of the 2nd International Workshop on Quantum Programming [275] Jordi Tura. 2020. Quantum algorithms for near-term devices. In International
Languages, TUCS General Publication No, Vol. 33. 127–143. Workshop on the Quantum Software Engineering & Programming.
[247] Peter Selinger and Benoit Valiron. 2006. A lambda calculus for quantum com- [276] Dominique Unruh. 2006. Quantum programming languages. Informatik-
putation with classical control. Mathematical Structures in Computer Science 16, forschung und entwicklung 21, 1-2 (2006), 55–63.
3 (2006), 527–552. [277] Dominique Unruh. 2019. Quantum relational Hoare logic. Proceedings of the
[248] Kostya Serebryany. 2015. libFuzzer–a library for coverage-guided fuzz testing. ACM on Programming Languages 3, POPL (2019), 1–31.
LLVM project (2015). [278] Macario Polo Usaola. 2020. Quantum Software Testing. In International Workshop
[249] Changpeng Shao, Yang Li, and Hongbo Li. 2019. Quantum algorithm design: on the Quantum Software Engineering & Programming.
Techniques and applications. Journal of Systems Science and Complexity 32, 1 [279] Mark Utting and Bruno Legeard. 2010. Practical model-based testing: a tools
(2019), 375–452. approach. Elsevier.
[250] Ehud Y Shapiro. 1982. Algorithmic program diagnosis. In Proceedings of the [280] Benoît Valiron. 2013. Quantum computation: From a programmer’s perspective.
9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. New Generation Computing 31, 1 (2013), 1–26.
299–308. [281] Benoît Valiron, Neil J Ross, Peter Selinger, D Scott Alexander, and Jonathan M
[251] Ehud Y Shapiro. 1983. Algorithmic Program Debugging. (1983). Smith. 2015. Programming the quantum future. Commun. ACM 58, 8 (2015),
[252] Mary Shaw, Robert DeLine, Daniel V. Klein, Theodore L. Ross, David M. Young, 52–61.
and Gregory Zelesnik. 1995. Abstractions for software architecture and tools to [282] AJ Van Tonder. 2003. Quantum computation, categorical semantics and linear
support them. IEEE transactions on software engineering 21, 4 (1995), 314–335. logic. Technical Report.
[253] Ruslan Shaydulin, Caleb Thomas, and Paige Rodeghero. 2020. Making Quantum [283] André Van Tonder. 2004. A lambda calculus for quantum computation. SIAM J.
Computing Open: Lessons from Open-Source Projects. In First International Comput. 33, 5 (2004), 1109–1135.
Workshop on Quantum Software Engineering (Q-SE 2020). [284] Lieven Vandenberghe and Stephen Boyd. 1996. Semidefinite programming.
[254] Seung Woo Shin, Graeme Smith, John A Smolin, and Umesh Vazirani. 2014. SIAM review 38, 1 (1996), 49–95.
How" quantum" is the D-Wave machine? arXiv preprint arXiv:1401.7087 (2014). [285] Edmond VanDoren. 1997. Maintenance of operational systems–an overview.
[255] Peter W Shor. 1994. Algorithms for quantum computation: discrete logarithms Software technology Roadmap. Carnegie Mellon Software Engineering Institute
and factoring. In Proceedings 35th annual symposium on foundations of computer (1997).
science. Ieee, 124–134. [286] Juliana Kaizer Vizzotto and Antônio Carlos da Rocha Costa. 2005. Concurrent
[256] Peter W Shor. 1995. Scheme for reducing decoherence in quantum computer quantum programming in Haskell. In VII Congresso Brasileiro de Redes Neurais,
memory. Physical review A 52, 4 (1995), R2493. Sessao de Computaçao Quântica. Citeseer.
[257] Peter W Shor. 1999. Polynomial-time algorithms for prime factorization and [287] Markus Völter. 2006. Software Architecture-A pattern language for building
discrete logarithms on a quantum computer. SIAM review 41, 2 (1999), 303–332. sustainable software architectures.. In EuroPLoP. 31–66.
[258] Kartik Singhal. 2019. Hoare types for quantum programming lan- [288] Di Wang and Robert Kleinberg. 2009. Analyzing quadratic unconstrained binary
guages. POPL 2020 Student Research Competition Extended Abstract optimization problems via multicommodity flows. Discrete Applied Mathematics
(2019). http://ks.cs.uchicago.edu/publication/quantum-hoare-types-src/ 157, 18 (2009), 3746–3753.
Quantum-Hoare-Types-SRC.pdf [289] Jiyuan Wang, Ming Gao, Yu Jiang, Jianguang Lou, Yue Gao, Dongmei Zhang,
and Jiaguang Sun. 2018. QuanFuzz: Fuzz Testing of Quantum Program. arXiv
30
 preprint arXiv:1810.10310 (2018).
[290] Dave Wecker, Bela Bauer, Bryan K Clark, Matthew B Hastings, and Matthias
Troyer. 2013. Can quantum chemistry be performed on a small quantum com-
puter. arXiv preprint arXiv:1312.1695 (2013), 15.
[291] Dave Wecker, Bela Bauer, Bryan K Clark, Matthew B Hastings, and Matthias
Troyer. 2014. Gate-count estimates for performing quantum chemistry on small
quantum computers. Physical Review A 90, 2 (2014), 022305.
[292] Dave Wecker and Krysta M Svore. 2014. LIQUi| ⟩ : A software design archi-
tecture and domain-specific language for quantum computing. arXiv preprint
arXiv:1402.4467 (2014).
[293] Colin P Williams and Alexander G Gray. 1998. Automated design of quantum
circuits. In NASA International Conference on Quantum Computing and Quantum
Communications. Springer, 113–125.
[294] HM Wiseman and GJ Milburn. 1993. Interpretation of quantum jump and
diffusion processes illustrated on the Bloch sphere. Physical Review A 47, 3
(1993), 1652.
[295] Marty J Wolf, Frances S Grodzinsky, and Keith W Miller. 2012. Artificial agents,
cloud computing, and quantum computing: Applying FloridiâĂŹs method of
levels of abstraction. In Luciano FloridiâĂŹs Philosophy of Technology. Springer,
23–41.
[296] Jim Woodcock and Jim Davies. 1996. Using Z: Specification, Refinement, and
Proof. (1996).
[297] www.merriam webster.com. 2020. Software Engineering. Accessed on: June 28,
2020 (2020). https://qiskit.org
[298] Jia-Fu Xu, Fang-Min Song, Shi-Jun Qian, Jing-An Dai, and Yun-Jie Zhang. 2008.
Quantum programming language NDQJava. Journal of Software 19, 1 (2008),
1–8.
[299] Zhenyu Yang, James Z Fan, Andrew H Proppe, F Pelayo García de Arquer,
David Rossouw, Oleksandr Voznyy, Xinzheng Lan, Min Liu, Grant Walters,
Rafael Quintero-Bermudez, et al. 2017. Mixed-quantum-dot solar cells. Nature
communications 8, 1 (2017), 1–9.
[300] Mingsheng Ying. 2012. Floyd–hoare logic for quantum programs. ACM Trans-
actions on Programming Languages and Systems (TOPLAS) 33, 6 (2012), 1–49.
[301] Mingsheng Ying. 2016. Foundations of Quantum Programming. Morgan Kauf-
mann.
[302] Mingsheng Ying, Yuan Feng, Runyao Duan, Yangjia Li, and Nengkun Yu. 2012.
Quantum programming: From theories to implementations. Chinese science
bulletin 57, 16 (2012), 1903–1909.
[303] Mingsheng Ying, Shenggang Ying, and Xiaodi Wu. 2017. Invariants of quantum
programs: characterisations and generation. ACM SIGPLAN Notices 52, 1 (2017),
818–832.
[304] Mingsheng Ying, Nengkun Yu, Yuan Feng, and Runyao Duan. 2013. Verification
of quantum programs. Science of Computer Programming 78, 9 (2013), 1679–1700.
[305] Edward Yourdon and Larry L Constantine. 1979. Structured design: fundamentals
of a discipline of computer program and systems design. Prentice-Hall, Inc.
[306] Michal Zalewski. 2007. American fuzzy lop.(2007). (2007).
[307] Christof Zalka. 1998. Efficient simulation of quantum systems by quantum
computers. Fortschritte der Physik: Progress of Physics 46, 6-8 (1998), 877–879.
[308] Anton Zeilinger. 1999. Experiment and the foundations of quantum physics. In
More Things in Heaven and Earth. Springer, 482–498.
[309] Huiyang Zhou and Gregory T Byrd. 2019. Quantum Circuits for Dynamic
Runtime Assertions in Quantum Computation. IEEE Computer Architecture
Letters 18, 2 (2019), 111–114.
[310] Li Zhou, Nengkun Yu, and Mingsheng Ying. 2019. An applied quantum Hoare
logic. In Proceedings of the 40th ACM SIGPLAN Conference on Programming
Language Design and Implementation. 1149–1162.
[311] Margherita Zorzi. 2019. Quantum Calculi - From Theory to Language Design.
Applied Sciences 9, 24 (2019), 5472.
[312] Paolo Zuliani. 2001. Formal reasoning for quantum mechanical nonlocality.
Technical Report. Technical Report RR-01-05, Oxford University Computing
Laboratory.
[313] Paolo Zuliani. 2001. Quantum programming. Ph.D. Dissertation. University of
Oxford.
[314] Paolo Zuliani. 2004. Non-deterministic quantum programming. Proc. QPL (2004),
179–195.

31