Survey

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts

Renormalization wikipedia, lookup

Double-slit experiment wikipedia, lookup

Ensemble interpretation wikipedia, lookup

Bell test experiments wikipedia, lookup

Bohr–Einstein debates wikipedia, lookup

Delayed choice quantum eraser wikipedia, lookup

Basil Hiley wikipedia, lookup

Quantum dot cellular automaton wikipedia, lookup

Topological quantum field theory wikipedia, lookup

Relativistic quantum mechanics wikipedia, lookup

Particle in a box wikipedia, lookup

Theoretical and experimental justification for the Schrödinger equation wikipedia, lookup

Scalar field theory wikipedia, lookup

Quantum field theory wikipedia, lookup

Renormalization group wikipedia, lookup

Hydrogen atom wikipedia, lookup

Bra–ket notation wikipedia, lookup

Quantum dot wikipedia, lookup

Path integral formulation wikipedia, lookup

Quantum electrodynamics wikipedia, lookup

Coherent states wikipedia, lookup

Copenhagen interpretation wikipedia, lookup

Quantum decoherence wikipedia, lookup

Quantum fiction wikipedia, lookup

Measurement in quantum mechanics wikipedia, lookup

Orchestrated objective reduction wikipedia, lookup

Bell's theorem wikipedia, lookup

Many-worlds interpretation wikipedia, lookup

Max Born wikipedia, lookup

Quantum entanglement wikipedia, lookup

Probability amplitude wikipedia, lookup

History of quantum field theory wikipedia, lookup

Quantum computing wikipedia, lookup

Interpretations of quantum mechanics wikipedia, lookup

Quantum machine learning wikipedia, lookup

Quantum teleportation wikipedia, lookup

Quantum key distribution wikipedia, lookup

Density matrix wikipedia, lookup

T-symmetry wikipedia, lookup

Quantum group wikipedia, lookup

Hidden variable theory wikipedia, lookup

Canonical quantization wikipedia, lookup

Quantum state wikipedia, lookup

Symmetry in quantum mechanics wikipedia, lookup

Transcript
```The final version of this paper appeared in Math. Struct. in Comp. Science 14(4):527-586, 2004
Towards a Quantum Programming Language
PETER SELINGER†
Department of Mathematics and Statistics
University of Ottawa
Email: [email protected]
Received 13 Nov 2002, revised 7 Jul 2003
We propose the design of a programming language for quantum computing. Traditionally, quantum
algorithms are frequently expressed at the hardware level, for instance in terms of the quantum
circuit model or quantum Turing machines. These approaches do not encourage structured
programming or abstractions such as data types. In this paper, we describe the syntax and semantics
of a simple quantum programming language with high-level features such as loops, recursive
procedures, and structured data types. The language is functional in nature, statically typed, free of
run-time errors, and it has an interesting denotational semantics in terms of complete partial orders
of superoperators.
1. Introduction
Quantum computation is traditionally studied at the hardware level: either in terms of gates and
circuits, or in terms of quantum Turing machines. The former viewpoint emphasizes data flow
and neglects control flow; indeed, control mechanisms are usually dealt with at the meta-level, as
a set of instructions on how to construct a parameterized family of quantum circuits. On the other
hand, quantum Turing machines can express both data flow and control flow, but in a sense that
is sometimes considered too general to be a suitable foundation for implementations of future
quantum computers.
In this paper, we seek to investigate quantum computation from the point of view of programming languages. We propose a view of quantum computation which is able to express both data
flow and control flow, while not relying on any particular hardware model. Our approach can be
summarized by the slogan “quantum data, classical control”. Thus, the data which is manipulated
by programs may involve quantum superpositions, but the control state of a program is always
classical; there is no “quantum branching” and no notion of executing a quantum superposition
of two different statements. This is more general than quantum circuits, where control flow is not
modeled at all, but more restrictive than quantum Turing machines, where both data and control
may be “quantum”. The paradigm “quantum data, classical control” seems to be precisely what
is embodied in most known practical quantum algorithms, such as Shor’s factoring algorithm,
Grover’s search algorithm, or the Quantum Fourier Transform (Shor 1994; Grover 1996).
†
Research supported by NSERC.
Peter Selinger
2
The programming language presented in this paper is functional, in the sense that each (atomic
or composite) statement operates by transforming a specific set of inputs to outputs. This is in
contrast to imperative programming languages, which operate by updating global variables. Our
language is also statically typed, which implies that the well-formedness of a program can be
checked at compile time, rather than relying on run-time checks. For instance, the principle of
non-duplication of quantum data, known as the no-cloning property, is enforced by the syntax of
our language. Unlike previous proposals for quantum programming languages (Knill 1996; Ömer
1998; Sanders and Zuliani 2000; Bettelli, Calarco, and Serafini 2001), our language guarantees
that any well-typed program is free of run-time errors.
The language also provides high-level control features such as loops and recursion, and it can
accommodate structured data types such as lists or trees. We provide two alternative syntactic
representations of quantum programs: a graphical representation in terms of flow charts, and a
textual, more structured representation. The choice of syntax is a matter of taste, because the two
representations are semantically equivalent.
Perhaps the most important feature of our programming language is that it admits a denotational semantics. This is achieved by assigning a certain kind of linear operator, called a superoperator, to each program fragment. For the semantics of loops and recursion, we use the fact that
the superoperators of each given type form a complete partial order. The denotational semantics
is fully abstract in the sense that two program fragments are denotationally equivalent if and only
if they are indistinguishable in the context of any larger program.
While the semantics of our quantum programming language can (and will) be described without reference to any particular hardware model, it helps the intuition to think of a particular
hardware device on which the language might be implemented. Here, it is understood that actual
future quantum hardware may differ; these differences must be handled by implementors and
have no direct impact on the language design. A suitable hardware model for our purposes is the
QRAM machine of (Knill 1996). This machine consists of a general-purpose classical computer
which controls a special quantum hardware device. The quantum device provides a potentially
large number of individually addressable quantum bits. Quantum bits can be manipulated via
two fundamental operations: (1) unitary transformations and (2) measurements. Typically, the
quantum device will implement a fixed, finite set of unitary transformations which operate on
one or two quantum bits at a time. The classical controller communicates with the quantum device by sending a sequence of instructions, specifying which fundamental operations are to be
performed. The only output from the quantum device consists of the results of measurements,
which are sent back to the classical controller. Note that in the QRAM model, it is not necessary
for the classical hardware and the quantum device to be in the same physical location; it is even
possible for several classical controllers to share access to a single quantum device.
In quantum complexity theory, algorithms are often presented in a certain normal form: a
quantum computation consists of an initialization, followed by a unitary transformation, followed
by a single final measurement, just before the classical result of the algorithm is read. While
no theoretical generality is lost in postponing all measurements until the end, this presentation
does not necessarily lead to the most natural programming style. Quantum algorithms are often
more naturally described by interleaving quantum and classical operations, allowing the results
of measurements to influence subsequent operations. In addition to being conceptually more
Towards a Quantum Programming Language
3
natural, this style of programming can also lead to savings in the resources consumed by an
algorithm, for instance, in the number of quantum bits that must be allocated.
One issue not addressed in this paper is the question of quantum communication. The programming language described here deals with quantum computation in a closed world, i.e., it
describes a single process which computes a probabilistic result depending only on its initial
input parameters. We do not deal with issues related to the passing of quantum information, or
even classical information, between different quantum processes. In particular, our programming
language currently does not support primitives for input or output, or other side effects such as
updating shared global data structures. While adding such features would not cause any problems from an operational point of view, the denotational semantics of the resulting language is
not currently very well understood. In other words, in a setting with side effects, it is not clear
how the behavior of a complex system can be described in terms of the behaviors of its individual parts. On the one hand, these difficulties are typical of the passage from purely functional
programming languages to concurrent languages. On the other hand, there are particular complications that arise from the very nature of quantum information flow, which is a subject of ongoing
research.
Another issue that we do not address in this paper is the issue of “idealized” vs. “real” hardware. Just as in classical programming language theory, we assume that our language runs on
idealized hardware, i.e., hardware that never produces flawed results, where quantum states do
not deteriorate, where no unintended information is exchanged between programs and their environment, etc. This seems to be a reasonable assumption from the point of view of language
design, although it might only be approximated in actual implementations. It is intended that
implementations will use quantum error correction techniques to limit the adverse effects of
imperfect physical hardware. Ideally, error correction should be handled transparently to the programmer. This can potentially be achieved at several different levels: error correction could be
built into the hardware, it could be handled by the operating system, or it could be added automatically by the compiler. The tradeoffs associated with each of these choices remain the subject
of future work, and we do not consider them further in this paper.
Since there are some differences between the customary languages of physics and computer
science, it seems appropriate to comment on the notation used in this paper. Because this paper
was primarily written with an audience of computer scientists in mind, we tend to use computer
science notation instead of physics notation. For instance, we write states as columns vectors (not
row vectors, as is usual in physics), and we represent operators as matrices, using a fixed basis
and fixed indexing conventions. It is hoped that notational issues will not prove too distracting
In order to keep the paper as self-contained as possible, we provide a brief review of some basic
concepts from linear algebra and quantum computation in Sections 2 and 3. These introductory
sections contain no original contributions except for the definition of the complete partial order
of density matrices in Section 3.8. The main body of the paper starts in Sections 4 and 5 with
the introduction of the quantum flow chart language. We proceed to discuss its formal semantics
in Section 6, and we conclude with some syntactic considerations and a discussion of possible
language extensions in Section 7.
Peter Selinger
4
Previous work
The recent literature contains several proposals for quantum programming languages. One of the
first contributions in this direction is an article by Knill (1996). While not proposing an actual
programming language, Knill outlines a set of basic principles for writing pseudo-code for quantum algorithms. These principles have influenced the design of some later language designs. The
first actual quantum programming language is due to Ömer (1998). Ömer defines a rich procedural language QCL, which contains a full-fledged classical sublanguage and many useful highlevel quantum features, such as automatic scratch space management and syntactic reversibility
of user-defined quantum operators. Partly building on Ömer’s work, Bettelli et al. (2001) present
a quantum programming language which is an extension of the well-known language C++. The
distinguishing feature of this language is that it treats quantum operators as first-class objects
which can be explicitly constructed and manipulated at run-time, even allowing run-time optimizations of operator representations.
A quantum programming language of a somewhat different flavor is given by Sanders and
Zuliani (2000). Their language qGCL, which is based on an extension of Dijkstra’s guardedcommand language, is primarily useful as a specification language. Its syntax includes high-level
mathematical notation, and the language supports a mechanism for stepwise refinement which
can be used for systematic program derivation and verification.
Of the languages surveyed, only that of Sanders and Zuliani possesses a formal semantics.
This semantics is purely operational, and it works by assigning to each possible input state a
probability distribution on output states. One problem with this approach is that the resulting
probability distributions are generally very large, incorporating much information which is not
physically observable. The present paper offers a better solution to this problem, using density
matrices and superoperators instead of probability distributions.
A common feature of the quantum programming languages surveyed in the literature is that
they are realized as imperative programming languages. Quantum data is manipulated in terms
of arrays of quantum bit references. This style of data representation requires the insertion of
a number of run-time checks into the compiled code, including out-of-bounds checks and distinctness checks. For instance, distinctness checks are necessary because quantum operators can
only be applied to lists of distinct quantum bits. In imperative languages, this condition cannot be checked at compile-time. For similar reasons, most optimizations cannot be performed
at compile-time and must therefore be handled at run-time in these languages. By contrast, the
language proposed in the present paper is a functional programming language with a static type
system which guarantees the absence of any run-time errors.
2. Basic notions from linear algebra
In this section, we recall some well-known concepts from linear algebra, for the purpose of fixing
the notation used in later parts of this paper. Readers may safely skip this section and refer back
to it when needed.
From the outset, we have to make an important choice of presentation. It is generally understood that the basic notions of linear algebra can be expressed in a basis-independent way.
Thus, the standard way of introducing the concepts of quantum mechanics is in the language of
Towards a Quantum Programming Language
5
Hilbert spaces, linear operators, etc. However, in the concrete setting of quantum computation,
such generality is not needed, as it turns out that there is always a “preferred” basis to work
with. Therefore, we may as well identify our vector spaces with C n . This allows us to express
all operations though manipulations of concrete objects, such as columns vectors and matrices.
Nevertheless, it is of course understood that all covered concepts are basis independent unless
stated otherwise.
2.1. Vectors and matrices
Let C be the set of complex numbers, which are also called scalars. The complex conjugate of
z ∈ C is written z̄. We write Cn for the space of n-dimensional column vectors, and C n×m
for the space of matrices with n rows and m columns. We identify C n with Cn×1 and C1 with
C. Matrix multiplication is defined as usual. The identity matrix is written I. The adjoint of a
matrix A = (aij ) ∈ Cn×m is given by A∗ = (āji ) ∈ Cm×n . The trace of a square matrix
P
A = (aij ) ∈ Cn×n is defined as tr A = i aii . Note that for A, B ∈ Cn×n , tr(AB) = tr(BA).
Column vectors are denoted by u, v, etc. We write e i for the ith canonical basis vector. Note
P
that if u is a column vector, then u ∗ is√a row vector. Note that u ∗ u = i |ui |2 > 0. The norm
kuk of a vector u is defined by kuk = u∗ u. The vector u is called a unit vector if kuk = 1.
If A, B, C and D are matrices of equal dimensions, we often denote the matrix obtained by
“horizontal and vertical concatenation” by
A B
.
C D
Sometimes, we also use an analogous notation for vectors.
2.2. Unitary matrices
A square matrix S ∈ Cn×n is called unitary if S ∗ S = I is the identity matrix, or equivalently,
if S ∗ = S −1 . Unitary matrices are precisely the isometries, because kSuk = kuk holds for all
u iff S is unitary. If S is unitary and A = SBS ∗ , then tr A = tr B. Thus, the trace is invariant
under a unitary change of basis.
2.3. Hermitian and positive matrices
A square matrix A ∈ Cn×n is called hermitian if A = A∗ . Note that if A is hermitian, then u ∗ Au
is always real. A matrix A is called positive semidefinite, or simply positive, if it is hermitian and
u∗ Au > 0 for all u ∈ C n . Note that hermitian matrices are closed under addition and real
scalar multiples, i.e., they form an R-linear subspace of C n×n . Moreover, the positive matrices
are closed under addition and non-negative real scalar multiples.
A matrix A is hermitian if and only if A = SDS ∗ , for some unitary matrix S and some
real-valued diagonal matrix D. The diagonal entries of D are the eigenvalues of A, and they are
uniquely determined up to a permutation. The columns of S are the corresponding eigenvectors.
Moreover, a hermitian matrix A is positive iff all its eigenvalues are non-negative.
A matrix A ∈ Cn×n is called pure if A = vv ∗ for some v ∈ Cn . Every pure matrix is positive;
conversely, every positive matrix is a non-negative real linear combination of pure matrices.
Peter Selinger
6
In dimension 2, a matrix
a b
c d
is hermitian when b = c̄ and a, d ∈ R. Furthermore, it is positive when the trace a + d and the
determinant ad − bc are non-negative, and pure when the determinant is zero.
Remark 2.1. Any complex C n×n matrix is a linear combination of four positive hermitian matrices. Because first, any complex matrix A can be written as a linear combination B + iC of two
hermitian matrices, where B = 21 (A∗ + A) and C = 2i (A∗ − A). Second, any hermitian matrix
B can be written as the difference of two positive matrices, namely B = (B + λI) − (λI), where
−λ is the most negative eigenvalue of B.
Remark 2.2. Every positive matrix A ∈ C n×n is of the form BB ∗ , for some B ∈ Cn×n . This
is evident for diagonal matrices, and follows for arbitrary positive matrices by a change of basis.
2.4. Tensor product
The tensor product of two vector spaces is defined as usual; here we only need two special cases:
Cn ⊗ Cm = Cnm and Cn×n ⊗ Cm×m = Cnm×nm .
The tensor product w = u ⊗ v ∈ C nm of two vectors u ∈ C n , v ∈ Cm is defined by
w(i,j) = ui vj . Similarly, the tensor product C = A ⊗ B ∈ C nm×nm of two matrices is defined
by c(i,j),(i0 ,j 0 ) = aii0 bjj0 . Here we order the pairs (i, j) lexicographically; thus, for instance,
B
0
0 1
.
⊗B =
−1 0
−B 0
3. Basic notions from quantum computation
In this section, we provide a brief review of some basic notions from quantum computation. For
a more thorough introduction, see e.g. (Cleve 2000; Preskill 1998; Gruska 1999; Nielsen and
Chuang 2000).
3.1. Quantum bits
The basic data type of quantum computation is a quantum bit, also called a qubit. Recall that the
possible states of a classical bit b are b = 0 and b = 1. By contrast, the state of a quantum bit
q can be any complex linear combination q = α0 + β1, where α, β ∈ C and α, β are not both
zero. The coefficients α and β are called the amplitudes of this quantum state, and they are only
significant up to scalar multiples, i.e., q = α0+β1 and q 0 = α0 0+β 0 1 denote the same quantum
state if α0 = γα and β 0 = γβ for some non-zero γ ∈ C. One often assumes that the amplitudes
α and β are normalized, i.e., that |α| 2 +|β|2 = 1. Note, however, that this normalization does not
determine α and β uniquely; they are still only well-defined up to multiplication by a complex
unit.
Thus, the classical boolean constants 0 and 1 are identified with two basis vectors e 0 and e1
of a 2-dimensional complex vector space. In the literature, it is common to denote these basis
Towards a Quantum Programming Language
7
vectors in the so-called “ket” notation as e 0 = |0i and e1 = |1i. Thus, the state of a typical
quantum bit is written as α |0i + β |1i. Here the word ket is the second half of the word bracket;
bras also exist, but we shall not use them.
The basis states |0i = 1 |0i + 0 |1i and |1i = 0 |0i + 1 |1i are called the classical states, and
any other state is said to be a quantum superposition of |0i and |1i.
The first interesting fact about quantum bits is that the state of two or more quantum bits is not
just a tuple of its components, as one might have expected. Recall the four possible states of a
pair of classical bits: 00, 01, 10, and 11. The state of a pair of quantum bits is a formal complex
linear combination of these four classical states, i.e., it is a linear combination of the form
X
αij |iji .
α00 |00i + α01 |01i + α10 |10i + α11 |11i =
i,j∈{0,1}
Again, we have used the ket notation to identify the four classical states with the basis states of
a 4-dimensional vector space. As before, we require that at least one of the α ij is non-zero, and
the whole state is only well-defined up to a complex scalar multiple. If q = α |0i + β |1i and
p = γ |0i + δ |1i are two independent quantum bits, then their combined state is
q ⊗ p = αγ |00i + αδ |01i + βγ |10i + βδ |11i .
However, note that in general, the state of a pair of quantum bits need not be of the form q ⊗ p.
For instance, the state
1
1
√ |00i + √ |11i
2
2
is clearly not of the form q ⊗ p, for any q and p. If the state of a pair of quantum bits is of the
form q ⊗ p, then the pair is said to be independent, otherwise it is called entangled.
n
In general, the state of n quantum bits is a non-zero vector in C 2 , i.e., a formal linear combination
X
αb1 ...bn |b1 . . . bn i ,
b1 ,...,bn ∈{0,1}
taken modulo scalar multiples.
3.2. Indexing conventions
Consider a quantum state q = α |00i + β |01i + γ |10i + δ |11i. By identifying the basis vectors
|00i, |01i, |10i, and |11i with the canonical basis of C 4 , we can write the state q as a column
vector


α
 β 

q=
 γ .
δ
Here, the ordering of the basis vectors is relevant. In general, we need an indexing convention
which determines how the basis vectors |b 1 b2 . . . bn i are to be identified with the canonical basis
n
vectors of C2 . We use the following convention:
Convention 3.1 (Lexicographic convention). Consider the set of bit vectors of length n, i.e.,
tuples (b1 , b2 , . . . , bn ), where b1 , . . . , bn ∈ {0, 1}. We identify each such bit vector with the
Peter Selinger
8
number i ∈ 0, . . . , 2 n − 1 of which it is the binary representation. We also identify the “ket”
n
|b1 b2 . . . bn i with the ith canonical basis vector of C 2 .
Note that this convention is equivalent to saying that the bit vectors shall always be ordered
lexicographically when they are used to index the rows or columns of some vector or matrix.
Sometimes, we need to consider a permutation of quantum bits, such as exchanging the
first with the second quantum bit in a sequence. This induces a corresponding permutation of
states. More precisely, any permutation of n elements, φ : {1, . . . , n} → {1, . . . , n}, induces
a permutation 2 φ of the set of bit vectors of length n, which is defined by 2 φ (x1 , . . . , xn ) =
(xφ−1 (1) , . . . , xφ−1 (n) ), for x1 , . . . , xn ∈ {0, 1}. Note that this definition is covariant, in the
sense that 2φ ◦ 2ψ = 2φ◦ψ . As an illustration, consider the permutation φ such that φ(1) = 2,
φ(2) = 3, and φ(3) = 1. Then 2 φ (b1 , b2 , b3 ) = (b3 , b1 , b2 ). Thus, 2φ maps 000 7→ 000,
100 7→ 010, 110 7→ 011, and so forth.
3.3. Unitary transformations
There are precisely two kinds of operations by which we can manipulate a quantum state: unitary transformations and measurements. We describe unitary transformations in this section and
measurements in the next one.
The state of a quantum system can be transformed by applying a unitary transformation to it.
For instance, consider a quantum bit in state u = α |0i+β |1i, and let S be a unitary 2×2-matrix.
Then we can perform the operation
α
α
7→ S
.
β
β
Similarly, if v = α |00i + β |01i + γ |10i + δ |11i is the state of a two-qubit quantum system,
we can transform it by a unitary 4 × 4-matrix, and similarly for three or more quantum bits. A
unitary operation on n quantum bits is also known as an n-ary quantum gate. While every unitary
matrix can be realized in principle, one usually assumes a fixed finite set of gates that are built
into the hardware. The particular choice of basic gates is not important, because a compiler will
easily be able to translate one such set to another. One possible choice is the following, which
consists of four unary and five binary gates:
1 1
1 0
1 √
0
0 1
, V =
,
W =
,
N=
,
H = √12
1 −1
0 i
0
i
1 0
Nc =
I 0
0 N
I 0
, Hc =
,
0 H
1
 0
X=
 0
0

Vc =
0
0
1
0
0
1
0
0
I 0
0 V

0
0 
.
0 
1
I 0
, Wc =
,
0 W
The unary gate N is called the not-gate, because it induces the following mapping of basis
vectors: |0i 7→ |1i and |1i 7→ |0i. Geometrically, it corresponds to the symmetry of axis π/4.
Towards a Quantum Programming Language
9
The unary gate H is called the Hadamard gate, and it corresponds to the symmetry of axis π/8.
The unary gates V and W represent complex phase changes.
The binary gate N c is called the controlled not-gate. It corresponds to a permutation of basis
vectors: |00i 7→ |00i, |01i 7→ |01i, |10i 7→ |11i, and |11i 7→ |10i. Its action can be described
as follows: if the first bit is 0, do nothing, else apply the N -gate to the second bit. In this sense,
the first bit controls the action of the second one. More generally, for each unary gate S, there is a
corresponding binary controlled gate S c . Finally, the binary X-gate corresponds to an exchange
of two qubits: it maps |b 1 b2 i to |b2 b1 i, whenever b 1 , b2 ∈ {0, 1}. The X-gate is classical in the
sense that it can be implemented as an operation on addresses of qubits, rather than on qubits
themselves. In the quantum computation literature, its existence is often assumed implicitly.
Unitary transformations can be used to create quantum superpositions, and they can also be
used to create entanglement between quantum bits. For example, the Hadamard gate H, when
applied to the classical state |0i, creates a quantum superposition √12 |0i + √12 |1i. Also, the
controlled not-gate, applied to two independent quantum bits ( √12 |0i + √12 |1i) ⊗ |0i, creates
an entangled state √12 |00i + √12 |11i.
A quantum gate can be applied in the presence of additional quantum bits. For example, to
apply a unary gate S to the second quantum bit in a 4-bit system, we transform the system by the
matrix I ⊗ S ⊗ I ⊗ I. Here I is the 2 × 2-identity matrix.
Clearly, the above set of nine standard gates contains some redundancy; for instance, V = W 2 ,
N = HV 2 H, etc. On the other hand, the set is complete, in the sense that any n-ary unitary gate
can be approximated, up to an arbitrarily small error , by a combination of the given gates. In
fact, three of the nine gates suffice:
n
n
Proposition 3.2 (see (Cleve 2000, Thm. 1)). Let n > 2. For any unitary matrix S ∈ C 2 ×2 and
any > 0, there exists a unitary matrix S 0 and a unit complex number λ such that kS − λS 0 k < and such that S 0 can be written as a product of matrices of the form I ⊗ A ⊗ J, where I, J are
identity matrices of the appropriate dimensions, and A is one of the gates H, V c , and X.
Thus, if we assume that the above nine gates (or some other finite complete set of gates) are
implemented in hardware, then any other unitary gate can be simulated by software. In practice,
decomposing a given unitary matrix into standard gates is not an easy problem, and the best
known algorithms are not very efficient. However, we will ignore this problem and simply assume
that we can apply arbitrary unitary gates to a quantum state.
3.4. Measurement
The second fundamental operation on the state of a quantum system is known as a measurement.
This occurs when we try to “observe” the value of a quantum bit and convert it into a classical
bit. Consider for instance the state of a single quantum bit q = α |0i + β |1i. For simplicity,
let us assume that the amplitudes have been normalized such that |α| 2 + |β|2 = 1. The act
of measuring this quantum bit will yield an answer which is either 0 or 1. The answer 0 will
occur with probability |α| 2 , and 1 with probability |β| 2 . Moreover, the measurement causes the
quantum state to collapse: after the measurement, the quantum state will have changed to either
|0i or |1i, depending on the result of the measurement. In particular, if we immediately measure
the same quantum bit again, we always get the same answer as the first time.
Peter Selinger
10
The situation is more complex if more than one quantum bit is involved. Consider a two-qubit
system in the state α |00i + β |01i + γ |10i + δ |11i. We assume again that the amplitudes have
been normalized. If we measure the value of the first bit, one of the following things will happen:
— with probability |α| 2 + |β|2 , the result of the measurement will be 0 and the quantum state
will collapse to α |00i + β |01i, and
— with probability |γ| 2 + |δ|2 , the result of the measurement will be 1 and the quantum state
will collapse to γ |10i + δ |11i.
Note that only the portion of the quantum state pertaining to the bit that we are observing
collapses. If we were observing the second bit instead, the observed answer would be 0 with
probability |α| 2 + |γ|2 , and 1 with probability |β| 2 + |δ|2 , and the quantum state would collapse,
respectively, to α |00i + γ |10i or β |01i + δ |11i.
Now let us see what happens if we measure the second quantum bit after the first one. The
situation can be summarized in the following diagram:
α |00i + β |01i + γ |10i + δ |11i
2
p0 =|α| +|β|2
p00 =
α |00i + β |01i
|α|2
|α|2 +|β|2
p01 =
0
α |00i
1
0
|β|2
|α| +|β|2
2
β |01i
1
p10 =
p1 =|γ|2 +|δ|2
γ |10i + δ |11i
|γ|2
|γ|2 +|δ|2
γ |10i
p11 =
0
1
|δ|2
|γ|2 +|δ|2
δ |11i
In this tree, the nodes are labeled with states, and the transitions are labeled with probabilities. Note that the overall probability of observing 00 as the result of the two measurements is
p0 p00 = |α|2 , the probability of observing 01 is p 0 p01 = |β|2 , and so forth. In particular, these
probabilities are independent of the order of measurement; thus, the result does not depend on
which quantum bit we measure first, or indeed, on whether we measure both of them simultaneously or in sequence. The technical term for this phenomenon is that the two measurements
commute. In general quantum mechanics, two measurements need not always commute; however, in quantum computation, they always do. This is due to the fact that we only measure along
subspaces spanned by standard coordinate vectors.
We mentioned that it is customary to normalize quantum states so that the sum of the squares
of the amplitudes is 1. However, in light of the above diagram, we find that it is often more
convenient to normalize states differently.
Convention 3.3 (Normalization convention). We normalize each state in such a way that the
sum of the squares of the amplitudes is equal to the total probability that this state is reached.
With this convention, it becomes unnecessary to renormalize the state after a measurement has
been performed. We will see later that this convention greatly simplifies our computations.
3.5. Pure and mixed states
We know that the state of a quantum system at any given time can be completely described by
n
its state vector u ∈ C2 , modulo a scalar multiple. However, an outside observer might have
Towards a Quantum Programming Language
11
incomplete knowledge about the state of the system. For instance, suppose that we know that a
given system is either in state u or in state v, with equal probability. We use the ad hoc notation
1
1
2 {u} + 2 {v} to describe this situation. In general, we write λ 1 {u1 } + . . . + λm {um } for a
system which, from the viewpoint of some observer, is known to be in state u i with probability
P
λi , where i λi = 1. Such a probability distribution on quantum states is called a mixed state.
The underlying quantum states, such as u, are sometimes called pure states to distinguish them
from mixed states.
It is important to realize that a mixed state is a description of an observers knowledge of the
state of a quantum system, rather than a property of the system itself. In particular, a given system
might be in two different mixed states from the viewpoints of two different observers. Thus, the
notion of mixed states does not have an independent physical meaning. Physically, any quantum
system is in a (possibly unknown) pure state at any given time.
Unitary transformations operate componentwise on mixed states. Thus, the unitary transformation S maps the mixed state λ 1 {u1 } + . . . + λm {um } to λ1 {Su1 } + . . . + λm {Sum }.
The collapse of a quantum bit takes pure states to mixed states. For instance, if we measure a
quantum bit in state α |0i + β |1i, but ignore the outcome of the measurement, the system enters
(from our point of view) the mixed state |α| 2 {|0i} + |β|2 {|1i}.
3.6. Density matrices
We now introduce a better notation for mixed quantum states, which is due to von Neumann.
First, consider a pure state, represented as usual by a unit column vector u. In von Neumann’s
notation, this quantum state is represented by the matrix uu ∗ , called its density matrix. For example, the state of a quantum bit u = √12 |0i − √12 |1i is represented by the density matrix
uu∗ =
1
2
− 21
− 12
1
2
.
Note that no information about a pure state is lost in this notation, because the vector u is uniquely
determined, up to a scalar multiple, by the matrix uu ∗ . There are several advantages to the density
matrix notation. A mundane advantage is that we do not have to write so many square roots. More
importantly, if u = γv, for some complex scalar γ with |γ| = 1, then uu ∗ = γγ̄vv ∗ = vv ∗ . Thus,
the scalar factor disappears, and the normalized representation of each pure quantum state as a
density matrix is unique. Also note that tr(uu ∗ ) = kuk2 . In particular, if u is a unit vector, then
the density matrix has trace 1.
But the real strength of density matrices lies in the fact that they also provide a very economical
notation for mixed states. A mixed state λ 1 {u1 }+. . .+λn {un } is simply represented as a linear
combination of the density matrices of its pure components, i.e., as λ 1 u1 u∗1 + . . . + λn un u∗n .
For example, the mixed state 12 {|0i} + 12 {|1i} is expressed as the matrix
1
1 0 0
1 1 0
0
2
+
=
.
0 12
2 0 0
2 0 1
Remark 3.4. Some information about a mixed state is lost in the density matrix notation. For
example, let u = √12 |0i + √12 |1i and v = √12 |0i − √12 |1i. Then the mixed state 12 {u} + 12 {v}
Peter Selinger
gives rise to the following density matrix:
1
1
1 12 12
2
+
2 12 12
2 − 21
12
− 12
1
2
=
1
2
0
0
1
2
,
which is the same as the density matrix for the mixed state 12 {|0i} + 12 {|1i} calculated above.
But as we shall see in the next section, there is no observable difference between two mixed states
that share the same density matrix, and thus there is no harm (and indeed, much benefit) in identifying such states. Another example of this phenomenon of two different, but indistinguishable
mixed states will be discussed later in Example 4.6.
We note that a matrix A is of the form λ 1 u1 u∗1 + . . . + λn un u∗n , for unit vectors u i and
P
non-negative coefficients λ i with i λi 6 1, if and only if A is positive hermitian and satisfies
P
P
tr A 6 1. (The reason for allowing i λi 6 1, rather than i λi = 1, will become apparent
later). The left-to-right direction is trivial, and the right-to-left direction follows because any such
P
P
A can be diagonalized as A = SDS ∗ , for some D = i λi ei e∗i . We then have A = i λi ui u∗i ,
where ui = Sei . This motivates the following definition:
Definition (Density matrix). A density matrix is a positive hermitian matrix A which satisfies
tr A 6 1. We write Dn ⊆ Cn×n for the set of density matrices of dimension n.
Remark 3.5. In any dimension, a density matrix is pure iff its rank is at most 1. More generally,
any density matrix of rank k can be decomposed into a sum of k pure density matrices. In
particular, since the addition of positive hermitians can only be rank-increasing, the sum of a
pure and an impure matrix is always impure.
3.7. Quantum operations on density matrices
The two kinds of quantum operations, namely unitary transformation and measurement, can
both be expressed with respect to density matrices. A unitary transformation S maps a pure
quantum state u to Su. Thus, it maps a pure density matrix uu ∗ to Suu∗ S ∗ . Moreover, a unitary
transformation extends linearly to mixed states, and thus, it takes any mixed density matrix A to
SAS ∗ .
Now consider the effect of a measurement on a density matrix. We begin by considering a pure
state uu∗ , for some unit vector u. Suppose that
v
vv ∗ vw∗
∗
u=
, therefore uu =
.
w
wv∗ ww∗
Assuming that the rows of u are ordered according to the lexicographic convention(Conven
v
tion 3.1), then if we perform a measurement on the first bit, the outcome will be
with
0
0
probability kvk 2 , and w with probability kwk 2 . Or in density matrix notation, the outcome
will be
vv ∗ 0
0
0
or
,
0 0
0 ww∗
where the first matrix occurs with probability kvk 2 , and the second matrix occurs with probability
Towards a Quantum Programming Language
13
kwk2 . Note that the probability that each matrix occurs is equal to its trace: kvk 2 = tr(vv ∗ ) and
kwk2 = tr(ww∗ ). Thus, the normalization convention (Convention 3.3) extends naturally to
density matrices: the density matrix of a state shall be normalized in such a way that its trace
corresponds to the overall probability that this state is reached. Note that with this convention,
each of the two possible outcomes of a measurement is a linear function of the incoming state.
The measurement operation extends linearly from pure to mixed states. Thus, performing a
measurement on a mixed state of the form
A B
C D
results in one of the two states
A 0
0 0
or
0 0
0 D
,
where each of the two matrices occurs with probability equal to its trace. If one ignores the
classical bit of information that is observed from the measurement, then the resulting state is a
mixed state
A 0
.
0 D
Thus, collapsing a quantum bit (measuring it while ignoring the result) corresponds to setting a
certain region of the density matrix to 0.
We have seen that the effect of the two fundamental operations of quantum mechanics, unitary
transformations and measurements, can be described in terms of their action on density matrices.
Since unitary transformations and measurements are our only means of interacting with a quantum state, it follows that there is no observable difference between mixed states which have the
same density matrix representation.
3.8. The complete partial order of density matrices
Recall that Dn is the set of density matrices of dimension n:
Dn = {A ∈ Cn×n | A positive hermitian and tr A 6 1}.
Definition (Löwner partial order). For matrices A, B ∈ C n×n , we define A v B if the matrix
B − A is positive.
It is immediately obvious that v defines a partial order on the set C n×n . This partial order
is known in the literature as the L öwner partial order (Löwner 1934), and it is commonly used
in an area of linear programming known as semidefinite programming. When restricted to the
set Dn of density matrices, this partial order has the zero matrix 0 as its least element. We also
denote the zero matrix by ⊥ in this context.
Proposition 3.6. The poset (D n , v) is a complete partial order, i.e., it has least upper bounds
of increasing sequences.
Proof. Positive hermitian matrices in C n×n are in one-to-one correspondence with positive
quadratic forms on C n . The order on hermitians is just the pointwise order of quadratic forms
Peter Selinger
14
because A v B iff for all u, u ∗ Au 6 u∗ Bu. Moreover, for all positive A with tr A 6 1, we have
|u∗ Au| 6 kuk2; this follows from diagonalization. Thus, any trace-bounded increasing sequence
of quadratic forms has a pointwise least upper bound, which is clearly a quadratic form; the limit
satisfies the trace condition by continuity of the trace.
Remark 3.7. The poset (D n , v) is not a lattice for n > 2; in fact, it does not even have least
upper bounds of bounded sets. For instance, in D 2 ,
0.3 0
0.4 0.2
and
0 0.3
0.2 0.4
are two different minimal upper bounds of
0.3 0
and
0 0
0 0
0 0.3
.
Remark 3.8. For any increasing sequence in D n , A is the least upper bound if and only if A is
the topological limit of the sequence, with respect to the standard Euclidean topology on C n×n .
It follows, among other things, that a monotone function f : D n → Dm is Scott continuous
(i.e., preserves least upper bounds of increasing sequences) if it is topologically continuous.
The
a
b
converse is not in general true; a counterexample is f : D 2 → D1 which maps c d to
a/(1 − d) if d 6= 1, and to 0 otherwise.
A B
with B, C 6= 0, we have
Remark 3.9. For a density matrix
C D
0 0
A 0
A 0
v
v
,
0 0
0 0
0 D
but
A
0
0
0
6v
A
C
B
D
and
A 0
0 D
6v
A
C
B
D
.
The latter inequalities fail because the difference of the two matrices has null entries on the
diagonal, and thus can be positive only if the corresponding non-diagonal entries also vanish.
4. Quantum flow charts (QFC)
We now turn to the question of how to design a quantum programming language, and how to
define its semantics. One of the first issues that we are faced with is the choice of a convenient syntax. Out of the many possibilities, we choose to represent programs as flow charts, also
known as control flow diagrams. However, unlike traditional flow charts for imperative programming languages, our flow charts have a more “functional” flavor; in our setting, commands act
by transforming specific inputs to outputs, rather than by updating global variables. Thus, we
combine the language of control flow with some elements of data flow.
In this section and the next one, we describe the syntax of flow charts, and we introduce their
semantics informally. The formal semantics is given in Section 6. Some alternative language
choices are discussed in Section 7.
Towards a Quantum Programming Language
15
input b, c : bit
b, c : bit
branch b
0
1
b, c : bit
b := c
b, c : bit
b, c : bit
c := 0
b, c : bit
◦
b, c : bit
output b, c : bit
Fig. 1. A simple classical flow chart
4.1. Classical flow charts
The concept of a flow chart in “functional style” is best illustrated by giving some examples. It is
instructive to consider the classical (i.e., not quantum) case first. Consider the simple flow chart
shown in Figure 1.
Unless otherwise indicated by arrows, the flow of control is from top to bottom. Each edge is
labeled with a typing judgment, i.e., by a list of typed variables. These are the variables which
are available at that given point in the program. For simplicity, we consider only a single data
type for now: the type bit of a classical bit (also known as the type of booleans). In the example
in Figure 1, no variables are created or disposed of, so each edge is labeled with the same typing
judgment b, c : bit.
This program fragment inputs a pair of bits, performs a conditional branch and some updates,
and then outputs the pair (b, c). The semantics of this program can be described as a map from
its inputs to its outputs. Specifically, the map computed by this program is:
00
01
10
11
7→
7
→
7
→
7
→
00
01
00
10
The state of the program, between instructions, is given by a pair (e, ρ), where e is an edge
of the flow chart (thought of as the program counter), and ρ is an assignment of values to the
variables with which e is labeled.
An important observation is that the two components of the state, instruction pointer and value
assignment, are fundamentally of the same nature. Thus, the instruction pointer could be thought
of as a variable (and indeed, in most hardware implementations, it is represented by a machine
register). Conversely, the content of a boolean variable can be thought of as encoding a choice
between two alternative control paths. For example, an edge labeled with a boolean variable b
Peter Selinger
16
input b, c : bit
00 01 10 11
A
◦
B
◦
C
◦
D
◦
(∗ branch b ∗)
◦
◦
◦
◦
◦
◦
0
◦
◦
0
◦
◦
C
◦
D
◦
(∗ b := c ∗)
◦
A
0
B
0
◦
◦
0
C
◦
0
D
◦
◦
◦
◦
◦
◦
◦
◦
(∗ c := 0 ∗)
0
C
◦
◦
◦
◦
◦
◦
D 0
◦
◦
(∗ merge ∗)
◦
A+C
output b, c : bit
◦
◦
B
◦
D 0
00 01 10 11
Fig. 2. Classical flow chart from Figure 1, with boolean variables expanded
can be equivalently replaced by two parallel (unlabeled) edges, corresponding to the states b = 0
and b = 1, respectively. Similarly, an edge labeled with two boolean variables can be replaced
by four parallel edges, corresponding to the four possible states 00, 01, 10, and 11, and so on.
In this way, each classical flow chart can be transformed into an equivalent (though much larger)
flow chart that uses no variables. After such a transformation, each conditional branch has a
predetermined outcome, and each assignment corresponds to a jump to the appropriate parallel
component. To illustrate this point, the expansion of the flow chart from Figure 1 is explicitly
shown in Figure 2. Here, the four entrance points of the expanded program correspond to the
four possible pairs of boolean inputs of the original program, and the four exit points correspond
to the four potential pairs of boolean outputs.
It is this connection between control and classical state, namely, the fact that a control edge
labeled with a tuple of classical variables can be replaced by a number of parallel control edges,
which we mean when we say “control is classical”. We will see later that a similar observation
does not apply to quantum data; quantum data is of a fundamentally different nature.
4.2. Probabilistic view of classical flow charts
Consider again the flow chart from Figure 2. We will describe an alternative view of its semantics. This time, imagine that one of the four possible entrance points 00, 01, 10, or 11 is
Towards a Quantum Programming Language
17
selected randomly, with respective probabilities A, B, C, and D. Then we can annotate, in a
top-down fashion, each edge of the flow chart with the probability that this edge will be reached.
In particular, any edge that is unreachable will be annotated with “0”. The resulting annotation
is shown in Figure 2. We find that the probabilities of the final outcomes 00, 01, 10, and 11
are A + C, B, D, and 0, respectively. In this way, each program gives rise to a function from
tuples of input probabilities to tuples of output probabilities. In our example, this function is
F (A, B, C, D) = (A + C, B, D, 0).
Note that our original reading of a flow chart, as a function from inputs to outputs, is completely subsumed by this probabilistic view. For instance, the fact that the input 11 is mapped to
10 is easily recovered from the fact that F (0, 0, 0, 1) = (0, 0, 1, 0).
In practice, it is usually preferable to think of a small number of variables rather than of a
large number of control paths. Therefore, we will of course continue to draw flow charts in the
style of Figure 1, and not in that of Figure 2. However, the preceding discussion of probabilities
still applies, with one modification: each edge that is labeled with n boolean variables should be
annotated by a tuple of 2 n probabilities, and not just a single probability.
4.3. Summary of classical flow chart components
The basic operations for boolean flow charts are summarized in Figure 3. Here, Γ denotes an
arbitrary typing context, and A and B denote tuples of probabilities with sum at most 1. If A and
B are tuples of equal length, we use the notation (A, B) to denote the concatenation of A and B.
We distinguish between the label of an edge and its annotation. A label is a typing context,
and it is part of the syntax of our flow chart language. An annotation is a tuple of probabilities,
and it is part of the semantics. We use the equality symbol “=” to separate labels from annotations. Thus, Figure 3 defines both the syntax and the semantics of the language. Note that the
statement of the rules makes use of the indexing convention of Section 3.2, because the order of
the probabilities in each tuple is determined by the lexicographical ordering of the corresponding
states.
There are four rules in Figure 3 that have not been discussed so far: “new” allocates a new
variable and initializes it to 0, “discard” deallocates a variable, “initial” creates an unreachable
control path (this was used e.g. in Figure 2), and “permute” is a dummy operation which allows us
to rearrange the variables in the current typing context. Note that the statement of the “permute”
rule uses the operation 2 φ on permutations which was defined in Section 3.2.
It is interesting to note that, although we have not imposed a block structure on the uses of
“new” and “discard”, the typing rules nevertheless ensure that every allocated variable is eventually deallocated, unless it appears in the output. Also note that the “initial” node is essentially a
0-ary version of “merge”.
Naturally, we will allow various kinds of syntactic sugar in writing flow charts that are not
directly covered by the rules in Figure 3. For instance, an assignment of the form b := c can be
regarded as an abbreviation for the following conditional assignment:
Peter Selinger
18
Allocate bit:
Assignment:
b : bit, Γ = (A, B)
Γ=A
b : bit, Γ = (A, B)
b := 0
new bit b := 0
b : bit, Γ = (A + B, 0)
b : bit, Γ = (A, 0)
b := 1
b : bit, Γ = (0, A + B)
Branching:
b : bit, Γ = (A, B)
b : bit, Γ = (A, B)
branch b
0
Γ = A+B
Merge:
Initial:
Γ=A
b : bit, Γ = (0, B)
Permutation:
b1 , . . . , bn : bit = A0 , . . . , A2n −1
Γ=B
◦
1
b : bit, Γ = (A, 0)
◦
Γ = A+B
permute φ
Γ=0
bφ(1) , . . . , bφ(n) : bit = A2φ (0) , . . . , A2φ (2n −1)
Fig. 3. Rules for classical flow charts
b, c : bit, Γ = (A, B, C, D)
branch c
b, c : bit, Γ = (A, 0, C, 0)
0
1
b := 0
b, c : bit, Γ = (A + C, 0, 0, 0)
b, c : bit, Γ = (0, B, 0, D)
b := 1
◦
b, c : bit, Γ = (0, 0, 0, B + D)
b, c : bit, Γ = (A + C, 0, 0, B + D)
4.4. Quantum flow charts
Quantum flow charts are similar to classical flow charts, except that we add a new type qbit
of quantum bits, and two new operations: unitary transformations and measurements. A unitary
transformation operates on one or more quantum bits; we write q ∗= S for the operation of
applying a unary quantum gate S to the quantum bit q. Note that this operation updates q; the
Towards a Quantum Programming Language
(a)
19
(b)
input p, q : qbit
input p, q : qbit
p, q : qbit
p, q : qbit =
measure p
0
p, q : qbit
q ∗= N
p, q : qbit =
p ∗= N
p, q : qbit
!
measure p
1
p, q : qbit
A B
C D
p, q : qbit
◦
p, q : qbit
output p, q : qbit
A 0
0 0
!
0
1
p, q : qbit =
q ∗= N
p, q : qbit =
N AN
0
∗
0
0
!
0 0
0 D
!
p ∗= N
p, q : qbit =
◦
p, q : qbit =
D 0
0 0
!
N AN ∗ + D 0
0
0
!
output p, q : qbit
Fig. 4. A simple quantum flow chart
notation is analogous to the notation b := 1 for classical assignment. For the application of a
binary quantum gate S to a pair p, q of quantum bits, we use the notation p, q ∗= S, and so forth
for gates of higher arity. Sometimes we also use special notations such as q ⊕= 1 for q ∗= N ,
and q ⊕= p for p, q ∗= N c , where N and N c are the not- and controlled not-gate, respectively.
The second new operation, the measurement, is a branching statement since it can have two
possible outcomes.
Note that we give the name qbit to the type of qubits, thus dropping the letter “u”. We do
this for the sake of brevity. Note that there is a long tradition in computer science of such abbreviations; for instance, many programming languages use bool for the type of booleans, thus
dropping the final “e” from George Boole’s name.
As a first example, consider the simple flow chart shown in Figure 4(a). This program fragment
inputs two quantum bits p and q, measures p, and then performs one of two possible unitary
transformations depending on the outcome of the measurement. The output is the modified pair
p, q.
The behavior of a quantum flow chart can be described as a function from inputs to outputs.
For instance, in the flow chart of Figure 4(a), the input |00i leads to the output |01i, and the input
√1 |00i+ √1 |01i leads to the output √1 |00i+ √1 |01i. However, due to the probabilistic nature
2
2
2
2
of measurement, the output is not always a pure state: for example, the input √12 |00i + √12 |10i
will lead to the outputs |00i or |01i with equal probability. We can represent this outcome by
the mixed state 12 {|00i} + 12 {|01i}.
As the example shows, the output of a quantum flow chart is in general a mixed state. We may
take the input to be a mixed state as well. Thus, the semantics of a quantum flow chart is given as
a function from mixed states to mixed states. To calculate this function, let us use density matrix
Peter Selinger
20
notation, and let us assume that the input to the program is some mixed state
A B
M=
,
C D
where each of A, B, C, D is a 2 × 2-matrix. Recall that the indexing convention of Section 3.2
prescribes that the rows and columns of M are indexed by the basic states 00, 01, 10, and 11
in this respective order. We can now decorate the flow chart in top-down fashion, by annotating
each edge with the mixed state that the program is in when it reaches that edge. The resulting
annotation is shown in Figure 4(b). The semantics of the entire program fragment is thus given
by the following function of density matrices:
A B
N AN ∗ + D 0
F
=
.
C D
0
0
Note that we have followed our usual convention of normalizing all density matrices so that
their trace equals the probability that the corresponding edge is reached. This convention has
several nice properties: First and foremost, it ensures that the annotation of each edge is a linear function of the input. In particular, the merge operation (the joining of two control edges)
amounts to a simple matrix addition. The normalization convention also implies that the traces
of the matrices along any horizontal section of the flow chart add up to 1 (assuming that the trace
of the input matrix is 1).
Another interesting observation about the program in Figure 4 is that if the input is a pure
state, then the states along each of the two branches of the measurement continue to be pure.
Unitary transformations also preserve pure states. It is finally the merge operation, denoted by a
small circle “◦”, which combines two pure states into an impure state. Thus, the source of impure
states in a quantum system is not the measurement operation (as one might have thought), but
rather the merge operation, i.e., the erasure of classical information.
4.5. Summary of quantum flow chart operations
The operations for basic quantum flow charts are summarized in Figure 5. As before, we distinguish between the label of an edge and its annotation. The label is a typing context Γ, and
it is part of the syntax of the language. The annotation is a density matrix, and it is part of the
semantics. Quantum bits can be allocated and discarded; here it is understood that allocating a
quantum bit means to request an unused quantum bit from the operating system. Such newly
allocated quantum bits are assumed to be initialized to |0i. Unitary transformations and measurement were discussed in the previous section, and “merge”, “initial”, and “permute” are as for
classical flow charts. The permutation rule again uses the notation 2 φ from Section 3.2.
4.6. Detour on implementation issues
We briefly interrupt our description of quantum flow charts to contemplate some possible implementation issues. It is understood that no actual quantum hardware currently exists; thus any
discussion of implementations is necessarily speculative. But as outlined in the introduction, it
is useful to keep in mind a hypothetical hardware device on which the language can be implemented. Following Knill (1996), we imagine that practical quantum computing will take place on
Towards a Quantum Programming Language
Allocate qubit:
21
Unitary transformation:
q̄ : qbit, Γ = A
Γ=A
q̄ ∗= S
new qbit q := 0
!
A 0
0 0
q : qbit, Γ =
q̄ : qbit, Γ = (S ⊗ I)A(S ⊗ I) ∗
Measurement:
q : qbit, Γ =
A B
C D
!
q : qbit, Γ =
A B
C D
!
measure q
q : qbit, Γ =
Γ = A+D
Merge:
Initial:
Γ=A
0
1
q : qbit, Γ =
0 0
0 D
!
Permutation:
q1 , . . . , qn : qbit = (aij )ij
Γ=B
◦
A 0
0 0
!
◦
Γ = A+B
permute φ
Γ=0
qφ(1) , . . . , qφ(n) : qbit = (a2φ (i),2φ (j) )ij
Fig. 5. Rules for quantum flow charts
a QRAM machine, which consists of a general-purpose classical computer controlling a special
quantum hardware device which provides a bank of individually addressable quantum bits. The
classical computer determines the sequence of elementary quantum operations (built-in unitary
gates and measurements) to be performed by the quantum device.
To make the quantum device available to user programs, we further imagine that the operating
system provides a number of services. One of these services is access control. The operating
system keeps a list of quantum bits that are currently in use by each process. When a process
requests a new qubit, the operating system finds a qubit that is not currently in use, marks that
qubit as being in use by the process, initializes the contents to |0i, and returns the address of
the newly allocated qubit. The process can then manipulate the qubit, for instance via operating
system calls which take the qubit’s address as a parameter. The operating system ensures that
processes cannot access qubits that are not currently allocated to them – this is very similar to
classical memory management. Finally, when a process is finished using a certain qubit, it may
deallocate it via another operating system call; the operating system will then reset the qubit to
|0i, and mark it as unused.
In practice, there are many ways of making this scheme more efficient, for instance by dividing
the available qubits into regions, and allocating and deallocating them in blocks, rather than indi-
Peter Selinger
22
vidually. However, for the purpose of this theoretical discussion, we are not too concerned with
such implementation details. What is important is the interface presented to user programs by
the operating system. In particular, the above discussion is intended to clarify the operations of
“allocating” and “discarding” qubits; clearly, these concepts do not refer to physical acts of creation and destruction of qubits, but rather to access control functions performed by the operating
system.
We have mentioned several instances in which the operating system resets or initializes a
qubit to 0. This is indeed possible, and can be implemented by first measuring the qubit, and
then performing a conditional “not” operation dependent on the outcome of the measurement.
The following program fragment illustrates how an arbitrary qubit q can be reset to 0:
q : qbit, Γ =
measure q
0
q : qbit, Γ =
A 0
0 0
1
A
C
q : qbit, Γ =
q ⊕= 1
q : qbit, Γ =
◦
q : qbit, Γ =
B
D
0 0
0 D
D
0
A+D
0
0
0
0
0
4.7. Combining classical data with quantum data
We observed in Section 4.1 that classical data can be equivalently viewed in terms of control
paths. Since our quantum flow charts from Section 4.4 already combine quantum data with control paths, there is nothing particularly surprising in the way we are going to combine classical
data with quantum data. The combined language has two data types, bit and qbit. Typing contexts are defined as before. For the semantics, observe that an edge which is labeled with n
bits and m qubits can be equivalently replaced by 2 n edges which are labeled with m qubits
only. Thus, a state for a typing context Γ containing n bits and m qubits is given by a 2 n -tuple
(A0 , . . . , A2n −1 ) of density matrices, each of dimension 2 m × 2m . We extend the notions of
trace, adjoints, and matrix multiplication to tuples of matrices as follows:
P
tr(A0 , . . . , A2n −1 )
:=
i tr Ai ,
(A0 , . . . , A2n −1 )∗
:= (A∗0 , . . . , A∗2n −1 ),
S(A0 , . . . , A2n −1 )S ∗ := (SA0 S ∗ , . . . , SA2n −1 S ∗ ).
We often denote tuples by letters such as A, B, C, and as before, we use the notation (A, B)
for concatenation of tuples, if A and B have the same number of components. If A, B, C, D are
tuples of matrices of identical dimensions, then we write
A B
C D
Towards a Quantum Programming Language
23
Ai Bi
, where Ai is the ith component of A
to denote the tuple whose ith component is
Ci Di
etc. In this way, we use componentwise notation both along the “tuple dimension” and along the
“matrix dimension”.
Flow charts are acyclic graphs whose edges are labeled with typing contexts, and whose nodes
are of the types shown in Figures 3 and 5. A flow chart may have any number of global incoming
(input) and outgoing (output) edges.
An annotation of a flow chart is an assignment of a matrix tuple to each edge, consistent with
the rules of Figures 3 and 5. Here it is now understood that A, B, C, D denote matrix tuples of
the correct dimensions determined by the corresponding typing context. For reasons that will be
explained in Section 5.3, we allow flow charts to be annotated with arbitrary matrices, and not
just density matrices.
The annotation of a flow chart is uniquely determined by the annotation of its input edges, and
can be calculated in a top-down fashion. The semantics of a flow chart is given by the function
which maps each annotation of the input edges to the resulting annotation of the output edges.
By inspecting the rules in Figures 3 and 5, we observe that this function is necessarily linear.
Moreover, it takes adjoints to adjoints, and thus it preserves hermitian matrix tuples. Moreover,
this function preserves positivity, and it preserves trace, in the sense that the sum of the traces
of the inputs is equal to the sum of the traces of the outputs. Intuitively, the last property reflects
the fact that the probability of entering a program fragment is equal to the probability of leaving
it. When we introduce loops into the flow chart language in Section 5, we will see that the trace
preservation property no longer holds: in the presence of loops, some programs have a non-zero
probability of non-termination. For such programs, the trace of the outputs will in general be less
than the trace of the inputs.
Remark. By working with tuples of matrices, we separate the classical data (“tuple dimension”)
from the quantum data (“matrix dimension”). Formally, it is possible to suppress this distinction by identifying a tuple of matrices (A 0 , . . . , Ak−1 ) with the single block matrix which has
A0 , . . . , Ak−1 along the diagonal, and 0 everywhere else. This notation would leave all our operations well-defined, but would incur the additional overhead of having to state explicitly which
matrix entries are assumed to be 0. This is analogous to the situation in functional analysis, where
an algebra of functions may be represented as an algebra of commuting diagonal operators. However, we do not currently find a conceptual or formal advantage in working with block matrices,
and thus we stick to the “tuples of matrices” formulation.
4.8. Static typing and the no-cloning property
By the well-known no-cloning property, it is not possible to duplicate a quantum bit, i.e., there is
no physically meaningful operation which maps α |0i+β |1i to (α |0i+β |1i)⊗(α |0i+β |1i).
Semantically, this is immediately clear, as this operation is not linear in α and β, and thus can
never be the denotation of any quantum flow chart. One interesting feature of our formulation
of quantum flow charts is that cloning is prohibited by the syntax, which means that compliance
with the no-cloning property can be checked statically when the program is written, rather than
when it is run. This is an improvement over other formalisms (Knill 1996; Ömer 1998; Sanders
and Zuliani 2000; Bettelli, Calarco, and Serafini 2001), where cloning is syntactically allowed
Peter Selinger
24
(via duplication of a reference to a qubit), but can lead to errors at run-time (for instance when a
unitary operation is applied to multiple copies of the same qubit).
Formally, our system has the property that within any given typing context, syntactically distinct variables refer to distinct objects at run-time. In particular, in the rule for unitary transformations in Figure 5, q̄ stands for a list of distinct variables. This takes care of the requirement that
“multi-qubit operations need distinct physical locations”, in the words of Bettelli et al. (2001,
footnote 9). As a consequence, a well-typed program in our language can never produce a runtime error. This property remains true in the presence of loops and recursion, which will be
introduced in Section 5, and in the presence of structured types, which will be introduced in
Section 7.3.
4.9. Examples
We give some examples of flow charts that can be built from the basic components.
Example 4.1. The first example shows how a probabilistic fair coin toss can be implemented,
i.e., a branching statement which selects one of two possible outcomes with equal probability.
Γ=A
new qbit q := 0
A 0
0 0
q ∗= H
A A
q : qbit, Γ = 12
A A
measure q
A 0
0 0
1
1
0
1
q : qbit, Γ = 2
q : qbit, Γ = 2
0 0
0 A
q : qbit, Γ =
Γ = 21 A
Γ = 21 A
Here, H is the Hadamard matrix introduced in Section 3.3. Coin tosses with probabilities other
than 12 can be implemented by replacing H with some other appropriate unitary matrix.
Towards a Quantum Programming Language
25
Example 4.2. The next example shows the correctness of a program transformation: a measurement followed by deallocation is equivalent to a simple deallocation.
A B
A B
q : qbit, Γ =
q : qbit, Γ =
C D
C D
measure q
1
0
A 0
0 0
q : qbit, Γ =
q : qbit, Γ =
0 0
0 D
◦
A 0
q : qbit, Γ =
0 D
Γ=A+D
Γ=A+D
The correctness of this program transformation is of course due to the fact that the “discard”
operation already has an implicit measurement built into it.
Example 4.3. This example shows how to define a “rename” operation for renaming a variable
of type qbit. The given implementation is not very efficient, because it involves the application of
a quantum gate. In practice, a compiler might be able to implement such renamings by a pointer
operation with minimal runtime cost.
q : qbit, Γ = A
new qbit p := 0
q : qbit, Γ = A
rename p ← q
p ⊕= q
is definable as
q ⊕= p
p : qbit, Γ = A
p : qbit, Γ = A
Of course, variables of type bit can be similarly renamed. We will from now on use the rename
operation as if it were part of the language.
Example 4.4. This example formalizes a point that was made in Section 4.1: a control edge labeled with a classical bit is equivalent to two parallel control edges. In other words, the following
two constructions are mutually inverse:
Γ=A
b : bit, Γ = (A, B)
Γ=B
new bit b := 0
new bit b := 1
branch b
0
b : bit, Γ = (A, 0)
◦
b : bit, Γ = (0, B)
b : bit, Γ = (A, B)
b : bit, Γ = (A, 0)
Γ=A
1
b : bit, Γ = (0, B)
Γ=B
Peter Selinger
26
Example 4.5. This example shows that if a program fragment X has an outgoing edge which
is reached with probability 0, then this edge can be eliminated. Here we have used an obvious
abbreviation for multiple “discard” and “new” nodes.
X
Γ=0
Γ0 = A
∅=0
new Γ0
Γ0 = 0
◦
Γ0 = A
Example 4.6. The next example shows something more interesting: it is possible to collapse
a quantum bit q by means of a coin toss, without actually measuring q. The coin toss can be
implemented as in Example 4.1. Let Γ = q : qbit, Γ 0 .
Γ=
A B
C D
coin toss
0
Γ=
1
2
A B
C D
1
1
2
A B
C D
Γ=
A B
C D
measure q
Γ=
1 0
q ∗=
0 −1
A −B
1
Γ= 2
−C
◦
D
A 0
Γ=
0 D
0
Γ=
A 0
0 0
1
Γ=
◦
Γ=
0 0
0 D
A 0
0 D
This example shows that it is possible for two programs to have the same observable behavior,
despite the fact that their physical behavior is obviously different. In particular, the correctness
of the left program depends critically on the fact that the outcome of the coin toss is “forgotten”
when the two control paths are merged.
To understand this example, it is helpful to consider what each of these programs would do
9
12
when run in the pure state uu ∗ , where u = 35 |0i + 45 |1i. In this case, A = 25
, B = C = 25
,
16
and D = 25 . The left program will leave the state unchanged with probability1/2, and perform
a phase
change with
probability 1/2. Thus, it ends up in the mixed state 21 53 |0i + 54 |1i +
4
1 3
2 5 |0i − 5 |1i . The right program simply measures the qubit, leading to the mixed state
16
9
25 {|0i} + 25 {|1i}. The point of the example is that these two different mixed states correspond
Towards a Quantum Programming Language
27
to the same density matrix, and thus they are indistinguishable:

9
1  25
2 12
12
25
16
25 25

1
+ 
2

−12
9
25
25
−12 16
25
25


=
9
25
0
0
16
25

,

 



9
0
9  1 0  16  0 0   25

+
=
16
25 0 0
25 0 1
0 25
Note that, if the outcome of the coin toss is known to some outside observer (e.g., to someone
who has been eavesdropping), then it is possible, for this outside observer, to restore the initial
state of the left program from its final state, simply by undoing the conditional unitary operation.
On the other hand, the initial state of the right program is irretrievably lost after the measurement.
This apparent paradox is due to the fact, as discussed in Section 3.5, that a mixed state is a
description of our knowledge of a physical state, rather than of a physical state itself. The two
program fragments are equivalent in the sense that they will behave in the same way as part of
any larger program, not in the sense that they cannot be distinguished by an outside observer with
privileged knowledge. It is precisely for this reason that the theory of quantum communication,
i.e., of quantum programs which interactive input and output, is much more complicated than the
theory of closed-world programs considered in this paper.
Example 4.7. This example shows that the discarding of a quantum bit can always be postponed.
Thus, the following two flow charts are equivalent, provided that X is a flow chart not containing
q:
q : qbit, Γ1
···
Γ1
q : qbit, Γn
Γn
X
∆1
···
q : qbit, Γ1 · · ·
X
q : qbit, ∆1
∆m
q : qbit, Γn
∆1
···
q : qbit, ∆m
∆m
This can be easily shown by induction on flow charts. Note that this observation implies that
there is effectively no difference between “discarding” a quantum bit and simply “forgetting”
the quantum bit (by dropping any reference to it). In particular, it is not observable whether
a “forgotten” quantum bit has been collapsed or not. This is true even if the quantum bit was
entangled with other data in the computation — but only as long as no information about the
collapsed quantum bit is leaked back to the program, not even via a third party such as the
operating system. Because of the possibility of such unintended leaks, the discard operation
should in practice always be implemented via an explicit collapse of the kind discussed at the
end of Section 4.6.
Peter Selinger
28
5. Loops, procedures, and recursion
5.1. Loops
A loop in a flow chart is constructed as in the following illustration:
(∗) . . .
X
(∗∗) . . .
Here X stands for an arbitrary flow chart fragment with n + 1 incoming and m + 1 outgoing
edges. After adding the loop, there are n incoming and m outgoing edges left. The semantics of
loops is initially defined by “infinite unwinding”. The above loop is unwound as follows:
(∗) A
◦
X
F21 (A)
◦
F11 (A)
X
◦
F22 F21 (A)
◦
F11 (A) + F12 F21 (A)
X
◦.
..
F22 F22 F21 (A)
..
.
(∗∗) G(A)
Here, we have simplified the typesetting by representing potential multiple parallel control
edges by a single line. Thus, A = (A 1 , . . . , An ) denotes a tuple of input matrices. We can
decorate the unwound diagram with states in the usual top-down fashion. Specifically, suppose
that the semantics of X is given by the linear function F (A 1 , . . . , An , B) = (C1 , . . . , Cm , D).
We can split this function into four components F 11 , F12 , F21 , and F22 such that F (A, 0) =
(F11 (A), F21 (A)) and F (0, B) = (F12 (B), F22 (B)). Then we can label the states of the unwound loop diagram as shown in the illustration above. We find that the state at the edge (or
tuple of edges) labeled (∗∗) is given by the infinite sum
G(A) = F11 (A) +
∞
X
i
F12 (F22
(F21 (A))).
(1)
i=0
This formula is similar to the execution formula of Girard’s Geometry of Interaction (Girard
Towards a Quantum Programming Language
(a)
Proc1:
29
(b)
input p, q : qbit
a : qbit
p, q : qbit
◦
a : qbit
p, q ∗= S
p, q : qbit
new qbit b := 0
a, b : qbit
measure p
0
1
p, q : qbit
p, q : qbit
output1 p, q : qbit
q : qbit
output2 q : qbit
a : qbit
input a, b
Proc1
output1 c, d
output2 a
c, d : qbit
Fig. 6. A procedure and a procedure call
1989). We will see in Section 6 that this sum indeed always converges. Furthermore, if A is
positive, then so is G(A), and tr G(A) 6 tr A.
An interesting point is that the inequality of traces may be strict, i.e., it is possible that
tr G(A) < tr A. This can happen if there is a non-zero probability that the loop may not terminate. In this case, the probability that the program reaches state (∗∗) is strictly less than the
probability that it reaches state (∗).
Note that the formula (1) allows us to calculate the semantics of the loop directly from the
semantics of X, without the need to unwind the loop explicitly. This is an example of a compositional semantics, which we will explore in more detail in Section 6.
5.2. Procedures
A procedure is a flow chart fragment with a name and a type. Consider for example the procedure
Proc1 defined in Figure 6(a). This procedure has one entrance and two possible exits. The input
to the procedure is a pair of qubits. The output is a pair of qubits when exiting through the first
exit, or a single qubit when exiting through the second exit. The type of the procedure captures
this information, and it is
Proc1 : qbit × qbit → qbit × qbit; qbit.
Here, it is understood that “×” binds more tightly than “;”. In general, the type of a procedure
is of the form Γ̄ → Γ̄0 , where Γ̄, Γ̄0 are lists of products of basic types. Most procedures have a
single entrance and a single exit, but there is no general reason why this should be so; we allow
procedures with multiple entrances as well as multiple exits.
Figure 6(b) shows an example of a call to the procedure Proc1 just defined. The example illustrates several points. The procedure call respects the type of the procedure, in the sense that it
has as many incoming and outgoing edges as the procedure, and the number and type of parameters matches that of the procedure. The actual parameters are named inside the procedure call
Peter Selinger
30
box. The order of the parameters is significant, and they are subject to one important restriction:
the parameters corresponding to any one procedure entrance or exit must be distinct. Thus, we
cannot for instance invoke Proc1 with parameters (a, a).
We do not require that the names of the actual parameters match those of the formal parameters. For instance, in Figure 6, the actual parameters a, b correspond to the formal parameters p, q
in the input of the procedure. We do not even require that the actual parameters must match the
formal parameters consistently: for instance, the formal parameter q corresponds to the actual
parameter b in the input, but to a in the second output. This is not important, as the compiler can
implicitly insert renaming operations as in Example 4.3.
In general, a procedure may be called in a context which contains other variables besides
those that are parameters to the procedure call. For instance, the procedure of Figure 6(a) can be
invoked in the presence of an additional typing context Γ as follows:
a, b : qbit, Γ
input a, b
Proc1
output1 c, d
c, d : qbit, Γ
output2 a
a : qbit, Γ
Here, the set Γ of unused variables must be identical for all inputs and outputs of the procedure
call. Intuitively, the variables in Γ are “not changed” by the procedure call; however, in reality, the
behavior is more subtle because some of the variables from Γ might be quantum entangled with
the procedure parameters, and thus may be indirectly affected by the procedure call. However,
we will see that the semantics of procedure calls is nevertheless compositional; i.e., once the
behavior of a procedure is known in the empty context, this uniquely determines the behavior in
any other context.
5.3. Context extension
Before we can fully describe the semantics of procedure calls, we first need to explore the concept of context extension, by which we mean the addition of dummy variables to a flow chart.
Recall that the semantics of a flow chart X is given by a linear function F from matrix tuples to
matrix tuples, as discussed in Section 4.7. This situation is shown schematically in Figure 7(a). In
general, X may have several incoming and outgoing control edges, but for simplicity we consider
the case where there is only one of each.
Now suppose that we modify the flow chart X by picking a fresh boolean variable b and
adding it to the context of all the edges of X. The result is a new flow chart X b , which is
schematically shown in Figure 7(b). We claim that the semantics of the modified flow chart X b
is given by G(A, B) = (F (A), F (B)). This is easily proved by induction on flow charts: all the
basic components have this property, and the property is preserved under horizontal and vertical
Towards a Quantum Programming Language
(a)
(b)
Γ=A
X
Γ0 = F (A)
31
(c)
b : bit, Γ = (A, B)
Xb
b : bit, Γ0 = (F (A), F (B))
q : qbit, Γ =
A B
C D
!
Xq
0
q : qbit, Γ =
F (A) F (B)
F (C) F (D)
!
Fig. 7. Context extension
composition and under the introduction of loops. Intuitively, since the variable b does not occur
in X, its value is neither altered not does it affect the computation of F .
Analogously, we can modify X by adding a fresh quantum variable q to all its edges, as shown
schematically in Figure 7(c). Then the semantics of the modified chart X q is given by the function
A B
F (A) F (B)
G
=
.
C D
F (C) F (D)
This, too, is easily proved by induction.
Remark 5.1.
At this point, we should make the following interesting observation. Note that, if
A B
is a density matrix, then so are A and D, but not necessarily B and C. In fact, up
C D
to a scalar multiple, B may be completely arbitrary. If the function F had been defined only on
density matrices, then F (B) and F (C) would be in general undefined, and thus, G would be
undefined. This is the reason why, in Section 4.7, we defined the semantics of a flow chart to be
a function on arbitrary matrices, and not just on density matrices, as one might have expected.
However, this remark is only of notational, not of fundamental, importance. By Remark 2.1,
the density matrices span C n×n as a complex vector space. Since F is a linear function, this
implies that F is already determined by its value on density matrices. Thus, the fact that F is
given as a function on all matrices conveys no additional information.
5.4. Semantics of non-recursive procedure calls
The intended semantics of a non-recursive procedure call is that of “inlining”: a procedure call
should behave exactly as if the body of the procedure was inserted in its place. Before the procedure body can be inserted, it needs to be transformed in two steps: first, appropriate renamings
(as in Example 4.3) need to be inserted to match the formal parameters with the actual ones.
Second, the context of the procedure body needs to be extended in the sense of Section 5.3, i.e.,
all variables in the context of the procedure call that are not parameters must be added as dummy
variables to the procedure body. If necessary, the local variables of the procedure body must be
renamed to avoid name clashes with these dummy variables.
The semantics of a procedure call can be computed compositionally, i.e., without having to
do the actual inlining. Namely, the renaming step does not affect the semantics at all, and the
semantics of the context extension step can be computed as in Section 5.3.
Peter Selinger
(a)
X:
32
(b)
input p, q : qbit
X:
input p, q : qbit
p, q : qbit
p, q : qbit
measure p
measure p
0
0
1
1
p, q : qbit
new qbit r := 0
new qbit r := 0
p, q : qbit
p, q, r : qbit
p, q : qbit
p, q : qbit
p, q, r : qbit
q, r ∗= Hc
q, r ∗= Hc
p, q, r : qbit
p, q, r : qbit
measure q
input q, r
0
1
X
new qbit s := 0
output q, r
p, q, r, s : qbit
p, q, r : qbit
p, q, r : qbit
r, s ∗= Hc
q ⊕= r
p, q, r, s : qbit
p, q, r : qbit
···
p, q, r, s : qbit
◦
p, q, r : qbit
r ⊕= s
p, q : qbit
p, q, r, s : qbit
p, q : qbit
output p, q : qbit
p, q, r : qbit
◦
p, q, r : qbit
q ⊕= r
p, q, r : qbit
◦
p, q : qbit
p, q : qbit
output p, q : qbit
Fig. 8. A recursive procedure and its unwinding
5.5. Recursive procedures
A procedure is recursive if it invokes itself, either directly or indirectly. An example of a recursive
procedure is shown in Figure 8(a). Before reading on, the reader is invited to figure out what this
procedure does.
The intended semantics of recursive procedures is given by infinite unwinding, similar to the
way we treated loops. Unwinding the procedure X from Figure 8(a) yields the infinite flow chart
Towards a Quantum Programming Language
33
shown in Figure 8(b). This example demonstrates that the unwinding of a recursive procedure
may lead to a flow chart with an unbounded number of variables, as new local variables are introduced at each level of nesting. The typing conventions enforce that such qubits will eventually
be deallocated before the procedure returns.
To compute the semantics of a recursive procedure, we could, in principle, annotate its infinite
unwinding with states just as we did for loops. However, since the number of variables keeps
increasing with each nesting level, this would require writing an infinite number of larger and
larger matrices, and the computation of the resulting limits would be rather cumbersome. Therefore, we skip the explicit annotation and move on to a more denotational (and more practical)
approach to calculating the semantics of X.
To find a good description of the unwinding process, let us write X(Y ) for the flow chart which
is the same as X, except that it has another flow chart Y substituted in place of the recursive call.
We can then define the ith unwinding of X to be the flow chart Y i , where Y0 is a non-terminating
program, and Y i+1 = X(Yi ).
Now let us write Fi for the semantics of the flow chart Y i just defined. By compositionality,
the semantics of X(Y ) is a function of the semantics of Y . If Φ denotes this function, then we
can recursively compute F i for all i via the clauses F 0 = 0 and Fi+1 = Φ(Fi ). Finally, it is
natural to define the semantics of X to be the limit of this sequence,
G = lim Fi .
(2)
i→∞
The existence of this limit will be justified in Section 6. For now, let us demonstrate the use of
this method by computing the denotation of the sample flow chart from Figure 8. If A = (a ij )ij ,
then we find






a00 a01 0
0
a00 a01 0 0
a00 a01 0 0
0
0 
0 0
a a 0 0
a a
a a
F1 (A) =  010 011 0 0 , F2 (A) =  010 011 a 0 , F3 (A) =  010 011 a
0 ,
22
22
1
0 0 00
0 0 0 0
0 0 0 2 a33
a00
 a10
F4 (A) =  0
0

a01
0
a11
0
0 a22 + 14 a33
0
0


a00
0
0 
 a10
0 , F5 (A) =  0
1
0
2 a33
a01
0
a11
0
0 a22 + 41 a33
0
0
a00
 a10
F6 (A) =  0
0
a01
0
a11
0
0 a22 + 41 a33 +
0
0

0
0

,
0
1
1
2 a33 + 8 a33

1
16 a33
and so forth. The limit is
a00
 a10
G(A) =  0
0

a01
0
a11
0
0 a22 + 13 a33
0
0

0
0 
0 ,
2
3 a33

0
0

,
0
1
1
2 a33 + 8 a33
and this is the denotation of X. Note that, in this example, tr G(A) = tr A, which means this
particular procedure terminates with probability 1. In general, it is possible that tr G(A) < tr A.
Peter Selinger
34
(b)
(a)
(c) A :
◦
X
X
A
◦
A
◦
Fig. 9. Loops from recursion
5.6. Recursion vs. loops
It is possible to encode loops in terms of recursion. Namely, the loop in Figure 9(a) can be
expressed as the procedure call (b), where A is defined recursively as in (c). On the other hand,
recursion cannot in general be encoded in terms of loops. This is because recursive procedures
can allocate an unbounded number of variables.
6. Formal semantics
In this section, we give a more systematic and formal treatment of the semantics of quantum
flow charts. We justify the well-definedness of the various constructions that were introduced
informally in Sections 4 and 5, and in particular the existence of the limits in equations (1) and
(2). We also consider a more abstract view of the semantics in terms of CPO-enriched traced
monoidal categories.
6.1. Signatures and matrix tuples
As outlined informally in Section 4.7, the denotation of a flow chart is given as a certain linear
function from matrix tuples to matrix tuples. We begin our formal semantics by defining the
spaces of such matrix tuples.
A signature is a list of non-zero natural numbers σ = n 1 , . . . , ns . To each signature we associate a complex vector space
Vσ = Cn1 ×n1 × . . . × Cns ×ns .
The elements of Vσ are tuples of matrices of the form A = (A 1 , . . . , As ), where the number and
dimensions of the matrices A i are determined by σ. As before, we often use the letters A, B, . . .
to denote elements of V σ . We define the trace of a matrix tuple to be the sum of the traces of its
components:
P
tr A :=
i tr Ai .
We say that a matrix tuple A ∈ Vσ is hermitian (respectively, positive) if A i is hermitian (respectively, positive) for all i. We define the set D σ ⊆ Vσ of density matrix tuples to be the obvious
generalization of the set D n of density matrices:
Dσ = {A ∈ Vσ | A positive hermitian and tr A 6 1}.
Towards a Quantum Programming Language
35
We extend the Löwner partial order to matrix tuples by letting A v B if B − A is positive.
This makes Dσ into a complete partial order with least element 0. Completeness follows from
Proposition 3.6, together with the fact that D σ is a closed subset of Dn1 × . . . × Dns .
Definition (Special signatures). Several signatures have special names; we write
bit = 1, 1
qbit = 2
I = 1
0 = (the empty list)
We call a signature simple if it is a singleton list. Thus, for example, qbit and I are simple,
whereas bit and 0 are not.
6.2. The category V
Definition. The category V has as its objects signatures σ = n 1 , . . . , ns . A morphism from σ
to σ 0 is any complex linear function F : V σ → Vσ0 .
Note that V, as a category, is equivalent to the category of finite dimensional complex vector
spaces. However, we will later use the additional, non-categorical structure on objects to define
an interesting subcategory Q which has fewer isomorphic objects than V.
Let σ ⊕ σ 0 denote concatenation of signatures. Then σ ⊕ σ 0 is a product and coproduct in V,
with the obvious injection and projection maps. The co-pairing map [F, G] : σ ⊕ σ 0 → τ is
given by [F, G](A, B) = F (A) + G(B), and the pairing map hF, Gi : σ → τ ⊕ τ 0 is given by
hF, Gi(A) = (F A, GA). The neutral object for this biproduct is the empty signature 0.
Tensor product. If σ = n 1 , . . . , ns and τ = m1 , . . . , mt are signatures, their tensor product
σ ⊗ τ is defined as
σ ⊗ τ = n 1 m1 , . . . , n 1 mt , . . . , n s m1 , . . . , n s mt .
Note that the components of σ ⊗ τ are ordered lexicographically. The operation ⊗ extends to a
symmetric monoidal structure on V with unit I = 1. The morphism part of the tensor product
is defined as in the category of vector spaces; thus, if F : σ → τ and G : σ 0 → τ 0 , then
F ⊗G : σ⊗σ 0 → τ ⊗τ 0 is defined on a basis element A⊗B via (F ⊗G)(A⊗B) = F (A)⊗G(B),
and extends to arbitrary elements by linearity. We note that this monoidal structure is strict (i.e.,
the associativity and unit morphisms are identity maps, rather than just isomorphisms). We also
have the following strict distributivity law:
(σ ⊕ σ0 ) ⊗ τ = (σ ⊗ τ ) ⊕ (σ 0 ⊗ τ ).
6.3. Superoperators
Definition (Completely positive operator, superoperator). Let F : V σ → Vσ0 be a linear
function. We say that F is positive if F (A) is positive for all positive A ∈ V σ . We say that F
is completely positive if idτ ⊗ F : Vτ ⊗σ → Vτ ⊗σ0 is positive for all signatures τ . Finally, F
Peter Selinger
36
is called a superoperator if it is completely positive and satisfies the following trace condition:
tr F (A) 6 tr A, for all positive A ∈ Vσ .
Remark 6.1. In the physics literature, superoperators are usually assumed to be trace preserving,
i.e., satisfying tr F (A) = tr A for all A (see e.g. (Preskill 1998)). In our setting, it is appropriate
to relax this condition in view of possible non-termination of programs.
Example 6.2. To illustrate the concept of a completely positive operator, consider the following
three linear maps Fi : V2 → V2 .
a b
a 2b
a b
a c
a b
a 0
F1
=
,
F2
=
,
F3
=
.
c d
2c d
c d
b d
c d
0 d
All three maps are linear, and thus morphisms in V. Also, all three maps preserve trace and
hermitian matrices. F1 is not positive, because it maps a positive matrix to a non-positive matrix:
1 1
1 2
F1
=
.
1 1
2 1
F2 is positive, but not completely positive. While F 2 maps positive matrices to positive matrices,
the same is not true for id 2 ⊗ F2 , for instance,

 

1 0 0 1
1 0 0 0
 0 0 0 0   0 0 1 0 
 

(id2 ⊗ F2 )
 0 0 0 0  =  0 1 0 0 ,
1 0 0 1
0 0 0 1
which is not positive. Finally, F 3 is completely positive.
As we will see in Section 6.9, superoperators are precisely the functions which arise as the
denotations of quantum programs.
Lemma 6.3. The following hold in the category V:
(a) Identity morphisms are superoperators, and superoperators are closed under composition.
(b) The canonical injections in 1 : σ → σ ⊕ σ0 and in2 : σ 0 → σ ⊕ σ 0 are superoperators, and if
F : σ → σ0 and G : τ → σ 0 are superoperators, then so is [F, G] : σ ⊕ τ → σ 0 .
(c) If F : σ → σ 0 and G : τ → τ 0 are superoperators, then so are F ⊕ G : σ ⊕ σ 0 → τ ⊕ τ 0 and
F ⊗ G : σ ⊗ σ0 → τ ⊗ τ 0 .
(d) A morphism F : σ → σ 0 is completely positive if and only if id τ ⊗F is positive, for all simple
signatures τ .
(e) Let S be a unitary n × n-matrix. Then the morphism F : n → n defined by F (A) = SAS ∗
is a superoperator.
(f) Let S1 and S2 be n × n-matrices such that S 1∗ S1 + S2∗ S2 = I. Then the morphism F : n →
n, n defined by F (A) = (S 1 AS1∗ , S2 AS2∗ ) is a superoperator.
Proof. (a) and (b) are trivial. The first part of (c) follows from (b). For the second part of (c),
note that F ⊗ G = (idσ0 ⊗ G) ◦ (F ⊗ idτ ). The two component maps are completely positive by
definition, and they clearly satisfy the trace condition. For (d), only the right-to-left implication
is interesting. Any object τ can be written as a sum τ = τ 1 ⊕ . . . ⊕ τt of simple objects. Then by
distributivity, id τ ⊗ F = (idτ1 ⊗ F ) ⊕ . . . ⊕ (idτt ⊗ F ), which is positive by assumption and (c).
Towards a Quantum Programming Language
37
For (e), first note that if A is positive, then so is SAS ∗ , and tr SAS ∗ = tr A. Thus F is positive
and satisfies the trace condition. To see that it is completely positive, note that for any n and
identity n × n-matrix I, (id n ⊗ F )(A) = (I ⊗ S)A(I ⊗ S)∗ . But I ⊗ S is unitary, thus id n ⊗ F
is again of the same form as F , hence positive. By (d), it follows that F is a superoperator. For
(f), note that F preserves positivity and trace, thus F is positive. The fact that it is completely
positive follows as in (e).
6.4. The category Q
Definition. The category Q is the subcategory of V which has the same objects of V, and whose
morphisms are the superoperators.
By Lemma 6.3(a)–(c), Q is indeed a subcategory of V, and it inherits coproducts and the
symmetric monoidal structure from V. However, unlike V, the category Q does not have finite
products. This is because the diagonal morphism hid, idi : τ → τ ⊕ τ does not respect trace,
and hence it is not a superoperator. However, the two projections π 1 : σ ⊕ σ 0 → σ and π2 :
σ ⊕ σ 0 → σ 0 are present in Q.
Also note that the category Q distinguishes more objects than V; for instance, the objects
bit ⊕ bit = 1, 1, 1, 1 and qbit = 2 are isomorphic in V, but not in Q.
CPO-enrichment. Recall that D σ is the subset of Vσ consisting of density matrix tuples, i.e.,
of positive matrix tuples A with tr A 6 1. Every superoperator F : V σ → Vτ restricts to a
function F : Dσ → Dτ . We note that F respects the Löwner partial order: if A v B ∈ D σ , then
B = A+A0 for some A0 ∈ Dσ , and thus F (B) = F (A)+F (A0 ), which implies F (A) v F (B).
Also, F : Dσ → Dσ0 preserves least upper bounds of increasing sequences. This follows from
Remark 3.8 and the fact that F , as a linear function on a finite-dimensional vector space, is
continuous with respect to the usual Euclidean topology. Thus, we obtain a forgetful functor
D : Q → CPO, from Q to the category of complete partial orders, which maps σ to D σ and F
to itself.
If σ and σ 0 are objects of Q, we can also define a partial order on the hom-set Q(σ, σ 0 ), by
letting F v G if for all τ and all A ∈ D τ ⊗σ , (idτ ⊗ F )(A) v (idτ ⊗ G)(A).
Lemma 6.4. The poset Q(σ, σ 0 ) is a complete partial order.
Proof. Let F0 v F1 v . . . be an increasing sequence of morphisms in Q(σ, σ 0 ). Define
W
F : Dσ → Dσ0 as the pointwise limit: F (A) = i Fi (A). By Remark 3.8, F (A) is also the
topological limit F (A) = lim i→∞ Fi (A), and it follows by continuity that F is linear on the
convex subset D σ ⊆ Vσ . Since, by Remark 2.1, D σ spans Vσ , F can be extended to a unique
linear function F : Vσ → Vσ0 , i.e., to a morphism of V. F satisfies the trace condition and is
positive by construction. To see that it is completely positive, note that for any object τ and any
B ∈ Dτ ⊗σ , (τ ⊗ F )(B) = limi→∞ (τ ⊗ Fi )(B), and hence τ ⊗ F is positive for the same reason
as F . Thus, F : σ → σ 0 is a morphism of Q, and hence the desired least upper bound of (F i )i .
Also, the categorical operations (composition, co-pairing, and tensor) are Scott-continuous,
i.e., they preserve least upper bounds of increasing sequences. This makes Q into a CPOenriched category.
Peter Selinger
38
Trace. A monoidal trace on a monoidal category (Q, ⊕) is a natural family of operations
Trτσ,σ0 : Q(σ ⊕ τ, σ 0 ⊕ τ ) → Q(σ, σ0 ),
subject to a number of equations (Joyal, Street, and Verity 1996; Hasegawa 1997; Selinger 1999).
A monoidal category with a monoidal trace is called a traced monoidal category. A monoidal
trace is usually just called a “trace”, but we add the adjective “monoidal” here to avoid confusion
with the trace of a matrix as in Section 2.1.
The category Q is equipped with a monoidal trace for the monoid which is given by coproducts
⊕ (not for the tensor product ⊗). In fact, the construction of this monoidal trace is an instance of
a general construction which works in any CPO-enriched category with coproducts.
To define the monoidal trace of a morphism F : σ ⊕ τ → σ 0 ⊕ τ , we construct a family of
morphisms Hi : σ ⊕ τ → σ0 as follows. We let H0 = 0, the constant zero function. For all
i, we define Hi+1 = [idσ0 , Hi ◦ in2 ] ◦ F . Then H0 v H1 , because H0 is the least element in
the given partial order. By monotonicity of the categorical operations (a consequence of CPOenrichment), it follows that H i v Hi+1 for all i. Hence (H i )i is an increasing sequence. Let
W
H = i Hi : σ ⊕ τ → σ0 be the least upper bound. Finally, define Tr F = H ◦ in 1 : σ → σ0 .
It is standard to check that this construction indeed defines a monoidal trace, i.e., that it satisfies
all the necessary equations (Hasegawa 1997).
In more concrete terms, suppose that F : σ ⊕ τ → σ 0 ⊕ τ has been decomposed into components F11 : σ → σ0 , F21 : σ → τ , F12 : τ → σ0 , and F22 : τ → τ as in Section 5.1. Then we
have
H0 (A, 0) = 0,
H1 (A, 0) = F11 (A),
H2 (A, 0) = F11 (A) + F12 F21 (A), etc,
so that
(Tr F )(A) = H(A, 0) = F11 (A) +
∞
X
i
F12 (F22
(F21 (A))).
i=0
Comparing this to equation (1) of Section 5.1, we find that the monoidal trace is precisely the
construction we need for the interpretation of loops. In particular, this justifies the convergence
of the infinite sum in equation (1).
We also note that the monoidal trace is related to the tensor ⊗ by the following property: if
F : σ ⊕ τ → σ0 ⊕ τ , and ρ is any object, then
Tr(F ⊗ ρ) = (Tr F ) ⊗ ρ.
Here it is understood that we identify the objects (σ ⊕ τ ) ⊗ ρ and (σ ⊗ ρ) ⊕ (τ ⊗ ρ) (which
happen to be identical anyway). We can summarize this property together with distributivity by
saying that for any ρ, the functor (−) ⊗ ρ is a traced monoidal functor. We call a traced monoidal
category with this additional structure a distributively traced monoidal category.
6.5. The interpretation of flow charts
To each type A, we associate an object [[A]] of the category Q. There are only two types, and
their interpretations are suggested by the names of the corresponding objects: [[bit]] = bit and
Towards a Quantum Programming Language
39
[[qbit]] = qbit. To each typing context Γ = x 1 :A1 , . . . , xn :An , we associate an object [[Γ]] as
follows:
[[Γ]] = [[A1 ]] ⊗ . . . ⊗ [[An ]]
Further, if Γ̄ = Γ1 ; . . . ; Γn is a list of typing contexts, we define [[ Γ̄]] = [[Γ1 ]] ⊕ . . . ⊕ [[Γn ]]. Each
quantum flow chart
Γ1
Γ2
···
Γn
···
Γ0m
X
Γ01
Γ02
is interpreted as a morphism
[[X]] : [[Γ1 ]] ⊕ . . . ⊕ [[Γn ]] → [[Γ01 ]] ⊕ . . . ⊕ [[Γ0m ]]
in the category Q. The interpretation is defined by induction on the construction of the flow chart.
Atomic charts. The basic flow charts from Figures 3 and 5, with context Γ empty, are interpreted
as the following morphisms.
[[new bit b := 0]]
= newbit :
I → bit :
a 7→ (a, 0)
a 0
a 7→
0 0
[[new qbit q := 0]]
= newqbit :
I → qbit :
= discardbit : bit → I :
= discardqbit : qbit → I :
[[b := 0]]
= set0 :
bit → bit :
(a, b) 7→ (a + b, 0)
[[b := 1]]
= set1 :
bit → bit :
(a, b) 7→ (0, a + b)
[[q̄ ∗= S]]
= unitaryS :
qbitn → qbitn :
A 7→ SAS ∗
[[branch b]]
= branch :
bit → bit ⊕ bit :
[[measure q]]
= measure :
(a, b) 7→ (a, 0, 0, b)
a b
a 0
0 0
qbit → qbit ⊕ qbit :
7→ (
,
)
c d
0 0
0 d
[[merge]]
= merge :
I⊕I→I :
(a, b) 7→ a + b
[[initial]]
= initial :
0→I:
() 7→ 0
[[permute φ]]
= permute φ :
A1 ⊗ . . . ⊗ An → Aφ(1) ⊗ . . . ⊗ Aφ(n)
(a, b) 7→ a + b
a b
7→ a + d
c d
Here, permuteφ is the natural permutation map based on the symmetric tensor ⊗. There is also
the trivial flow chart, consisting of one edge only, which is naturally interpreted as the identity
map, and the flow chart consisting of two wires crossing each other, which is interpreted as the
symmetry map for coproducts, [in 2 , in1 ] : σ ⊕ τ → τ ⊕ σ.
Peter Selinger
(a)
···
40
(b)
(c)
···
···
X
Y
···
···
(d) X :
···
X
···
···
Yi
···
X
Y
···
···
···
···
Fig. 10. Some composite flow charts
Composite charts. Complex flow charts are built by combining simpler ones in one of the following ways:
— Adding variables (context extension): If Y is obtained from X by adding an additional context Γ to all the edges of X, then
[[Y ]] = [[X]] ⊗ [[Γ]].
— Vertical composition: If A is the vertical composition of X and Y , as in Figure 10(a), then
[[A]] = [[Y ]] ◦ [[X]].
— Horizontal composition: If B is the horizontal composition of X and Y , as in Figure 10(b),
then
[[B]] = [[X]] ⊕ [[Y ]]
— Loops: If C is obtained from X by introducing a loop, as in Figure 10(c), then
[[C]] = Tr([[X]])
Two important results from the theory of traced monoidal categories ensure that this interpretation is well-defined: first, every possible flow chart (not containing procedure calls) can be
build up from basic flow charts and the operations in Figure 10(a)-(c). Second, if there is more
than one way of constructing a given flow chart from smaller pieces, the equations of distributively traced monoidal categories guarantee that the resulting interpretations coincide, i.e., the
interpretation is independent of this choice.
Procedures and recursion. For dealing with procedures, we formally augment the flow chart
¯i → ∆
¯ 0 . If Yi is
language with a set Y1 , . . . , Yn of flow chart variables, each with a type Y i : ∆
i
such a variable, then we allow the flow chart
∆i1
···
∆ik
Yi
∆0i1
···
∆0il
to be used as a basic component. We write X = X(Y 1 , . . . , Yn ) for a flow chart X which depends
on Y1 , . . . , Yn , a situation which is shown schematically in Figure 10(d). The interpretation of
Towards a Quantum Programming Language
41
such an X is given relative to an environment ρ, which is an assignment which maps each variable
¯i → ∆
¯ 0 to a morphism ρ(Y i ) : σi → σ 0 of the appropriate type in Q. The interpretation
Yi : ∆
i
i
[[X]]ρ of X with respect to an environment ρ is given inductively, with base case [[Y i ]]ρ = ρ(Yi ),
and inductive cases as before. In this way, each flow chart X(Y 1 , . . . , Yn ) defines a function
ΦX : Q(σ1 , σ10 ) × . . . × Q(σn , σn0 ) → Q(τ, τ 0 ),
which maps an environment ρ = (f 1 , . . . , fn ) to [[X]]ρ . An easy induction shows that this function is Scott-continuous; in fact, it is given by a term in the language of distributively traced
monoidal categories.
The interpretation of recursive procedures is then given by the solution of fixpoint equations. In
concrete terms, if the procedures Y 1 , . . . , Yn are defined by mutual recursion by a set of equations
Yi = Xi (Y1 , . . . , Yn ), for i = 1, . . . , n, then their joint interpretation is given as the least fixpoint
of the Scott-continuous function
hΦX1 , . . . , ΦXn i : Q(σ1 , σ10 ) × . . . × Q(σn , σn0 ) → Q(σ1 , σ10 ) × . . . × Q(σn , σn0 ).
As a special case, let us consider the case of a single recursive procedure Y , defined by Y =
X(Y ) for some flow chart X. In this case, X defines a Scott-continuous function
ΦX : Q(σ, σ0 ) → Q(σ, σ0 ).
The interpretation [[Y ]] will be given as the least fixpoint of Φ X . This fixpoint can be calculated
as the limit of an increasing sequence F 0 v F1 v . . ., where F0 = 0, the constant zero function,
and Fi+1 = ΦX (Fi ). We find that
_
[[Y ]] =
Fi = lim Fi .
i
i
Comparing this to equation (2) of Section 5.5, we find that this least fixpoint is precisely the
required interpretation of the recursively defined procedure Y = X(Y ). In particular, since least
fixpoints of Scott-continuous endofunctions on pointed complete partial orders always exist, this
justifies the convergence of the limit in equation (2).
6.6. Structural and denotational equivalence
The interpretation of quantum flow charts can be generalized from the category Q to any category
which has the requisite structure.
Definition (Elementary quantum flow chart category). An elementary quantum flow chart
category is a symmetric monoidal category with traced finite coproducts, such that A ⊗ (−)
is a traced monoidal functor for every object A, together with a distinguished object qbit and
morphisms ι : I ⊕ I → qbit and p : qbit → I ⊕ I, such that p ◦ ι = id. Here I is the unit object
of the symmetric monoidal structure.
In an elementary quantum flow chart category, we define an object bit := I ⊕ I. Then the morphisms newbit, discardbit, set 0 , set1 , branch, merge, and initial, needed in the interpretation of
atomic quantum flow charts, are definable from the finite coproduct structure. Furthermore, the
Peter Selinger
42
morphisms newqbit, discardqbit, and measure can be defined in terms of ι and p. The only additional piece of information needed to interpret quantum flow charts in an elementary quantum
flow chart category is an interpretation of built-in unitary operators.
Consider a flow chart language with loops, no recursion, and a certain set of built-in unitary
operator symbols. Let C be an elementary quantum flow chart category, and let η be an assignment which maps each built-in n-ary operator symbol S to a morphism η S : qbitn → qbitn in
C. Then there is an evident interpretation of quantum flow charts, which maps each X : Γ̄ → Γ̄0
to a morphism [[X]] η : [[Γ̄]] → [[Γ̄0 ]], defined inductively as in Section 6.5. Further, if the category
C is CPO-enriched, then we can also interpret recursively defined flow charts in it.
Definition (Structural equivalence, denotational equivalence). We say that two quantum flow
charts X, Y : Γ̄ → Γ̄0 are structurally equivalent if for every elementary quantum flow chart
category C and every interpretation η of basic operator symbols, [[X]] η = [[Y ]]η . Further, X and
Y are said to be denotationally equivalent if [[X]] = [[Y ]] for the canonical interpretation in the
category Q of signatures and completely positive operators.
Clearly, structural equivalence implies denotational equivalence, and the converse is not true.
Structural equivalence is essentially a syntactic notion: if two flow charts are structurally equivalent, then one can be obtained from the other by purely symbolic manipulations, without any
assumptions about the behavior of the built-in unitary operators. For instance, the two flow charts
in Example 4.2 are structurally equivalent, as are those in Example 4.7. On the other hand, the
two flow charts in Example 4.6 are not structurally equivalent. Structural equivalence is probably
the smallest reasonable equivalence which one might want to consider on flow charts.
Denotational equivalence, on the other hand, is a semantic notion. It captures precisely our
concept of “behavior” of quantum programs, fully taking into account the meaning of the builtin operators. We should remark that, like any denotational notion of “behavior”, denotational
equivalence abstracts from some aspects of the actual physical behavior of a system; for instance,
issues like the running time or space usage of an algorithm are not modeled. Denotational equivalence is only concerned with the probabilistic input-output relationship of programs. It is the
largest possible equivalence on quantum flow charts in the following sense: if X, Y : Γ̄ → Γ̄0 are
not denotationally equivalent, then there exists a context C[−] (a flow chart with a “hole”) such
that C[X] and C[Y ] are of type I → bit, and C[X] evaluates to 0 with a different probability
than C[Y ].
6.7. Characterizations of completely positive operators and superoperators
We will now give some basic and well-known characterizations of superoperators. These results
will be used in Section 6.9 to prove that every superoperator arises as the denotation of a quantum
flow chart.
As before, let ei denote the ith canonical unit column vector. The space C n×n of n × nmatrices has a canonical basis (as a vector space), consisting of the matrices E ij = ei e∗j . Any
linear function F : C n×n → Cm×m is uniquely determined by its action on the basis elements.
Definition (Characteristic matrix, characteristic matrix tuple). The characteristic matrix of
Towards a Quantum Programming Language
43
a linear function F : C n×n → Cm×m is the matrix χF ∈ Cnm×nm defined by


F (E11 ) · · · F (E1n )

..
..
..
χF = 

.
.
.
.
F (En1 ) · · · F (Enn )
More generally, let σ = n 1 , . . . , ns and τ = m1 , . . . , mt be signatures, and let F : V σ → Vτ
be a linear function. We define the ij-component of F to be the function F ij = πj ◦ F ◦ ini :
Cni ×ni → Cmj ×mj . The characteristic matrix tuple of F is
χF = (χF11 , . . . , χF1t ,
...
, χFs1 , . . . , χFst ).
Note that if F : Vσ → Vτ is a linear function, its characteristic matrix tuple is an element
χF ∈ Vσ⊗τ . Moreover, F and χF determine each other uniquely.
One might ask whether it is possible to characterize the completely positive operators, or
respectively the superoperators, in terms of a property of their characteristic matrices. This is
indeed possible. In the following theorems, we start by considering the simple case, i.e., the case
of operators F : C n×n → Cm×m . The general non-simple case is treated afterwards.
Theorem 6.5. Let F : Cn×n → Cm×m be a linear operator, and let χF ∈ Cnm×nm be its
characteristic matrix.
(a) F is of the form F (A) = U AU ∗ , for some U ∈ Cm×n , if and only if χF is pure.
(b) The following are equivalent:
(i) F is completely positive.
(ii) χF is positive.
(iii)F is of the form F (A) =
Cm×n .
P
i
Ui AUi∗ , for some finite sequence of matrices U 1 , . . . , Uk ∈
Proof. For part (a), observe that the matrix χF is pure iff it is of the form χF = uu∗ , for some
u ∈ Cnm . We can write


v1


u =  ...  ,
vn
for some vectors v i ∈ Cm , and let U = (v1 | . . . |vn ) ∈ Cm×n . Then F (Eij ) = vi vj∗ = U Eij U ∗ ,
for all i, j, and thus F (A) = U AU ∗ for all A. Conversely if F (A) = U AU ∗ , then χF = uu∗
with u constructed from U as above.
For part (b), to show (i) ⇒ (ii), it suffices to observe that the matrix


E11 · · · E1n

.. 
..
E =  ...
.
. 
En1 · · · Enn
is positive, and that χF = (idn ⊗ F )(E). To prove that (ii) ⇒ (iii), assume that χF is positive.
Then χF can be written as a sum of pure matrices, say, χF = B1 + . . . + Bk . For each i =
1, . . . , k, let Fi be the linear operator whose characteristic matrix is χFi = Bi . By part (a),
Peter Selinger
44
Fi (A) = Ui AUi∗ , hence F (A) =
trivial.
P
i
Ui AUi∗ as desired. Finally, the implication (iii) ⇒ (i) is
Corollary 6.6. Two linear functions F, G : C n×n → Cm×m satisfy F v G if and only if
χF v χG . Here F v G is defined as in Section 6.4.
Next, we wish to characterize superoperators, i.e., completely positive operators which satisfy
the trace condition. We start with some preliminary observations. First, note that for any signature
σ, the trace operator trσ : Vσ → V1 is a superoperator. We also call it the erasure map, as it
corresponds to an erasure of (quantum and classical) information.
Definition (Trace characteristic matrix tuple). The trace characteristic matrix tuple of a linear
function F : Vσ → Vτ is defined to be χ(Ftr) = χtrτ ◦F ∈ Vσ , i.e., the characteristic matrix tuple
of trτ ◦ F . Note that χ(Ftr) is easily calculated by taking a “partial trace” of χF , i.e., χ(Ftr) =
(idσ ⊗ trτ )(χF ).
Theorem 6.7. Let F : Cn×n → Cm×m be a completely positive operator. The following are
equivalent:
(i) F is a superoperator.
(ii) χ(Ftr) v In , where In ∈ Cn×n is the identity matrix.
P
P
(iii)F is of the form F (A) = i Ui AUi∗ , for matrices U1 , . . . , Uk with i Ui∗ Ui v In .
Proof. For the equivalence of (i) and (ii), note that F is a superoperator iff tr F (A) 6 tr A, for
all positive A. This is the case iff tr m ◦F v trn , and by Corollary 6.6, iff χtrm ◦F v χtrn . But
χtrn = In , and thus this is equivalent to χ(Ftr) v In . For the equivalence of (ii) and (iii), first note
P
that by Theorem 6.5, F can be written as F (A) =
Ui AUi∗ , for some matrices U 1 , . . . , Uk .
iP
P ∗
(tr)
But then, χF = i Ui Ui , the complex conjugate of i Ui∗ Ui . Thus the equivalence follows.
The equivalence (i) ⇔ (iii) is known as the Kraus Representation Theorem. Note that F is
P
trace preserving, i.e., tr F (A) = tr A for all A, iff χ(Ftr) = In iff i Ui∗ Ui = In . Theorems 6.5
and 6.7 can be straightforwardly generalized to the non-simple case, as summarized in the next
theorem.
Theorem 6.8. Let σ = n1 , . . . , ns and τ = m1 , . . . , mt be signatures, and let F : V σ → Vτ be
a linear function.
(a) F is completely positive iff χF is positive.
(b) F is a superoperator iff χF is positive and χ(Ftr) v Iσ , where Iσ ∈ Vσ is the tuple consisting
of identity matrices.
(c) F is a superoperator iff it can be written in the form
X
X
∗
∗
F (A1 , . . . , As ) = (
Ui1l Ai Ui1l
,...,
Uitl Ai Uitl
),
il
mj ×ni
for matrices Uijl ∈ C
finite index set.
where
P
∗
jl Uijl Uijl
il
v Ini for all i. Here, l ranges over some
Proof. All three parts follow from straightforward componentwise arguments. Let F ij = πj ◦
Towards a Quantum Programming Language
45
F ◦ ini : Vni → Vmj be the ij-component of F as before, and let F i = F ◦ ini : Vni → Vτ .
For (a), observe that F is completely positive iff each F ij is completely positive. For (b), note
that F satisfies the trace condition iff each F i satisfies it. This is the case iff trτ ◦Fi v trni , or
(tr)
v Iσ . For (c), first note that
equivalently, χ(Ftri) v Ini , for all i. The latter is equivalent to χF
P
∗
by Theorem 6.5, each F ij can be written as Fij (A) = l Uijl Ai Uijl
, where l = 1, . . . , k ij . By
setting k = maxij kij and Uijl = 0 if l > kij , we may assume that l ranges uniformly over
P
∗
, and
1, . . . , k. Thus, F can be written in the desired form; further tr F i (A) = tr jl Uijl Ai Uijl
P
∗
hence, by Theorem 6.7(iii), F is a superoperator iff jl Uijl Uijl v Ini for all i.
Remark 6.9 (Compact closed structure up to scalar multiples). Recall that V and Q are
symmetric monoidal categories whose objects are signatures, and whose morphisms are, respectively, linear functions, and superoperators. The characteristic matrix determines a one-to-one
correspondence between hom-sets V(ρ ⊗ σ, τ ) ∼
= V(ρ, σ ⊗ τ ) (they both correspond to matrix
tuples in Vρ⊗σ⊗τ ). Moreover, this one-to-one correspondence is natural in ρ and τ . A category
with this property is called compact closed. Abramsky and Coecke (2003) suggest that such a
compact closed structure could be taken as the basis for a semantics of higher-order types in a
quantum programming language.
Let W be the category whose objects are signatures and whose morphisms are completely positive operators. Thus Q, W, and V share the same objects, and Q ⊆ W ⊆ V. Theorem 6.8(a)
implies that W inherits the compact closed structure from V. However, by Theorem 6.8(b), the
category Q of superoperators is not compact closed; indeed, if F : V σ → Vτ is a superoperator,
then is characteristic matrix χF is not in general a density matrix, because in general, tr χF > 1.
Nevertheless, one has the following, weaker property: λ χF is a density matrix for some scalar
0 < λ 6 1. In this sense, we may say that Q possesses a compact closed structure up to scalar
multiples. Whether or not such a weaker structure can serve as a useful implementation of higherorder types is an interesting question.
Remark 6.10 (Basis-free presentation of the characteristic matrix). If V and W are finite
dimensional vector spaces and V ∗ and W ∗ are their respective dual spaces, then linear maps
F : V ∗ ⊗V → W ∗ ⊗W are in canonical one-to-one correspondence with elements χF ∈ U ∗ ⊗U ,
where U = V ∗ ⊗ W . Explicitly, the correspondence is given by tr(w 1 ⊗ w2∗ ⊗ F (v1∗ ⊗ v2 )) =
tr(v2 ⊗ w2∗ ⊗ v1∗ ⊗ w1 ⊗ χF ), for all v1∗ ∈ V ∗ , v2 ∈ V , w1 ∈ W , w2∗ ∈ W ∗ . If moreover V and
W are Hilbert spaces, then one may speak of positive matrices as certain elements of V ∗ ⊗ V .
In this case, F : V ∗ ⊗ V → W ∗ ⊗ W is completely positive if and only if χF is positive. This
is the basis-free formulation of Theorem 6.5(b) (i)⇔(ii).
Note that linear maps F : V ∗ ⊗V → W ∗ ⊗W are also in canonical one-to-one correspondence
with elements of Ũ ∗ ⊗ Ũ, where Ũ = V ⊗W . However, this latter correspondence does not enjoy
good properties for our purposes; in particular, it does not satisfy the equivalent of Theorem 6.5.
6.8. Normal form for superoperators
As a consequence of Theorems 6.5 and 6.7, we obtain a normal form for superoperators: any
superoperator can be expressed as a sub-unitary transformation, followed by an erasure and a
measurement. This normal form is not unique.
Peter Selinger
46
Definition (Sub-unitary). A matrix U ∈ C m×n is said to be sub-unitary if U is a submatrix
of some unitary matrix U 0 , i.e., if there exist matrices U 1 , U2 , U3 (not necessarily of the same
dimensions as U ) such that
U U1
U0 =
U2 U3
is unitary. A linear function F : C n×n → Cm×m is called sub-unitary if it is of the form
F (A) = U AU ∗ , for some sub-unitary matrix U ∈ C m×n . More generally, a linear function F :
Vσ → Vτ is called sub-unitary if it is of the form F (A 1 , . . . , As ) = (U1 A1 U1∗ , . . . , Us As Us∗ ),
for sub-unitary matrices U i ∈ Cmi ×ni , where σ = n1 , . . . , ns and τ = m1 , . . . , ms .
Lemma 6.11. A matrix U ∈ C m×n is sub-unitary iff U U ∗ v Im iff U ∗ U v In .
Proof. Clearly, U is sub-unitary iff there exists a matrix U 1 such that the rows of (U |U 1 ) form
an orthonormal set. This is the case iff U U ∗ + U1 U1∗ = Im , and by Remark 2.2, iff U U ∗ v Im .
The second equivalence is similar.
Definition (Measurement operator, erasure operator). Let σ = n 1 , . . . , ns be a signature,
and let σ̃ = n1 + . . . + ns , an integer regarded as a simple signature. The measurement operator
µσ : Vσ̃ → Vσ is defined as


A11 · · · A1s
 .
.. 
..
µσ  ..
.
.  = (A11 , A22 , . . . , Ass ),
As1 · · · Ass
where Aij ∈ Cni ×nj . An erasure operator, also known as a partial trace operator, is an operator
of the form (tr σ ⊗ idτ ) : Vσ⊗τ → Vτ .
Note that sub-unitary transformations, measurements and erasures are superoperators; the following theorem states that any superoperator is a combination of these three basic ones.
Theorem 6.12.
(a) Every superoperator F : C n×n → Cm×m can be factored as F = E ◦ G, where G is
sub-unitary and E is an erasure operator.
(b) Every superoperator F : V σ → Vτ can be factored as F = M ◦E◦G, where G is sub-unitary,
E is an erasure operator, and M is a measurement operator.
Proof. (a) By Theorem 6.7, there exist matrices U 1 , . . . , Uk ∈ Cm×n such that F (A) =
P
P ∗
∗
i Ui AUi and
i Ui Ui v In . Let U be the vertical stacking of the matrices U 1 , . . . , Uk ,


U1


U =  ...  ,
Uk
P ∗
and define G : Cn×n → Ckm×km by G(A) = U AU ∗ . Since U ∗ U =
i Ui Ui , the matrix
U is sub-unitary by Lemma 6.11. Also, let E = (tr k ⊗ idm ) : Ckm×km → Cm×m . Then
P
E(G(A)) = (trk ⊗ idm )(U AU ∗ ) = i Ui AUi∗ = F (A), as claimed.
(b) Suppose σ = n 1 , . . . , ns and τ = m1 , . . . , mt . By Theorem 6.8(c), F can be written as
Towards a Quantum Programming Language
47
P
P
∗
∗
F (A1 , . . . , As ) = ( il Ui1l Ai Ui1l
, . . . , il Uitl Ai Uitl
), for matrices Uijl ∈ Cmj ×ni where
P
∗
jl Uijl Uijl v Ini for all i, and where l ranges over 1, . . . , k, for some k. For each i, let U i ∈
k(m1 +...+mt )×ni
C
be the vertical stacking of the matrices U i11 , . . . , Uit1 , . . . , Ui1k , . . . , Uitk .
Let σ 0 = k, . . . , k be a list of length s. Define G : V σ → Vσ0 ⊗τ̃ by
G(A1 , . . . , As ) = (U1 A1 U1∗ , . . . , Us As Us∗ ).
P
∗
Clearly, Ui∗ Ui = jl Uijl
Uijl v Ini for all i, and thus G is sub-unitary. Let E = (tr σ0 ⊗ idτ̃ ) :
Vσ0 ⊗τ̃ → Vτ̃ , and let M = µτ : Vτ̃ → Vτ . An easy calculation shows that M ◦E◦G(A) = F (A),
as desired.
6.9. Fullness of the interpretation
We defined the interpretation of a quantum flow chart X to be a morphism [[X]] in the category
Q, i.e., a superoperator. We now want to show that every superoperator is definable in this way.
More precisely, we want to show that the interpretation is full: whenever Γ̄ and Γ̄0 are lists of
typing contexts and F : [[ Γ̄]] → [[Γ̄0 ]] is a superoperator, then there exists a quantum flow chart
X : Γ̄ → Γ̄0 such that [[X]] = F .
For the purpose of this section, we consider the flow chart language which has loops, and
which contains all unitary operators as built-in operators. In a more realistic setting, one would
only have a finite, but complete set of built-in operators (in the sense of Proposition 3.2); in this
case, fullness is true up to epsilon, i.e., for every > 0, one can find X such that k[[X]] − F k < .
Lemma 6.13.
(a) If Γ̄ and Γ̄0 are lists of typing contexts such that [[ Γ̄]] = [[Γ̄0 ]] = σ, then there exists a flow
chart X : Γ̄ → Γ̄0 such that [[X]] = id σ .
(b) Suppose n = 2 k , m = 2l , and F : Cn×n → Cm×m is sub-unitary. Then there exists a
quantum flow chart X : qbit k → qbitl such that [[X]] = F .
Proof. For part (a), first note that if neither Γ̄ nor Γ̄0 contain the type bit, then Γ̄ = Γ̄0 and
there is nothing to show. Further, all occurrences of the type bit can be removed by repeated
application of the transformation from Example 4.4.
For (b), we have F (A) = U AU ∗ for some sub-unitary matrix U ∈ C m×n . Then there exist
matrices U1 , U2 , U3 , not necessarily of the same dimensions as U , such that
U U1
∈ Cp×p
U0 =
U2 U3
is unitary. Without loss of generality, we may assume that p = 2 r is a power of two. Then F =
[[X]], where X is the flow chart shown in Figure 11. Here we have used obvious abbreviations
for multiple “new”, “measure” and “discard” operations. Note that all but one branch of the
measurements lead into an infinite loop; this is due to the fact that F may not be trace preserving.
Theorem 6.14 (Fullness). For given lists of typing contexts Γ̄, Γ̄0 , if F : [[Γ̄]] → [[Γ̄0 ]] is a
superoperator, then there exists a quantum flow chart X : Γ̄ → Γ̄0 such that [[X]] = F .
Peter Selinger
48
q1 , . . . , qk : qbit = A
new qbit qk+1 , . . . , qr := 0
q1 , . . . , qr : qbit =
q1 , . . . , qr ∗= U 0
q1 , . . . , qr : qbit =
A
0
0
0
!
U AU ∗
U2 AU ∗
U AU2∗
U2 AU2∗
!
measure ql+1 , . . . , qr
0,...,0
otherwise
discard ql+1 , . . . , qr
◦
q1 , . . . , ql : qbit = U AU ∗
Fig. 11. Flow chart realizing a sub-unitary transformation
Proof. This is an almost trivial consequence of Theorem 6.12 and Lemma 6.13. First, by
Lemma 6.13(a), it is sufficient to consider the case where Γ̄ = qbitk1 ; . . . ; qbitks and Γ̄0 =
qbitl1 ; . . . ; qbitlt . Second, let l > l i for all i, and let 2 r > t. Then F can be factored as F 2 ◦ F1 ,
where F1 : [[Γ̄]] → [[qbitl ×bitr ]] is a superoperator and F 2 : [[qbitl ×bitr ]] → [[Γ̄0 ]] is a canonical
projection. F2 is clearly definable. Let σ = [[ Γ̄]] and τ = [[qbitl × bitr ]]. Then τ̃ = [[qbitl+r ]].
By the proof of Theorem 6.12, F 1 can be factored as M ◦ E ◦ G, where G : σ → σ 0 ⊗ τ̃
is sub-unitary, E : σ 0 ⊗ τ̃ → τ̃ is the canonical erasure operator, and M : τ̃ → τ is the
canonical measurement operator. Moreover, σ 0 = k, . . . , k is a list of length s, and without loss
of generality, we may assume that k = 2 p is a power of two, so that σ 0 = [[qbitp ; . . . ; qbitp ]].
Now M is definable by Lemma 6.13(b), E is definable by a sequence of “discard” and “merge”
operations, and M : [[qbit l+r ]] → [[qbitl × bitr ]] is definable by r measurements.
7. Towards a structured syntax
In previous sections, we have presented a view of quantum programming in terms of flow charts.
The reasons were partly pedagogical, because flow charts explicitly highlight the “atomic” concepts of control flow, which are often left implicit in more structured programming languages.
Particularly the “merge” operation, with its associated erasure of classical information, is of fundamental importance to quantum computing because it causes the passage from pure to impure
states. Another reason for presenting the language in terms of flow charts was semantical: flow
charts, because of their close connection with traced monoidal categories, provide a convenient
setting for describing the semantics of quantum programs.
However, for actual programming, flow charts are generally too cumbersome as a notation.
The reasons for this are the same as in classical programming language theory: their graphical
nature makes flow charts difficult to manipulate, and they also discourage a structured approach
to programming. We now present a more “textual” syntax for quantum programs, which is also
more “structured” in the sense of structured programming languages such as Pascal.
Towards a Quantum Programming Language
49
It is worth emphasizing, once again, that we are describing a functional programming language, despite the fact that its syntax superficially looks imperative. Each statement acts as a
function from an explicitly identified set of inputs to outputs, rather than operating on an implicitly defined global state.
7.1. The language QPL
We assume a countable set of variables, denoted x, y, b, q, . . .. We also assume a countable set
of procedure variables X, Y, . . ..
Types. A type t, s is either bit or qbit. A procedure type T is defined to be an expression of the
form t1 , . . . , tn → s1 , . . . , sm , where ti and sj are types. A typing context Γ is a finite list of pairs
of a variable and a type, such that no variable occurs more than once. Typing contexts are written
in the usual way as x1 :t1 , . . . , xn :tn . A procedure context Π is defined similarly, except that it
consists of procedure variables and procedure types. We use the notation x:t, Γ and X:T, Π for
extension of contexts, and in using this notation, we always implicitly assume that the resulting
context is well-defined, i.e., that x does not already occur in Γ and X does not already occur in
Π.
Terms. The set of QPL terms is defined by the following abstract syntax:
QPL Terms P, Q ::= new bit b := 0 new qbit q := 0 discard x
b := 0 b := 1 q1 , . . . , qn ∗= S
skip P ; Q
if b then P else Q measure q then P else Q while b do P
proc X : Γ → Γ0 { P } in Q y1 , . . . , ym = X(x1 , . . . , xn )
Here, S denotes a built-in unitary transformation of arity n, and Γ, Γ 0 denote typing contexts. The
intended meaning of the basic terms is the same as that of the corresponding atomic flow chart
components. P ; Q denotes sequential composition of terms, and the skip command does nothing.
(proc X : Γ → Γ0 { P } in Q) defines a procedure X with body P and scope Q; Γ and Γ 0 are
bindings of the formal parameters for input and output. The term ȳ = X(x̄) denotes a procedure
call. In writing programs, it is common to use certain derived terms, writing for instance b := c
as an abbreviation for (if c then b := 0 else b := 1), or (if b then P ) for (if b then P else skip).
Typing judgments. A typing judgment is an expression of the form
Π ` hΓi P hΓ0 i,
where Π is a procedure context and Γ, Γ 0 are typing contexts. The intended meaning is that under
the procedure binding Π, P is a well-typed term which transforms a set of variables Γ into a set
of variables Γ0 . The typing rules are shown in Figure 12.
Note that the typing rules enforce that in the term (q 1 , . . . , qn ∗= S), the variables q 1 , . . . , qn
are distinct. Similarly, in a procedure call ȳ = X(x̄), each of x̄ and ȳ is a list of distinct variables
(although it is possible that x i = yj ). Also note that each term has explicit inputs and outputs;
for instance, the term ȳ = X(x̄) has inputs x̄ and outputs ȳ, whereas the term b := 0 has input b
Peter Selinger
50
(newbit)
Π ` hΓi new bit b := 0 hb:bit, Γi
(newqbit)
Π ` hΓi new qbit q := 0 hq:qbit, Γi
Π ` hx:t, Γi discard x hΓi
(assign0 )
Π ` hb:bit, Γi b := 0 hb:bit, Γi
(assign1 )
(unitary)
Π ` hb:bit, Γi b := 1 hb:bit, Γi
S is of arity n
Π ` hq1 :qbit, . . . , qn :qbit, Γi q̄ ∗= S hq1 :qbit, . . . , qn :qbit, Γi
(skip)
Π ` hΓi skip hΓi
Π ` hΓi P hΓ0 i
Π ` hΓ0 i Q hΓ00 i
Π ` hΓi P ; Q hΓ00 i
(compose)
Π ` hb:bit, Γi P hΓ0 i
Π ` hb:bit, Γi Q hΓ0 i
Π ` hb:bit, Γi if b then P else Q hΓ 0 i
(if )
Π ` hq:qbit, Γi P hΓ0 i
Π ` hq:qbit, Γi Q hΓ0 i
Π ` hq:qbit, Γi measure q then P else Q hΓ0 i
(measure)
(while)
Π ` hb:bit, Γi P hb:bit, Γi
Π ` hb:bit, Γi while b do P hb:bit, Γi
(proc)
X:t̄ → s̄, Π ` hx̄:t̄i P hȳ:s̄i
X:t̄ → s̄, Π ` hΓi Q hΓ0 i
Π ` hΓi proc X : x̄:t̄ → ȳ:s̄ { P } in Q hΓ0 i
(call)
(permute)
X:t̄ → s̄, Π ` hx̄:t̄, Γi ȳ = X(x̄) hȳ:s̄, Γi
Π ` hΓi P h∆i,
Fig. 12. Typing rules for QPL
Π0 , Γ0 , ∆0 permutations of Π, Γ, ∆
Π ` hΓ0 i P h∆0 i
0
Towards a Quantum Programming Language
51
and output b. The latter term should be thought of as consuming a variable b, then creating a new
one with the same name. A more “functional” way of expressing this would be to write b = 0(b)
Semantics. The language QPL can be immediately translated into the flow chart language of
Section 4. The semantics of a QPL term is simply the semantics of the corresponding flow chart.
Alternatively, the semantics can be defined directly by induction on typing judgments; the rules
for doing so are obvious and we omit them here. It suffices to say that each typing judgment
X1 :t̄1 → s̄1 , . . . , Xn :t̄n → s̄n ` hΓi P hΓ0 i
is interpreted as a Scott-continuous function
[[P ]] : Q([[t̄1 ]], [[s̄1 ]]) × . . . × Q([[t̄n ]], [[s̄n ]]) → Q([[Γ]], [[Γ0 ]]).
The language QPL differs from the flow chart language in some minor ways. Specifically, QPL
contains the following restrictions:
— branchings and loops must be properly nested,
— merge operations can only occur in the context of a branching or loop,
— each program fragment has a unique incoming and a unique outgoing control path. In particular, procedures have only one entry and exit.
Note that the typing rules for QPL allow procedure definitions to be recursive; however, we
have omitted a facility for defining two or more mutually recursive procedures. However, this
is not a genuine restriction, because mutually recursive procedures can be easily expanded into
simply recursive ones. Where desired, one can augment the syntax in the standard way to allow
mutual recursion to be expressed directly.
7.2. Block QPL
The language QPL imposes a block structure on control constructs such as if and while, but not
on memory management. Unlike in block-oriented languages such as Pascal, we have allowed
variables to be allocated and deallocated anywhere, subject only to the typing rules. This is not
unsafe, because the type system is there to ensure that variables are deallocated when they are no
longer used. However, allowing non-nested allocations and deallocations carries an implementation cost, because it means that variables must be allocated from a heap rather than a stack. It is
therefore interesting to investigate an alternate version of QPL in which a stricter block structure
is imposed. We call this alternative language “Block QPL”.
Thus, in Block QPL, we want to restrict allocations and deallocations to occur in properly
nested pairs. Moreover, this nesting should also respect the nesting of the control constructs
if, measure, and while. We thus introduce the notion of a block, which is a program fragment
enclosed in curly brackets { P }. The convention is that the scope of any variable declaration
extends only to the end of the current block; moreover, the bodies of conditional statements,
loops, and procedures are implicitly regarded as blocks in this sense.
In the presence of such a block structure, the explicit discard command is no longer needed,
so we remove it from the language. Also, we note that with these changes, the incoming and
Peter Selinger
52
outgoing variables of any procedure must necessarily be the same. Thus, we also modify the
syntax of procedure calls, writing call X(x 1 , . . . , xn ) instead of x1 , . . . , xn = X(x1 , . . . , xn ).
This leaves us with the following syntax for Block QPL:
Block QPL Terms P, Q ::= new bit b := 0 new qbit q := 0
b := 0 b := 1 q1 , . . . , qn ∗= S
skip P ; Q { P }
if b then P else Q measure q then P else Q while b do P
proc X : Γ → Γ { P } in Q call X(x1 , . . . , xn )
The typing rules remain unchanged, except for a new rule (block), and appropriate changes to
the rules for branchings and procedures.
Π ` hΓi P hΓ0 i
Π ` hΓi { P } hΓi
(block)
(if )
(measure)
(proc)
(call)
Π ` hb:bit, Γi P hΓ0 i
Π ` hb:bit, Γi Q hΓ00 i
Π ` hb:bit, Γi if b then P else Q hb:bit, Γi
Π ` hq:qbit, Γi P hΓ0 i
Π ` hq:qbit, Γi Q hΓ00 i
Π ` hq:qbit, Γi measure q then P else Q hb:bit, Γi
X:t̄ → t̄, Π ` hx̄:t̄i P hΓ0 i
X:t̄ → t̄, Π ` hΓi Q hΓ00 i
Π ` hΓi proc X : x̄:t̄ → x̄:t̄ { P } in Q hΓi
X:t̄ → t̄, Π ` hx̄:t̄, Γi call X(x̄) hx̄:t̄, Γi
Note that, for any valid typing judgment Π ` hΓi P hΓ 0 i, we necessarily have Γ ⊆ Γ 0 ; thus the
rule (block) has a similar effect as the QPL rule (discard).
The advantage of having a strict block structure as in Block QPL is that allocation follows a
stack discipline, thus potentially simplifying implementations. However, there seems to be little
added benefit for the programmer, particularly since the QPL type system already prevents memory leaks. In fact, the restrictions of Block QPL seem to encourage an unnatural programming
style; on balance, it is probably not worth having these restrictions.
7.3. Extensions of the type system
So far, the only data types we have considered are bit and qbit, because this is the bare minimum
needed to discuss the interaction of quantum data, classical data, and classical control. In practice,
such a finitary type system is much too restrictive; for instance, the full power of loops and
recursion does not manifest itself unless programs can operate on variable size data. In this
section, we briefly discuss how the QPL type system can be extended with more complex types,
and particularly infinitary types. It is remarkable that these extensions work seamlessly, even
Towards a Quantum Programming Language
53
when mixing classical and quantum types in a data structure. In discussing possible extensions
to the type system, we keep in mind the semantic framework of Section 6, as well as the potential
physical realizability of the resulting types.
Tuples. We extend the type system of QPL adding a new type t 1 ⊗ . . . ⊗ tn , whenever t 1 , . . . , tn
are types. We introduce statements for constructing and deconstructing tuples:
(tuple)
Π ` hx1 :t1 , . . . , xn :tn , Γi x = (x1 , . . . , xn ) hx : t1 ⊗ . . . ⊗ tn , Γi
(untuple)
Π ` hx : t1 ⊗ . . . ⊗ tn , Γi (x1 , . . . , xn ) = x hx1 :t1 , . . . , xn :tn , Γi
The semantics of such tuples can be given in the framework of Section 6 without any changes;
one simply adds an equation [[t ⊗ s]] = [[t]] ⊗ [[s]], and interprets the basic tupling and untupling
operations as the semantic identity map.
Tuples can be used to encode fixed-length classical or quantum integers. For instance, the type
of 4-bit classical integers is defined as int 4 = bit ⊗ bit ⊗ bit ⊗ bit. If desired, one may add
appropriate built-in functions to facilitate the manipulation of such integers.
Sums. We further extend the type system by introducing a sum type t 1 ⊕ . . . ⊕ tn , whenever
t1 , . . . , tn are types. A sum type expresses a choice between several alternatives. Note that the
selection of alternatives is classical; for instance, the type of classical booleans is definable as
bit = I ⊕ I. Elements of sum types are constructed and deconstructed via injection and case
statements, much as in other functional programming languages:
(inj)
(case)
Π ` hx:ti , Γi y = ini x : t1 ⊕ . . . ⊕ tn hy : t1 ⊕ . . . ⊕ tn , Γi
Π ` hx1 :t1 , Γi P1 hΓ0 i
...
Π ` hxn :tn , Γi Pn hΓ0 i
Π ` hy : t1 ⊕ . . . ⊕ tn , Γi case y of in1 x1 ⇒ P1 | . . . | inn xn ⇒ Pn hΓ0 i
Note that by adding sum types to the language QPL, it is possible to encode procedures with
multiple points of entry and exit.
Infinite types. The semantics of Section 6 cannot directly handle infinite types, since it is based
on finite dimensional vector spaces. However, it is not difficult to adapt the semantics to the
infinite-dimensional case. This allows us, for instance, to accommodate an infinite type of classical integers, which is defined as the countable sum int = I ⊕ I ⊕ . . .. The semantics of infinite
types is based on positive linear operators of bounded trace; details will be given elsewhere.
Perhaps more controversial than infinite sums are infinite tensor products. For instance, a naive
implementation of “arbitrary size quantum integers” would be as the infinite tensor qbit ⊗ qbit ⊗
. . .. While infinite tensor products create no particular problem from the point of view of denotational semantics, a sensible implementation can only use finitely many quantum bits at any
Peter Selinger
54
given time. This can be achieved by imposing a semantic “zero tail state” condition, which means
that only finitely many non-zero bits are allowed to occur at any given time in the computation.
The compiler or the operating system has to implement a mechanism by which the zero tail
state condition is enforced. This requires some overhead, but might be a useful abstraction for
programmers.
Structured types. A particularly useful class of infinite sum types is the class of structured recursive types, such as lists, trees, etc. For example, the type of lists of quantum bits can be defined
recursively as qlist := I ⊕ (qbit ⊗ qlist). Note that, because the use of the ⊕ operator implies a
classical choice, quantum data occurs only “at the leaves” of a structured type, while the structure
itself is classical. Thus, the length of a list of quantum bits is a classically known quantity. This
view of structured quantum types fits well with our paradigm of “classical control”.
Lists of quantum bits are a good candidate for an implementation of a type of “variable-size
quantum integers”. With this implementation, each quantum integer has a classically determined
size. One can thus write programs which operate on quantum integers of arbitrary, but known,
size. This seems to be precisely what is required by many currently known number-theoretic
quantum algorithms, such as Shor’s factoring algorithm or the Quantum Fourier Transform.
Moreover, representing quantum integers as lists, rather than as arrays as is usually done ( Ömer
1998; Bettelli, Calarco, and Serafini 2001), means that no out-of-bounds checks or distinctness
checks are necessary at run-time; the syntax automatically guarantees that distinct identifiers refer to distinct objects at run-time. An example of a quantum algorithm using lists is given in
Section 7.4.
On a more speculative note, one might ask whether it is possible to have structured types
whose very structure is “quantum” (for instance, a quantum superposition of a list of length 1
and a list of length 2). Such types do not readily fit into our “classical control” paradigm. It is
an interesting question whether there is a physically feasible representation of such types, and
whether they can be manipulated in an algorithmically useful way.
Higher-order functions. Unlike typical functional programming languages, the language QPL
does not presently incorporate higher-order functions. There is currently no mechanism for abstracting procedures and considering them as data to be manipulated. It is an interesting question
whether it is possible to augment the language with functional closures in the style of a typed linear lambda calculus. To account for the non-duplicability of quantum data due to the no-cloning
property, it appears that such a language should be equipped with a linear type system along the
lines of Girard’s linear logic (Girard 1987).
7.4. Example: The Quantum Fourier Transform.
We given an example of the use of recursive types. Let qlist be the type of lists of quantum bits,
defined by the recursive equation qlist := I ⊕ (qbit ⊗ qlist). Figure 13 shows an implementation
of the Quantum Fourier Transform (QFT) (Shor 1994; Preskill 1998), which is of type qlist →
qlist. The algorithm shown differs from the standard Quantum Fourier Transform in that we have
omitted the final step which reverses the order of the bits in the output. Note that the procedure
QFT uses recursion to traverse its input list; it also uses an auxiliary procedure rotate which
Towards a Quantum Programming Language
input l:qlist
QFT:
55
rotate:
input h:qbit, t:qlist, n:int
l:qlist
h:qbit, t:qlist, n:int
case t
case l
in1 nil
in1 nil
in2 b
in2 c
h:qbit, c:qbit ⊗ qlist, n:int
b:qbit ⊗ qlist
(h, t) = b
(x, y) = c
h:qbit, nil:I, n:int
h, x:qbit, y:qlist, n:int
h:qbit, t:qlist
x, h ∗= Rn
h ∗= H
h:qbit, t:qlist
new int n := 2
h, x:qbit, y:qlist, n:int
n := n + 1
h:qbit, t:qlist, n:int
nil:I
(h, t) = rotate (h, t, n)
h, x:qbit, y:qlist, n:int
(h, y) = rotate (h, y, n)
h:qbit, nil:I
h:qbit, t:qlist
QF T (t)
h:qbit, t:qlist
l = in1 (nil)
l = in2 (h, t)
l:qlist
l:qlist
h, x:qbit, y:qlist
t = in1 (nil)
t = in2 (x, y)
h:qbit, t:qlist
h:qbit, t:qlist
◦
h:qbit, t:qlist
◦
output h:qbit, t:qlist
l:qlist
output l:qlist
Fig. 13. The Quantum Fourier Transform
is recursive in its own right. For simplicity, we have augmented the language by a classical
integer type int with built-in addition, and we have added an obvious case statement of type
A ⊕ B → A; B. We also use the Hadamard operator H, as well as a parameterized family of
unitary operators R n , which are defined by


1 0 0
0
 0 1 0

0
.
Rn = 
 0 0 1

0
n
0 0 0 e2πi/2
References
S. Abramsky and B. Coecke. Physical traces: Quantum vs. classical information processing. In Proceedings
of Category Theory and Computer Science, CTCS’02, Ottawa, Canada, Electronic Notes in Theoretical
Computer Science 69, 2003.
Peter Selinger
56
S. Bettelli, T. Calarco, and L. Serafini. Toward an architecture for quantum programming. arXiv:cs.PL/
0103009 v2, Nov. 2001.
R. Cleve. An introduction to quantum complexity theory. In C. Macchiavello, G. Palma, and A. Zeilinger,
editors, Collected Papers on Quantum Computation and Quantum Information Theory, pages 103–127.
World Scientific, 2000.
J.-Y. Girard. Linear logic. Theoretical Computer Science, 50:1–102, 1987.
J.-Y. Girard. Geometry of interaction I: Interpretation of system F . In Logic Colloquium ’88, pages 221–
260. North Holland, Amsterdam, 1989.
L. K. Grover. A fast quantum mechanical algorithm for database search. In Proceedings of the 28th Annual
ACM Symposium on Theory of Computing (STOC ’96), pages 212–219, 1996.
J. Gruska. Quantum Computing. McGraw Hill, 1999.
M. Hasegawa. Models of Sharing Graphs: A Categorical Semantics of let and letrec. PhD thesis, Department of Computer Science, University of Edinburgh, July 1997.
A. Joyal, R. Street, and D. Verity. Traced monoidal categories. Mathematical Proceedings of the Cambridge
Philosophical Society, 119:447–468, 1996.
E. H. Knill. Conventions for quantum pseudocode. LANL report LAUR-96-2724, 1996.
K. Löwner. Über monotone Matrixfunktionen. Mathematische Zeitschrift, 38:177–216, 1934.
M. A. Nielsen and I. L. Chuang. Quantum Computation and Quantum Information. Cambridge University
Press, 2000.
B. Ömer. A procedural formalism for quantum computing. Master’s thesis, Department of Theoretical
Physics, Technical University of Vienna, July 1998. http://tph.tuwien.ac.at/˜oemer/qcl.html.
J. Preskill. Quantum information and computation. Lecture Notes for Physics 229, California Institute of
Technology, 1998.
J. W. Sanders and P. Zuliani. Quantum programming. In Mathematics of Program Construction, Springer
LNCS 1837, pages 80–99, 2000.
P. Selinger. Categorical structure of asynchrony. In Proceedings of MFPS 15, New Orleans, Electronic
Notes in Theoretical Computer Science 20, 1999.
P. Shor. Algorithms for quantum computation: discrete log and factoring. In Proceedings of the 35th IEEE
FOCS, pages 124–134, 1994.
```
{"ft_lang_label":"__label__en","ft_lang_prob":0.88632935,"math_prob":0.9847056,"size":143558,"snap":"2021-21-2021-25","text_gpt3_token_len":38573,"char_repetition_ratio":0.16103348,"word_repetition_ratio":0.08778462,"special_character_ratio":0.27236378,"punctuation_ratio":0.15367085,"nsfw_num_words":1,"has_unicode_error":false,"math_prob_llama3":0.996214,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-05-08T22:41:14Z\",\"WARC-Record-ID\":\"<urn:uuid:fe8ea108-41c7-4722-925c-4f1391e43a99>\",\"Content-Length\":\"199528\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:01ff52fe-a8a0-42c4-9fd0-d4f8d7134108>\",\"WARC-Concurrent-To\":\"<urn:uuid:356a006e-3f43-4bb1-b69b-7a788ecfd9d5>\",\"WARC-IP-Address\":\"104.21.88.174\",\"WARC-Target-URI\":\"https://studyres.com/doc/1268609/towards-a-quantum-programming-language\",\"WARC-Payload-Digest\":\"sha1:GLIVHXH5UB6LCHFZF6RDKWTRWLPXTH6A\",\"WARC-Block-Digest\":\"sha1:CGWXMLUWVFWVG2C4GOECWB2OSFCGXN4L\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-21/CC-MAIN-2021-21_segments_1620243988927.95_warc_CC-MAIN-20210508211857-20210509001857-00570.warc.gz\"}"}