Download Quantum Lambda Calculus - Department of Mathematics and

1
Quantum Lambda Calculus
Peter Selinger
Dalhousie University, Canada
Benoı̂t Valiron
INRIA and École Polytechnique, LIX, Palaiseau, France.
Abstract
We discuss the design of a typed lambda calculus for quantum computation. After a brief discussion of the role of higher-order functions in
quantum information theory, we define the quantum lambda calculus
and its operational semantics. Safety invariants, such as the no-cloning
property, are enforced by a static type system that is based on intuitionistic linear logic. We also describe a type inference algorithm, and
a categorical semantics.
1.1 Introduction
The lambda calculus, developed in the 1930’s by Church and Curry, is a
formalism for expressing higher-order functions. In a nutshell, a higherorder function is a function that inputs or outputs a “black box”, which
is itself a (possibly higher-order) function. Higher-order functions are a
computationally powerful tool. Indeed, the pure untyped lambda calculus has the same computational power as Turing machines (Turing,
1937). At the same time, higher-order functions are a useful abstraction
for programmers. They form the basis of functional programming languages such as LISP (McCarthy, 1960), Scheme (Sussman and Steele Jr,
1975), ML (Milner, 1978) and Haskell (Hudak et al., 2007).
In this chapter, we discuss how to combine higher-order functions with
quantum computation. We believe that this is an interesting question for
a number of reasons. First, the combination of higher-order functions
with quantum phenomena raises the prospect of entangled functions.
Certain well-known quantum phenomena can be naturally described in
1
2
P. Selinger and B. Valiron
terms of entangled functions, and we will give some examples of this in
Section 1.2.
Another interesting aspect of higher-order quantum computation is
the interplay between classical objects and quantum objects in a higherorder context. A priori, quantum computation operates on two distinct
kinds of data: classical data, which can be read, written, duplicated,
and discarded as usual, and quantum data, which has state preparation,
unitary maps, and measurements as primitive operations. The higherorder computational paradigm introduces a third kind of data, namely
functions, and one may ask whether functions behave like classical data,
quantum data, or something intermediate.
The answer is that there will actually be two kinds of functions: those
that behave like “quantum” objects, and those that behave like “classical” objects. Functions of the first kind carry the potential to be entangled, and can only be used once. They are effectively a “quantum state
with an interface”. Functions of the second kind carry no possibility of
being entangled, and can be duplicated and reused at will. Interestingly,
this classification of functions in not directly related to the types of their
inputs and outputs: as we will see, there exist quantum-like functions
that act on classical data, as well as classical-like functions that act on
quantum data. In Section 1.3.2, we will discuss a type system by which
one can mechanically determine, for every expression of the quantum
lambda calculus, which of these categories it falls into.
When designing a quantum lambda calculus, one naturally has to
make a number of choices. We do not attempt to present all possible
design choices that could have been made; instead, we present one set
of coherent choices that we think is particularly useful, with occasional
comments on possible alternatives. Various aspects of our quantum
lambda calculus and its semantics were developed in (Valiron, 2004a,b;
Selinger and Valiron, 2005, 2006, 2008b,a; Valiron, 2008). We briefly
discuss some of the main design choices, as well as related work, in
Section 1.3.8.
The remainder of this paper is organized as follows. In Section 1.2,
we give some examples of the use of higher-order functions in quantum computation. In Section 1.3, we introduce the quantum lambda
calculus, its syntax, type system, and operational semantics. A type
inference algorithm is described in Section 1.4. We discuss an extension of the language with infinite data types in Section 1.5. Finally, in
Section 1.6 we discuss the category-theoretic semantics of the quantum
lambda calculus.
Quantum Lambda Calculus
|1i
H
|yi
|y⊕f (x)i
|0i
H
|xi
|xi
3
Uf
H
|f (0) ⊕ f (1)i
Fig. 1.1. The Deutsch-Jozsa algorithm.
Errata. This version of the paper differs from the published version. A
typo in Definition 1.6.21 has been corrected.
1.2 Higher-order quantum computation examples
At the heart of the higher-order computation paradigm is the idea that
“functions are data”. As such, functions can appear in any context in
which data is normally used. In particular, they can appear as inputs
to other functions, appear as outputs of other functions, or be stored in
data structures (such as a pair of functions, or a list of functions). An
important restriction of higher-order computation is that all functions
must be accessed via their interface. In other words, a program may
interact with a function-as-data by applying it to an argument, but not,
for instance, by examining its code.
We give some examples illustrating how some common phenomena
in quantum computation can be interpreted in terms of higher-order
functions. In these examples, we will informally use some concepts (such
as types) that will be more rigorously defined in later sections.
1.2.1 The Deutsch-Jozsa algorithm
Maybe the easiest example to interpret in the context of higher-order is
the Deutsch-Jozsa algorithm (Deutsch and Jozsa, 1992). In its simplest
form, this algorithm decides whether a boolean function f : bit → bit is
balanced or constant. It does so by interacting with an encoding of f ,
and uses this encoding only once (contrary to the classical case, where
two calls to f are needed).
The function f must be provided in the form of a unitary 2-qubit circuit Uf , where Uf (|xi⊗ |yi) = |xi⊗ |y ⊕ f (x)i. The algorithm constructs
and runs the circuit shown in Figure 1.1. It measures the indicated qubit
and returns f (0)+f (1). As the Deutsch-Jozsa algorithm inputs a binary
gate, which is a function of type qbit ⊗ qbit → qbit ⊗ qbit , and outputs
4
P. Selinger and B. Valiron
qubit 1: |φi
(2)
(1)
qubit 2: |0i
qubit 3: |0i
H
•
•
⊕
⊕
H
_ _ M
__
x,y
location A
ED
location B
@A
Uxy
|φi
(3)
Fig. 1.2. Quantum teleportation protocol.
a classical bit, its type is:
(qbit ⊗ qbit → qbit ⊗ qbit ) → bit .
We note that the preparation of the encoding Uf from the original
boolean function f is itself a higher-order function of type
(bit → bit ) → (qbit ⊗ qbit → qbit ⊗ qbit ).
However, this latter function must still call f twice (or else, it must
examine the implementation of f , which is not allowed in the higherorder paradigm).
1.2.2 The teleportation procedure
The teleportation algorithm (Bennett et al., 1993) is a procedure for
sending a quantum bit in an unknown state |φi from a location A to a
location B using two classical bits. The procedure can be reversed to
send two classical bits using a quantum bit. In this case it is called the
dense coding algorithm (Bennett and Wiesner, 1992). The teleportation
procedure is summarized in Figure 1.2. The parts (1), (2) and (3) can
be described functionally as follows:
(1) takes no input and outputs an EPR pair of entangled quantum bits.
Its type is therefore ⊤ → qbit ⊗ qbit .
(2) performs a Bell measurement on two quantum bits and outputs two
classical bits x, y. Its type is thus qbit ⊗ qbit → bit ⊗ bit .
Quantum Lambda Calculus
5
(3) performs a correction. It takes one quantum bit, two classical bits, and
outputs a quantum bit. It has a type of the form qbit ⊗bit ⊗bit → qbit .
If one curries† parts (2) and (3), one gets two respective functions
qbit → (qbit → bit ⊗ bit ),
qbit → (bit ⊗ bit → qbit ).
Tensoring them and composing with (1) yields a map
⊤ → qbit ⊗ qbit → (qbit → bit ⊗ bit ) ⊗ (bit ⊗ bit → qbit ).
That is, the teleportation algorithm produces a pair of entangled functions
f : qbit → bit ⊗ bit ,
g : bit ⊗ bit → qbit ,
such that g(f (|φi)) = |φi for all qubits |φi, and f (g(x, y)) = (x, y) for
all booleans x and y. These two functions are each other’s inverse, but
because they contain an embedded qubit each, they can only be used
once. They can be said to form a “single-use isomorphism” between the
(otherwise non-isomorphic) types qbit and bit ⊗ bit .
Note that the two functions f and g are entangled, since they still
share the created EPR pair. One can also identify the “location” of
each function: f is located at B while g is located at A. The tensor “⊗”
acts as “space-like” separation.
1.2.3 Bell’s experiment
Recall Bell’s experiment (Bell, 1964). Two quantum bits A and B are
created in the maximally entangled state |φAB i = √12 (|0i⊗|1i−|1i⊗|0i).
These qubits are sent to Alice and Bob, respectively. Suppose that
Alice and Bob can independently choose one of the following three bases
{a, b, c} for measuring their qubit:
√
√
1
1
3
3
|1i, |0c i = |0i −
|1i,
|0a i = |0i, |0b i = |0i +
2
2
2
2
√
√
3
3
1
1
|1a i = |1i |1b i =
|0i − |1i, |1c i =
|0i + |1i.
2
2
2
2
The question is to compute the probability of obtaining the same output
when measuring A and B with respect to each of the nine possible choices
of a pair of bases.
† Consider a function of two arguments h : A × B → C. Currying h means building
a function h′ : A → (B → C) as follows: h′ is the function that outputs the
function x 7→ h(a, x) when given the input a.
6
P. Selinger and B. Valiron
One can interpret this experiment in the context of higher-order quantum computation. First, the state preparation can be viewed as a map
EPR : ⊤ → qbit ⊗ qbit . Then each of Alice and Bob takes one qubit,
chooses a basis, and measures: the measurement they perform is then a
function f : qbit ⊗ trit → bit , where trit = {0, 1, 2} is a classical threeelement type. One can curry this function to f ′ : qbit → (trit → bit ).
The Bell experiment can be viewed as the composition
EPR
f ′ ⊗f ′
⊤ −−−→ qbit ⊗ qbit −−−−→ (trit → bit ) ⊗ (trit → bit ),
which produces a term of type (trit → bit ) ⊗ (trit → bit ), i.e., a pair
hf, gi of entangled functions. Although this final type is purely classical,
the Bell inequalities prove that there is no classical probabilistic pair of
functions exhibiting the same behavior, namely, such that f (x) = g(y)
with probability 1 if x = y, but with probability 1/4 if x 6= y.
1.3 Design of a typed quantum lambda calculus
In this section, we describe the design of a lambda calculus for quantum
computation in which one can, in particular, interpret the algorithms
described in Section 1.2.
1.3.1 Terms
We begin by defining a generic lambda calculus to support the following
programming constructs: higher-order functions, tuples, disjoint unions,
and recursive function definitions.
Definition 1.3.1 We define a set of lambda terms by the following
abstract syntax:
M, N, P ::= c | x | λx.M | M N |
hM, N i | ∗ | let hx, yi = M in N |
inj l (M ) | inj r (M ) | match P with (x 7→ M | y 7→ N ) |
let rec f x = M in N .
Here, c ranges over a given set of term constants (to be instantiated
below), the symbol x ranges over a fixed given infinite set of term variables.
The intended meaning of the different terms is as follows. The term
λx.M denotes the function x 7→ M . For example, λx.x is the identity
Quantum Lambda Calculus
7
function. The term M N stands for the application of the function M
to the argument N . The term hM, N i represents a pair, and ∗ is the
unique 0-tuple. The term let hx, yi = M in N is the program which first
evaluates M to compute a pair hV, W i, then assigns V to x and W to y
before executing N . The terms inj l (M ) and inj r (M ) denote the left and
right inclusion function of data into a disjoint union, whereas the term
match P with (x 7→ M | y 7→ N ) evaluates P to an element of a disjoint
union, and then proceeds by case distinction depending on whether P is
of the form inj l (x) or inj r (y). Finally, the term let rec f x = M in N
defines a recursive function f (x) = M before evaluating N .
The notions of free and bound variables, of substitution and of αequivalence are defined in a standard way (see e.g. Barendregt, 1984).
We identify terms up to renaming of bound variables, so for instance,
λx.x and λy.y are regarded as equal.
Convention 1.3.2 The set of terms defined in Definition 1.3.1 is somewhat spartan. Following common practice, we will use the following
shorthand notations to make terms more readable:
λx1 . . . xn .M = λx1 .λx2 . . . . λxn .M
M1 M2 . . . Mn = (. . . ((M1 M2 )M3 ) . . . Mn )
hM1 , . . . , Mn i = hM1 , hM2 , . . .ii
λhx, yi.M = λz.(let hx, yi = z in M )
λ∗.M = λz.M
(where z is fresh),
let x = M in N = (λx.N )M
let ∗ = M in N = (λz.N )M
(where z is fresh)
let f y1 . . . yn = M in N = let f = (λy1 . . . yn .M ) in N
let rec f x y1 . . . yn = M in N = let rec f x = (λy1 . . .yn .M ) in N
0 = inj r (∗)
1 = inj l (∗)
if P then M else N = match P with (x 7→ M | y 7→ N )
(where x, y are fresh)
We now specify a set of term constants specific to quantum computation. The constants are:
• new is a function for state preparation. It inputs a classical bit (i.e.,
0 or 1 as defined in Convention 1.3.2), and outputs a quantum bit
prepared in state |0i or |1i, respectively.
8
P. Selinger and B. Valiron
• meas is a function for measurement. It inputs a quantum bit, measures
it in the standard basis {|0i, |1i}, and outputs the result as a classical
bit.
• a set of constants U , ranging over some fixed universal set of unitary
gates of varying arities.
The set of constants can be expanded when it is convenient to do so,
for example to include new language features. We will make use of this
prerogative in Section 1.5.1.
Example 1.3.3 In this language, one can write lambda terms that
compute quantum algorithms. For example, a fair coin can be implemented as c = λ∗. meas(H(new 0)), where H is the Hadamard gate.
More examples will be given in Section 1.3.4.
1.3.2 Types
Clearly, not every term defined in Section 1.3.1 makes sense in every
possible context. For example, the term M N only makes sense if M is
a function; the term let hx, yi = M in N only makes sense when M is a
pair; the term match P with (x 7→ M | y 7→ N ) only makes sense when
P is a member of a disjoint union; and the term meas M only makes
sense if M is a quantum bit.
Moreover, a term such as λx.hx, xi only makes sense when x is a
duplicable value, such as a classical bit, and not, for example, a quantum
bit (which cannot be duplicated by the no-cloning theorem).
As is common in programming languages, we define a type system
to rule out terms that “don’t make sense”. An important feature of a
static type system is that well-typedness can be checked when a term
is written, and not when it is executed. Another useful feature of some
type systems is that types can be inferred automatically, rather than
having to be explicitly specified by the programmer. As we will see, the
type system we are about to introduce has all of the above properties.
Informally, and as a first approximation, it is useful to think of a type
as a set of values. For example, qbit is the set of all one-qubit states,
whereas bit is the set of classical booleans. A ⊗ B is the set of (possibly
entangled) pairs of an element of type A and and element of type B. ⊤
is a singleton type, and A ⊕ B is the disjoint union of A and B. Since
we are interested in higher-order computation, the functions from A to
B also form a type, which we write as A ⊸ B. Finally, we write !A for
Quantum Lambda Calculus
9
the subset of values of type A that have the additional property of being
re-usable (i.e., duplicable, cloneable).
The type systems is based on intuitionistic linear logic (Girard, 1987),
and is formally defined as follows.
Definition 1.3.4 The set of types for the quantum lambda calculus is
given by the following abstract syntax.
Type A, B ::= qbit | !A | (A ⊸ B) | ⊤ | (A ⊗ B) | (A ⊕ B).
We call the operator “!” the exponential.
Convention 1.3.5 We write !n A for !!! . . .!!A, with n repetitions of !.
We also use the notation A⊗n for the n-fold tensor product
A ⊗ . . . ⊗ A = (. . . (A ⊗ A) . . . ⊗ A).
Similarly, we write A⊕n for the n-fold sum:
A ⊕ . . . ⊕ A = (. . . (A ⊕ A) . . . ⊕ A).
Finally, we use the shorthand notation bit = ⊤ ⊕ ⊤.
When it is convenient, the set of types can be extended to support
new language features. For example, in Section 1.5.1, we will define a
type list (A) of list of elements of type A.
1.3.3 Typing rules
We have stated informally that !A is the set of values of type A that have
the additional property of being re-usable. Consequently, any term that
has type !A should automatically also have type A. We say that !A is a
subtype of A. The concept of a subtype also extends to composite types,
for instance, any function of type A ⊸ B that can accept an argument
of type A can also accept a re-usable argument of type A. Therefore,
A ⊸ B is a subtype of !A ⊸ B. This motivates the following definition:
Definition 1.3.6 We define the subtyping relation <: to be the smallest relation on types satisfying the rules in Table 1.1, using the overall
condition on n and m that (m = 0) ∨ (n > 1).
Note that the rules in Table 1.1 should be read as follows: if the
premises (above the horizontal line) are all true, then the conclusion
(below the horizontal line) is true.
10
P. Selinger and B. Valiron
!n qbit <: !m qbit
(qbit),
A1 <: B1 A2 <: B2
(⊗),
! (A1 ⊗ A2 ) <: !m (B1 ⊗ B2 )
n
!n ⊤ <: !m ⊤
(⊤),
A <: A′ B <: B ′
(⊸),
! (A ⊸ B) <: !m (A ⊸ B ′ )
n
′
A1 <: B1 A2 <: B2
(⊕).
!n (A1 ⊕ A2 ) <: !m (B1 ⊕ B2 )
Table 1.1. Subtyping relation
Lemma 1.3.7 The subtyping relation <: is reflexive and transitive.
Lemma 1.3.8 If A <: !B, then A = !A′ for some type A′ . Dually, if A
is not of the form !A′ and if A <: B, then B is not of the form !B ′ .
The purpose of the type system is to assign a (not necessarily unique)
type to each well-formed term, with the goal that a well-typed term can
never perform an illegal operation. We write M : A to indicate that the
term M is well-typed of type A. In general, it is not sufficient to reason
about judgements of the form M : A, because the well-typedness of a
term M also depends on the types of all of the free variables that appear
in M . We therefore introduce the notion of a typing context.
Definition 1.3.9 A typing context is a finite set {x1 : A1 , . . . , xn : An }
of pairs of a variable and a type, such that no variable occurs more
than once. We often write ∆ for a typing context, and we write |∆| =
{x1 , . . . , xn } and ∆(xi ) = Ai . We also write !∆ for a context of the form
{x1 : !A1 , . . . , xn : !An }. If |∆| and |∆′ | are disjoint, we write ∆, ∆′ for
the union of two typing contexts. Moreover, we extend the subtyping
relation to contexts as follows. We write ∆<:∆′ if and only if |∆| = |∆′ |
and for all x ∈ |∆|, ∆(x) <: ∆′ (x).
Definition 1.3.10 A typing judgement is an expression of the form
∆ ⊲ M : B, where ∆ is a typing context, M is a term, and B is a type.
A typing derivation is called valid if it can be inferred from the rules in
Table 1.2.
In the table, the symbol c ranges over the set of term constants
{meas, new , U }. To each constant c we associate a type Ac , as follows:
Anew = bit ⊸ qbit , AU = qbit ⊗n ⊸ qbit ⊗n , Ameas = qbit ⊸ !bit .
Quantum Lambda Calculus
A <: B
(ax 1 )
∆, x : A ⊲ x : B
∆ ⊲ M : !n A
(⊕.I1 )
∆ ⊲ inj l (M ) : !n (A ⊕ B)
!∆, Γ1 ⊲ P : !n (A ⊕ B)
11
!Ac <: B
(ax 2 )
∆⊲c:B
∆ ⊲ N : !n B
(⊕.I2 )
∆ ⊲ inj r (N ) : !n (A ⊕ B)
!∆, Γ2 , x : !n A ⊲ M : C
!∆, Γ2 , y : !n B ⊲ N : C
Γ1 , Γ2 , !∆ ⊲ match P with (x 7→ M | y 7→ N ) : C
(⊕.E)
Γ1 , !∆ ⊲ M : A ⊸ B Γ2 , !∆ ⊲ N : A
(app)
Γ1 , Γ2 , !∆ ⊲ M N : B
x : A, ∆ ⊲ M : B
(λ1 )
∆ ⊲ λx.M : A ⊸ B
If F V (M ) ∩ |Γ| = ∅:
Γ, !∆, x : A ⊲ M : B
Γ, !∆ ⊲ λx.M : !n+1 (A ⊸ B)
!∆, Γ1 ⊲ M1 : !n A1 !∆, Γ2 ⊲ M2 : !n A2
(⊗.I)
!∆, Γ1 , Γ2 ⊲ hM1 , M2 i : !n (A1 ⊗ A2 )
(λ2 )
∆ ⊲ ∗ : !n ⊤
(⊤)
!∆, Γ1 ⊲ M : !n (A1 ⊗ A2 ) !∆, Γ2 , x1 :!n A1 , x2 :!n A2 ⊲ N : A
(⊗.E)
!∆, Γ1 , Γ2 ⊲ let hx1 , x2 i = M in N : A
!∆, f : !(A ⊸ B), x : A ⊲ M : B !∆, Γ, f : !(A ⊸ B) ⊲ N : C
(rec)
!∆, Γ ⊲ let rec f x = M in N : C
Table 1.2. Typing rules
Lemma 1.3.11 The following are derived rules:
⊲ 0 : !n bit ,
(bit .I1 )
⊲ 1 : !n bit ,
(bit .I2 )
!∆, Γ1 ⊲ P : bit !∆, Γ2 ⊲ M, N : A
(bit .E)
!∆, Γ1 , Γ2 ⊲ if P then M else N : A.
Proof The proof is straightforward using the typing rules and Conventions 1.3.2 and 1.3.5.
Remark 1.3.12 The type !Ac is understood as being the “most generic”
one for c, as enforced by the typing rule (ax 2 ). For example, we defined
Anew to be bit ⊸ qbit . Since by the rule (ax 2 ), new can take any type
B such that !Ac <: B, the term new can be typed with any type in the
12
P. Selinger and B. Valiron
following poset:
!(!bit ⊸ qbit ) [ [[
cc<:cc
<:
!bit ⊸ qbit .
!(bit ⊸ qbit ) [[<:[[[
ccc<:cc
bit ⊸ qbit
This implies, as expected, that no created quantum bit can have the
type !qbit .
Remark 1.3.13 Note that the type system enforces the requirement
that variables holding quantum data cannot be freely duplicated; thus
λx.hx, xi is not a valid term of type qbit ⊸ qbit ⊗ qbit . On the other
hand, we allow variables to be discarded freely.
Note also that due to rule (λ2 ) the term λx.M is duplicable only if
all the free variables of M (other that x) are duplicable. This answers
the question, raised in the introduction, what it means for a higherorder function to be “classical”. A function is classical (and therefore
re-usable) if and only if it does not contain any embedded non-duplicable
data. This definition is of course recursive, in a way that is made precise
by the typing rules.
1.3.4 Examples
Example 1.3.14 The term c = λ∗. meas(H(new 0)) of Example 1.3.3
can be typed as ⊲ c : ⊤ ⊸ bit .
Example 1.3.15 Consider the term
M
= let rec f x = (if (c ∗) then H (f x) else x) in f p,
where c is the fair coin of Example 1.3.14. Intuitively, this term applies
the Hadamard gate a random number of times to a qubit p. We claim
that p : qbit ⊲ M : qbit is a valid typing judgement. Indeed, assuming
that ⊲ c : ⊤ ⊸ bit is a valid typing judgement, one can write the
following typing derivation:
1
(ax 1 )
f : !(qbit ⊸qbit ), x : qbit ⊲ x : qbit
2
(⊸)
!(qbit ⊸qbit ) <: qbit ⊸ qbit
3
(2, ax1 )
f : !(qbit ⊸qbit ) ⊲ f : qbit ⊸ qbit
4
(3, 1, app)
f : !(qbit ⊸qbit ), x : qbit ⊲ (f x) : qbit
5
(2, ax 2 )
⊲ H : qbit ⊸ qbit
Quantum Lambda Calculus
6
(5, 4, app)
f : !(qbit ⊸qbit ), x : qbit ⊲ H (f x) : qbit
7
(Ex.1.3.14)
8
(⊤.I)
⊲ c : ⊤ ⊸ bit
9
(7, 8, app)
10 (9, 6, 1, if )
13
⊲∗:⊤
⊲ c ∗ : bit
f : !(qbit ⊸qbit ), x : qbit ⊲
if (c ∗) then H (f x) else x : qbit
11 (ax 1 )
p : qbit ⊲ p : qbit
12 (3, 11, app)
p : qbit , f : !(qbit ⊸ qbit ) ⊲ f p : qbit
13 (10, 12, rec) p : qbit ⊲ let rec f x =
if (c ∗) then H (f x) else x)
in f p : qbit
Here, we have used the notation (x,y,z,R) for “The rule R is used with
hypothesis lines x, y and z”. The rule (⊸) refers to Table 1.1.
Example 1.3.16 Consider the Deutsch-Jozsa algorithm introduced in
Section 1.2.1. We claimed that one can interpret it as a term of type
(qbit ⊗ qbit ⊸ qbit ⊗ qbit ) → bit .
Here is an implementation in the quantum lambda calculus, using the
notations of Convention 1.3.2:
let Deutsch Uf =
let tens f g = λhx, yi.hf x, gyi in
let hx, yi = (tens H (λx.x))(Uf hH(new 0), H(new 1)i) in
meas x,
One can check that
⊲ Deutsch : !((qbit ⊗ qbit ⊸ qbit ⊗ qbit ) ⊸ bit )
is a well-typed typing judgement. Note that Deutsch is duplicable, and
that Uf does not need to be duplicable, since it is used only once.
Example 1.3.17 The teleportation algorithm can similarly be defined.
Part (1) is the function EPR : !(⊤ ⊸ (qbit ⊗ qbit )), defined as
EPR = λx.CNOT hH(new 0), new 0i.
14
P. Selinger and B. Valiron
Part (2) is the function BellMeasure : !(qbit ⊸ (qbit ⊸ bit ⊗ bit )), defined as
BellMeasure =
λq2 .λq1 .(let hx, yi = CNOT hq1 , q2 i in hmeas(Hx), meas yi.
Part (3) is the function U : !(qbit ⊸ (bit ⊗ bit ⊸ qbit )) defined as
U = λq.λhx, yi.if x then (if y then U11 q else U10 q)
else (if y then U01 q else U00 q).
The teleportation procedure as described in Section 1.2.2 can be written
with the following code:
telep =
let hx, yi = EPR ∗ in
let f = BellMeasure x in
let g = U y
in hf, gi.
It can then be shown that
⊲ telep : (qbit ⊸ bit ⊗ bit ) ⊗ (bit ⊗ bit ⊸ qbit )
is a valid typing judgement (for details, see Selinger and Valiron, 2006).
1.3.5 The evaluation of terms: operational semantics
So far, we have concentrated on the static properties of lambda terms,
and have only informally described their intended behavior. In this
section, we will present the formal computation rules by which terms
are evaluated.
Our informal description of the behavior of lambda terms has left
many details undefined. For example, when evaluating a pair of terms
hM, N i, we have not specified whether M or N will be evaluated first.
Similarly, in terms such as let x = M in N , we have not specified
whether M should be evaluated immediately, or whether it should be reevaluated each time the term N needs to access the value of the variable
x. Such seemingly arbitrary choices actually can affect the outcome of
the computation, as the following example shows.
Example 1.3.18 Consider the boolean addition function, defined as
plus = λxy.if x then (if y then 0 else 1) else (if y then 1 else 0).
Quantum Lambda Calculus
15
Now consider the term
let x = c ∗ in plus x x,
where c is the fair coin from Example 1.3.3. If we evaluate c ∗ each time
the variable x is needed, we obtain plus(c ∗)(c ∗), which will be 0 or 1
with equal probability. On the other hand, if we evaluate c ∗ ahead of
time, we obtain either plus 0 0 or plus 1 1, and in either case the final
answer is 0. The former evaluation method is called the call-by-name
method, and the latter is called the call-by-value method.
One of the reasons we give a formal definition of the behavior of
lambda terms is to resolve such imprecisions. Thus, we will have to
make a specific choice in each instance where an ambiguity might arise.
For example, we will be choosing the call-by-value reduction strategy.
Another reason for making a formal definition is that this will allow us
to prove meta-theorems about the behavior of quantum lambda terms.
For example, we will prove in Section 1.3.7 that a well-typed lambda
term never executes an illegal operation such as attempting to clone a
quantum bit.
Definition 1.3.19 A quantum closure (or state) is a tuple [Q, L, M ],
where
• Q is a normalized vector of ⊗ni=1 C2 , for some integer n > 0. The
vector Q is called the quantum array;
• L is a list of n distinct term variables, written as |x1 , . . . , xn i.
• M is a lambda term whose free variables all appear in L.
We write |L| = {x1 , . . . , xn }, and we also write L(xi ) = i for the position
of a variable xi in the list.
The purpose of a quantum closure is to provide a mechanism to talk
about terms with embedded quantum data. The idea is that the variable
xi is bound in the term M to qubit number L(xi ) of the state Q. So for
example, the quantum closure
1
[ √ (|00i + |11i),
2
|pqi,
λx.xpq]
denotes a term λx.xpq with two embedded qubits p, q in the entangled
state |pqi = √12 (|00i + |11i).
The notion of α-equivalence extends naturally to quantum closures,
for instance, the states [Q, |xi, λy.x] and [Q, |zi, λy.z] are equivalent. We
identify quantum closures up to renaming of bound variables.
16
P. Selinger and B. Valiron
[ Q, L, let x = V in M ] →1 [ Q, L, M [V /x] ]
[ Q, L, let hx, yi = hV, W i in N ] →1 [ Q, L, N [V /x, W/y] ]
[ Q, L, match inj l (V ) with (x 7→ M | y 7→ N ) ] →1 [ Q, L, M [V /x] ]
[ Q, L, match inj r (W ) with (x 7→ M | y 7→ N ) ] →1 [ Q, L, N [W/y] ]
[ Q, L, let rec f x = M in N ]
→1 [ Q, L, N [λx.(let rec f x = M in M ) / f ] ]
Table 1.3. Reductions rules: classical control
[ Q, |x1 . . . xn i, U hxj1 , . . . , xjn i ] →1 [ Q′ , |x1 . . . xn i, hxj1 , . . . , xjn i ]
[ α|Q0 i + β|Q1 i, |x1 . . . xn i, meas xi ] →|α|2 [ |Q0 i, |x1 . . . xn i, 0 ]
[ α|Q0 i + β|Q1 i, |x1 . . . xn i, meas xi ] →|β|2 [ |Q1 i, |x1 . . . xn i, 1 ]
[ Q, |x1 . . . xn i, new 0 ] →1 [ Q ⊗ |0i, |x1 . . . xn+1 i, xn+1 ]
[ Q, |x1 . . . xn i, new 1 ] →1 [ Q ⊗ |1i, |x1 . . . xn+1 i, xn+1 ]
Table 1.4. Reductions rules: quantum data
The evaluation of quantum lambda terms will be defined as a probabilistic rewrite procedure on quantum closures, using a call-by-value
reduction strategy.
Definition 1.3.20 A value is a term defined with the following grammar.
Value V, W ::= c | x | λx.M | inj r V | inj l V | ∗ | hV, W i
The quantum closure [Q, L, V ] is called a value state if V is a value.
Definition 1.3.21 The reduction rules are shown in Tables 1.3–1.5. We
write [Q, L, M ] →p [Q′ , L′ , M ′ ] for a single-step reduction of quantum
closures that takes place with probability p. In the rules for let, let
rec, and match, M [V /x] denotes the term M where the free variable x
has been replaced by V (renaming bound variables as necessary). In
the rule for reducing the term U hxj1 , . . . , xjn i, U is an n-ary built-in
unitary gate, j1 , . . . , jn are pairwise distinct, and Q′ is the quantum
state obtained from Q by applying this gate to qubits j1 , . . . , jn . In the
Quantum Lambda Calculus
17
[ Q, L, N ] →p [ Q′ , L′ , N ′ ]
[ Q, L, M N ] →p [ Q′ , L, M N ′ ]
[ Q, L, M ] →p [ Q′ , L′ , M ′ ]
[ Q, L, M V ] →p [ Q′ , L′ , M ′ V ]
[ Q, L, M2 ] →p [ Q′ , L′ , M2′ ]
[ Q, L, hM1 , M2 i ] →p [ Q′ , L′ , hM1 , M2′ i ]
[ Q, L, M1 ] →p [ Q′ , L′ , M1′ ]
[ Q, L, hM1 , V2 i ] →p [ Q′ , L′ , hM1′ , V2 i ]
[ Q, L, M ] →p [ Q′ , L′ , M ′ ]
[ Q, L, inj l (M ) ] →p [ Q′ , L′ , inj l (M ′ ) ]
[ Q, L, M ] →p [ Q′ , L′ , M ′ ]
[ Q, L, inj r (M ) ] →p [ Q′ , L′ , inj r (M ′ ) ]
[ Q, L, P ] →p [ Q′ , L′ , P ′ ]
[ Q, L, match P with . . . ] →p [ Q′ , L′ , match P ′ with . . . ]
[ Q, L, M ] →p [ Q′ , L′ , M ′ ]
[ Q, L, let hx, yi = M in N ] →p [ Q′ , L′ , let hx, yi = M ′ in N ]
Table 1.5. Reductions rules: congruence rules
rule for measurement, |Q0 i and |Q1 i are normalized states of the form
|Q0 i =
X
j
αj |φ0j i ⊗ |0i ⊗ |ψj0 i,
|Q1 i =
X
j
βj |φ1j i ⊗ |1i ⊗ |ψj1 i,
where φ0j and φ1j are i-qubit states (so that the measured qubit is the
one pointed to by xi ). In the rule for new , Q is an n-qubit state, so that
Q ⊗ |ii is an (n + 1)-qubit state.
We write → for the reduction →1 , and →∗ for the reflexive, transitive
closure of →.
Note that the only probabilistic reduction step is the one corresponding to measurement.
Example 1.3.22 Consider the term
M
= let rec f x = (if (c ∗) then H (f x) else x) in f p
18
P. Selinger and B. Valiron
from Example 1.3.15. Let us write
P = if (c ∗) then H (f x) else x
R = let rec f x = P in P .
We have
M → [ |0i, |pi, (f p)[λx.R / f ] ]
→ [ |0i, |pi, (λx.R)p ]
→ [ |0i, |pi, let rec f x = P in (if (c ∗) then H (f p) else p) ]
→ [ |0i, |pi, (if (c ∗) then H (f p) else p)[λx.R / f ] ]
→ [ |0i, |pi, if (c ∗) then H ((λx.R) p) else p ]
= [ |0i, |pi, if (meas(H(new 0))) then H ((λx.R) p) else p ]
→ [ |00i, |pqi, if (meas(H q)) then H ((λx.R) p) else p ]
1
→ [ √ (|00i + |01i), |pqi, if (meas q) then H ((λx.R) p) else p ]
2
[ |00i, |pqi, if 0 then H ((λx.R) p) else p ]
→
[ |01i, |pqi, if 1 then H ((λx.R) p) else p ]
[ |00i, |pqi, p ]
→
[ |01i, |pqi, H ((λx.R) p) ]

 [ |00i, |pqi, p ]
→
[ |01i, |pqi, H (letrec f x = P in

if (c ∗) then H ((λx.R) p) else p) ]


 [ |00i, |pqi, p ]
∗
[ √12 (|010i + |011i), |pqri,
→


H if (meas r) then H ((λx.R) p) else p ]

[ |00i, |pqi, p ]
 →
[ |010i, |pqri, H if 0 then H ((λx.R) p) else p ]

[ |011i, |pqri, H if 1 then H ((λx.R) p) else p ]

[ |00i, |pqi, p ]
 →
[ |010i, |pqri, H p ]

[ |011i, |pqri, H (H ((λx.R) p)) ]

[ |00i, |pqi, p ]




  [ √1 (|010i + |110i), |pqri, p ]
 2
→∗

[ |0110i, |pqrsi, H (H p) ]


 

[ |0111i, |pqrsi, H (H (H ((λx.R) p))) ]
Quantum Lambda Calculus
→∗













19
[ |00i, |pqi, p ]
 1
[ √2 (|010i + |110i), |pqri, p ]



 
[ |0110i, |pqrsi, p ]

 (

[ √12 (|01110i + |11110i), |pqrsti, p ]

 


···
where each split occurs with probability 12 , and where the result is read
as the term part of the value state. On average, the term M reduces to
|0i with probability
∞
2
1
1
1X 1
=
=
2 n=0 22n
2 1 − 14
3
and to √12 (|0i + |1i) with probability 13 . Note that since there is no
garbage collection, the quantum array is filled up with unused quantum bits. It is possible to define an operational semantics that removes
unused quantum bits (see e.g. Selinger and Valiron, 2008b).
Remark 1.3.23 (Error states) The purpose of the reduction rules is
to evaluate a quantum closure until a value state is reached. However,
this does not always succeed: there are states (so-called error states)
that are not values, but from which no reduction is possible. Such
states correspond to run-time errors of the programming language (and
in actual implementations, these would either lead to run-time error
messages, or to undefined behavior). Examples of error states are the
quantum closures [Q, L, let hx, yi = inj l (M ) in N ], [Q, L, meas(λx.x)],
and [Q, |xyzi, U hx, xi].
In Sections 1.3.2 and 1.3.3, we introduced a type system precisely for
the purpose of ruling out such error states. And indeed, we will show in
Section 1.3.7 that well-typed closure can never lead to an error state.
1.3.6 Properties of the type system
Before we can prove type soundness of the reduction rules, we need to
record some basic properties of the type system.
Lemma 1.3.24
(1) If x 6∈ FV (M ) and ∆, x : A ⊲ M : B, then ∆ ⊲ M : B.
(2) If ∆ ⊲ M : A, then Γ, ∆ ⊲ M : A.
(3) If Γ <: ∆ and ∆ ⊲ M : A and A <: B, then Γ ⊲ M : B.
20
P. Selinger and B. Valiron
Proof By structural induction on the type derivation of M .
The next lemma is crucial in the proof of the substitution lemma. Note
that it is only true for a value V , and in general fails for an arbitrary
term M .
Lemma 1.3.25 If V is a value and ∆ ⊲ V : !A, then for all x ∈ FV (V ),
there exists some type B such that ∆(x) = !B. Conversely, if FV (V ) =
|∆| and if !∆, Γ ⊲ V : A is valid, so is !∆, Γ ⊲ V : !A.
Proof By structural induction on V .
Lemma 1.3.26 (Substitution) If V is a value such that Γ1 , !∆, x :
A ⊲ M : B and Γ2 , !∆ ⊲ V : A, then Γ1 , Γ2 , !∆ ⊲ M [V /x] : B.
Proof By structural induction on the derivation of the typing judgement
Γ1 , !∆, x : A ⊲ M : B, using Lemma 1.3.24. In the case (λ2 ), one uses
Lemma 1.3.25.
Remark 1.3.27 Those readers familiar with intuitionistic linear logic
(Girard, 1987; Troelstra, 1992) may note that all the rules of affine intuitionistic logic are derived rules of our type system, except for the general
promotion rule
!∆ ⊲ M : A
!∆ ⊲ M : !A.
The absence of this rule is necessary: indeed, although the typing judgement ⊲ new 0 : qbit is valid, the judgement ⊲ new 0 : !qbit should not
be allowed. However, as stated in Lemma 1.3.25, the promotion rule is
true if M is a value. This point will be further developed in Section 1.6
when we study the categorical semantics.
1.3.7 Safety properties
In this section, we wish to show that a well-typed program cannot reach
an error state. We first define what it means for a quantum closure to
be well-typed:
Definition 1.3.28 Consider the quantum closure [ Q, L, M ] where L =
|x1 . . . xk i. We say that [ Q, L, M ] is well-typed (or valid ) of type C,
Quantum Lambda Calculus
21
written [ Q, L, M ] : C, if x1 : qbit , . . . , xk : qbit ⊲ M : C is a valid typing
judgement. A well-typed quantum closure is also called a program.
The first step in proving type safety is to show that well-typedness is
preserved by the reduction rules. This property is known as the subject
reduction property. In order to get the strongest possible result, we
will prove that type safety holds even in the presence of decoherence
and imprecision of the physical operations. To that end, we define a
notion of reachability of quantum closures that includes reduction steps
of probability 0, as well as arbitrary perturbations of the quantum state.
Definition 1.3.29 The reachability relation
is the smallest transitive
reflexive relation on quantum closures such that [Q, L, M ]
[Q′ , L′ , M ′ ]
holds whenever [Q, L, M ] →p [Q′ , L′ , M ′ ] with some probability p (even
for p = 0), and such that [Q, L, M ]
[Q′ , L, M ] whenever Q′ is a
normalized vector of dimension equal to that of Q.
Theorem 1.3.30 (Subject reduction) Suppose [ Q, L, M ] : A and
[ Q, L, M ]
[ Q′ , L′ , M ′ ]. Then [ Q′ , L′ , M ′ ] : A.
Proof Since well-typedness is defined without reference to Q, it suffices
to show that if [ Q, L, M ] : A and if [ Q, L, M ] →p [ Q′ , L′ , M ′ ], then
[ Q′ , L′ , M ′ ] : A. This is proved by induction on the derivation of the
reduction, using Lemma 1.3.26 in the “let”, “let rec” and “match” cases.
We detail one of the less immediate cases, the case let rec. Suppose
that
..
..
.. π2
.. π1
!∆, f : !(A ⊸ B), x : A ⊲ M : B !∆, Γ, f : !(A ⊸ B) ⊲ N : C
!∆, Γ ⊲ let rec f x = M in N : C
is a valid derivation. Then so is
..
..
.. π1
.. π1
!∆, f : !(A ⊸ B), x : A ⊲ M : B !∆, f : !(A ⊸ B), x : A ⊲ M : B
!∆, x : A ⊲ let rec f x = M in M : B
!∆ ⊲ λx.(let rec f x = M in M ) : !(A ⊸ B).
By Lemma 1.3.26, one concludes
!∆, Γ ⊲ N [λx.(let rec f x = M in M ) / f ] : C.
22
P. Selinger and B. Valiron
Lemma 1.3.31 A well-typed value is either a constant, a variable, or
one of the following case occurs: if it is of type !n (A ⊕ B), it is of the
form inj l (V ) or inj r (V ) with V a value; if it is of type !n (A ⊗ B), it is of
the form hV, W i with V and W values; if it is of type !n ⊤, it is precisely
the term ∗; if it is of type !n (A ⊸ B), it is a lambda-abstraction.
Proof By structural induction on the derivation of the typing judgement.
Theorem 1.3.32 (Progress) Let [ Q, L, M ] be a program of type B.
Then either [ Q, L, M ] is a value state, or there is a program [ Q′ , L′ , M ′ ]
such that [ Q, L, M ] →p [ Q′ , L′ , M ′ ]. Moreover, the total probability of
all possible single-step reductions from [ Q, L, M ] is 1.
Proof By structural induction on the derivation of the reduction of
[ Q, L, M ], using Lemma 1.3.31.
Corollary 1.3.33 (Type safety) A well-typed program does not reach
an error state. In particular, any probabilistic computation path of a
well-typed program is either infinite, or reaches a value state in a finite
number of steps.
Remark 1.3.34 The evaluation rules of the quantum lambda calculus
were defined on untyped quantum closures. This is in line with our
remark, in Section 1.3.2, that well-typedness is a property to be checked
when a term is written, and not when it is executed. In other words,
once it is established that a term is well-typed, it can be safely executed,
without further well-typedness checks at runtime, and the type safety
property guarantees that there will be no errors. In particular, the type
system introduces no computational overhead in the evaluation of terms.
1.3.8 Design choices and some related work
We briefly discuss some of the design decisions underlying our quantum
lambda calculus.
Classical control. Our quantum lambda calculus has classical control,
by which we mean that it essentially fits into the QRAM paradigm of
quantum computing (Knill, 1996). This means that, while programs
operate on quantum data, the programs themselves are classical. For
Quantum Lambda Calculus
23
example, we do not allow superpositions of two arbitrary lambda terms.
Van Tonder (2004) gives convincing evidence that this choice is essentially necessary.
Call-by-value reduction. We have equipped the quantum lambda calculus with a call-by-value reduction strategy, which means that the arguments to any function call are completely evaluated before the function is
called. This is in contrast to call-by-name or lazy languages, which evaluate the arguments only if they are actually needed. Example 1.3.18
shows that it is necessary to choose a reduction strategy; the actual
choice is largely a matter of taste.
Uniformity of data. Our language treats classical and quantum data
uniformly. This means that we do not have, for example, distinct sets
of classical variables and quantum variables. For example, we use the
same syntax for a function, regardless of whether the function accepts
a classical argument, a quantum argument, or indeed, a more complex
object (such as a pair of a classical bit and a quantum bit). We use a
type system to ensure well-formedness of programs.
Implicit linearity tracking. Perhaps the most important choice that
we have made, which distinguishes the quantum lambda calculus from
other linear lambda calculi in the literature, is that there is no explicit
syntax for linearity in the untyped language. This was motivated by the
desire to design a language for practical use, which would be as natural
as possible to the programmer.
The literature contains a number of lambda calculi for intuitionistic
linear logic. For example, the linear lambda calculi of (Abramsky, 1993)
and (Benton et al., 1993b; Benton, 1995; Benton and Wadler, 1996) have
typing rules such as
∆ ⊲ M : !A
∆ ⊲ derelict(M ) : A
Γ ⊲ M : !A
∆, x : !A, y : !A ⊲ N : B
Γ, ∆ ⊲ copy M as x, y in N : B
Γ ⊲ M : !A
∆⊲N :B
Γ, ∆ ⊲ discard M in N : B
This means, if one has a variable x of duplicable type !A, and one wants
to use this variable twice, then one must write
copy x as x1 , x2 in f (derelict(x1 ), derelict(x2 )),
24
P. Selinger and B. Valiron
whereas in the quantum lambda calculus, we would simply write
f (x, x).
Our syntax is less faithful to the inference rules of intuitionistic linear
logic. For example, the term f (g(x, x)) in the quantum lambda calculus could ambiguously refer to either of the following two terms in the
language of Benton et al.:
copy x as x1 , x2 in f (g(derelict(x1 ), derelict(x2 ))), or
f (copy x as x1 , x2 in g(derelict(x1 ), derelict(x2 ))).
Our point of view is that this apparent ambiguity does not matter from
a practical point of view, because the two terms will compute precisely
the same thing. Therefore, the programmer should not have to worry
about such details as the precise time of the duplication of a particular
value.
While this makes programming in the quantum lambda calculus simpler, it leads to a more complicated meta-theory. Some of the technical
complications are: we need to introduce a subtyping relation, which
complicates the proofs of type soundness. Also, because of the above
ambiguities, typing derivations are not unique in the quantum lambda
calculus, which means that we have to work harder to prove that the
meaning of terms is independent of the typing derivation used (see Theorem 1.6.30 below).
Ultimately, we feel that this is a worthwhile trade-off, as the more
complicated meta-theory can be settled once and for all. Moreover, it
is reassuring to know that type checking, including checking of linearity
constraints, can be completely automated by a type inference algorithm
(see Section 1.4), so that the slightly more complicated type system does
not result in a burden to the programmer.
Type isomorphisms. In our formulation of the quantum lambda calculus, we have a type isomorphism !!A ∼
= !A, which is not valid e.g.
in Benton’s system. This is a necessary consequence of our choice of
implicit linearity tracking, as a value of type !A can be used with type
!!A and vice versa. For similar reasons, we have a type isomorphism
!(A ⊗ B) ∼
= !A ⊗ !B, which is not valid in general linear logic. This is
because in the quantum lambda calculus, a pair hx, yi of type A ⊗ B is
duplicable if and only if x and y are duplicable.
Quantum Lambda Calculus
25
Copying vs. cloning. Altenkirch and Grattage (2005) have described
a quantum programming language where implicit copying of quantum
data is allowed, but is interpreted as creating an entangled pair, rather
than as cloning. This, however, requires an explicit operation for discarding unused data, similar to Benton et al.’s “discard” operation.
1.4 Type inference algorithm
When writing programs in the quantum lambda calculus, it is an important task, as we have seen in the previous section, to check that
the program is well-typed. One way to ensure this would be to require
the programmer to supply all type information. This means, the programmer would have to explicitly state the type of every variable and
subexpression used in the program. In practice, this is quite cumbersome, as the types can be long and error-prone to write, and make the
program hard to read.
Fortunately, the process can be automated. A type inference algorithm
is an algorithm that inputs an untyped quantum closure, and either
outputs a possible type for it, or else announces that no such type exists.
When a type inference algorithm exists, the programmer is free to write
terms in an untyped way and can rely on the type inference algorithm
to point out any potential safety problems.
In “classical” lambda calculus, there exists a well-known type inference
algorithm (for a reference, see e.g. Pierce, 2002), which is based on the
fact that every term admits a principal type. A type is principal among
the possible types of a term if any other possible type can be obtained
from it by instantiation of type variables. For example, in simply typed
lambda calculus, the term M = λf x.f x admits a principal type of the
form (X ⇒ Y ) ⇒ (X ⇒ Y ). Here, X and Y are type variables, and any
valid type of M , such as (A ⇒ (B ⇒ A)) ⇒ (A ⇒ (B ⇒ A)), can be
obtained by substituting particular types for X and Y .
The quantum lambda calculus of this chapter does not satisfy the
principal type property. The main complication is the subtyping relation
<:, which allows a term to possess multiple types that are not instances
of each other. Indeed, consider again the term M = λf x.f x. Naively, a
principal type would be (1) the most general with respect to instantiation
of type variables, and (2) the smallest with respect to the subtyping
relation. Here are some possible types for M , ordered by the subtyping
relation (from left to right) as shown in Table 1.6. Note that the types
!((X ⊸ Y ) ⊸ !(X ⊸ Y )) and (X ⊸Y )⊸!(X ⊸ Y ) are not valid for the
26
P. Selinger and B. Valiron
/ (X⊸Y )⊸(X⊸Y )
TTTT
SSSS
S)
T*
/ !(X⊸Y )⊸(X⊸Y ).
!(!(X⊸Y )⊸(X⊸Y ))
j4
k5
jjjj
kkkk
/
!(!(X⊸Y )⊸!(X⊸Y ))
!(X⊸Y )⊸!(X⊸Y )
!((X⊸Y )⊸(X⊸Y ))
Table 1.6. Partial ordering of some possible types of λf x.f x
term M . Therefore, there is no smallest element in the set of possible
types for M .
Despite the absence of principal types, it is nevertheless possible to
find a type inference algorithm for the quantum lambda calculus. The
idea is to proceed in two steps: first, find the principal type derivation for
M in a simply-typed version of the language (i.e., without the operator !,
and without any restriction on duplication). Second, try to “annotate”
this type derivation by putting “!” in the smallest possible number of
locations to satisfy the constraints of the linear type system. It was
shown in (Valiron, 2004a) that this algorithm succeeds if and only if the
term M is typable in the quantum lambda calculus. We refer the reader
to (Valiron, 2004a; Selinger and Valiron, 2006) for the full discussion.
1.5 Extending the language with an infinite data type
For a computational formalism to be fully expressive, it must be able to
operate on data of unlimited size. For example, in the quantum circuit
model, an algorithm is not given by a single quantum circuit, but rather,
by a uniform family of circuits, one for each possible size of input.
In the form given in Section 1.3, the quantum lambda calculus is
only able to operate on finite dimensional data, and therefore, it is not
universal for quantum, or even classical, computation. This situation
can be easily remedied by adding an unbounded data type, such as a
type of lists. We describe such an extension in Section 1.5.1, and then
illustrate its use in Section 1.5.2 with the Quantum Fourier Transform
on an unbounded number of qubits.
1.5.1 The type list (A)
The notion of a list can be easily defined recursively: a list of objects of
type A is either the empty list, or else it is a pair consisting of a head
Quantum Lambda Calculus
27
of type A and a tail that is another list of objects of type A. Therefore,
if list (A) is the type of lists of elements of type A, then the following
recursive equation is satisfied:
list (A) = ⊤ ⊕ (A ⊗ list (A)).
To add such list types to the quantum lambda calculus, we extend:
• the type formation rules: whenever A is a type, then list (A) is a type;
• the term formation rules: we add three term constructors cons(M, N ),
nil and unfold (M );
• the typing rules: we add three new rules
!∆, Γ1 ⊲ M : !n A
!∆, Γ2 ⊲ N : !n list (A)
!∆, Γ1 , Γ2 ⊲ cons(M, N ) : !n list (A),
!∆, Γ1 , Γ2 ⊲ nil : !n list (A),
(list .I1 )
(list .I2 )
∆ ⊲ M : !n list (A)
(list .E)
∆ ⊲ unfold A (M ) : !n ((!⊤) ⊕ (A ⊗ list (A)));
• the reduction rules:
[ Q, L, unfold nil ] →1 [ Q, L, inj l (∗) ],
[ Q, L, unfold(cons(V, W )) ] →1 [ Q, L, inj r hV, W i ],
and the congruence rules:
[ Q, L, N ] →1 [ Q, L, N ′ ]
[ Q, L, cons(M, N ) ] →1 [ Q, L, cons(M, N ′ ) ]
[ Q, L, M ] →1 [ Q, L, M ′ ]
[ Q, L, cons(M, V ) ] →1 [ Q, L, cons(M ′ , V ) ]
[ Q, L, M ] →1 [ Q, L, M ′ ]
[ Q, L, unfold(M ) ] →1 [ Q, L, unfold(M ′ ) ]
Note that a list is duplicable only if all of its elements are duplicable.
In particular, a list of quantum bits is duplicable only if it is empty.
Remark 1.5.1 The extended language still satisfies the safety properties described in Theorems 1.3.30 and 1.3.32. Moreover, since the principal type property still applies for intuitionistic types in this context,
the type inference algorithm can be extended to this situation.
28
P. Selinger and B. Valiron
1.5.2 Implementing the Quantum Fourier Transform
From the list type, we can define a data type of natural numbers Nat =
list (⊤). Then we define the closed terms succ : Nat ⊸Nat and two : Nat
as follows:
let succ n = cons(∗, n),
let two = succ (succ nil ).
Assume that rn : Nat ⊸ (qbit ⊗ qbit ⊸ qbit ⊗ qbit ) is a term such that
rn n computes the gate


1 0 0
0
0 1 0
0 

.
0 0 1
0 
n
0 0 0 e2πi/2
Then one can define the term rotate : qbit ⊸qlist ⊸Nat ⊸(qbit ⊗qlist ):
let rec rotate h t n = match unfold (t) with
x 7→ nil
b 7→ let hx, yi = b in
let hx, hi = (rn n) hx, hi in
let hh, yi = rotate h y (succ n) in
hh, cons(x, y)i,
and the term QFT : qlist ⊸ qlist :
let rec QFT l = match unfold (l) with
x 7→ nil
b 7→ let hh, ti = b in
let hh, ti = rotate h t two in
let t = QFT t in
cons(h, t).
The QFT term implements the quantum Fourier algorithm but does
not reverse the order of the qubits in the output list. Reversing the
order of the elements in a list can be efficiently implemented as a map
rev : list (A) ⊸ list (A), defined using an auxiliary map aux : list (A) ⊗
list (A) ⊸ list (A):
let rec aux l1 l2 = match unfold (l1 ) with
x 7→ l2
b 7→ let hx, yi = b in aux y cons(x, l2 ),
let rev l = aux l nil .
Quantum Lambda Calculus
29
Note that these functions are linear: the function rev can therefore be
used to reverse the order of a list of quantum bits to implement the end
of the QFT algorithm.
Remark 1.5.2 Unlike the examples of Section 1.2, the implementation
of the quantum Fourier transform does not use higher-order structures.
1.6 Categorical semantics
In this section, we present some more advanced material on categorical
models for the quantum lambda calculus. The mathematical area of
category theory (Mac Lane, 1971) is well-suited for the study of programming languages, as it reveals the structure of programming language features, such as higher-order functions, computational effects, or
linearity, at a more abstract level.
For example, there is a well-known connection between higher order
functions and the theory of cartesian-closed categories (Lambek and
Scott, 1986). Moggi (1991) has given a general theory of computational
effects (such as probabilistic programs) in terms of the categorical concept of a strong monad. Finally, Seely (1989), Bierman (1993), and
Benton et al. (1993b,a) have given categorical models of linear logic. In
this section, we show how to combine these models to obtain a categorical description of the higher-order probabilistic linear features of the
quantum lambda calculus.
Categorical semantics is fundamentally a theory of equations between
programs. In investigating the equational theory of the quantum lambda
calculus, we find that the equations can be divided into two classes:
structural equations, such as (λx.M )V = M [V /x], which derive from the
higher-order type and term constructors, and ground equations, such as
meas(H(H(new 0))) = 0, which encode special properties of the chosen
set of elementary operators.
The ground operations for quantum computation are already well understood: they are given by state preparation, unitary operations, and
measurements, and they satisfy precisely the equations that hold in the
usual formalism of finite-dimensional Hilbert spaces, density matrices,
and superoperators (see e.g. Selinger, 2004).
In constructing a concrete model for a programming language, one
usually first focuses on the structural equations, i.e., without fixing a
particular set of ground operations. This allows one to identify a whole
class of categories that possess the required higher-order structure. In a
30
P. Selinger and B. Valiron
second step, one may then look for a particular member of this class of
categories that also supports the required ground operations.
We will focus exclusively on the first step, i.e., we will work relative
to an unspecified, but fixed set of ground types (denoted α), ground
operations (denoted c), and ground equations. The construction of a
concrete model of higher-order quantum computation, i.e., a specific
model that supports both the ground operations and the higher-order
structure, is an open problem.
To keep the presentation reasonably simple, we restrict ourselves to
the subset of the quantum lambda calculus without union types or recursive function definitions. We call this the “core fragment” of the
quantum lambda calculus. The results presented here can be easily extended to the full language.
1.6.1 Equational description of the core fragment
Definition 1.6.1 The core fragment of the linear lambda calculus is
defined as follows:
Type A, B
::= α | !A | A ⊸ B | ⊤ | A ⊗ B
Value V
::= x | c | ∗ | λx.M | hV, V ′ i,
Term M, N ::= V | hM, N i | (M N ) | let hx, yi = M in N .
Definition 1.6.2 We define an equivalence relation on typing judgements as being the smallest equivalence relation ≈ax satisfying the axioms in Table 1.7, and satisfying the usual congruence relations, stating
that if M is a term of the form C[N ], i.e. with a subterm N , such that
N ≈ax N ′ , then M is equivalent to C[N ′ ]. We use the notations . , .. and
... as place holders for x and hx, yi (not respectively). We also assume
that V is a value.
Note that the relation ≈ax is on typing judgements, and not on untyped terms. We write ∆ ⊲ M ≈ax M ′ : A if we want to make the
typing context explicit, but we also often write M ≈ax M ′ when the
typing information is implicit.
Quantum Lambda Calculus
(βλ )
(β⊗ )
(β∗ )
(ηλ )
(βλ2 )
(η⊗ )
(η∗ )
(let app )
(let λ )
(let ⊗ )
(let 1 )
(let 2 )
31
let x = V in M
≈ax M [V /x],
let hx, yi = hV, W i in M
≈ax M [V /x, W/y],
let ∗ = ∗ in M
≈ax M,
λx.V x
≈ax V,
let x = N in x
≈ax N,
let hx, yi = N in hx, yi
≈ax N,
let ∗ = N in ∗
≈ax N,
let x = M in let y = N in xy
≈ax M N,
let x = V in λy.M
≈ax λy.let x = V in M ,
let x = M in let y = N in hx, yi ≈ax hM, N i,
let . = (let .. = M in N ) in P
≈ax let .. = M in let . = N in P ,
let . = V in let .. = W in M
≈ax let .. = W in let . = V in M ,
Table 1.7. Axiomatic equivalence
1.6.2 The term model
Having an equivalence relation on typing judgements, it is possible to define categories from axiomatic equivalence classes of typing judgements,
as in (Lambek and Scott, 1986).
Definition 1.6.3 We define the notion of extended value as follows:
ExtValue E, E ′ ::= V | hE, E ′ i | let x = E in E ′ | let hx, yi = E in E ′ ,
where V is a value. To distinguish between the two sorts of values we
also call the values of Definition 1.6.1 core values.
The relationship between extended values and core values is explained
by the following lemma.
Lemma 1.6.4 Suppose that no constant term c has a type of the form
!n (A ⊗ B). Then for every extended value E such that ⊲ E : A, there
exists a core value V with ⊲ E ≈ax V : A.
Proof The proof is done by induction on the size of E.
Remark 1.6.5 The restriction on constants in Lemma 1.6.4 is not a
serious one: if a constant c of type !n (A ⊗ B) were ever needed, one
could instead use two constants c1 : !n (A) and c2 : !n (B).
32
P. Selinger and B. Valiron
Definition 1.6.6 We define three categories:
The category D of computations. Objects are types and arrows of
the form A → B are valid typing judgements x : A ⊲ M : B.
The composition of x : A ⊲ M : B and y : B ⊲ N : C is x : A ⊲
let y = M in N : C and the identity on A is x : A ⊲ x : A.
The category C of values. Objects are types and arrows A → B are
valid typing judgements of the form x : A ⊲ E : B, where E is
an extended value. Composition and identity are defined in the
same way as for D.
The category B of classical values. Objects are types and arrows
A → B are valid typing judgements of the form x : !A ⊲ E : !B,
where E is an extended value. Composition and identity are
defined in the same way as for D.
The category D represents the class of quantum computations, i.e.,
terms that must still be evaluated and can result in a probability distribution of values. The category C stands for the category of quantum
values. The category B is more specific: it is composed of the duplicable values with only duplicable free variables. We therefore call it the
category of classical values.
Lemma 1.6.7 The structures defined in Definition 1.6.6 are categories.
The remainder of this section is devoted to a study of the abstract
properties of the categories B, C, and D.
1.6.3 Structure of the tensor operator “ ⊗”
The first structural element coming from the type system is the tensor
⊗. As suggested by the notation, the tensor possesses the structure of
a symmetric monoidal category.
Definition 1.6.8 A monoidal category E is a tuple (E, ⊗, ⊤, α, λ, ρ)
where E is a category, ⊗ : E × E → E is a functor, ⊤ is an object of E
and α, λ, ρ are three natural isomorphisms
αA,B,C : A ⊗ (B ⊗ C) → (A ⊗ B) ⊗ C,
λA : ⊤ ⊗ A → A,
ρA : A ⊗ ⊤ → A
Quantum Lambda Calculus
33
such that the diagrams
(1.1)
(A ⊗ B) ⊗ (C ⊗ D)
WWWαWW
α g3
W+
ggggg
((A ⊗ B) ⊗ C) ⊗ D
A ⊗ (B ⊗ (C ⊗ D))
AA
|=
AA
||
A
|
id ⊗α A
|| α⊗id
/
A ⊗ ((B ⊗ C) ⊗ D) α (A ⊗ (B ⊗ C)) ⊗ D,
(1.2)
A ⊗ (⊤ ⊗ C)
QQQQ
(
id⊗λ
α
A ⊗ C,
/ (A ⊗ ⊤) ⊗ C
mm
vmmρ⊗id
⊤⊗⊤
ρ λ
⊤
(1.3)
commute. A monoidal category is said to be symmetric when it is
equipped with a natural isomorphism σA,B : A ⊗ B → B ⊗ A such
that the diagrams
σA,B
(1.4)
A⊗B l
(1.6)
σB,A
-
B ⊗ A,
A ⊗ (B ⊗ C)
id ⊗σ A ⊗ (C ⊗ B)
B⊗⊤
σB,⊤
/⊤⊗B
λB
/5 B,
(1.5)
ρB
α
/ (A ⊗ B) ⊗ C
α
/ (A ⊗ C) ⊗ B
σ
σ⊗id
/ C ⊗ (A ⊗ B)
α
/ (C ⊗ A) ⊗ B
commute.
Lemma 1.6.9 Equipped with the morphisms
αA,B,C = x : A ⊗ (B ⊗ C) ⊲ let hy, zi = x in
λA =
ρA =
σA,B =
let ht, ui = z in hhy, ti, ui : (A ⊗ B) ⊗ C,
x : ⊤ ⊗ A ⊲let hy, zi = x in let ∗ = y in z : A,
x : A ⊗ ⊤ ⊲let hy, zi = x in let ∗ = z in y : A,
x : A ⊗ B ⊲let hy, zi = x in hz, yi : B ⊗ A,
and with the map of arrows (x : A ⊲ V : B) ⊗ (y : C ⊲ W : D) = z :
A ⊗ B ⊲ let hx, yi = z in hV, W i : C ⊗ D, the category C is symmetric
monoidal.
Like the category C, the category B is also a category of values. One
expects it to be symmetric monoidal too. This turns out to be the case,
but in fact, the category B has more structure: it is cartesian.
34
P. Selinger and B. Valiron
Definition 1.6.10 Given a category E and two objects A and B, the
cartesian product of A and B is, if it exists, the data consisting of an
1
2
object A × B and two maps πA,B
: A × B → A and πA,B
: A × B → B,
such that for any pair of maps f : C → A and g : C → B, there
1
exists a unique map hf, gi : C → A × B satisfying hf, gi; πA,B
= f and
2
hf, gi; πA,B = g. Note that uniqueness is equivalent to the equation
1
2
hh; πA,B
, h; πA,B
i = h for all h : C → A × B.
We say that the category E has binary products if there is a cartesian
product for all A and B. We say that it is cartesian if it also has a
terminal object T .
Lemma 1.6.11 The category (B, ⊗, ⊤) is cartesian.
1
2
Proof Consider A and B any types. One constructs πA,B
and πA,B
respectively as follows:
x : !(A ⊗ B) ⊲ let hy, zi = x in y : !A,
x : !(A ⊗ B) ⊲ let hy, zi = x in z : !B.
In this case, given two maps f and g respectively of the form x : !C ⊲
U : !A and x : !C ⊲ V : !B, one constructs the map hf, gi : C → A ⊗ B
simply as x : !C ⊲ hU, V i : !A ⊗ B.
1
2
Remark 1.6.12 Note that, although the maps πA,B
and πA,B
can be
similarly defined in C and although ⊤ is terminal in C, the map hf, gi
cannot in general be defined due to linearity: for instance, there is no
diagonal map for the type qbit .
1.6.4 Structure of the function operator “ ⊸”
Before explaining the nature of the function operator “⊸”, we must
briefly comment on the distinction between computations and values,
which is reflected in the definitions of the categories C and D. This
distinction holds in any call-by-value programming language, including
the quantum lambda calculus.
A computation is an arbitrary term M , i.e., something that must be
evaluated to obtain a result. On the other hand, a value V represents
the result of a computation. Because of the probabilistic nature of the
quantum lambda calculus, a computation M in general does not yield
a value, but a probability distribution of values. In the presence of
recursive function definitions, a computation M may also diverge with
Quantum Lambda Calculus
35
non-zero probability. It is therefore natural to think of a value V : A
as an “element” of type A, and to think of a computation M : A as a
sub-probability distribution of such elements. We informally write T (A)
for the set of sub-probability distributions on a set of values A.
In the context of higher-order computation, computations of type A
can be identified with values of type ⊤ ⊸ A. Indeed, given any computation M : A, we can form the value λ∗.M : ⊤ ⊸ A (called a “thunk”);
and conversely, given any value V : ⊤ ⊸ A, we can form a computation
V ∗ : A. The two constructions are mutually inverse modulo the axioms
in Table 1.7. We can therefore identify T (A) with ⊤ ⊸ A.
Moggi (1991) has established a general framework for dealing with values and computations in the context of side-effects (such as probability
and non-termination), in terms of the concept of strong monad.
Definition 1.6.13 A monad over a category E is a tuple (T, η, µ),
where T : E → E is a functor, η : id →
˙ T and µ : T 2 →
˙ T are natural
transformations and the diagrams (1.7) and (1.8) in Table 1.8 commute.
The natural transformation µ is called the multiplication of the monad
and η the unit of the monad.
A monad over a monoidal category (E, ⊗, ⊤) is strong if moreover there
exists a natural transformation tA,B : A ⊗ T B → T (A ⊗ B), called the
tensorial strength, such that the diagrams (1.9), (1.10), (1.11) commute.
The category C described in Definition 1.6.6 does admit a strong
monad:
Lemma 1.6.14 In C, define the following maps:
ηA =
µA =
tA,B =
x : A ⊲ λ∗.x : ⊤⊸ A,
x : ⊤⊸(⊤⊸ A) ⊲ λ∗.(x∗)∗ : ⊤⊸ A,
z : A ⊗ (⊤⊸ B) ⊲ let hx, yi = z in λ∗.hx, y∗i : ⊤⊸(A ⊗ B),
and define a functor T as follows: for every object A, T A = ⊤⊸ A and
for every morphism f : A → B of the form x : A ⊲ V : B, the image
T f : T A → T B is
y : ⊤⊸ A ⊲ λ∗.let x = (y∗) in V : ⊤⊸ B.
Then (T, η, µ, t) is a strong monad on C.
Definition 1.6.15 Given a monad (T, η, µ) over E, the Kleisli category
ET is defined as follows:
36
P. Selinger and B. Valiron
T 3A
(1.7)
T µA
/ T 2A
µT A
µA
T 2A
µA
/ T A,
T AE
ηT A
/ T 2A o
T ηA
T A.
(1.8)
x
EE
xx
EE
µA xx
E
x
E
id T A
E" |xxx id T A
TA
λ
α
/ TA
(A ⊗ B) ⊗ T C o
A ⊗ (B ⊗ T C)
O
JJJ
JJtJ
(1.9)
id⊗t
t
JJJ T λ
%
T (⊤ ⊗ A),
T ((A ⊗ B) ⊗ C)
A ⊗ T (B ⊗ C)
A ⊗ BJ
hPPP
JJJ
P
η
P
JJJ
PPP
id⊗η
t
PPP
JJJ
(1.10)
T (α)
P
%
t
/ T (A ⊗ B)
T (A ⊗ (B ⊗ C)),
A ⊗O T B
fNNN
NNNµ
NNN
id⊗µ
NN
t/
Tt /
2
T (A ⊗ T B)
T 2 (A ⊗ B) (1.11)
A⊗T B
⊤ ⊗ TA
J
Table 1.8. Equations for a strong monad
•
•
•
•
the objects of ET are the objects of E,
the set ET (A, B) of morphisms from A to B in ET is E(A, T B),
the identity on A is ηA : A → T A,
The composition of f ∈ ET (A, B) and g ∈ ET (B, C) in ET is
f ; T g; µC : A → T C.
Remark 1.6.16 The category D of computations is the Kleisli category
CT over the category of values C, where (T, µ, η) is the monad described
in Lemma 1.6.14.
The operator ⊸ has more structure than “just” providing a monad.
Definition 1.6.17 A symmetric monoidal category (E, ⊗, ⊤) together
with a strong monad (T, η, µ) is said to have T -exponentials (Moggi,
1991), or Kleisli exponentials, if it is equipped with a bifunctor ⊸ :
E op × E → E, and a natural isomorphism
∼
=
Φ : E(A, B ⊸ C) −−−−−→ E(A ⊗ B, T C).
Lemma 1.6.18 Consider the functor ⊸ : C op × C → C, defined on
Quantum Lambda Calculus
37
arrows by
A ⊸ (x : B ⊲ V : C)
=
y : A ⊸ B ⊲ λz.let x = yz in V : A ⊸ C,
(x : A ⊲ V : B) ⊸ C
= y : B ⊸ C ⊲ λx.yV : A ⊸ C,
and the map ΦA,B,C : C(A, B ⊸ C) → C(A ⊗ B, ⊤⊸ C), sending the
morphism x : A ⊲ V : B ⊸ C to
t : A ⊗ B ⊲ λ∗.let hx, yi = t in V y : ⊤ ⊸ C.
Together with these structures, C has T -exponentials, where (T, µ, η) is
the monad described in Lemma 1.6.14.
1.6.5 Structure of the exponential operator “ !”
The type operator “!” is first dealt with using a subtyping relation.
Using this relation, one can construct a comonad for the category C.
Definition 1.6.19 A comonad in a category E is a tuple (L, ǫ, δ),
where L : E → E is a functor and ǫ : L →
˙ I and δ : L →
˙ L2 are natural
transformations such that the following diagrams commute:
(1.12)
LA
δA
/ L2 A
δA
LδA
L2 A
δLA
/ L3 A,
(1.13)
LA F
FF
yy
F
id
y
LA
y
δA FFF
yy
FF
|yy
"
o
2
LA ǫLA L A Lǫ / LA.
id LA
A
A comonad is said to be idempotent if the comultiplication δ is an isomorphism.
Lemma 1.6.20 Consider the map ! sending A to !A and sending x :
A ⊲ V : B to x : !A ⊲ V : !B (which is well-typed by Lemmas 1.3.24
and 1.3.25). Also consider the arrows
ǫA = x : !A ⊲ x : A,
δA = x : !A ⊲ x : !2 A.
Then (!, ǫ, δ) is an idempotent comonad in C.
The goal of the type operator “!” is to indicate when and how an object
is duplicable. Besides being an idempotent comonad, it has additional
properties, which we will detail below. As we have already remarked,
the operator “!” is taken from intuitionistic linear logic (Girard, 1987).
It is therefore not surprising that its categorical semantics closely follows
38
P. Selinger and B. Valiron
the model of intuitionistic linear logic proposed by Bierman (1993), and
later simplified by Benton et al. (1993b,a). Good additional references
are Melliès (2003) and Maneggia (2004). We will follow the terminology
of Schalk (2004) and use the concept of linear exponential comonad.
Definition 1.6.21 (Benton et al., 1993a; Bierman, 1993) Let (E, ⊗, ⊤)
be a (symmetric) monoidal category. A (symmetric) monoidal comonad
on E is a comonad (L, δ, ǫ):
• equipped with two natural transformations dA,B : LA ⊗ LB →
L(A ⊗ B) and d⊤ : ⊤ → L⊤ making (L, d) a lax (symmetric)
monoidal functor,
• such that δ and ǫ are monoidal natural transformations, i.e. such
that the following diagrams commute:
dA,B
(1.14) LA ⊗ LB
?
??
??
??
ǫA ⊗ǫB
?
⊤4
⊤
A⊗B
dA,B
LA⊗LB
L2 A⊗L2 B
/ L(A⊗B),
(1.16)
δA ⊗δA
/ L(LA⊗LB)
Ld
dLA,LB
⊤
/ L2 (A⊗B)
d⊤
/ L⊤.
(1.17)
d⊤
δA⊗B
A,B
d⊤
/ L⊤, (1.15)
44
4
ǫ⊤
id ⊤ 4
4 / L(A ⊗ B),
~
~~
~
~ ǫA⊗B
~~
~
L⊤
δ⊤
Ld⊤
/ L2 ⊤
Definition 1.6.22 Let (E, ⊗, ⊤, α, λ, ρ, σ) be a symmetric monoidal
category. Let (L, δ, ǫ, dL , dL ) be a monoidal comonad. We say that L is
a linear exponential comonad provided that
(i) each object in E of the form LA is equipped with a commutative
comonoid (LA, △A , ♦A ), where △A : LA → LA ⊗ LA and ♦A :
LA → ⊤;
(ii) △A and ♦A are monoidal natural transformations, i.e. the fol-
Quantum Lambda Calculus
39
lowing diagrams
LA ⊗ LB
△A ⊗△B
/ (LA ⊗ LA) ⊗ (LB ⊗ LB)
sw
(LA ⊗ LB) ⊗ (LA ⊗ LB)
dL
A,B
L(A ⊗ B)
(1.19)
L
dL
A,B ⊗dA,B
♦A ⊗♦B
/ ⊤⊗⊤
dL
⊤
L⊤
/ L(A ⊗ B) ⊗ L(A ⊗ B)
△(A⊗B)
λ−1
⊤
⊤
(1.18)
L
dL
⊤ ⊗d⊤
dL
A,B
/ L⊤ ⊗ L⊤
△
⊤
id
L⊤
(1.20)
λ⊤
L(A ⊗ B)
⊤
⊤ TTTTT
TTT)
dL
/ ⊤⊗⊤
LA ⊗ LB
♦A⊗B
/5 ⊤;
jjjj
j
j
j
j ♦⊤
/⊤
(1.21)
commute.
(iii) The maps
△A : (LA, δA ) → (LA ⊗ LA, (δA ⊗ δA ); dA ),
♦A : (LA, δA ) → (⊤, dL
⊤)
are L-coalgebra morphisms, i.e.
LA
(1.22)
δA
L2 A
△A
/ LA ⊗ LA
δA ⊗δA
L2 A ⊗ L2 A
L
dLA,LA
/ L(LA ⊗ LA),
L△A
LA
♦A
/⊤
dL
⊤
δA
L2 A
L♦A
(1.23)
/ L⊤;
(iv) Every map δA is a comonoid morphism
(LA, ♦A , △A ) → (L2 A, ♦LA , △LA ),
i.e. satisfying the diagrams
(1.24)
LA
△A LA ⊗ LA
δA
/ L2 A,
△LA
2
δA
/ L A ⊗ L2 A
⊗δ
A
LAC
CCC
♦A !
δA
⊤
/ L2 A.
w
w
{ww♦
LA
(1.25)
40
P. Selinger and B. Valiron
Lemma 1.6.23 If we define the maps
d!A,B =
d!⊤
=
△A =
♦A =
z : !A ⊗ !B ⊲ let hx, yi = z in hx, yi : !(A ⊗ B),
z : ⊤ ⊲ ∗ : !⊤,
x : !A ⊲ hx, xi : !A ⊗ !A,
x : !A ⊲ ∗ : ⊤,
the comonad (!, δ, ǫ) is an idempotent linear exponential comonad on the
category C.
Lemma 1.6.24 The category B is the co-Kleisli category of the comonad
described in Lemma 1.6.23.
Remark 1.6.25 Note that the map d!A,B and d!⊤ in Lemma 1.6.23 are
isomorphisms of C. In other words, we require the monoidal comonad to
be strongly monoidal. This is because, unlike the work of Bierman (1993)
and Benton et al. (1993b), the types !(A ⊗ B) and !A⊗!B are isomorphic
in the quantum lambda calculus (as explained in Section 1.3.8).
1.6.6 A linear category for duplication
Putting together the features developed on the last three sections, we
can abstract from the properties of the term categories B, C, and D, and
define a sound model for the core fragment of the linear lambda calculus
of Section 1.6.1.
Definition 1.6.26 A linear category for duplication is a category E
with the following structure:
• a symmetric monoidal structure (⊗, ⊤, α, λ, ρ, σ);
• an idempotent, strongly monoidal, linear exponential comonad
(L, δ, ǫ, dL , dL , ♦, △);
• a strong monad (T, µ, η, t);
• a Kleisli exponential ⊸, that is, a natural map of arrows
Φ : E(A ⊗ B, T C) → E(A, B ⊸ C)
and a bifunctor ⊸ : E op × E → E.
A linear category for duplication E is said to be weak if ⊤ is a terminal
object.
Quantum Lambda Calculus
41
Theorem 1.6.27 The category C (from Definition 1.6.6) is a weak linear
category for duplication.
Proof The proof uses Lemmas 1.6.9, 1.6.14, 1.6.18 and 1.6.23.
Remark 1.6.28 A linear category for duplication gives rise to a double
adjunction
UL
EL g
⊥
FL
UT
&
Ef
⊥
'
ET .
FT
Here the left adjunction arises from the co-Kleisli category EL of the
comonad L. It is a linear-non-linear model in the sense of Benton (1995).
The right adjunction arises from the Kleisli category ET of the computational monad T .
1.6.7 Interpretation of the core fragment
The core fragment of linear lambda calculus, as given in Section 1.6.1,
can be interpreted in any weak linear category for duplication E.
Suppose that for each type constant α, we are given an object Θ(α)
of E. Then we can recursively assign to each type A an object [[A]]
via [[α]] = Θ(α), [[!A]] = L[[A]], [[A ⊸ B]] = [[A]] ⊸ [[B]], [[⊤]] = ⊤, and
[[A ⊗ B]] = [[A]] ⊗ [[B]]. Moreover, for any valid subtyping A <: B, there
exists a canonical arrow IA,B : [[A]] → [[B]] in E, definable from the
structure of the comonad L. If ∆ = {x1 : A1 , . . . , xn : An } is a typing
context, we write [[∆]] = [[A1 ]] ⊗ . . . ⊗ [[An ]].
Further, suppose that for each constant c : Ac , we are given an interpretation as an arrow Θ(c) : ⊤ → [[Ac ]] in E. Then to each valid typing
derivation, we can recursively assign an arrow of E as follows:
• If π is a typing derivation of a value judgement x1 : A1 , . . . xn : An ⊲
V : B, then [[π]]v is an arrow [[A1 ]] ⊗ . . . ⊗ [[An ]] → [[B]];
• if π is a typing derivation of a general judgement x1 : A1 , . . . xn : An ⊲
M : A, then [[π]]c is an arrow [[A1 ]] ⊗ . . . ⊗ [[An ]] → T ([[B]]).
The actual definition is by recursion on typing derivations, and consists
of a large number of straightforward cases. We only give one of the cases
as an example, and refer to (Selinger and Valiron, 2008a; Valiron, 2008)
42
P. Selinger and B. Valiron
for complete details. Consider a typing derivation ending in the rule
Γ1 , !∆ ⊲ M : A ⊸ B Γ2 , !∆ ⊲ N : A
Γ1 , Γ2 , !∆ ⊲ M N : B
.
If the two premises are interpreted, respectively, as morphisms
f : [[!∆]] ⊗ [[Γ1 ]] → T ([[A]] ⊸ [[B]])
g : [[!∆]] ⊗ [[Γ2 ]] → T ([[A]]),
then the interpretation the conclusion is defined as
˜
∆
[[!∆]] ⊗ [[Γ1 ]] ⊗ [[Γ2 ]] −→ [[!∆]] ⊗ [[!∆]] ⊗ [[Γ1 ]] ⊗ [[Γ2 ]]
id ⊗σ⊗id
−−−−−−→ [[!∆]] ⊗ [[Γ1 ]] ⊗ [[!∆]] ⊗ [[Γ2 ]]
f ⊗g
−−−→ T ([[A]]⊸[[B]]) ⊗ T ([[A]])
Ψ
1
−−→
T (([[A]]⊸[[B]]) ⊗ [[A]])
T (ε)
−−−→ T (T ([[B]]))
µ
−
→ T ([[B]]),
˜ : [[∆]] → [[∆]] ⊗ [[∆]] is the canonical map definable from ∆A :
where ∆
LA → LA ⊗ LA of the linear exponential comonad, and ε : (A ⊸ B) ⊗
A → T B is the canonical map arising from the Kleisli exponential.
Remark 1.6.29 Note that the interpretation is defined on typing
derivations, and not on typing judgements. And indeed, a valid typing judgement can in general possess many different typing derivations.
For example, consider the following two typing judgements, where V
and W are values:
x : A ⊲ V : !B,
y : B ⊲ W : C.
Then the typing judgement x : A ⊲ let y = V in W : C has two distinct
valid typing derivations:
x : A ⊲ V : !B y : !B ⊲ W : C
x : A ⊲ let y = V in W : C,
x:A⊲V :B y:B⊲W :C
x : A ⊲ let y = V in W : C.
Therefore, a major complication in the proof of soundness of the interpretation is that we must first show that the interpretation is welldefined on typing judgements, and independent of the particular typing
derivation used to derive it. This is the subject of the following theorem.
Quantum Lambda Calculus
43
Theorem 1.6.30 Given a valid typing judgement with two typing deric
vations π and π ′ , for any interpretation Θ we have the equality [[π]]Θ =
v
v
′ c
[[π ]]Θ (and [[π]]Θ = [[π ′ ]]Θ if the typing judgement is a value).
The proof of this theorem is technically complicated, and occupies almost three chapters of Valiron’s Ph.D. thesis (see Valiron, 2008, Corollary 11.2.6).
Theorem 1.6.31 (Soundness) If ∆ ⊲ M ≈ax M ′ : A then we have
c
c
v
v
[[∆ ⊲ M : A]]Θ = [[∆ ⊲ M ′ : A]]Θ (and [[∆ ⊲ M : A]]Θ = [[∆ ⊲ M ′ : A]]Θ
′
if M and M are values) for every interpretation Θ in a weak linear
category for duplication.
Proof By induction on the definition of ≈ax , using a substitution lemma.
Theorem 1.6.32 (Completeness) If for every interpretation Θ in
c
every weak linear category for duplication, the equality [[∆ ⊲ M : A]]Θ =
c
′
′
[[∆ ⊲ M : A]]Θ holds, then ∆ ⊲ M ≈ax M : A.
Proof It suffices to consider the term model C of Section 1.6.2, with Θ
the identity map.
1.6.8 Toward a concrete model
In light of the results of the last few subsections, we can now say what
it means to be a “concrete model of the quantum lambda calculus”.
Such a model should have the structure of a weak linear category for
duplication, with the further property that the ground type operations
(new , meas, and unitary operations) can be interpreted with their usual
meanings. More precisely, a concrete model of the quantum lambda calculus is a weak linear category for duplication E with distributive finite coproducts, preserved by L, together with an object qbit ∈ |E|,
such that the full monoidal subcategory of ET of objects of the form
qbit n1 ⊕ . . . ⊕ qbit nk is equivalent to the category Q of tuples of finite
dimensional Hilbert spaces and norm non-increasing completely positive
maps (Selinger, 2004).
As mentioned in the introduction of Section 1.6, at the time of this
writing, it is still an open problem to find such a concrete model (other
than the term model).
44
P. Selinger and B. Valiron
The only partial result in this direction is a model for the strictly linear
fragment of the quantum lambda calculus (i.e., without the !A operator,
and without the possibility of duplication or erasure of either classical
or quantum information). A fully abstract model for this fragment was
given in (Selinger and Valiron, 2008b).
Bibliography
Abramsky, S. (1993) Computational interpretations of linear logic. Theoretical
Computer Science 111:3–57.
Altenkirch, T. and Grattage, J. (2005) A functional quantum programming
language. In Proceedings of the 20th IEEE Symposium on Logic in Computer Science, LICS’05 , pages 249–258. IEEE Computer Society Press.
Barendregt, H. P. (1984) The Lambda Calculus: Its Syntax and Semantics,
volume 103 of Studies in Logic and the Foundation of Mathematics. North
Holland, 2nd edition.
Bell, J. S. (1964) On the Einstein Podolsky Rosen paradox. Physics 1:195–200.
Bennett, C. H., Brassard, G., Crépeau, C., Jozsa, R., Peres, A. and Wootters, W. K. (1993) Teleporting an unknown quantum state via dual
classical and Einstein-Podolsky-Rosen channels. Physical Review Letters
70(13):1895–1899.
Bennett, C. H. and Wiesner, S. J. (1992) Communication via one- and twoparticle operators on Einstein-Podolsky-Rosen states. Physical Review
Letters 69(20):2881–2884.
Benton, N. (1995) A mixed linear and non-linear logic: Proofs, terms and
models (extended abstract). In Proceedings of the Eighth Workshop on
Computer Science Logic, CSL’94, Selected Papers, volume 933 of Lecture
Notes in Computer Science, pages 121–135. Springer.
Benton, N., Bierman, G., de Paiva, V. and Hyland, M. (1993a) Linear λcalculus and categorical models revisited. In Proceedings of the Sixth
Workshop on Computer Science Logic, CSL’92, Selected Papers, volume
702 of Lecture Notes in Computer Science, pages 61–84. Springer.
Benton, N., Bierman, G., de Paiva, V. and Hyland, M. (1993b) A term calculus
for intuitionistic linear logic. In Proceedings of the International Conference on Typed Lambda Calculi and Applications, TLCA’93 , volume 664
of Lecture Notes in Computer Science, pages 75–90. Springer.
Benton, N. and Wadler, P. (1996) Linear logic, monads and the lambda calculus. In Proceedings of the 11th IEEE Symposium on Logic in Computer
Science, LICS’96 , pages 420–431. IEEE Computer Society Press.
Bierman, G. (1993) On Intuitionistic Linear Logic. Ph.D. thesis, University
of Cambridge Computer Laboratory, Cambridge, England. Available as
Technical Report 346, August 1994.
Deutsch, D. and Jozsa, R. (1992) Rapid solution of problems by quantum
computation. Proceedings of the Royal Society of London A 439:553–558.
Girard, J.-Y. (1987) Linear logic. Theoretical Computer Science 50(1):1–101.
Hudak, P., Hughes, J., Peyton Jones, S. and Wadler, P. (2007) A history of Haskell: Being lazy with class. In HOPL III: Proceedings of
the Third ACM SIGPLAN Conference on History of Programming Languages, pages 12.1–55. Association for Computing Machinery.
Quantum Lambda Calculus
45
Knill, E. H. (1996) Conventions for quantum pseudocode. Technical Report
LAUR-96-2724, Los Alamos National Laboratory.
Lambek, J. and Scott, P. (1986) Introduction to Higher Order Categorical
Logic, volume 7 of Cambridge Studies in Advanced Mathematics. Cambridge University Press.
Mac Lane, S. (1971) Categories for the Working Mathematician, volume 5 of
Graduate Texts in Mathematics. Springer.
Maneggia, P. (2004) Models of Linear Polymorphism. Ph.D. thesis, School of
Computer Science, University of Birmingham.
McCarthy, J. (1960) Recursive functions of symbolic expressions and their
computation by machine, part I. Communications of the ACM 3(4):184–
195.
Melliès, P.-A. (2003) Categorical models of linear logic revisited. Technical
Report 22, Laboratoire Preuves, Programmes et Systèmes, CNRS and
Paris 7. To appear in Theoretical Computer Science.
Milner, R. (1978) A theory of type polymorphism in programming. Journal
of Computer and System Sciences 17:348–375.
Moggi, E. (1991) Notions of computation and monads. Information and Computation 93(1):55–92.
Pierce, B. C. (2002) Types and Programming Languages. MIT Press.
Schalk, A. (2004) What is a categorical model of linear logic? Manuscript,
available from http://www.cs.man.ac.uk/∼schalk/work.html.
Seely, R. A. (1989) Linear logic, *-autonomous categories and cofree coalgebras. In Proceedings of Categories in Computer Science and Logic,
Boulder, 1987 , volume 92 of Contemporary Mathematics, pages 371–382.
American Mathematical Society.
Selinger, P. (2004) Towards a quantum programming language. Mathematical
Structures in Computer Science 14(4):527–586.
Selinger, P. and Valiron, B. (2005) A lambda calculus for quantum computation with classical control. In Proceedings of the Seventh International
Conference on Typed Lambda Calculi and Applications, TLCA’05 , volume
3461 of Lecture Notes in Computer Science, pages 354–368. Springer.
Selinger, P. and Valiron, B. (2006) A lambda calculus for quantum computation with classical control. Mathematical Structures in Computer Science
16(3):527–552.
Selinger, P. and Valiron, B. (2008a) A linear-non-linear model for a computational call-by-value lambda calculus. In Proceedings of the Eleventh
International Conference on Foundations of Software Science and Computation Structures, FOSSACS 2008 , volume 4962 of Lecture Notes in
Computer Science, pages 81–96. Budapest, Hungary.
Selinger, P. and Valiron, B. (2008b) On a fully abstract model for a quantum
linear functional language. In Proceedings of the Fourth International
Workshop on Quantum Programming Languages, QPL 2006 , volume 210
of Electronic Notes in Theoretical Computer Science, pages 123–137.
Sussman, G. J. and Steele Jr, G. L. (1975) Scheme: An interpreter for extended
lambda calculus. Technical Report AIM-349, MIT.
Troelstra, A. S. (1992) Lectures on Linear Logic, volume 29 of CSLI Lecture
Notes. University of Chicago Press, 2nd edition.
Turing, A. M. (1937) On computable numbers, with an application to the
Entscheidungsproblem. Proceedings of the London Mathematical Society,
Series 2 42:230–265.
46
P. Selinger and B. Valiron
Valiron, B. (2004a) A functional programming language for quantum computation with classical control . Master’s thesis, Department of Mathematics
and Statistics, University of Ottawa.
Valiron, B. (2004b) Quantum typing. In Proceedings of the Second International Workshop on Quantum Programming Languages, QPL 2004 ,
TUCS General Publication 33, pages 163–178. Turku Centre for Computer Science, Turku, Finland.
Valiron, B. (2008) Semantics for a Higher-Order Functional Programming
Language for Quantum Computation. Ph.D. thesis, Department of Mathematics and Statistics, University of Ottawa.
van Tonder, A. (2004) A lambda calculus for quantum computation. SIAM
Journal of Computing 33(5):1109–1135.