Lecture 1

Sougato Bose
January 11, 2021

To be able to encode information in a system, and more generally to make

it at all worthwhile to study the system, the minimal requirement is that it
has at least two discernible states. Such an entity is called a bit.
Familiar objects such as coins, with their two states “heads up” and “tails
up”, and switches with their two states “on” and “o↵” are examples of bits.
Some properties of such things are so evident from our day to day experience
that these are taken for granted. If someone places a bit, say a coin, in
an unknown state and asks you to learn its state without disturbing it, you
would think it is a very easy task! You merely have to look at the coin to
learn whether it is heads or tails facing up and the act of “looking” should
not change the state of the coin. On the other hand, if you flip a coin in a
well defined state, you are sure to change its state – from heads to tails and
vice versa. Both these properties are a result of the fact the the coin can
have exactly two possible states of existence – “heads up” or “tails up”.
Both the obvious properties described above are known to become false
when we move over from coins and consider much smaller analogues of bits.
These can exist is a much wider class of states. Examples are the tiniest
possible magnets called spins. Orientations of their tiny magnetic moments
“along” or “against” a given direction can stand for heads or tails respec-
tively. The rules the spins follow are not familiar to us from our everyday
experience and one has to learn them afresh. These set of unfamiliar rules
is quantum mechanics, and thereby these tiny analogues of bits are called
quantum bits or qubits. In this lecture, we are going to acquaint ourselves
with the peculiar behaviour of qubits. If you have never been introduced to
quantum mechanics before, then this lecture is also your opportunity to have
a rapid introduction to quantum mechanics.

1 Bits, information processing and miniatur-

ization
When n bits of information are conveyed, then one can learn which one of
N = 2n possibilities has occurred (reversing the same statement, to describe
a situation so accurately as to be selective among N options, one needs log2 N
bits).
If information can be represented in strings of bits, as exemplified above,

1
Figure 1: Schematic examples of bits used in classical computers. Note their
robustness – if a single or a few spins flip then nothing much happens to the
net magnetic field generated and hence to the value of the bit; Similar holds
for small amounts of charge shifting from one plate of the capacitor to the
other.

Figure 2: The ultimate miniaturized form of bits: a single spin (of an atom
or an electron or a nuclear spin) or a single charge in one box or other –
a double quantum dot. These single systems are also quantum mechanical
systems

then it can also be processed (i.e., manipulated) by actions on strings of bits,

and essentially this is what our everyday computers do! For example, they
might change an input bit string 001011010111000101010000101001001 de-
pending on the instructions in another programme bit string 10110000101000
101010000101001001. This type of information processing is called classical
Boolean information processing. Some of the compact ways in which bits are
represented in our everyday computers are depicted in Fig. 1.

2 Gates on bits and their matrix representa-

tions
The two states of a bit, namely 0 and 1 can also be represented by column
vectors as follows  
1 0
0⌘ , 1⌘ (1)
0 1
Certainly the above is not the most economical way of representing bits (two
numbers instead of one for each bit!). The reason that we introduce the

2
representation of the state of bits as column vectors with two components is
that this representation is more versatile than a single number and will also
enable us to represent all the states of a qubit. Once bits are represented as
column vectors as in the above Eq.(1), logic gates have to be represented as
matrices. For example, the NOT gate1 that changes 0 to 1 and vice versa is
given by the matrix 
0 1
NOT = . (2)
1 0
We will often call it the X gate (as is the norm in the field of quantum
information, where this gate is also used). As far as operations on a single
bit are concerned, you can do only two things: (a) not do anything, i.e. the
1 0
Identity gate I = and (b) flip the bit, i.e., the NOT (or X) gate.
0 1
However, when more bits are available, there are further operations that one
may do. For ascertaining the matrix representation of these gates, one first
has to specify the column vector representation of states of multiple bits.
For two bits, for example, one can represent the states as one of four options
00, 01, 10 and 11, and thereby by a column matrix of four components as
follows
2 3 2 3 2 3 2 3
1 0 0 0
6 0 7 6 1 7 6 0 7 6 0 7
00 ⌘ 6 7 6 7 6 7 6 7
4 0 5 , 01 ⌘ 4 0 5 , 10 ⌘ 4 1 5 , 11 ⌘ 4 0 5 . (3)
0 0 0 1

Note that the above way of writing can be generalized to many bits simply
by noting that the
 vector form of 00 can be generated by taking the outer
1 1
product ⌦ . For example, following this convention, the vector
0 0
representation of the bit string 001011 is
     
1 1 0 1 0 0
001011 = ⌦ ⌦ ⌦ ⌦ ⌦ (4)
0 0 1 0 1 1

In order to be systematic about convention, and have always a distinct col-

umn vector for each distinct bit string, we will use the rule exemplified in
Eq.(4) for finding out our column vector representation of the state of mul-
tiple bits.

Exercise .1
Write down the 8 component column vector representing to the state 010 of
3 bits.

We can now represent some logic gates on two bits using matrices. For
example the XOR gate (which we will call a CNOT gate, as this is its name in
the field of quantum information) accomplishes the following transformation
1
We assume familiarity with basic boolean logic gates.

3
on two bits: 00 ! 00, 01 ! 01, 10 ! 11, 11 ! 10, and can thereby be
represented by the matrix
2 3
1 0 0 0
6 0 1 0 0 7
CNOT = 6
4 0 0 0 1 5.
7 (5)
0 0 1 0

The trick for writing matrices in the above form is that you arrange
00, 01, 10 and 11 along rows and columns along the top and the left of the
matrix, and then write 1 in the places to which a certain element goes (e.g.,
as 10 goes to 11, the (4,3) element is 1, while the rest of the elements in
column 3 are 0..

Exercise .2
Write down the 8 ⇥ 8 matrix for the Controlled-Controlled-NOT (or TOF-
FOLI) Gate.

Exercise .3
Write down the 8 ⇥ 8 matrix for a Gate P that permutes bits cyclically, i.e.,
P |abci = |cabi.

Exercise .4
Show that the gates CNOT2 = I, TOFFOLI2 = I, but P 2 6= I, and instead
P P = I and P 3 = I.
T

3 A physical process as a computation: bil-

liard ball computation
Physical processes can be viewed as a computation. For example, consider
something as simple as an elastic collision of two billiard balls as shown in
Fig.3. If the binary input a is 0 or 1 in accordance to whether a ball is present
or absent and similarly for input b, then the final positions of the ball/balls
indicate the output of computations. In the notation that ā indicates the
complement of a and similarly for b, if a ball is found in a certain output
channel we conclude that the corresponding product (as indicated in Fig.3)
is 1, while otherwise it is 0. Of course this process can be concatenated with
others using more billiard balls to perform more elaborate computations. An
important point to note here is that this is an example of conservative logic
whereby no energy expenditure necesarily need to be made for the process
of computation, i.e., a logic gate (the energy of the billiard balls initially and
finally can remain the same if the surface is frictionless). In practice this
means, as a completely frictionless system is only an ideality, that the energy
cost of logic gates can be arbitrarily reduced.

4
 a
ab

ab

ab
ab
b

Figure 3: The figure shows how a simple physical process can be regarded as
a computation.

4 Computation and energy: energy loss on

bit erasure
A minimum of KB T log 2 energy (where the logarithm is natural logarithm
as opposed to that in most of this course) is expended to erase a bit from
a finite memory. This is best demonstrated using a bit encoded in the left
or the right side of a one molecule gas. Please see the explanation given in
video.

5 Qubits
We now proceed to describe the peculiar behaviour that the tiniest possible
magnetic moments in nature, the so called spin-1/2 particles. These would be
the ultimate miniaturized version of the magnetic domain bits, where each
domain is now replaced by a single particle carrying the smallest possible
magnetic moment (an electron is an example of such a spin-1/2 particle,
as are several types of atoms). As will become clear to you soon, their
behaviour in experiments readily show that they violate the property (a) of
bits mentioned in the begining of the chapter – therefore it is not right to
call them bits any more – rather they are a classic example of a qubit.
One may measure the magnitude of the magnetic moment of the spin-1/2
particle (henceforth only referred to as a spin) by the famous Stern-Gerlach

5
experiment where the particle is made to fly through an inhomogeneous mag-
netic field oriented along the direction in which one wants to measure the
magnetic moment. For example, Fig.4 shows a Stern Gerlach apparatus for
measuring the magnetic moment of a particle along the Z (vertical) direction.
The magnetic moment is measured from the direction towards which its path
bends while leaving the inhomogeneous magnetic field – for example, if an
upwards deflection from the original direction signifies a positive magnetic
moment then a downwards deflection signifies a negative magnetic moment.
The magnitude of the deflection (i.e., the angle by which it deflects) gives the
magnitude of the magnetic moment. The most striking result here is that
measuring the value of the the magnetic moment of a spin-1/2 particle in any
direction yields only two values which can be labelled as +1 (corresponding
to a magnetic moment +µB in relevant units) and -1 (corresponding to µB
in relevant units). No other value of magnetic moment, apart from ±µB , is
ever observed in any experiment, though the direction of the initial magnetic
moment can be anything! This experimental fact is very peculiar and readily
implies two important things:

1. The magnetic moment directions of the spin (and indeed the state of
any quantum mechanical system) can randomly change (or what we shall
call jump) when measured, manifestly violating the fact that a bit can be
measured without changing its state.

2. It is strictly a 2 state system: In any given direction (which means for

any given type of experiment) there are exactly 2 distinguishable states as
shown by the deflections of the spin.

Let us now make the case that there are sudden jumps induced by a mea-
surement a bit clearer and also give you the probabilties of these jumps as has
been deduced by experimentation. For example, the Stern-Gerlach apparatus
along the Z direction of Fig.4 could have been preceded by another Stern-
Gerlach apparatus in any other direction such as a direction making an angle
✓ with the Z direction. When a spin exiting that preceding apparatus with a
magnetic moment +1 is observed, then we are sure that the spin entering our
Stern-Gerlach apparatus oriented along the Z direction possess a magnetic
moment along a direction ✓ to the Z axis. Yet when it exits the Z oriented
Stern-Gerlach apparatus, its magnetic moment is found to be (measured to
be) exclusively either along +Z or Z directions. Thereby the magnetic
moment must be making a jump from the direction ✓ with the Z axis to a di-
rection +Z or Z by virtue of passing through the Z oriented Stern-Gerlach
apparatus. Moreover the probablility of these jumps as dictated by exper-
imental observations are found to be cos2 ✓/2 and sin2 ✓/2 = cos2 (✓ + ⇡)/2
to jump to the +Z and Z axes respectively. Therefore the general rule for
jumps on measurement is that the probabilty of jumps of a spin-1/2 magnetic
moment between two directions separated by an angle ↵ is cos2 ↵/2.

6
Figure 4: A spin-1/2 particle passing through a Stern-Gerlach apparatus ori-
ented in the vertical (Z) direction. Whatever the initial direction of the spin
(this can be prepared from a previous Stern Gerlach apparatus – explained
in the text), it exits oriented either in the +Z direction (i.e., with magnetic
moment +µB in the Z direction) or in the Z direction (i.e., with magnetic
moment µB in the Z direction)

Exercise .5
Consider a large collection of n spin-1/2 particles, all of whose magnetic
moments are oriented along the +Z direction. The particles are sufficiently far
apart so as to not interact among themselves. Show that the net magnetic
moment of all the particles taken together when the magnetic moment of each
particle is measured along the same direction ✓ is nµ cos ✓.

6 Vector representation of a general state of

a qubit
We would like to construct a suitable column vector representation of an
arbitrary state of a qubit from the results of the Stern-Gerlach experiment
described so far. In general, the state of a qubit, as clear from the case study
of the spin-1/2 particle (a typical qubit), can be labelled by two variables
✓ and representing a direction in 3-dimensional space, which is called the
Bloch sphere representation of the state of a qubit (see next section). We will
now attempt to generalize the column vector representation of bits shown in
section 2 to represent all possible states of a qubit. We introduce a new type
of symbol |i called a ket which essentially implies that we are dealing with
quantum systems (qubits) rather than bits. First we concentrate only on
one of the axes of the Bloch sphere, namely, the z-axis. As we have seen
in the section on Stern-Gerlach experiments, there are exactly two states
of the qubit along this axis and these states are fully distinguishable in an
appropriately designed Stern-Gerlach experiment. Thereby these two states
can serve very well as states of a bit and following the example of states of

7
bits, the two states of a spin-1/2 along the z axis are depicted as kets |0i and
|1i and represented in the same way as the two states of a bit as represented
in section 2.  
1 0
|0i ⌘ , |1i ⌘ (6)
0 1
In the above ket notation, let us represent the general state of a qubit as
| (✓, )i, where is taken as the symbol of a general quantum state following
the historical convention in quantum mechanics, while the variables ✓ and
denote the spherical polar coordinates in the Bloch sphere. Note that the
number of possible states of a qubit (labelled by the two variables ✓ 2 [0, ⇡]
and 2 [0, 2⇡]) is infinite, and thus, for spin states other than those along
the z axis, we have to keep our minds open for the possibility for a more
general representation such as

↵
| (✓, )i = , (7)

where ↵ and can be any number (including the possibility of being complex
numbers) and it is natural to expect them to be some functions of ✓ and .
The spin states along the z axis (Eq.6) are then special cases with ↵ = 1, =
0 and ↵ = 0, = 1 respectively. For these special pair of states, if we take
the row vectors [1 0] and [0 1] corresponding to the states in Eq.(6), and
represent them as h0| and h1| respectively, then, multiplications of di↵erent
row and column vectors in the set {h0|, h1|, |0i, |1i} (with always the row
vector first and the column vector second, so as to yield a single number as
the answer) would give
 
1 0
h0|0i = [1 0] = 1, h1|1i = [0 1] = 1, (8a)
0 1
 
0 1
h0|1i = [1 0] = 0, h1|0i = [0 1] = 0. (8b)
1 0
As what one takes as the z axis of the Bloch sphere is completely arbitrary,
then, generalizing the above Eq.(8a), we would like to construct a vector
representation | (✓, )i such that

h (✓, )| (✓, )i = 1, (9)

which is called the normalization condition. If we want the keep the option
open for complex values of ↵ and and yet satisfy Eq.(9) (which implies
h (✓, )| (✓, )i > 0) then one has to define

h (✓, )| = [↵⇤ ⇤
], (10)

where ↵⇤ and ⇤ are complex conjugates of ↵ and , so that h (✓, )| (✓, )i =

|↵|2 + | |2 > 0. In analogy with the kets, Eq.(10) is taken as the definition
of a bra h (✓, )| corresponding to the ket | (✓, )i. Thus row vectors h0|
and h1| defined previously in this section are in fact bras corresponding to
the kets |0i and |1i respectively.

8
 Exercise .6
2 q 3
2
3
For a ket |⌘i = 4 q 5 find the bra and hence compute h⌘|⌘i. With
i 13
" #
0
p1 0
5
another ket |⌘ i = compute h⌘ |⌘i. Important: Use Eq.(10) and do
i p25
not forget to take the complex conjugates necessary in the definition of the bra.

We now present a vector representation of the form | (✓, )i which gives

us an easy prescription for calculating correctly the probability of jumps
between di↵erent states of a qubit based on simple vector multiplication
rules (namely the inner product of two vectors as defined above). Let us
represent the probability of a state represented by any vector | i to jump to
another state |⇠i on measurement to be P| i!|⇠i . Then taking as rule for the
jump on a measurement to be

with P| i!|⇠i = |h |⇠i|2 , (11)

which is called the Born-rule, and a representation of the arbitrary state to

be 
cos 2✓
| (✓, )i = , (9)
ei sin 2✓
all the results of the Stern-Gerlach experiment can be explained (modelled).
It is important to note that any phase factor outside the state does not
matter as the P| i!|⇠i according to the Born-rule Eq.(11) remains the same
if we replace | i ! by ei | i ! and similarly for any other state.

7 States on the Bloch sphere

A state of a quantum two level system (a qubit) as given by | (✓, )i of Eq.(9)
is represented as a point on a sphere, precisely as the point with the spherical
polar coordinates (✓, ). One must remember that this representation holds
for any quantum two-level system (qubit) – not merely for spins. In the case
of a spin-1/2 system, the direction of the spin coincides with the normal to
the Bloch-sphere — in this sense, we can classically visualize all points of the
Bloch sphere as spins pointing in a given direction. However, two important
are to be noted: (1) All states of a qubit are truly quantum. Despite being
able to visualize the state of a spin-1/2 as a direction in space, it is quantum
in the sense that if it is measured in a perpendicular direction to its orienta-
tion, it will give a random 50-50 result of being ”up” or ”down” along that
given direction. It will never give a zero value as would be expected as the
component of a classical magnetic moment vector in a perpendicular direc-
tion to its orientation. (2) The Bloch sphere representation is an abstract
representation: the direction of a state on the Bloch sphere do not have any
correspondence with an actual direction (as for the spin) for other variables

9
Figure 5: The states of two di↵erent physical systems, the spin-1/2 and the
polarization of a photon on the Bloch sphere.

which can act as qubits. For example, for a polarization state of a photon,
horizontally and vertically polarized states |Hi and |V i can correspond to |0i
and |1i, while 45 and 135 degree polarizations and circular polarizations cor-
respond to other directions as shown in Fig.5. The correspondence between
points on the Bloch sphere and physical states (spin-1/2 and polarization of
light) are shown in Fig.5. Moreover, the correspondence between di↵erent
points and state vectors are shown in Fig.6. This latter figure also shows
important notation |+i and | i states, as well as how nonclasical they really
are in terms of the Schoredinger Cat.

8 The Hadamard: An illustration of a possi-

ble operation on a qubit
1
H|0i = p (|0i + |1i) (10a)
2
1
H|1i = p (|0i |1i) (10b)
2
An importrant property of the Hadamard is (work out): H 2 = 1. This means
that the Hadamard is its own inverse. It simply changes from the so called
computational or Z-basis states {|0i, |1i} to X basisstates{—+i, | i}. It
also means that the Hadamard is not a ⇡/2 rotation about the x or y axes,

10
 θ θ
ψ (θ , φ ) = cos 0 + eiφ sin 1
0 2 2
1
− =
2
(0 −1 )

φ
1 1
2
( 0 −i 1 ) 2
( 0 +i 1 )

1
+ =
2
(0 +1 )
1

Figure 6: The points of the Bloch sphere connected with the state vectors
they represent. Note the important notation of |+i and | i states. The
figure illustrates how non-classical states (states which do not correspond
to our everyday classical experience) reside along the equator of the Bloch
sphere if one identifies the |0i and |1i states with states of classical experience
such as alive and dead states of a cat.

11
as then its square (its application twice) would correspond to a N OT instead
of 1.

9 P-Q coin tossing game

See description in video.

10 How Quantum Mechanics violtaes Macro-

scopic Realism
See description in video.

11 NOT operations for x and y basis states


0 1
beginequation X= .(10)As shown in section 2 the X operator (also
1 0
commonly called the Pauli x operator in physics texts) flips the the ket
|0i to the ket |1i and vice versa. It is easy to check using the matrix form
Eq.(11) of X and the vector form of | (✓, )i from Eq. (9) that
 i 
e sin 2✓ i cos ⇡ 2 ✓
X| (✓, )i = = e ⌘ | (⇡ ✓, 2⇡ )i, (11)
cos 2✓ e i sin ⇡ 2 ✓

were in the last step a phase factor of ei outside the ket has been ignored (as
we mentioned in section 6, a phase factor outside the state of a qubit can be
ignored as long as we are only dealing with that qubit). If you visualize the
state | (⇡ ✓, 2⇡ )i in the Bloch sphere, it will be clear that it corresponds
to the rotation of the state | (✓, )i by an angle ⇡ about the x axis. Thus

X = Rx (⇡), (12)

where the notation Rx (↵) denotes the operator rotating kets in the Bloch
sphere by an angle ↵ about the x axis. Similarly, it is easy to verify that the
operators 
0 i
Y = , (13)
i 0
and 
1 0
Z= , (14)
0 1
perform rotations by ⇡ about the y and z axes respectively. Note that (verify
yourself by matrix multiplications)

X 2 = XX = 1, Y 2 = Y Y = 1, Z 2 = ZZ = 1, (15)

and
Y = iZX. (16)

12
The identities Eq.(15) will be used very often in constructing circuits for
quantum computation, while because of identity Eq.(16), the operator Y is
used less frequently in quantum information texts (the operators X and Z
are successively applied to implement the operator Y ; the extra phase factor
which will appear is not relevant as long as we are dealing with a single qubit,
and can be taken into consideration in the other cases).

Exercise .7
By applying the matrix form of the operators Y and Z on the vector | (✓, )i
verify that Y = Ry (⇡) and Z = Rz (⇡), were Ry ( ) and Rz ( ) denote rotations
about the y and z axes by angles and respectively.

Exercise .8
Show that HZH = X and HXH = Z (In words, this is called: Hadamard
changes from X basis to Z basis).

12 Qudits
Qubits manifest only two possible fully distinguishable states in any given
measurement (remember the Stern-Gerlach experiment, where for any given
experiment, i.e., for any given orientation of the Stern-Gerlach setup, there
are only two possible outcomes), which we call |0i and |1i. We call these
2-state quantum systems. However, most systems in nature are not 2-state
systems. For example, if you measure the position of an object you obtain
real numbers from an infinite range of possibilities – ideally one should call
it infinite-state quantum system in conformity with calling a qubit a 2-state
quantum system – but in practice, it is called an infinite dimensional quantum
system (here the dimensions have nothing to do with the physical dimensions
occupied by the system, such as the 3 dimensions of our world, but the num-
ber of possible fully distinguishable outcomes a measurement of the system
can give) or simply a continuous variable system. Alternatively, in contrast
to Fig.2, which depicts a double quantum dot charge qubit (each box being
a quantum dot which holds an electron), imagine multiple dots (boxes) in a
row, with an electron having the possibility of being in any one of the dots.
If there are d such dots, teh system is called a quantum d-dimensional system
or a “qudit”.
To appreciate the number of possible states of a qudit, it is advisable to
look at yet another realization of a qubit, namely the state at the slits of a
Young double slit experiment. This is shown in the left hand side of Fig.7.
Here we can recast the notation used for qubits so that we relabel cos 2✓ , sin 2✓
and in terms of arbitrary complex numbers c0 and c1 obeying the condition
|c0 |2 + |c1 |2 = 1 (called the normalization condition). As noted in section 6 a
phase factor outside the state does not matter, so that an arbitrary state of

13
a qubit is represented as

| i = c0 |0i + c1 |1i

The above is called a normalized state as it satisfies the normalization con-

dition.
The generalization of the above representation to qubits is straightfor-
ward. A qudit is a system (ideally imagined as the state at the slits of a
d-slit interferometer) with d fully distinguishable states |0i, |1i, ...|d 1i so
that it can be in an arbitrary state
d 1
X
| i= cj |ji
j=0

Now consider the generalization of the Pauli matrices to qudits. These

are defined in terms of Xd and Zd , which are two of the d-dimensional gen-
eralizations of the Pauli operators. These are defined by their action on the
state |ji
Xd |ji = |j 1i

, where is modulo d addition (i.e., (d 1) 1 = 0). Similarly, Zd is a d-

i2⇡j
dimensional generalization of the Pauli operator defined by Zd |ji = e d |ji.
You can check that for d = 2 they reduce to the usual Pauli matrices X and
Z. However, note that for qudits, the number of independent operators are
more than 2. The full set of operators generalizing the usual Pauli matrices
for a qudit are
X r Z s with r, s = 0, 1, .., d 1
.

14
 0 c0

1 c1

0 c0
2 c2
1 c1
. iδ j
. cj = cj e
.
θ θ .
cos = c0 , sin = c1 ,
2 2
iδ j
c j = c j e , φ = δ1 − δ0
d −1 cd−1

Qubits Qudits

Figure 7: Pictorial representation of a qudit, in analogy with a similar one

for qubits.

15
 Lecture 2
Sougato Bose
January 17, 2021

1 The central aim of cryptography

Any seceret message is transmitted by encoding with a key. It could be (as in
the past) a physical key which can open a box in which a message is locked.
It could be a mathematical key such as a random bit string known only to
the secretly communicating parties (Alice and Bob). Thus the target for
Alice and Bob is to share a secret key. Whether they are separated parties to
start with, or have generated a shared key and then gone to a distance, they
have to transmit the key over a distance to share it. The central aim of an
evesdropper is to learn (or obtain a copy) of the key without being detected. A
little bit of thinking clarifies why this is the best strategy for the evesdropper.
If the evesdropper is detected, then Alice and Bob will simply stop locking
their secret messages with the compromised key and resort to other means.
Reverting back, in key distribution (i.e., in sharing the secret random key)
the central aim is to detect the level of Eve’s knowledge of the shared key. If
the Evesdropper has too much knowledge, they do not go ahead with using
the key. If the knowledge is minimal, they can upgrade the security of their
secret key by generating a shorter one using known protocols. Quantum key
distribution (QKD) o↵ers a method of performing key distribution in a way
so that an evesdropper cannot learn about the key without leaving a trace.

2 One time pad

See Zoom lecture notes.

3 BB84 (Bennett Brassard 1984) protocol of

quantum key distribution
Step 1: Alice generates two random bit-strings a = 10011.....0101 of zeros
and ones (shown in the first row of Fig.1), and another random bit string
b = xzzxz....zzxz of x’s and z’s (shown in the second row of Fig.1). ai and
bi denote the ith element of the bit-strings a and b respectively. Then Alice

1
 1 0 0 1 0 1 1 0 1 0 1 1 1 0 1 0 1 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0
X X X X Z Z Z Z Z Z X X Z Z X Z Z Z X Z X X X Z X X Z Z X Z X Z
− + + − 0 1 1 0 1 0 + − 1 0 − 0 1 0 + 1 − + + 1 − + 0 0 − 0 + 0

X Z Z X X X Z X X Z X Z Z Z X X
+ 0 1 + − − 0 + + 1 + 1 1 0 − +

0 0 1 0 1 1 0 0 0 1 0 1 1 0 1 0

X Z X X Z Z X Z Z X Z Z X Z Z X Z X X X Z X Z Z Z X Z X X Z X Z
− 0 + 0 0 1 + 0 1 − 0 1 + 0 1 + 1 + + − 0 + 0 1 0 + 0 − − 1 + 0

1 0 0 0 0 1 0 0 1 1 0 1 0 0 1 0 1 0 0 1 0 0 0 1 0 0 0 1 1 1 0 0
Eavesd 1 0 0 1 1 0 1 0 1 0 0 1 0 0 1 1 0 0
ropper
detec2
on E K K K K K E

Error
Reconc
0 1 0 0 1 0 1 1 0 0
ilia2on

0 1 0 0 1 0
Privacy
Amplifi 1 0 1
ca2on

Figure 1: An example of the implementation of BB84 protocol. Caution:

given the short strings (32) of random bits being used at the start, the results
do not reflect the true statistical behaviour of the much larger strings which
are actually used.

generates quantum states of qubits in accordance to the rule:

If ai = 0, bi = x, qubit state = |+i

If ai = 1, bi = x, qubit state =| i
If ai = 0, bi = z, qubit state = |0i
If ai = 1, bi = z, qubit state = |1i

The generated states are shown in the third row of Fig.1. Typically in long
distance cryptography, the states will be encoded in photon polarizations as
|0i = |Hi, |1i = |V i, |+i = p12 (|Hi + |V i) = |45i, | i = p12 (|Hi |V i) =
|135i, where H stands for horizontally polarized, V for vertically polarized
photons, while the two other directions mentioned are polarized along the
angles mentioned.
Step 2: Alice transmits the generated quantum states to Bob using some
channel (e.g. for photons it will be an optical fiber). This is shown as the
downward directing blue arrows in Fig.1.
Step 2.5 (Only if Eve is present): Eve does an intercept and resend
attack on the transmitted states. This means that Eve measures a fraction f
of the states that Alice had sent randomly in the x or z basis (Eve’s basis is
depicted in row 5 of Fig.1), encodes the measured state on to a new carrier
(e.g. new photon) (row 6) and sends the state to Bob. Eve generates a bit

2
string key from the measurement outcomes following the same prescription
as Alice’s key generation (row 7). In Fig.1 the fraction measured by Eve is
f = 1/2 – Eve measures every alternate qubit transmitted by Alice. This
is depicted by downward arrows alternating between continuing to Bob and
stopping at Eve, who resends the state (depicted as new arrows emanating
below Eve’s measured states) to Bob. As Eve does not know Alice’s basis
string b, Eve will measure a fraction f /2 in the correct basis and a fraction
f /2 in the wrong basis.
Step 3: Bob measures randomly in the x or z basis according to another
bit-string xxzzz....xzzx of x’s and z’s (row 9). This bit string is di↵erent
from Alice’s bit string b and randomly chosen. So the basis chosen has
1/2 probability to overlap with Bob. Bob generates a bit string (row 11)
according to the states he obtains as outcomes of his measurements (row
10) following the same prescription as Alice’s key generation, i.e., |+i =)
0, | i =) 1, |0i =) 0, |1i =) 1
Step 4: Public comparison of Bases – Alice and Bob publicly compare
their bases (announcing on a public channel: everyone can hear). They keep
only those cases for which their bases matched. The retained cases, where
Alice and Bob’s bases have matched, are depicted in row 12 of Fig.1. The
fraction of retained cases for large strings should be 1/2. However, as we can
see in the figure, due to small number fluctuations, 18 out of the 32 bits are
retained.
Step 5: Evedropper Detection/ Error Estimation – Alice and Bob
now take a small sub-string of their retained bits (this is shown as the purple
coloured section of 6 bits in row 12 of Fig.1) and publicly compare their
outcomes. Note that a fraction of these bits will be known by Eve. These
bits are denoted by K in Fig.1. Moreover, due to Eve’s actions, in a fraction
f /4 of the publicly compared bits Alice and Bob should be errors (see the
discussion of security below). Thus by comparison of a small substring of
their bits, Alice and Bob identify f . If f (quantifying the degree of Eve’s
intervention) is below a desired threshold, then they proceed with further
stages of the protocol. If f is too high, they abort the protocol, and seek
alternate methods to share their secret key. In Fig.1, the bits that have errors
(mismatch between Alice and Bob’s retained bits) are denoted by E in row
13. In the case considered in Fig.1 f = 1/2 and thus errors should be in 1/8
of the bits, but due to statistical fluctuations in the small sample, errors are
actually found in 2 out of 18 bits.
Step 6: Error Reconciliation The aim of this step is to find out the
location of the errors in the private (unannounced) part of Alice’s and Bob’s
retained bit strings (i.e., the 12 bits in the uncoloured part of row 12) and
eliminate them. We know that a fraction f /4 will have errors for large bit
strings. While finding out the errors Alice and Bob have to do it in such a
way that minimal or no extra information is leaked to Eve over what Eve
already knows. One fruitful strategy usually adopted for this is a bisective
search whereby the bit-string is divided to two equal parts down the middle
(in the figure, blocks of 6 each as shown by horizontal brackets in row 13),
their parities (the value of the binary addition of the bits modulo 2) are

3
announced publicly and the first bit of each collection is discarded. The
discarding is done for the purpose of getting rid of Eve’s information about
the parity from the public announcements – as the discarded bit is likely
to be unknown to Eve (for small f ), it gets rid of any information about
the parity of the bits retained after the above discarding. An assumption
in the bisective search is that at most 1 bit contains an error in the blocks
made for parity comparison, which should hold largely true for small f . The
bits remaining after this are shown in row 13. The blocks whose parities
match, are simply continued to the next step (row 14), while those for which
the parities did not match (the right block in Fig.1), a bisective search is
repeated by splitting that block into two further blocks. This is how the
bit labeled by E is identified and eliminated. On the way, because of parity
comparisons, several other bits are also eliminated. The final string after
this (row 14) is now without errors (Alice and Bob have perfect match in
the bits retained). In practice, for realistic larger cases, the bisective search
is followed by other searches to handle cases of two errors per block, and
errors are greatly minimized (to a desired quantifiable extent) rather than
fully eliminated in the end.
Step 7: Privacy Amplification – While the resulting strings (row 14) are
error-free and shared between Alice and Bob, Eve knows a fraction of these
correctly. The target in this step is to compress the shared (now nearly error
free) bit strings to get rid of Eve’s information to the best extent possible (i.e.
enhance the privacy of the key shared between Alice and Bob). In Fig.1, this
amounts to making the information Eve has of the bits marked K irrelevant.
This is done by combining selections of bits and using their parity as the
key (obviously which bits are being combined is publicly announced so that
Alice and Bob have the same final keys). In Fig.1, for example, moving left
to right along row 14, the parities of two successive bits is computed and
used as the final key between Alice and Bob (row 15). Note here that as Eve
knows only one bit within each combined pair, her knowledge is completely
eliminated (a random bit being added binary modulo 2 to the bit she knows).
In parctice for realistic cases, Alice and Bob will reduce Eve’s knowledge of
the key to a certain agreed threshold level.

4 A discussion of security
Let us consider the shared bit strings after the public comparison of bases
by Alice and Bob. Eve has measured a fraction f of the qubits transmitted
by Alice. Of these Eve will measure a fraction 1/2 in the correct basis
and the state sent by Alice will remain intact and be transmitted to Bob.
Thus for these cases, Bob will see no errors in the shared bit string obtained
after the public comparison. Of the rest 1/2 fraction of Eve’s measured
qubits, a fraction 1/2 will probabilistically collapse to the right outcome
as |h0|±i|2 = |h1|±i|2 = 1/2. Thus only 1/4 of those measured by Eve
will have errors, implying a error of f /4 observed by Alice and Bob. In
practice, Eve can attack in ways other than intercept and resend such as

4
by entangling another system with the qubit transmitted or by trying to
copy (clone) it. These also will leave an error trace of similar magnitude.
For example, entangling will increase the mixedness of the states reaching
Bob, with more mixedness for more entanglement Eve attempts to make in
order to get more information, while why Eve cannot clone will be discussed
later in the course. Indeed Eve can use a full quantum computer, which can
in e↵ect do entanglement of larger blocks of qubits with a large number of
ancillary qubits and subsequently measure those ancillary ones, but this will
also leave a trace due to increasing mixedness.

5 Photonic Qubits
Photonic qubits are generally used for QKD as photons can travel long dis-
tances without interacting significantly with their environment so that their
states (say polarization states as an example) are well preserved. However,
photons do not directly interact with each other. This makes their usage in
quantum computation, where interactions can aid in quantum gates very dif-
ficult (although people do accomplish it, albeit less efficiently than would be
possible through direct interactions using clever usage of quantum statistics
and measurements).

5
 Lecture 3: Quantum Evolutions and Circuits
Sougato Bose
January 29, 2021

We start by presenting explicit matrix forms for the rotation operators

about the X, Y and Z axes of the Bloch sphere for arbitrary angles
↵
Rx (↵) = ei 2 X , Ry ( ) = ei 2 X , Rz ( ) = ei 2 Z . (1)

What does the above exponentiations of a matrices X, Y and Z mean? In

fact, this is a symbolic shorthand notation for an infinite series. If the Taylor
expansion of any function f (x) = a0 + a1 x + a2 x2 + a3 x3 + ... is known, then
for a matrix A, f (A) = a0 1 + a1 A + a2 A2 + a3 A3 + ..., were 1 is the identity
operator of the same dimensions as A, and A2 = AA, A3 = AAA and so forth
are obtained by matrix multiplications. Thus

Rz ( ) = e i 2 Z
1
X
= 1+ (i )n Z n (Using the Taylor expansion of ex )
n=1
2

= {1 + (i )2 + (i )4 + ...}1 + {(i ) + (i )3 + ...}Z (Using Eq.(??))

2 2 2 2
= cos 1 + i sin Z. (2)
2 2
It is clear from Eq.(??) that without repeating the mathematics one can
immediately write down
↵ ↵
Rx (↵) = cos 1 + i sin X, Ry (↵) = cos 1 + i sin Y. (3)
2 2 2 2
Using the form Eq.(2) it is easy to show that Rz ( ) given above performs a
rotation by an angle about the z axis:
  i
cos 2✓ e 2 cos 2✓
Rz ( )| (✓, )i = (cos 1+i sin Z) i ✓ = ⌘ | (✓, )i.
2 2 e sin 2 e i 2 ei sin 2✓
(4)
Thus Rz ( ) as defined by us above performs a clockwise rotation about the
z axis of the Bloch sphere by an angle . As essentially the choice of what
one considers as x, y or z axes is arbitrary, it follows that Rx (↵) and Ry ( )
perform clockwise rotations about the x and the y axes by angles ↵ and
respectively. In continuation with the above let us point out (without proof)

1
that a clockwise rotation by an angle about any axis in space defined by
the unit vector n̂ = ex nx + ey ny + ez nz is given by

Rn̂ ( ) = ei 2 .n̂
= cos 1 + i sin .n̂, (5)
2 2
where = ex X + ey Y + ez Z. In general, of course, any transformation from
0 0
some state | (✓, )i to some other state | (✓ , )i on the Bloch sphere can
be thought of a rotation about some axes.

Exercise .1
Show that det{Rn̂ ( )} = 1, where det{A} means the determinant of the
matrix A.

0.1 Arbitrary rotations from rotations about fixed axes

Suppose for a certain type of qubit one can only do rotations about some fixed
axes. For example, for a double dot charged qubit It is an interesting question
to ask as to how many rotations about independent axes are needed in order
to perform an arbitrary rotation on the Bloch sphere. Let the independent
axes by y and z.
An arbitrary SU (2) operation in the Bloch sphere takes Rz ( )Ry ( )Rz ( )
form. This can be easily geometrically understood (and hence we will not
give a proof!) through the requirement that an arbitrary vector | (✓, )i
0 0
needs to be taken to another arbitrary vector | (✓ , )i. Rotations about
independent axes do not commute. Thus the minimal way to undertake the
above is as follows. We first rotate about z axis by = . Then we rotate
0 0
about the y axis by = ✓ + ✓ so that the new angle ✓ is obtained. Then
0 0
the new is obtained by a rotation about z-axis of angle = .
Thus a general U (2) operation on a single qubit (including an arbitrary
phase outside the state) is:

U = ei↵ Rz ( )Ry ( )Rz ( )

1 ABC Theorem
Before we move over to consider quantum operations on two qubits, we prove
a theorem. This theorem will be useful to construct Controlled-Unitaries
from a standard two qubit gates such as a CNOT (we will also show “how”
to construct a CNOT shortly). The statement of the theorem is:
Theorem: An arbitrary single qubit unitary operator can be expressed as
U = ei↵ AXBXC in terms of 3 single qubit unitary operators A, B and C
satisfying ABC = 1.
Proof: The proof is by construction. We assume

A = Rz ( )Ry ( ), B = Ry ( )Rz ( ), C = Rz ( + ).
2 2 2 2 2 2
2
By multiplication it is easily verified that ABC = 1. Now,

ei↵ AXBXC = ei↵ Rz ( )Ry ( )XRy ( )Rz ( )XC = Rz ( + )

2 2 2 2 2 2

= ei↵ Rz ( )Ry ( )XRy ( )XXRz ( )XC = Rz ( + )

2 2 2 2 2 2
(inserting XX = X 2 = 1 between the second Ry and second Rz operators)

= ei↵ Rz ( )Ry ( )Ry ( )Rz ( + )Rz ( + )

2 2 2 2 2 2
(using XRy (✓)X = Ry ( ✓) and XRz (✓)X = Rz ( ✓).)

= ei↵ Rz ( )Ry ( )Rz ( ) = U

2 Implementation of a CNOT gate

To implement a CNOT gate, we will first implement the CZ gate (Controlled-
Z gate) given by the following evolution

|00i ! |00i,

|01i ! |01i,
|10i ! |10i,
|11i ! |11i,
or simply by the matrix
2 3
1 0 0 0
6 0 1 0 0 7
CZ = 6
4 0
7
0 1 0 5
0 0 0 1

. To implement the CZ gate we can use the following Hamiltonian (called

the Ising Hamiltonian) between two qubits:

HIsing = gZA ⌦ ZB

where g > 0 is a coupling strength which has frequency units (h̄g is regarded
as the energy). Verify yourself that

HIsing |00i = g|00i

HIsing |01i = g|01i

HIsing |10i = g|10i
HIsing |11i = g|11i
One can thus think of HIsing as representing a Hamiltonian which ensures
that the states of the two qubits in the computational basis |00i, |01i, |10i

3
 0 0

1 0

(a) (b)

1 1

1 0

(c) (d)

Figure 1: Showing four diferent two qubit states and their the reason for their
energy di↵erence. The |01i and |10i configurations have a smaller distance
between charges and hence a higher energy. The zero of the energy is then
redefined as midway between those of the |00i and |01i states.

4
and |11i are energy eignestates with di↵erent energies ±h̄g. Physically it is
easiest to visualize this for two double-dot charge qubits placed one above
another as shown in Fig.1 with the definitions of the |0i and |1i state opposite
for the two qubits. Similarly, for spin qubits, the orientation of one of the
spins along the z axis controls the energy of the second one (It can originate
from the magnetic field in the z direction given out by one spin acting on the
other spin, causing it to align with the former in order to lower its energy,
when the individual energies of the spins due to other external magnetic
fields in the z direction are highly mismatched; Stronger ones can originate
from Coulomb interactions and the quantum indistinguishability of electrons
along with asymmerties posed by di↵erent z directed magnetic fields on the
two spins).
In addition to the above, we will use an extra Hamiltonian applied to
single qubits. This is easiest to visualize for spin qubits, being simply two
magnetic fields of equal strength directed along the z axis. This extra single
quibit Hamiltonian is

H0 = gZA ⌦ 1B + g1A ⌦ ZB

The relevant time evolution is thus via the total Hamiltonian

HCZ = H0 + HIsing ,

and to obtain a CZ gate we operate it for a time tCZ = ⇡4 . We can verify that
⇡ ⇡
i ⇡4 ZA ⌦1B i ⇡4 1A ⌦ZB i ⇡4 ZA ⌦ZB
ei 4 e iHCZ tCZ
|00i = ei 4 e e e |00i
i ⇡4 i ⇡4 i ⇡4 i ⇡4
=e e e e |00i = |00i
i ⇡4 iHCZ tCZ i ⇡4 i ⇡4 ZA ⌦1B i ⇡4 1A ⌦ZB i ⇡4 ZA ⌦ZB
e e |01i = e e e e |01i
i ⇡4 i ⇡4 i ⇡4 i ⇡4
=e e e e |01i = |01i
⇡ ⇡
i ⇡4 ZA ⌦1B i ⇡4 1A ⌦ZB i ⇡4 ZA ⌦ZB
ei 4 e iHCZ tCZ
|10i = ei 4 e e e |10i
i ⇡4 i ⇡4 i ⇡4 i ⇡4
=e e e e |10i = |10i
i ⇡4 iHCZ tCZ i ⇡4 i ⇡4 ZA ⌦1B i ⇡4 1A ⌦ZB i ⇡4 ZA ⌦ZB
e e |11i = e e e e |11i
i ⇡4 i ⇡4 i ⇡4 i ⇡4
= e e e e |11i = |11i
i⇡
Thus e iHCZ tCZ =e 4 CZ . When we want to implement CZ in a quantum
computation involving solely two qubits, the phase outside does not matter.
When it is being done on a part of a circuit involving more that 2 qubits, we
⇡
have to remember that an extra ei 4 phase is also present in this implemen-
tation using an Ising Hamiltonian and accordingly do phase adjustments by
local gates on other qubits as needed.
Once the CZ is obtained, we can implement a CNOT following the quan-
tum circuit of Fig.2 exploiting HZH = X.

5
a a

≡
b X b H Z H
H

Figure 2: Implementation of CNOT, once CZ is given. The controlled gates

are represented by the respective Pauli operators X for CNOT and Z for CZ
acting on the target qubit (the qubit in the lower rail of the figure) conditional
on the state of the control qubit (the qubit in the upper rail of the figure) –
the conditionality being depicted by the filled dots on the control qubit.

⎛ 1 0 ⎞
a a ⎜⎜ H iα ⎟⎟
⎝ 0 e ⎠

≡
b U b CH X H
B X H
A

U = eiα AXBXC
Figure 3: Circuit showing the construction of Controlled-U given the ability
to implement CNOT and local unitaries.

6
3 Controlled-U
Armed with CNOT and utilizing the ABC theorem, we will now see how one
can implement a Controlled-U operation. The circuit is given in Fig.3.
To understand why this circuit accomplishes a Controlled-U , we have to
check its operation one by one on each of the computational basis sates. In
Fig.3, a = 0, 1 stand for the bit values of the inputs when computational (z)
basis inputs are taken. Thus,

a = 0 =) Unitary on target qubit = ABC = 1

a = 1 =) Unitary on target qubit = ei↵ AXBXC = U

4 Controlled-Controlled-U s
Given the ability to contruct Controlled Unitaries (single control and single
target), we will now learn how to achieve Controlled-Controlled Unitaries
(two controls and a single target). Consider Fig.4 where we want to imple-
ment Controlled-Controlled-U . In the figure the Controlled Unitaries used
are Controlled-V and Controlled-V † such that V 2 = U (V is a unitary oper-
ation which is the square-root of the unitary U – obviously this is not unique
– any unitary V satisfying V 2 = U will suffice). COnsider the four cases of
di↵erent values for input computational states one by one, and the resulting
operation on qubit c
a = 0, b = 0 =) none of the controlled operations act =) I acts on c.
a = 0, b = 1 =) Only gates controlle by b acts, =) V † V = I acts on c.
a = 1, b = 0 =) Both CNOTs and the last Controlled-V acts, =)
V V † = I acts on c.
a = 1, b = 1 =) All Controlled gates act, =) V V = V 2 = U acts on c.
Note: One of the most important Controlled-Controlled-U gates is the
TOFFOLI or Controlled-Controlled-NOT. It is the fundamental gate for Re-
versible Classical Computation (all classical circuits can be constructed from
the TOFFOLI). Moreover, TOFFOLI and Hadamard together constitute a
complete set of gates for universal quantum computation. To accomplish a
TOFFOLI
p according to the methodology described here, one has to choose
V = X.

5 Multi-Controlled single target U s

Given the CC-U implementation above and its special case TOFFOLI (CC-
X), we can now design circuits with even more than two (in fact, an arbitrary
number) of qubits as control and a single qubit as target. The circuit is
shown in Fig.5. It is conceptually easy to understand its action. Only when
a = b = c = 1 does the qubit preceding d go to the |1i state. Then the
Controlled-U is implemented on the qubit d. The rest of the circuit resets
the qubits between c and d to their original states.

7
 a

b X X

c VH VH+ VH

Figure 4: Circuit showing the construction of Controlled-Controlled-Us given

the ability to implement Controlled Unitaries (in the above Controlled-V and
Controlled-V † are the Controlled Unitaries used.)

8
 a
b
c

0 X X 0

0
X X 0

d U
H

Figure 5: Circuit showing the construction of Multi controlled, single target

U s. in this case three controls a, b and c and a single target d. The two qubits
between c and d enable the gate, but are brought back to their original state
|0i at the end of the gate.

6 The implementation of arbitrary unitary

operations on n qubits
Now we will show how an arbitrary unitary operation may be implemented
on n qubits, essentially an arbitrary SU (2n ) operation. This implementation
uses two key ingredients: (a) the fact that being able to do arbitrary 2-level
unitaries suffice to impement an arbitrary unitary on any qudit with d 2
(this,of course, inlcuded d = 2n ) and (b) Arbitrary 2-level unitaries can be
accomplished via the multi-controlled single target U s discussed above.
We will discuss both aspects (a) and (b) via exemplification.

6.1 Arbitrary unitaries with 2-level unitaries:

2-levelConsider the following 3-level (qutrit, with states |0i, |1i and |2i) uni-
tary: 2 3
a d g
U = 4 b e h 5.
c f i
Consider the 2-level unitary V01 (acting on the levels |0i and |1i of the qutrit,
keeping the level |2i unchanged) given by
2 ⇤ ⇤
3
p a2 2 p b2 2 1
6 |a|b+|b| |a| +|b| 7
V01 = 6 p
4 |a|2 +|b|2 p a
2 2
1 7
5
|a| +|b|
0 0 1

9
. Then 2 3
1 d0 g
V01 U = 4 0 e0 h 5 .
c f i
Similarly applying another unitary operation V02 (similarly chosen for the
levels |0i and |2i) we can get
2 3
1 d0 g 0
V02 V01 U = 4 0 e0 h 5 .
0 f i0

As V02 V01 U is unitary, it must have the form

2 3
1 0 0
V02 V01 U = 4 0 e0 h 5 .
0 f i0

Now a last unitary V12 acting on the levels |1i and |2i (essentially the inverse
of the 2 ⇥ 2 matrix in the |1i,—2i subspace) can bring it to the form

V12 V02 V01 U = 1

Thus U = V01† V02† V12† is the implementation of the arbitrary qutrit unitary in
terms of three 2 level unitaries.

6.2 Multi control single target U s for arbitrary 2-level

unitaries
Consider the 3-qubit unitary (or a qudit unitary with d = 23 = 8) acting on
just two levels of the system – the |000i and the |111i levels. As the result of
the preceding subsection shows, if we can implement such an unitary then we
can implement any unitary on the qubits. We will first use several TOFFOLI
gates with modified controls (i.e., the TOFFOLI can be controlled on one or
more qubits being |0i rather than |1i (very easy to ensure by having X gates
on appropriate controls before and after the TOFFOLI). These can be used,
via steps taken in which only one of the bits is flipped, to go in multiple
steps, from |000i to |110i. Thus the steps are:

|000i $ |100i
|100i $ |110i
Now a unitary operation U is done on the third qubit and the above states
are repeated in the reverse order to take the |110i level back to |000i level.
This whole procedure is thus equivalent to performing the 2-level unitary U
in the {|000i, |111i} subspace.

10
7 Universal Quantum Computation
Universal quantum computation means being able to accomplish arbitrary
SU (2n ) on n qubits. From the above discussions it is clear that we can do
that if we could do arbitrary local unitaries and multi-control versions of
TOFFOLI for larger numbers of qubits with the control value being modi-
fied to 0 if needed. These, are, in turn, accomplished by CNOTs and local
unitaries as shown in earlier parts of this lecture. Thus

Universal quantum computation is possible if one can accomplish CNOTs

and arbitrary single qubit gates.

The CNOT in the above requirement can, in fact, be modified to be re-

placed by any entangling unitary operation (entangling gate) on two qubits.
Thus another statement for universality is:

Universal quantum computation is possible if one can accomplish any en-

tangling gate on two qubits and arbitrary single qubit gates.
(we do not prove this generalization of the result.) Some times, especially if
one is working with “encoded” qubits (when many physical qubits are used
to encode a logical qubit, as fo example, in quantum error correction), arbi-
trary local unitaries are not possible. Then the set of local unitaries can be
replaced by the gates
  
1 1 1 1 0 1 0
H=p ,P = ,S = ⇡
2 1 1 0 i 0 ei 4

(we do not prove here why this discrete set suffices to achieve any local
unitary operation).
Another interesting universality avenue is:
Universal quantum computation is possible with a TOFFOLI and Hadamard
H.
We do not prove the above here either.

11
Entangled States: Nonlocality & Dense Coding
Sougato Bose
February 5, 2021

1 Entangled States
Consider a generic ket representing a certain state to two quantum systems
A and B, given by X
| iAB = cjk |jiA ⌦ |kiB .
jk

We will often refer to | iAB as the joint or combined state of two systems as
it represents the total state of both the systems. It is not guaranteed that
we can write
| iAB = | iA ⌦ | iB .
In some special cases we can; for example
(1) 1
| iAB = p (|0iA ⌦ |0iB + |0iA ⌦ |1iB ) = |0iA ⌦ |+iB . (1)
2
In these cases, we call the above state factorizable or a product state. The
factorization works by taking out, as a common factor, a ket |⇠i↵ , from the
combined state of two systems where, in all the terms, both the ket label ⇠
and the system label (subscript) ↵ (in the above example, ↵ = A, B) must
be the same. In the above example Eq.(1), |0iA is common in both the first
and second term of the sum (superposition) of states in | (1) i, and hence it is
factored out in order for system B to be in the state p12 (|0iB + |1iB ) = |+iB .
Consider, now, instead, the example,
(2) 1
| iAB = p (|0iA ⌦ |0iB + |1iA ⌦ |1iB ). (2)
2
You cannot take out either |0iA or |1iA as a common factor from the two
terms as they are not the same state. You cannot take |0iB or |1iB as a
common factor either because of exactly the same reason. Thus | (2) i is
a non-factorizable state. It is, in fact, a canonical example of an entangled
state. As long as we are reperesenting the combined (or joint) state of the two
systems by a ket (we can only do that when they are pure states), whenever

| iAB 6= | iA ⌦ | iB , (3)

we call the state | iAB an entangled state. This definition has to be slightly
generalized when we consider mixed states of A and B as then we cannot use

1
a single ket to represent their joint state – this will be discussed in a later
lecture. If we have multiple systems 1, 2, 3, ..., n whose state is represented
by a ket
| i12...n 6= | 1 i1 ⌦ | 2 i2 ⌦ ... ⌦ | 3 i3 , (4)
we say it is an entangled state.

Note: In this lecture, we will be using the notations | iA ⌦ | iB ⌘

| iA | iB ⌘ | iA | iB ⌘ | iAB ⌘ | i. For example for states of 3 qubits,
when the qubits are in a state |0iA ⌦ |1iB ⌦ |1iC ⌘ |011i. The above short-
hands have been introduced in order to write longer expressions in a compact
way. In short, when there are multiple systems, the kronecker (outer) prod-
uct is understood to be implicitly there, extra ket signs separating the state
labels of the individual systems are omitted and it is understood that the
first label corresponds to the first system, the second to the second system
and so forth.

Exercise .1
Show that
(3) 1
| i = (|00iAB + |01iAB + |10iAB + |11iAB )
2
is a product state. Show that
(4) (3)
| i = CZAB | i

is an entangled state.

2 Quantum Nonlocaity
Entangled states demonstrate quantum nonlocaity when they are shared
among distant observers who do measurements on them. For example com-
sider the case when two qubits in the state | (2) iAB are shared between two
distant parties Alice and Bob; A being held by Alice and B being held by
Bob. Then quantum mechanics exhibits a peculiar feature that the corre-
lations obtained from measurements on | (2) iAB do not follow the locality
assumption: The choice (in this case the choice of one among two possible
measurement bases) made by Alice cannot a↵ect the measurement result
obtained by another observer Bob when they are space-like separated (out-
side each other’s light cone so that no physical signal can propagate between
them). Note that here that the locality assumption is merely demanding
that it is the choice of basis of one observer which should not influence the
measurement outcome of another observer. The choice of basis by Alice can-
not, in fact, provide any bits of information to the distant observer Bob. Bob
gets the same probability distribution of outcomes for all di↵erent choices of
Alice’s basis, and hence cannot infer what basis Alice had chosen (this will
be shown exactly in terms of the density matrix in a later lecture) and there-
fore cannot learn any bits of information from Alice. Thus there is no faster

2
 X Y
A
m x myA

Y
myB Y
myC
X X
mxB mxC
Figure 1: The setting for the demonstration of quantum nonlocality by the
GHZ state. Each observer measures her/his qubits in the X or Y basis with
outcomes labelled by mA A
x , my and similarly for B and C.

than light signalling and relativistic causality is fully respected. Nonetheless,

when Alice and Bob bring their results together to compare, then find that
the correlations between their observations cannot be explained by a model
where the basis choice of Alice did not influence the result of Bob through a
“spooky action at a distance” (an action outside the light cone). Thus quan-
tum nonlocality is not strong enough to violate relativistic causality, but is
yet, an instantaneous action at a distance – there is no dynamics associated
with this action – it is purely a statistical property of the entangled quantum
state shared between Alice and Bob. Here we will demonstrate quantum
nonlocality with the 3 qubit entangled state
1
|GHZiABC = p (|000iABC + |111iABC ),
2
which is called the Greenberger-Horne-Zeilinger (GHZ) state. We consider
the state to be shared between 3 distant parties Alice (possesing qubit A),
Bob (possesing qubit B) and Charlie (possesing qubit C) as shown in Fig. 1.
Each observer can measure in either the X or the Y basis, the corresponding
outcomes obtained are denoted by mA A B B C C
x , my , mx , my , mx , my = ±1 (For |±i
outcome in the X basis, we asign eigenvalues ±1 and similarly for the two
outcomes of the Y basis). Now here the locality assumption amounts to: mA x

3
value (either +1 or -1) is independent of whether Bob and Charlie measure
XB YC or YB XC . We will show that this cannot be true by the following
contradiction.
Note that (verify by calculation remembering that XA , YB and YC act
on the first, second and third qubits of the state respectively, with X|0i =
|1i , X|1i = |0i , Y |0i = i |1i , Y |0i = i |1i)

XA YB YC |GHZiABC = 1|GHZiABC =) mA B C
x my my = 1 (5a)
YA XB YC |GHZiABC = 1|GHZiABC =) mA B C
y mx my = 1 (5b)
YA YB XC |GHZiABC = 1|GHZiABC =) mA B C
y my mx = 1 (5c)

The locality assumption has been used in the rightmost equalities of Eqs.(5a)-
(5c) in the sense that the same mAy (whether it be +1 or -1) occurs in Eqs.(5b)
and (5c) and similarly for the other outcome values. Multiplying the right-
most equalities of Eqs.(5a)-(5c) and using the fact that (mA 2 B 2
y ) = (my ) =
(mC 2
y ) = 1 we get
mA B C
x mx mx = 1. (6)
On the other hand the outcomes mA B C
x , mx and mx should be obtained when
X basis measurements are performed on all 3 qubits (again by the local-
ity assumption that mA
x does not depend on whether Bob and Charlie are
measuring in the X or Y bases, and similarly for the other combinations).
However, quantum mechanics gives (check by direct application of the oper-
ator XA XB XC on the GHZ state)

XA XB XC |GHZiABC = +1|GHZiABC =) mA B C
x mx mx = +1. (7)

The direct contradiction of Eq.(6) and Eq.(7) implies that the locality as-
sumption must have been wrong (i.e., the value mA x is indeed influenced by
the context of the measurement – whether Bob and Charlie choose to measure
in the X or the Y basis – thus there is indeed a spooky action at a distance).

3 Bell-States
There are 4 canonical entangled states of 2 qubits which are called the Bell
states (in honour of John Bell who used one of these class of states first to
demonstrate the nonlocal nature of quantum correlations):

+
↵ 1
AB
= p (|0iA |1iB + |1iA |0iB )
2
↵ 1
AB
= p (|0iA |1iB |1iA |0iB )
2
+
↵ 1
AB
= p (|0iA |0iB + |1iA |1iB )
2
↵ 1
AB
= p (|0iA |0iB |1iA |1iB )
2

4
 In fact, the above states are in the class of the most entangled states pos-
sible for two qubits – we will discuss that when we discuss the quantification
of entanglement in another lecture. These states form a complete orthonor-
mal basis for two qubits (please verify for yourself by directly obtaining the
relevant inner products)

± ± + +
h | i=h | i=h | i = 0,
+ + + +
h | i=h | i=h | i=h | i = 1.
Thus a projective measurement on two qubits can be performed on this basis
to obtain one of the Bell states – this is called the Bell basis measurement
or Bell State Measurement (BSM). It is a complete basis for measurement
as there are only 4 possible orthogonal states for two qubits. In a later
lecture we will discuss how Bell states can be generated and how a BSM
can be performed both via a quantum circuit (possible for qubits between
which an interaction can be switched on to enact a CNOT gate) and how
they have been done in practice for noninteracting photonic qubits exploiting
quantum indistinguishability. For the time being, however, we will proceed
by assuming a BSM to be possible.
An interesting and important property of the Bell-States are their in-
terconvertability to each other simply through the action on one of the two
qubits. Such an operation, which acts only on an individual qubit is called
a local operation. For example, XA ⌦ 1B is regarded as a local operation as
the X operator only acts on qubit A and no operation acts on qubit B (i.e.,
it is acted on by the Identity operation).
Verify for yourself (by calculation remembering that operators XA , ZA
and IB act on their respective qubits with X|0i = |1i , X|1i = |0i , Z|0i =
|0i , Z|1i = |1i)
↵ ↵
XA ⌦ 1B + AB = +
AB
(8a)
↵ ↵
ZA ⌦ 1B + AB = (8b)
+
↵ ↵AB
ZA XA ⌦ 1B AB
= AB
(8c)

Exercise .2
Show that the set of states defined by
↵
GHZ srt = ZAs XAr ⌦ XBt ⌦ 1C |GHZiABC

with s, r, t = 0, 1 forms a complete orthonormal basis for 3 qubits.

4 Quantum Dense Coding

Quantum Dense Coding (Bennett and Wiesner 1992) was the first protocol
showing a practical application of a shared entangled state between two dis-
tant parties in communication. It shows that the classical communication

5
 Ψ+
AB

(a)
α ⇒ IA ⊗ IB
β ⇒ XA ⊗ IB
γ ⇒ ZA ⊗ IB
δ ⇒ ZA XA ⊗ IB (b)
BSM
Ψ+ ⇒ α
Ψ− ⇒ β
Φ+ ⇒ γ
(c)
Φ− ⇒ δ

Figure 2: Quantum Dense Coding protocol showing three of the steps of the
protocol.

capacity (which is quantified as the number of bits of information that Alice

can send to Bob) between Alice and Bob can be enhanced two-fold if they
share a Bell state as a resource. The situation is depicted in Fig.2. Es-
sentially if an entangled state is already shared as a resource between Alice
and Bob, then Alice can send 2 bits of information to Bob by transmitting
a single qubit. Naively this may seem a bit odd as a single qubit can be
measured to only give two outcomes – 1 bit of information. However, on the
prior shared entangled state Alice can actually encode 2 bits of information
solely through local operations on her qubit. When it is sent to Bob, then
Bob can perform joint measurement on two qubits together to obtain 2 bits
of information. We describe the protocol in 4 steps.

Step 1: Alice and Bob share many copies of the entangled state | + iAB of
two qubits through a quantum channel (a channel which can transmit quan-
tum states, in this case the state of a qubit). This is ideally done overnight
(or more generally in a non-rush hour time period) so that we do not really
need to “count” these transmissions as a significant load to the channel –
the channel is mostly unused at these times. Note no information is actually
transmitted at this stage from Alice to Bob – only the correlations entailed by

6
the state | + iAB . In fact, suppose that the information Alice will eventually
send to Bob has not even materialized (e.g., it could be the news emerging
from an event occuring the next day). The situation after the completion of
this step, depicting only one of the copies of | + iAB is shown as Fig.2(a).
We will describe the protocol using this single copy (with the understanding
that each copy will be used in exactly the same way)

Step 2: Alice now has information to send to Bob. She can now encode
this information on her qubit at the rate of 2 bits/qubit – thus dense coding
(twice the capacity as is possible for a single qubit). She performs one of
four possible operations on her qubit. Communicating 2 bits correspond
to communicating four letters – say we call these ↵, , and . Now Alice
performs the following protocol to encode her letter to the qubit she has (this
is shown in Fig.2(b)):
↵ =) 1A (no action) on qubit A
↵ ↵
=) State of A and B = 1A ⌦ 1B + AB = +
AB
=) XA on qubit A
+
↵ +
↵
=) State of A and B = XA ⌦ 1B AB
= AB
=) ZA on qubit A
+
↵ ↵
=) State of A and B = ZA ⌦ 1B AB
= AB
=) ZA XA on qubit A
+
↵ ↵
=) State of A and B = ZA XA ⌦ 1B AB
= AB
+
In the above the transformation of | iAB to the other states by Alice’s local
operation follows from Eqs.(8).
Step 3: Alice transmits her qubit to Bob. She intends Bob to learn the 2
bits of information she encoded from this. Of course, she encodes several such
qubits, one for each copy of | + iAB shared with Bob, with the intention that
each will communicate 2 bits of information (2 bits per transmitted qubit).
Note that these transmissions are occuring during the rush hour, so we do
count these transmissions as a load on the channel – however, now only one
qubit per two bits is being transmitted through the quantum channel (instead
of one qubit per bit).
Step 4: Bob receives Alice’s qubit and measures both qubit A and B
in the Bell basis (Bell State Measurement BSM, as schematically shown in
Fig.2(c). He gets four possible outcomes, from which he infers the 4 possible
letters sent by Alice as follows:
↵
Bob obtains + AB =) Alice sent = ↵,
↵
Bob obtains + AB =) Alice sent = ,
↵
Bob obtains =) Alice sent = ,
↵AB
Bob obtains AB
=) Alice sent = .
Thus Bob obtains 2 bits of information per qubit transmitted by Alice after
encoding.

7
 Exercise .3
Check that no dense coding will happen with the state |01iAB shared between
Alice and Bob (i.e., Alice will communicate at most 1 bit per qubit).
The above exercise illustrates the importance of sharing an entangled
state in the dense coding protocol.

8
 Quantum Teleportation
Sougato Bose
February 9, 2021

After dense coding, we will now study the most celebrated application of
entanglement, namely Quantum teleportation. Quantum teleportation is the
act of sending a quantum state accross a distance using shared entanglement
in a way that the original quantum state is destroyed, and a copy reappears
at a distance. Thus it is a very di↵erent strategy from the usual way you
send a “scanned” letter to a distance. You essentially make a copy of the
information which is sent over the internet, while the original remains with
you. Hwoever, this strategy does not work for quantum states – you cannot
make a copy – this is also the reason why QKD is secure – Eve cannot make an
exact copy of the quantum state transmitted by Alice to Bob. Thus before
studying teleportation, we should study the quantum no-cloning theorem,
which proves that you cannot construct a machine which makes a copy of an
arbitrary quantum state.

1 Quantum No Cloning Theorem:

This follows from the linearity of quantum mechanics (and hence it is valid
for linear theories more broadly, not just confined to quantum mechanics). It
states that it is impossible to design a machine to clone an arbitrary quantum
state. It is proven by contradiction. Let us assume such a universal quantum
cloning machine does exist and can clone two states | iS and | iS of a system
S such that | iS 6= | iS . If the machine is universal, it should also clone
| iS + | iS (we ignore normalization at this stage, which does not a↵ect
the proof). Assuming a linear evolution L – can be more general than the
unitary evolution of standard quantum mechanics, i.e., it can be any theory
with linear operators giving the evolution of states, assuming a blank state
|biA of an ancillary (ancilla) system A on which a given state is copied, and
a machine state |miM which represents the combined state of any additional
systems, collectively denoted by M evolving due to the action of the cloning
machine (this additional system is kept for generality). Then, by virtue of
our assumption:
L | iS |biA |miM = | iS | iA |m iM , (1a)
L | iS |biA |miM = | iS | iA |m iM . (1b)
In the above |m iM and |m iM are kept for generality as the system M also
evolves due to the operation. Furthermore, if the machine has to close any

1
quantum state, it should also clone | i + | i – linear combination of the two
states cloned above in Eqs. (1a) and (1b), so that we must also have

L(| iS + | iS ) |biA |miM = (| iS + | iS )(| iA + | iA ) |m + iM . (2)

In writing the above equation, we have ignored the issue of normalizing the
state | i + | i as that is not relevant to the logic of the proof. However, from
Eqs.(1a) and (1b), and the linearity of L it follows that

L(| iS + | iS ) |biA |miM = | iS | iA |m iM + | iS | iA |m iM . (3)

Clearly, the states on the right hand side of Eqs.(2) and (3) are not the
same as long as | i and | i are not the same (i.e. | h | i| = 6 1). As Eq.(3)
follows from linearity of the evolution operator in the theory, it has to be
correct. This automatically implies that Eqs.(2) is incorrect, and thereby
the | i + | i cannot be cloned. Thus arbitrary states (i.e., any random state
of your choice) cannot be cloned by a machine – or in other words, a universal
cloning machine which clones quantum states cannot exist.

2 Measurements on a subsystem of a quan-

tum system
Before proceeding to teleportation, we present a book-keeping rule to cal-
culate how a combined system of many particles evolves under the action
of quantum measurements on only a finite set of the particles. While not
essential to understand teleportation (in other books you will the mathemat-
ics has been done in a di↵erent way), it will help us do the mathematics of
quantum teleportation in a quick and simple way. Suppose particles A, B
and C of a combined system of particles A, B, C, D, E and F are subject to
a measurement which projects them to a normalized state |miABC . Then the
unnormalized state of the rest of the particles is given by
˜ DEF = hm|ABC | iABCDEF ,
| (m)i (4)

with the probability of the measurement being given by

˜
Pm = h (m)| ˜
(m)i, (5)

and thereby the normalized state of the rest of the particles being
1 ˜ DEF .
| (m)iDEF = p | (m)i (6)
Pm

Note that although the right hand side of Eq.(4) superficially looks like an
inner product, it is still not so as hm|ABC only acts on part of the state; it
is thus still a ket (depicting the state of the remaining 3 qubits as in the
left hand side of Eq.(4)). Eqs.(4)-(6) will be used extensively in our study of
teleportation. However, they are essentially the same as the more standard

2
 Ψ+
AB

ψ C
=α 0 C
+β 1 C (a)
ψ B
BSM
ZB ψ B

XB ψ B
+ − + −
Ψ ,Ψ ,Φ ,Φ XB ZB ψ
(b)
CA CA CA CA
B

2 bits
ψ B , ZB ψ B , XB ψ B , XB ZB ψ B

⇓ IB ⇓ ZB ⇓ XB ⇓ ZB XB
ψ B
ψ B
ψ B
ψ B
(c)

Figure 1: Quantum Teleportation protocol showing the steps of the protocol:

steps 1 and 2 as (a), step 3 as (b),

way of expressing the results of a measurement in terms of a projection

operator ⇧m = |mi hm|ABC acting on the initial state | iABCDEF . Just
by computing this action you will find the unnormalized state of the whole
system to be

˜ DEF ,
⇧m | iABCDEF = |miABC | (m)i
˜ DEF is the same as that in Eq.(4). Similarly, in terms of the
where | (m)i
standard projection operator ⇧m , simply by normalizing the above unnormal-
ized state, the appropriately normalized state of the whole system is (verify
by yourself)

⇧m | iABCDEF
|miABC | (m)iDEF = p .
Tr(⇧m | ih |ABCDEF ⇧m )

3 Quantum Teleportation
We describe quantum teleportation in the following steps:
Step 1: Alice shares an entangled state | + iAB with Bob, with Alice holding

3
qubit A and Bob holding qubit B.
Step 2: A qubit in an arbitrary and unknown state | iC = ↵ |0iC + |1iC
encoded in a qubit C is brought to Alice. Her task is to send this state over
a distance to Bob using measurements and classical communication (com-
munication of bits of information, but no qubits). The scenario combining
Steps 1 and 2 are shown in Fig.1(a). The joint state of the qubits C, A and
B is thus ↵
| iCAB = | iC + AB .
Step 3: Alice now conducts a Bell state measurement (BSM) on the
qubits C and A. This results in 4 di↵erent states of Bob’s qubit B corre-
sponding to the 4 possible outcomes (| + iCA , | iCA , | + iCA , | iCA ) of
Alice’s BSM as is depucted in Fig.1(b). We calculate the states of qubit B
for the various outcomes of the BSM, and the probabilities of these outcomes,
by using Eqs.(4)-(6) as follows:
↵ E
Outcome +
CA
=) Unnormalized state of qubit B = ˜(1)
⌦ + 1 1
= CA
| iCAB = p (h01|CA + h10|CA )(↵ |0iC + |1iC ) p (|01iAB + |10iAB )
2 2
1 1
= (↵ |0iB + |1iB ) =) ProbabilityP| + i = h ˜(1) | ˜(1) i =
2 ↵ 4
=) Normalized state of qubit B = (1) B = ↵ |0iB + |1iB = | iB .
(7a)
↵ 1
Outcome CA
=) Probability = , Normalized state of qubit B
(2)
↵4
= B
= ↵ |0iB |1iB = ZB | iB .
(7b)
↵ 1
Outcome + CA =) Probability = , Normalized state of qubit B
(3)
↵ 4
= B
= ↵ |1iB + |0iB = XB | iB .
(7c)
↵ 1
Outcome CA
=) Probability = , Normalized state of qubit B
↵ 4
(3)
= B
= ↵ |1iB |0iB = XB ZB | iB .
(7d)

In the above, we have only explicitly shown the calculations for Eq.(7a), while
identical calculations for the projections to the other 3 Bell states would yield
the results of Eqs(7b)-Eqs(7d).
Step 4: Alice communicates her BSM outcome to Bob. This is equiva-
lent to communicating 2 bits of information (one possibility of 4 outcomes).

Step 5: On receiving the above 2 bits of information, Bob performs a

di↵erent operation on his qubit according to the each outcome of Alice as

4
follows:
+
↵
Outcome =) Bob performsIB (nothing)
CA
↵
=) Bob’s state = IB (1) B = IB | iB = | iB . (8a)
↵
Outcome CA
=) Bob performsZB
(2)
↵
=) Bob’s state = ZB B
= Z B ZB | i B = | i B . (8b)
↵
Outcome + CA =) Bob performsXB
↵
=) Bob’s state = XB (3) B = XB XB | iB = | iB . (8c)
↵
Outcome + CA =) Bob performsZB XB
↵
=) Bob’s state = ZB XB (4) B = ZB XB XB ZB | iB = | iB . (8d)
Note that in each case, Eqs.(8a)-(8d), the initial state of C has exactly ap-
peared on the qubit B held by Bob. This concludes the process of telepor-
tation.

Exercise .1
Consider the entangled state of two qubits p12 (|0iA |+iB + i |1iA | iB ) being
used to teleport a state ↵ |0iC + |1iC . Find out the operations Bob should
perform in order to complete a teleportation process if Alice is using a standard
Bell-State measurement procedure.

4 Some points to note

Teleportation is interesting because of a multiple reasons:
(a) Only two bits of classical communication suffices to send the full infor-
mation of complex numbers ↵ and over to Bob’s side. Normally one would
assume that, a qubit, being described by ✓ and which have a continuous
domain and hence fully specified only by an infinite number of bits would not
be transferrable via just 2 bits of information. It is, in fact the shared entan-
gled state which accomplishes the job of reduction from an infinite number
of bits to 2 bits.
(b) You will see from the mathematics of step 3 that ↵ and are already
imprinted in qubit B instantaneously (faster than light) as soon as Alice gets
any one of the possible outcomes of the BSM on C and A. However, as we
have seen above, the 2 bits of information are sent to Bob (which can, at
best,↵be done↵only at ↵the speed of ↵light), there are 4 equally probable states
(1)
B
, (2) B , (3) B and (4) B of qubit B. From this probability dis-
tribution of states, it is impossible for Bob to extract any information about
↵ or (this will be seen more rigorously when we study the density matrix
in the next lecture). Thus it is only after his actions following the 2 bits of
communication received from Alice, that he can obtain the state that Alice
wanted to transmit (thus there is no faster than light signalling).

Note that the protocol of teleportation can be schematically written as

1ebit + 2bits = 1qubit,

5
where ebit is the unit with which we quantify the entanglement of 2 qubits
(again, this will become clearer – will be defined – in the next lecture), with
| + iAB possesing an ebit of entanglement. Note that the above equality is
not for changing sides – if you took qubit to the left or bits to the right, it
would not be a valid protocol. In a similar vein the dense coding protocol
can be written as
1ebit + 1qubit = 2bits.
In both the teleportation and dense coding protocols, what is common is
that they both require a shared | + iAB , i.e., 1 ebit.

6
 Bell State Measurements and Teleportation
Applications
Sougato Bose
February 10, 2021

In this lecture we are going to complete all the requirements for the
entanglement protocols we have presented, namely show how to do the Bell
State measurements, and then go on to present some of the applications
of teleportation and teleportation like operations in quantum information
processing.

1 Bell State Measurements

Both the protocols of quantum dense coding and quantum teleportation re-
quire performing a Bell State Measurement (BSM) – in quantum dense coding
it is performed by the receiver of classical infomation i.e bits (Bob), while
in teleportation, it is performed by the transmitter of quantum information
i.e. an arbitrary qubit state (Alice). We will consider two scenarios: when
the qubits interact with each other (e.g., two spin qubits), and when the
qubits (e.g., photonic qubits) do not interact with each other but only with
other elements such as beam-splitters. In the latter case, as we will show
one can still exploit quantum indistinguishability of identical particles to do
a (partial) BSM.

1.1 Interacting qubits

As we have shown in Lecture 3, qubits interacting via Ising interactions can
be used to do a CZ gate. Many other interactions (any interaction which
entangles two qubits) can be used to do a CZ gate along with appropriate
local unitary operations. Once we have the CZ, from there, via Hadamards,
we have a CN OT gate. Thus we will assume that for interacting qubits we
have a CNOT gate. Then the circuit for Bell state measurements is given in
Fig.1. For example, for the input | + iAB to the circuit the system evolves as

+
↵ CN OTAB 1 HA
AB
! p (|0iA + |1iA ) |0iB ! |0iA |)iB .
2
+
Thus detecting |0iA |0iB amounts to detecting the Bell state | iAB .

Exercise .1

1
 H 0 A

Φ+
AB

X 0 B

Figure 1: The quantum circuit for Bell State Measurement is shown with the
Bell state | + iAB as the input, which evolves to |00iAB . When the qubits
are detected in the state |00iAB , we conclude that the Bell state put into the
circuit was | + iAB . Other Bell state inputs give other computational basis
(z-basis) outputs.

Find out the outputs of the circuit of Fig.1 for the inputs | + iAB , | iAB
and | iAB and hence justify how measuring the two qubits at the output of
the circuit in the computational basis (z-basis) is equivalent to a BSM.

Exercise .2
Show that the circuit of Fig.1 run in reverse generates the 4 Bell states from
input states in the computational basis.

1.2 Non-interacting qubits

In this case we have to use the quantum indistinguishability of the qubits
encoded in identical particles (such as two photons) to accomplish the BSM.
We will need here to introduce just that little bit of extra knowledge and
symbols related to creation/annihilation operators in order to understand the
scheme. We will need to analyse the situation where particles are incident
on a Beam-Splitter (BS) from opposite ports A and B as shown in Fig.2.
Such particles are labelled by their momentum (or wave-vector) state k and
an internal spin/polarization label (think about a photon propagating in
a given direction – wave-vector k – have having a polarization = H).
†
Harmonic oscillator creation operators ak, create one such particle from
the vacuum state |0i which contains no particles. Thus a generic single
particle state is a†k, |0i, while a generic two particle state is a†k1 , 1 a†k2 , 2 |0i.
In addition to the above notation, we will need the following facts:
p
For bosons, e.g., photons a†k1 , 1 a†k2 , 2 = a†k2 , 2 a†k1 , 1 , a†nk, |0i = n |ni ,
(1a)
For fermions, e.g., electrons a†k1 , 1 a†k2 , 2
= a†k2 , 2 a†k1 , 1 , a†2k, |0i = 0,
(1b)

2
where |ni depicts a state with n bosons of wave-vector k and polarization .
A beam splitter has momentum/wave-vector states as inputs – particles
impinge from one of two given directions A and B (also called channels or
ports) and exits through one of two given ports C and D. Thus A, B, C
and D denote the momentum/wave-vector directions k. The BS reflects the
incident particle with some amplitude and transmits it with the rest of the
amplitude. Thus it essentially does a unitary transformation on the creation
operators of the modes, thus:

BS a†D, + ia†C,
a†A, ! p (2a)
2
† †
BS aC, + iaD,
a†B, ! p . (2b)
2
Essentially, in the above, the reflected channel (e.g. C is the channel obtained
by reflection of A) gets a i phase, while the transmitted channel continues
without phase change.
Let us first consider the case depicted in Fig.2(a) with two bosons (e.g.
photons) incident from opposite ports of the BS with the same polarization
H (horizontal). This state thus has the following evolution

BS a†D,H + ia†C,H a†C,H + ia†D,H

a†A,H a†B,H |0i ! ( p )( p ) |0i (Using Eq.(2b))
2 2
i i
= (a†C,H 2 + a†D,H 2 ) |0i = p (|2iC |0iD + |0iC |2iD )(Using Eq.(1a)) (3a)
2 2
The above implies that the bosons in the same polarization state bunch
at the outputs of the BS as shown in Fig.2(a). It is thus immediately evident
from the above that

Fact 1: The photonic version of the Bell state | ±

iAB = p1 (|Hi |HiB ±
2 A
†
|HiA |HiB ) = p1 (a a†
2 A,H B,H
+ a†A,V a†B,V |0i gives bunching at the outputs.

Exercise .3
Show that in the analogous case of two fermions in the same spin state
incident at a BS they anti-bunch (leave through opposite output ports of the BS
as shown in Fig.2(b).

Exercise .4
Show that in the analogous case of two bosons (e.g. photons) incident at a
BS in the state | + iAB = p12 (|HiA |V iB + |V iA |HiB ) bunch at a BS, while
| iAB = p12 (|HiA |V iB |V iA |HiB ) antibunches at a BS.
The above exercise provides
Fact 2: The photonic version of the Bell state | + iAB gives bunching at the
outputs, and

3
 a +A,H
A C

BS

B D
a +B,H
(a)
a +A,↑
A C

BS

B D
a +B,↑
(b)
Figure 2: The bunching of two bosons (a) and the anti-bunching of
two fermions (b) incident on a beam-splitter (BS) from opposite ports
(momenta/wave-vector channels) A and B. The internal states of both
bosons are assumed to be the same in (a), i.e., they are both in the hor-
izontally (H) polarized state, while the internal states of both fermions are
also both assumed to be the same in (b), i.e., they are both in the spin state
".

4
Fact 3: The photonic version of the Bell state | iAB gives antibunching at
the outputs.

Combining facts 1, 2 and 3 above, we obtain the photonic BSM measuring

setup as shown in Fig.3. It uses detectors D1 , D2 , D3 and D4 , as well as
polarization beam splitters PBS1 and PBS2. A polarization beam splitter
transmits a H polarized photon, while reflecting a V polarized photon (in
e↵ect sending distinctly polarized photons in distinct output channels).

Exercise .5
Using facts 1, 2 and 3, above, and the action of a PBS as described above,
argue that
(a) for the Bell state | + iAB photon detectors D1 and D2 or D3 and D4 will
click,
(b) for the Bell state | iAB photon detectors D1 and D3 or D2 and D4 will
click,
(c) for the Bell states | ± iAB photon detector D1 or D2 or D3 and D4 will click
(both photons will be detected by the same detector).
From the above exercise, it is clear that the apparatus of Fig.3 can detect,
even without any interactions between the photons, just by their individual
evolutions at the BS and aspects of their indistinguishable behaviour as en-
coded through the bosonic creation operators a†k, (Eq.(1a)), 3 alternatives:
| + iAB or | iAB or | ± iAB . This still enables dense coding, albeit with a
slightly reduce capacity, as 3 letters (instead of the 4 possible for interacting
qubits) can be transmitted by transmitting only a single qubit. In context
of teleportation, we can similarly teleport perfectly for two of the outcomes
| + iAB or | iAB and declare the process as a teleportation to a state with
partial overlap with the transmitted state for the other set of outcomes.

2 Entanglement Swapping
We will use the methodology of “Measurements on a subsystem of a quantum
system” from Lecture-4-Part B here. Consider the situation depicted in Fig.4.
Particles A and B are in an entanged state | + iAB , while particles C and
D are in an entanged state | + iCD . A and C may be light years apart, yet
when B and D are brought together and a BSM is performed on them, with
the outcome | + iBD , then A and C get projected to the state
⌦ + +
↵ +
↵
BD AB CD

1 1 1
= p (h01|BD + h10|BD ) p (|01iAB + |10iAB ) p (|01iCD + |10iCD )
2 2 2
1 E
= p (|01iAC + |10iAC ) = ˜+
2 2 AC

↵ D 1
= + AC (normalized state) with probability = ˜+ ˜+ i = .
4

5
 D1

D2

PBS1
± A C
Φ
AB

OR BS

B D PBS2
Ψ±
AB
D3

D4

Figure 3: The apparatus for performing partial BSM for photons. From
“which” of the combination of detectors D1 , D2 , D3 and D4 have clicked, it
is possible to fully discriminate between incident states | + iAB , | iAB and
both of them with | ± iAB , although it is not possible to distinguish be-
tween | + iAB and | iAB (thus 3 possible alternatives can be distinguished:
| + iAB or | iAB or | ± iAB ).

6
 Figure 4: The schematic of entanglement swapping.

Thus A and C, are immediately entangled. Of course, the outcomes of the

BSM will be one of the four possible Bell states and correspondingly also
the Bell state to which A and C are projected will vary. So the information
about the result of the BSM on B and D must be communicated to the
parties holding qubits A and C for them to know “which” entangled state
they are holding, which is essential for any application. The procedure is
schematically depicted in Fig.4 with the BSM being depicted by the dashed
line. It is called entanglement swapping as partners in entanglement are now
swapped. Entanglement swapping can also be regarded as a teleportation of
entanglement – the entanglement between A and B is being teleported to an
entanglement between A and C via the BSM on B and D.

3 Multiparticle Entanglement Swapping

If you had been around and doing Physics in 1998, you could have done the
following (very easy) calculation and published it in Physical Review A! (it
was one of my own early papers).

Exercise .6
Consider the situation depicted in Fig.5, where the 3, 4 and 5 particle entan-
gled states – shown as particles connected by lines are p12 (|000i+|111i), p12 (|0000i+
|1111i and p12 (|0000i + |1111i) respectively. The dashed line connects the pair
of particles on whom a BSM is conducted. Prove that the entanglement of the
particles evolves from the situation depicted in the left hand side of the figure to
the right hand side of the figure as a result of the BSM.

Exercise .7
Generalize the quantum circuit for BSM to a 3 qubit circuit that performs
a GHZ basis measurement given by a projection to any one of the 8 states
|GHZ srt i = ZAs XAr ⌦ XBt ⌦ 1C |GHZiABC , with s, r, t = 0, 1.

Exercise .8

7
 Figure 5: Multiparticle entanglement swapping.

Construct an example of a multiparticle entanglement swapping scheme by

using the above GHZ basis measurement.

4 Application of Teleportation and Entangle-

ment Swapping:
Entangling distant matter qubits: Matter qubits (atoms) will interact
with optical fields – thus entanglement of the atomic qubits with photonic
qubits are possible. Consider in the entanglement swapping example above
depicted in Fig.4. If A is an atom entangled with photon B and C is an
atom entangled with photon D, then performing a BSM on the photons B
and D entangles distant atoms A and C in one of the four Bell states. A and
C may belong to distant quantum registers. Now teleportation can be used
to transfer quantum states between these registers via the Bell state shared
between A and C.

For near perfect state transfer between quantum registers in

conjuction with the process of entanglement distillation: Entangle-
ment distillation (also called entanglement concentration when we consider
only pure states) is the process of upgrading the entanglement of many shared
weakly entangled pairs of particles to fewer perfectly entangled (⇠ | + i pairs
of particles purely through local operations on each qubit and classical com-

8
munination between the parties possessing them (LOCC – local operations
and classical communication). What is a weakly and what is a perfectly en-
tangled pair of particles is the subject of the next part of the lecture. Here
we only emphasize that even if one wants to share an ideal Bell state between
two distant parties, one or more particles have to traverse a quantum channel
in which they loose their high entanglement. Thus the two distant parties
should share a large number n of copies of degraded entanglement to obtain,
form it, a fewer number k  n of near perfect entangled states | + i. These
can then be used to connect distant quantum registers via teleportation.

9
 Quantification of Pure State Entanglement:
von Neumann Entropy
Sougato Bose
February 12, 2021

We have presented some of the applications of entanglement. We pre-

sented all the applications in terms of the Bell states, e.g., we started all pro-
tocols through imagining a situation in which distant q parties shared
q a state
| + iAB . However, there are entangled states, e.g., 23 |01iAB + 13 |10iAB
which will lead to imperfectness in both teleportation and dense coding proto-
cols. In some sense these states possess less entanglement – so it is important
to quantify “how much” entanglement is there in a given state. This is the
aim of this part of the lecture. The procedure of entanglement concentration
will be introduced alongside as the quantification is justified through this
procedure. To understand the measure, von Neumann entropy, however, we
need to understand both Shannon entropy and the density matrix, which will
be presented first.

1 Shannon Entropy
Consider mutually exclusive random events j which can occur with probabili-
ties Pj . Suppose someone (say, Bob) does not know which event has occured.
What is the minimum number of bits of information (essentially the num-
ber of yes/no questions) on average required to specify to this person the
event that has actually occurred? The answer is given by the Shannon en-
tropy. Before Bob learns which event has occurred, he has some uncertainty
in knowledge. Thinking about the same question in reverse, the amount of
uncertainty of Bob before he learns exactly which event has occurred is also
the same number of bits (the Shannon entropy), as learning the answer re-
moves his uncertainty. In information theory textbooks such as Cover and
Thomas, they prove that (by using a result called Kraft’s inequality) that for
the most efficient average length of codes, the number of bits used to convey
a specific outcome scales as nj = log2 (1/Pj ) – rarer the event we use more
bits. But you can also understand it heuristically (not rigorously!) from
common sense thinking as an answer to a ”yes/no” game where you have to
arrive at the right event after asking the least number of questions. It makes
sense to first ask whether the most probable one (say, there is an event with
probability ⇠ 1/2) was realized. If it was, yes (yes could stand for the bit
0), we have just used one bit to convey the information! If no (bit 1), we ask

1
whether the next most probable incident (say, something with probability
⇠ 1/4) was realized or not. If yes, then with the two bit string 10, we have
communicated that event, and so on (next probable event with probability
⇠ 1/8 would be communicated with the bit string 110, and so on). In the
above, you see that for a event with probability ⇠ 1/2nj , we are using nj
bits. Such codes are also called intantaneous or prefix codes – no code is
the prefix of another, so that there is no confusion when you get a string of
events (whenever there is a 0, we know we are ending the code of a given
event and starting a new one). Thus the average number of bits to convey
mutually exclusive random events j which can occur with probabilities Pj is
X X X
hnj i = Pj n j = Pj log2 (1/Pj ) = Pj log2 Pj
j j j

The above is called the Shannon entropy of the probability distribution Pj .

2 Density Matrix/Density Operator

So far we were considering states which could be reperesented by a ket.
However, there could be a system which is in a state which is adequately
only described as a probability distribution over a number of possible kets.
Thus consider a system in a state

With probability Pj , the system is in the state | ji .

To find an appropriate compact mathematical representation of the above

situation, consider the probability of finding the system in any state |mi on
measurement. After all, the most information you can find from a given
state in quantum mechanics is its probability to jump to various states |mi
on measurement. So if we can find an appropriate mathematical entity to
give us the right probability for the situation depicted above, then we are
done. Probability of projecting the system to state |mi on measurement is
X X X
Pm = Pj | hm| j i|2 = Pj hm| j i h j | mi = hm| ( Pj | j i h j |) |mi .
j j j

Thus if we define
X
⇢= Pj | ji h j| , (1a)
j

along with Pm = hm| ⇢ |mi , (1b)

we see that ⇢ is a mathematical entity that enables us to compute the correct

probabilities, and is called a density operator and more often simply (a bit
loosely) as the density matrix (strictly speaking the matrix will be the oper-
ator when reperesented in any given basis, but as is common, we will simply
refer to it as the sensity matrix). Eq.(1a) is taken to be the definition of the
density operator or density matrix. Generically when more than one Pj is

2
non-zero, the system is not described a unique ket, and thereby it is called a
mixed state. When a system is in a state which is exactly represented by a
single ket, it is called a pure state.
The density matrix has the P following properties (in the expressions below
{|mi} forms a complete basis, m |mi hm| = 1)
X X
Tr(⇢) = hm| ⇢ |mi = Pm = 1, (2a)
m m
(using def. of trace,& total prob. = 1)
⇢ = ⇢† (2b)
(Hermitian; checked from def. of ⇢),
hm| ⇢ |mi = Pm > 0 (2c)
(as it is a probability).In short depicted as⇢ > 0(a positive operator)

Furthermore, for a pure state

⇢2 = | ji h j| | ji h j| =| ji h j| = ⇢ =) Tr(⇢2 ) = 1. (3)

For a mixed state X

⇢2 6= ⇢, Tr(⇢2 ) = Pm2 < 1. (4)
m

3 von Neumann entropy

Given a density matrix of a quantum system one can ask some information
theoretic questions. For example consider the density matrix
X
⇢= Pj | j i h j |
j

where the states {| j i} are not necessarily orthonormal. This is unlike the
classical probability distribution Pj of events j discussed in the section on
Shannon entropy because, in the generic case of non-orthonormal {| j i} the
events occuring (di↵erent kets | j i) are not fully distinguishable as the classi-
cal events j. So in some sense
P the state has less uncertainty than quantified
by the Shannon entropy j Pj log2 Pj . Conversely you will need to learn
a lower number of bits of information to become certain of the state. To
treat the density matrix as a classical distribution we need its expression in
a diagonal form in an orthonormal basis with positive eigenvalues so that
we can treat each state of that basis as equivalent to a fully distinguishable
classical event and the eigenvalues as the probabilities of those events. This
is possible as the density matrix is a Hermitian operator (it is diagonaliz-
able with orthonormal eigenstates | j i), while the positivity of ⇢ ensures
j = h j | ⇢ | j i > 0 can be interpreted as probabilities. Thus it is always
possible to write X
⇢= j | ji h j| .
j

3
Thus the number of bits of uncertainty in ⇢ (or, given ⇢, the number of bits
you need to learn in order to become certain of the state) is given by the
Shannon entropy X
j log2 j
j

of the density matrix expressed in its eigenbasis. However, note that the
Shannon entropy in this particularly basis is equivalent to
X
S(⇢) = Tr(⇢ log2 ⇢) = j log2 j (5)
j

The above is called the von Neumann entropy of ⇢.

Exercise .1
0
Find the von Neumann entropy of the state ⇢ = 12 |0i h0| + 12 |+i h+| and
show that it is lower than (a) the Shannon entropy of a probability distribution
1
2
for event 1 and 12 for event 2, (b) the von Neumann entropy of the state
00
⇢ = 12 |0i h0| + 12 |1i h1|.
Aside the interpretation given above, the von Neumann entropy also has
a few other interpretations:
(a) If we try to communicate with quantum letters | j i with them being used
with probabilities Pj (think of English – you use e much more frequently than
z – we are generalizing this to a quantum alphabet with letters |ei and |zi not
necessarily orthogonal), then the average number of bits we can communicate
per letter (the classical capacity of the quantum alphabet in terms of numbers
of bits) is given by
X
C = S(⇢) with ⇢ = Pj | j i h j | .
j

While exact proof of the above is beyond the scope of this lecture, the in-
tuition is very clear from the arguments above that S(⇢) bits on average
per qubit is the information possible to be held in ⇢. This is known as the
Holevo-Schumacher-Westmoreland theorem for pure state letters. For mixed
state letters ⇢i occuring with probabilities Pi it can also be generalized to
X X
C = S(⇢) Pi S(⇢i ) where ⇢ = P j ⇢j .
i j

(b) The von Neumann entropy S(⇢) also quantifies the compressibility of
a quantum state (called Schumacher compression after Ben Schumacher, who
also coined the term “qubit”). If there are n qubits, each in a mixed state
⇢ , then only a smaller number m = nS(⇢) of qubits need to be faithfully
transmitted through a channel in order to reconstruct the joint mixed state
of the n qubits (i.e, ⇢⌦n ) faithfully at a distance. Again the proof is beyond
the scope of this lecture.

4
 (c) In this lecture, we will show (with a proof) the most classic application
of the von Neumann entropy – that it is a quantification of entanglement of
two systems in a pure state. But before that, we need to introduce the
reduced density matrix.

4 Reduced Density Matrix

Suppose you are given an arbitrary (possibly entangled) state of two systems,
such as X
| iAB = cj |⇠j iA | j iB . (6)
j

In the above, we have made no assumptions about orthogonalities of the sets

{|⇠j i} and {| j iB }. You can always write any pure joint state of the two
systems as above. For example,
1 1 1 1 1
p |0iA |0iB + |1iA |0iB + |1iA |1iB = p |0iA |0iB + p |1iA |+iB .
2 2 2 2 2
Can we write down a quantum state for any one of the systems (say, A) in
the state | iAB which will give us the right probabilities for any measure-
ment outcome |miA on A? Using the methodology of “Measurements on a
subsystem of a quantum system” from Lecture-4-Part B, we get

Pm,A = h |AB |miA hm|A | iAB

X
= c⇤i cj h⇠i | mihm |⇠j i h i | j i
ij

Using a complete basis {|kiB } of states for system B we insert 1A = |ki hk|A
in the above expression to obtain
X X
Pm,A = c⇤i cj h⇠i | mihm |⇠j i h i | kihk| j i
ij k

X X
= c⇤i cj hm |⇠j i h⇠i | mi hk| j i h i | ki
ij k
X
= hm|A ( hk|B | iAB h |AB |kiB )|miA
k

= hm|A TrB (| iAB h |AB )|miA

= hm|A TrB (⇢AB )|miA
= hm|A ⇢red
A |miA .

From the above it is clear that if we define a reduced density matrix of

system A by the prescription
X
⇢red
A = TrB (⇢AB ) = hk|B ⇢AB |kiB (7)
k

5
then we can obtain all relevant probabilities of outcomes on system A from
it. The above definition has been motivated by an initial pure state of the
two systems described by ⇢AB = | i h |AB , but it is easy to verify that this
definition also holds for mixed states described by ⇢AB .
We will, from now on, drop the superscript “red” for reduced in the den-
sity matrix, and simply use ⇢A to denote the reduced density matrix of a
system A. The deep reason for this is that when we have any given density
matrix, it is always possible to regard it as being part of a larger collection of
systems – whether it is entangled with them or not. So the term “reduced”
looses any intrinsic meaning. However, the method of computing the reduced
density matrix remains as outlined in Eq.(7) even if we are just refer to it as
⇢A .

Note/Observation: When in a joint state of A and B as given by

Eq.(6), h i | j i = ij (i.e., {| j i} form an orthonormal basis), the reduced
density matrix ⇢A can be immediately written down as
X
⇢A = hk|B ⇢AB |kiB
k
X X
= c⇤i cj |⇠j i h⇠i | hk| j i h i | ki
ij k
X X
= c⇤i cj |⇠j i h⇠i | h i | kihk| j i
ij k
X
= c⇤i cj |⇠j i h⇠i | h i | ji
ij
X
= |cj |2 |⇠j i h⇠i | .
j

Exercise .2
Using the above observation immediately write down (without calculations)
the reduced density matrices
q ⇢A and ⇢B for q
a combined state of two systems A
0↵
and B given by AB
= 23 |0iA |1iB + i 13 |1iA |0iB .

Exercise .3
Find out the reduced density matrices ⇢A and ⇢B for a combined state of two
systems A and B given by | iAB = p12 |0iA |0iB + p12 |1iA |+iB . (You have to
do a little work out to find ⇢A , while ⇢B can be immediately written down from
the observation above.)

5 Schmidt Decomposition
We now state a very powerful theorem (without proof) which is a key result
in the study of entanglement of two systems whose joint state is a pure state

6
(described by a single ket). This theorem is equivalent to a result from Linear
Algebra called the Singular Value Decomposition. This result states that the
combined state of two systems A and B can always be written as
Xp 0
E
| iAB = j | i
j A j . (8)
B
j

0↵
where each of {| j i} and { j } form an orthonormal basis (h j | k i =
⌦ 0 0
j k i = jk ). The sum over j extends to the dimension of the Hilbert
space of the smaller of the systems A and B – for example, for a qubit-qutrit
entangled state j would range over only 2 values 0 and 1. You might think
that Eq.(8) is a trivial result as one can always appropriately rewrite any two
particle state, say,
1 1 1 1 1
p |0iA |0iB + |1iA |0iB + |1iA |0iB = p |0iA |0iB + p |0iA |+iB .
2 2 2 2 2
However, note that in the above the set of states {|0iB , |+iB } is not an or-
thonormal basis, and thereby, Schmidt decomposition is a non-trivial result.
It guarantees that a decomposition in terms of orthonormal bases exists as
given by Eq.(8). The Schmidt decomposition and our observation in the
preceding section on reduced density matrices immediately imply that the
reduced density matrix of the systems A and B are respectively
X X 0
ED 0
⇢A = j | j i h j | , ⇢B = j j j ,
j j
P
and their von Neumann entropies are S(⇢A ) = S(⇢B ) = j j log2 j.

6 Entanglement units: ebits

We consider the setting of entanglement shared between distant parties as in
dense coding and teleportation. In order for us to give a quantification of en-
tanglement, we first have to choose units – as dense coding and teleportation
worked perfectly for the state | + iAB we choose it to have an entanglement
of 1 ebit. By the same token, any state which can be transformed to | + iAB
by local unitary operations (simply a change of local basis) also has an en-
tanglement of 1 ebit, as we can also do the above protocols perfectly with
such a state after appropriate local unitaries. Now consider the joint state of
n copies of | + iAB , which should hold n ebits of entanglement. Calling the
qubits of the jth pair as Aj and Bj respectively, we are essentially considering
the state n n
Y ↵ Y 1
+
A j Bj
= p (|00iAj Bj + |11iAj Bj )
j=1 j=1
2
1
= n (|00..0iA1 A2 ..An |00..0iB1 B2 ..Bn + |00..1iA1 A2 ..An |00..1iB1 B2 ..Bn +
22
... + |11..1iA1 A2 ..An |11..1iB1 B2 ..Bn

7
 n
2 1
1 X
= n |xiA |xiB .
2 2 x=0
In the above, x is taken to be the decimal number corresponding to the bi-
nary number represented by strings of n bits and A and B represent the full
collections of n qubits of the subscripts. Thus an equal amplitude superpo-
sition of d = 2n orthogonal states contains n = log2 d ebits. The entangled
state of two qudits
d 1
1 X
| d iAB = p |kiA |kiB (9)
d k=0
thus contains log2 d ebits of entanglement. We now consider how to quan-
tify the entanglement of two qubits in a general two qubit entangled pure
state. As these would result in imperfect protocols, these should have a lower
(fractional) ebit of entanglement in the units introduced here.

7 von Neumann entropy as the quantifier of

pure state entanglement
We will consider the situation in which entirely local operations (unitaries
and measurements) are conducted by Alice and Bob – namely they cannot let
their qubits interact, as this can entangle them/increase their entanglement,
nor can they transfer qubits to each other as that would be another way
to increase the entanglement (the transferred qubit may be entangled with
some ancillary system on Alice’s side and then transmitted to Bob, thereby
increasing the entanglement shared between Alice and Bob). Such actions
are called LOCC (local operations and classical communications). The rea-
son we consider Alice and Bob being restricted to such actions is that we
are considering the entanglement here as a resource which has already been
shared between the parties in form of some entangled states. If one needs to
quantify the amount of the resource of entanglement in these shared states,
one has to bring them to the standard form of Eq.(9), for which we know the
amount of entanglement in ebits, without considering processes which might
increase the entanglement – this is why we consider only LOCC. We will
consider a set of LOCC operations by which one can bring a number n of
partially entangled pure state systems can be reversibly (in the sense that
only unitary operations were used and hardly any portion of the state was
thrown away) brought to a lower number m of | + i states so that the ratio
m
n
gives the amount of entanglement of the partially entangled systems. The
setting is depicted in Fig.1 and called entanglement concentration (concen-
trates weaker entanglement of many pairs to fewer pairs in state | + iAj Bj ).
It was first introduce in a paper in 1996 by Bennett, Brassard, Popescu and
Schumacher.
We consider n copies of the partially entangled pairs with Schmidt ba-
sis rotated to computational basis states locally so that they are given by
p p
|⇠iAj Bj = p |00iAj Bj + p |11iAj Bj where q = 1 p (Note that the re-

8
 p 00 AB
+ q 11 AB

Φ+
AB
m = nS(ρ )

Figure 1: Entanglement concentration procedure.

9
duced density matrices are given by ⇢Aj = p |0i h0|Aj + q |1i h1|Aj and ⇢Bj =
p |0i h0|Bj + q |1i h1|Bj with the von Neumann entropy S(⇢Aj ) = S(⇢Bj ) =
Q
p log2 p q log2 q). Then their combined state nj=1 |⇠iAj Bj will have, for
large n approximately np 0’s and nq 1’s on each of Alice’s and Bob’s side
(you can understand this better by constructing the reduced density matrix
on each side and then considering the law of large numbers to get the typical
sequences which are possible for large n – all other sequences have a vanishing
probability). Thus
n
Cnp
n
Y X
1
|⇠iAj Bj ⇡ pn |jiA |jiB , (10)
j=1
Cnp j=1

where |ji represent the di↵erent states with

Qn the typical number (np) of 0’s.
Strictly speaking Alice needs to project j=1 |⇠iAj Bj on to the subspace to
get the RHS of Eq.(10), but in practice, for large n, all atypical sequences
have vanishing probability (e.g. probability of |00..0iA |00..0iB is pn ⇡ 0), so
Alice hardly changes the state through this projection and no information
of
Qnthe state is lost (the state can still approximately be brought back to
j=1 |⇠iAj Bj with a very high accuracy despite the projection – the process
is reversible). Thus the RHS of Eq.(10) can be mapped to a state of log2 n Cnp
pairs of | + i states, with each possesing a ebit. Entanglement of this state
is given by
log2 n Cnp = log2 n! log2 (np)! log 2(nq)!
⇡ n log2 n n np log2 np+np nq log2 nq+nq(using Sterling approximation)
= n( p log2 p q log2 q) = nS(⇢Aj ) = nS(⇢Bj ).
Thus the pure state |⇠iAj Bj contains an entanglement of E(|⇠iAj Bj ) = S(⇢Aj ) =
S(⇢Bj ). The proof generalizes to arbitrary dimensional quantum systems.
Thus to find the entanglement in any pure state | iAB one simply has
to compute the reduced density matrix of either system A or B and the
entanglement is given by

E(| iAB ) = S(⇢A ) = S(⇢B ).

Exercise .4
Find out the entanglement, as quantified by the von Neumann entropy of
two systems A and B in the entangled states (a) | iAB = p12 |0iA |0iB +
p
p1 3
2
|1iA |+iB , (b) |⌘iAB = 2
|0iA |1iB + 12 |1iA |0iB .

10
 Mixed State Entanglement, its Quantification
and Distillation
Sougato Bose
February 16, 2021

When entanglement is generated as a maximally entangled pure state

| + iAj Bj of qubits Aj and Bj , and transmitted through a quantum channel
(any entity through which quantum states can pass – e.g., an optical fiber
through with photons in |Hi and |V i states pass), it generically ends up as
a mixed state. This is simply because of the interaction of a transmitted
qubit (say, Bj ) with an environment while traversing the channel. The en-
vironment gets entangled with the two qubit state, and thereby the state of
the two qubits i.e., their reduced density matrix, ends up as a mixed state
⇢Aj Bj . Fig.1 depicts the transmission through a quantum channel. Under
these circumstances, two related relevant questions arise:

(a) How can we do something similar to the entanglement concentration

we described in the last lecture to get
n
Y m<n
Y
n!1 +
↵
⇢Aj ,Bj ! A j Bj
j=1 j=1

purely by using LOCC procedures. The situation is depicted in Fig.2 and

dubbed entanglement distillation. Here the motivation of using LOCC is
somewhat di↵erent from the previous lecture – here Alice and Bob have al-
ready done our best to transmit several (n ! 1) copies of an entangled state
through a channel – there is no more point of transmitting quantum states
(quantum communication). They only need to bring as many (m) of these
shared qubits to a form as close as possible to | + iAj Bj , so they can near per-
fectly teleport m qubits using those entangled pairs. The maximum fraction
m
n
obtainable this way is called the distillable entanglement ED (⇢Aj Bj ) of the
state ⇢Aj Bj . This entanglement distillation procedure is then key to quantum
mechanically connect two distinct quantum registers into one larger processor
– essentially, if you can transmit qubits between them via teleportation, you
can also perform quantum gates between them (just teleport a qubit from
register A to register B by using one copy of | + iAj Bj , do a two qubit gate
between this qubit and another qubit in register B, and teleport it back to
A using another copy of | + iAj Bj ). Thus if such distillation is possible then
this gives teleportation the real muscle as the protocol for a multi-register
quantum computer, as any realistic channel will convert | + iAj Bj to a mixed

1
Φ+
Ai Bi

ρ Ai Bi

Figure 1: Depiction of a quantum channel.

2
 ρ Ai Bi

Φ+
Ai Bi m=
nED ( ρ Ai Bi )

Figure 2: Entanglement distillation procedure.

state ⇢Aj Bj , which is non-ideal for teleportation.

(b) If the above procedure is possible, then, obviously it makes sense

to consider that we are dealing with mixed states ⇢Aj Bj which possess a
certain amount of entanglement, as we are able to extract some entangle-
ment, namely m = nED (⇢Aj Bj ) ebits from them purely by LOCC procedures
(by which there is no opportunity to create entanglement between separated
parties A and B, as no qubits are transmitted). Thus how to quantify the
entanglement inherent in a mixed state is also an important question – of
course, this could be more than the m ebits obtained in distillation as some
entanglement may be destroyed (wasted/become irrecoverable) in the pro-
cess of distillation. A more basic question is to identify “when” a mixed
state given by a certain density matrix does not have any entanglement or is
separable.

3
 Ψ+ = I Ai ⊗ X Bi Φ+
Ai Bi Ai Bi

Φ+
Ai Bi

1− P
Φ+
Ai Bi

Figure 3: Depiction of a Bit-flip channel.

4
1 Example of an Entanglement Distillation
Procedure
We will not discuss entanglement distillation in a general context, but only
illustrate its possibility through an example. Consider a particular quantum
channel in which a qubit has only a random chance of a bit flip, i.e., with
a probability P it applies a X operator on the qubit traversing the channel.
We consider Alice generating a state of two qubits | + iAj Bj and sending the
qubit Bj through the channel to Bob. Thus
+
↵
With Probability 1 P, Alice and Bob share A j Bj
,

+
↵ +
↵
With Probability P, Alice and Bob share 1Aj ⌦ XBj A j Bj
= A j Bj
.
The action of this bit-flip channel is depicted in Fig.3. We can write the
above compactly as Alice and Bob sharing the mixed state
↵⌦ + ↵⌦ +
⇢Aj Bj = P + A j Bj
+ (1 P ) + A j Bj
.

(Note that when we write mixed states in the “ket-bra” notation, we often
omit the qubit label – here Aj Bj , subscripts on the ket part, just for com-
pactness). We will perform the circuit shown in Fig.4 on two copies of such
shared states ⇢A1 B1 and ⇢A2 B2 , measure the qubits A2 and B2 as shown in
the figure, and, conditional on the coincidence outcome (when the state of
qubits A2 and B2 measured in the computational basis match), retain the
states of qubits A1 and B1 . Consider 4 cases separately:
↵ ↵
With Probability (1 P )2 : +
A 1 B1
+
A 2 B2

CN OTA1 A2 CN OTB1 B2 +
↵ +
↵
! A 1 B1 A 2 B2

Coincidence between A2 and B2 ,

↵ ↵
With Probability P 2 : +
A 1 B1
+
A 2 B2
CN OTA1 A2 CN OTB1 B2 +
↵ +
↵
! A 1 B1 A 2 B2

Coincidence between A2 and B2 ,

+
↵ +
↵
With Probability P (1 P ) : A 1 B1 A 2 B2
CN OTA1 A2 CN OTB1 B2 +
↵ +
↵
! A 1 B1 A 2 B2

Anti-coincidence between A2 and B2 ,

+
↵ +
↵
With Probability P (1 P ) : A 1 B1 A 2 B2
CN OTA1 A2 CN OTB1 B2 +
↵ +
↵
! A 1 B1 A 2 B2

Anti-coincidence between A2 and B2 .

5
 ρ A1B1

ρ A2 B2
X X

ρ (1)
A1B1

Figure 4: Example entanglement distillation procedure using Bilateral

CNOT.

Thus in e↵ect, the state of the systems A1 and B1 are projected, conditional
on concidence, whose total probability is P 2 + (1 P )2 , to
(1) ↵⌦ ↵⌦
⇢A1 B1 = P (1) + +
A 1 B1
+ (1 P (1) ) + +
A 1 B1
,

P2
with P (1) = P 2 +(1 P )2
. Now note that when the bit-flip probability P < 12 ,
(1)
the relative proportion of | + iA1 B1 is more in the state ⇢A1 B1 in comparison
(1)
to the initial states ⇢Aj Bj shared between Alice and Bob. Thus ⇢A1 B1 is
now a better approximation to | + iA1 B1 than ⇢A1 B1 . Many such qubit pairs
(1)
(⇠ n{P 2 + (1 P )2 }) in the state ⇢Aj Bj will thus be obtained after the above
(1)
step, which we call the first iteration. However, ⇢Aj Bj has the same form
as ⇢Aj Bj except for the probabilities P being be replaced by P (1) . Thus one
can go on repeating the same procedure iteratively on pairs available at the
(k) (k+1)
kth stage of iteration ⇢Aj Bj giving, probabilistically ⇢Aj Bj for the next stage
of iteration. For P 6= 1/2, the proportion of a single Bell state in the state
(either | + iAj Bj or | + iAj Bj ) monotonically increases with each iteration.
In this way, after quite a few iterations a state is obtained which has a very
high proprotion of a single Bell state.

6
 Exercise .1
(k)
Choosing an initial state ⇢Aj Bj with P < 1/2 (make your own choice of P ,
e.g., P = 1/4), work out the number of iterations k needed to get a state with
1 P (k) 0.99. Find the yield (fraction m/n) obtained by the above distillation
procedure.

Exercise .2
Show that the above procedure can perfectly distill (convert to a Bell state)
a mixed state
↵⌦ +
⌘A j B j = P + A j Bj
+ (1 P ) |00i h00|Aj Bj

in one step, and find the probability for this one step distillation to happen.
Explain why for P > 12 , this probability is exceeded by the asymptotic (n ! 1)
fraction m/n of states arbitrarily close to a Bell states.

2 Coherent information
In general it is very difficult to find the optimal procedure for entangle-
ment distillation for an arbitrary entangled state ⇢AB . However it is known
(Devetak-Winter 2003) that if only one way classical communication between
Alice and Bob is allowed (e.g. from Alice to Bob, but not vice-versa), then
one can asymptotically distill a fraction of Bell states called the Coherent
information given by

Ic (A > B) = S(⇢B ) S(⇢AB ).

We give here the above formula without proof. Note that for pure states
(S(⇢AB ) = 0) the fraction obtainable reduces to the von Neumann entropy
of the reduced density matrix ⇢B . For mixed states, the rough intuition is that
while nS(⇢B ) Bell states would have been achieved without the mixedness,
one has to still “learn” nS(⇢AB ) bits of information to convert the results
to a pure Bell state (to purify), which sacrifices nS(⇢AB ) Bell pairs giving a
remaining number of nIc (A > B).

3 Mixed States: when Separable (not Entan-

gled), when Entangled?
Which states are valid to be called entangled states when we are dealing with
mixed states? We have to generalize the notion of factorizable (unentangled)
states to mixed states for this purpose – these are called separable states.
Any state which can be produced by two parties Alice and Bob purely by

7
classical communications is called a separable state (no transfer of qubits or
sharing of entanglement is allowed). This is then defined as
X
⇢Sep
AB = Pi ⌘(i)A ⌦ (i)B ,
i

where ⌘(i)A and (i)B are density matrices. Essentially we are telling that
because product (factorizable) states are the pure state versions of unentan-
gled states, probablity distributions over a number of such factorizable states
cannot be entangled either (just expand ⌘(i)A and (i)B in their eigenbasis
to check that this statement is same as the definition above). Note that these
can be correlated states. As you can see from Fig.5, Alice can throw a die
and corresponding to the outcome choose a state ⌘(i)A from an enormous
reservior of quantum states that she has, inform Bob, who correspondingly
chooses a state (i)B . Any state which can be written in the above form is
a separable state – not entangled. For example, the state
1
⇢Class,Max = (|0i h0|A ⌦ |0i h0|A + |1i h1|A ⌦ |1i h1|A ),
2
is as maximally correlated as is possible classically – Alice and Bob always
have the same state in the computational basis – but is separable, as it can
be generated by the above classical communication procedure. Any density
matrix not expressible in the form of ⇢Sep
AB above is entangled.

Exercise .3
By expressing the density matrix of an equal mixture of all four Bell states in
the computational basis, show that it is a separable state.

4 Peres-Horodecki Separability Criterion

Density matrices arising out of various calculations and considerations could
be entangled, but how do we check it? It is generically a very difficult
problem to check that a given density matrix cannot be expressed in the
form ⇢Sep
AB . For example, we know that the density matrix P |
+
i h + |AB +
+ +
(1 P ) | i h |AB contains entanglement as we gave a procedure of LOCC
to get Bell states from it in the last section. However, we cannot always
easily identify a distillation procedure. There is a simple test which helps
in this case. This test was found by Asher Peres and 3 of the members of
the Horodecki family. Let us define the partial transpose over system B, of a
density matrix ⇢AB by
hj|A hk|B ⇢TAB
B
|liA |miB = hj|A hm|B ⇢AB |liA |kiB .
In other words,
X TB
X
⇢AB = ⇢jklm |jiA |miB hl|A hk|B ! ⇢TAB
B
= ⇢jklm |jiA |kiB hl|A hm|B .
jklm jklm

8
 i
Sep
ρ AB = ∑ Pi η (i) A ⊗ χ (i)B
i
η (1) A χ (1)B
η (2) A η (3) A χ (2)B χ (3)B

…….
…….

Figure 5: Separable states being generated by Alice and Bob via telephone
interaction.

9
As you can see the “bra” and “ket” parts of the system B are swapped.
Similarly the partial transpose over A can be defined. This partial transpose
is not a physical operation – it is merely a mathematical operation. Now
note that X
⇢Sep
AB
TB
= Pi ⌘(i)A ⌦ (i)TB
i

where (i)TB denotes the ordinary transpose of (i)B . As (i)B is a density

matrix (positive eigenvalues with an orthonormal eigenbasis), its transpose
(essentially taking its bras to kets) is also a valid density matrix. The above
means that ⇢Sep
AB
TB
is also a valid density matrix, so that

⇢Sep
AB
TB
> 0 i.e., ⇢Sep
AB
TB
has positive eigenvalues.

The above is called the Peres-Horodecki criterion. It is a necessary criterion

for a state to be separable. This gives a very exciting consequence: for any
density matrix

if ⇢TAB
B
has negative eigenvalues =) ⇢AB is entangled.

Moreover, it is known (proof being difficult) that for 2 ⇥ 2 systems (2 qubits)

and 2 ⇥ 3 (3 ⇥ 2) systems it is also a sufficient criterion of separability – if
⇢Sep
AB
TB
> 0 the state is separable.

Exercise .4
+ +
By using the Peres-Horodecki criterion, show that ⌘AB = P | ih |AB +
(1 P ) |00i h00|AB is an entangled state for any P 6= 0.

5 Quantification of Mixed State Entanglement

From the definition of separable states it is clear that there can be separable
mixed states with S(⇢A ) > 0, S(⇢B ) > 0. The the von Neumann entropy
of the reduced density matrix is not a measure of entanglement for mixed
states. To define such a measure, one has to first put some criteria which
a bonafide mixed state entanglement measure should satisfy. Firstly, it is
required namely that it should be non-increasing under LOCC. This require-
ment is coming from the fact that if entanglement is that resource which can
only be created by a direct interaction and by quantum communication, then
its value should not be possible to increase under LOCC. Secondly, it should
be zero for separable states and attain its maximum value for Bell states (or
their counterpart for qudits) and all those states obtainable form them by
local unitary operations. This is because such states can be used to accom-
plish perfectly the various entanglement protocols – so they should have the
highest entanglement among all possible states. Morever, we demand that
mixing states together should decrease entanglement – recall exercise done

10
above where we mixed all Bell states (each maximally entangled) to obtain
a separable state. This is motivated by the fact that forgetting informa-
tion should only decrease entanglement. Quantities which satisfy the above
criteria are called entanglement measures.
While many such quantitites can be defined, very few are computable.
For example the distillable entanglement ED is obviously an entanglement
measure (as it is defined as the maximum fraction of Bell states extractable
by LOCC procedures, it cannot be increased under LOCC), but it cannot be
computed for arbitrary states. The one way LOCC distillable fraction given
by the Ic (A > B) is also not a measure as it could possibly enhance when
two way LOCC is allowed. A good and popular computable measure for two
qubits is called the concurrence (invented by Wootters 1998) which we will
not cover here (it is related to the amount of entanglement in the form of
Bell states needed to form a given entangled state – called the entanglement
of formation).
We will use here a measure called the negativity, which applies for arbitary
dimensional quantum systems. It is defined using the partial transpose op-
eration as follows:
X
N (⇢AB ) = | j |, where j are the eignevalues of ⇢TAB
B
.
j, j <0

Thus the modulus of the negative eigenvalues of ⇢AB are summed to get the
negativity. Armed with this simple prescription, one can now ascribe an
amount of entanglement to any mixed state ⇢AB of two systems.

Exercise .5
Compute the entanglement as quantified by the negativity for the state ⇢AB =
P | + i h + |AB + (1 P ) | + i h + |AB and find the only point at which the
entanglement is zero.

11
 Quantum Algorithms 1: Illustrations of
Quantum Speedup
Sougato Bose
February 22, 2021

1 Quantum Algorithms: Illustrating Speedup

We are now going to study some algorithms which are illustrative of the fact
that quantum mechanics can aid in the speed-up of certain problems over
what is possible using classical bits and operations on them. The agorithms
that we will discuss are those for which it is particularly intuitive to under-
stand that there is indeed a quantum speedup. Historically these were also
among the earliest algorithms formulated to illustrate quantum speedup, but
do not solve any particular problem of importance – but are artificial prob-
lems formulated specifically to show the possibility of a gap between quan-
tum and classical complexities (i.e., they show a clear gap in the number of
comparable elementary steps in each type of approach to the solution of a
problem – the quantum and the classical approaches). In fact, to be more
precise, all the speed-ups to be discussed are in terms of the number of usages
of an “oracle” or “black-box”, which is essentially a function evaluator. We
do not ask “how” the oracle is made, but accept the fact that the oracle is
possible in both the classical and quantum realms, and then show that the
quantum algorithms require fewer accesses to this oracle (i.e., fewer instances
of evaluations of a function) than what is possible classically.
We will start with a diagram of what a quantum algorithm generically
looks like: it is a huge multi-state interference experiment. We should point
out up-front that all possible quantum algorithms (including any that might
be discovered in the future!) may not necessarily conform to this pattern,
but it is a generic structure of many quantum algorithms.

2 The general structure of a quantum algo-

rithm
Consider a huge multi-slit Young’s interference scheme as depicted in Fig.1.
Quantum computation as a giant interference is illustrated in the figure and
the generic steps of an algorithm are explained in the caption. A few of
the important points to note here is that the giant superposition at the
start of the intereference experiment is conveniently created by a single local

1
 0 0 eiφ (0) 0

1 eiφ (1) 1

.
N −1 eiφ ( N−1) N −1

Hadamard transform to create Encoding the A quantum transform crea1ng Measure to find
the ini1al problem interference to solve the the answer
Large superposi1on of N=2n In terms of problem.
states of n qubits. phases.

Figure 1: The general structure of a quantum algorithm as an interference

experiment on an exponentially large number of slits. Note that the phases
encode the problem in the quantum algorithm; For example, the phases (x)
will be dependent on a f (x), where x is the slit label. For some algorithms,
instead of phases, a second register is used which subselects a certain num-
ber of slits depending on f (x) for the subsequent interference (other slits are
blocked out). In general one may need to repeat the algorithm (the interfer-
ence) a number of times, which would still be less, for all quantum algorithms
carrying a quantum advantage, than the number of times one will need to
evaluate the function in a classical algorithm. Sometimes, the algorithm con-
stitutes many runs of the interference, while after each run, one modifies the
phases applied according to measurement outcomes of previous runs. Some-
times, one may need to iterate the whole interferometry in series a number
of times and then measure at the very end of all the iterations.

2
Hadamard operation on each qubit, known the Hadamard transform, to be
discussed in section 6. In terms of operation time, we can regard this as
a single efficient step as all the Hadamards can be performed in parallel in
the same time-slot (when we include decoherence, to be described in a later
lecture, we will understand that we have to include the e↵ect of decoherence
in each of these n operations). The Hadamard transform leads to what we call
the starting state of all quantum algorithms with n qubits (obviously there
will be algorithms which do not start with this state, but we will mostly see
examples of those that do):
N 1
1 X
| i= p |xi , (1)
N x=0
where N = 2n and x represents all the 2n possible states of n bits, from
00..0 to 11..1. Actually we will use two equivalent representations of x when
we use the above equation, or similar equations, in various contexts. x will
sometimes mean the bit string x = x1 x2 x3 ...xn (where each xj 2 {0, 1}
is a bit), and will some times be used to mean the decimal number x =
x1 2n 1 + x2 2n 2 + ... + xn 1 2 + xn – it will be clear from the context which
way we are using x in a certain step of an equation.
Another crucial fact to note is that, although we are using the standard
multi-slit interferometry for the depiction of a generic quantum algorithm,
there are a number of diferences. The interference is not in a whole continuous
variable spatial degree of freedom as in standard interferometry learnt in
physics, but in a discretized version of it – only superpositions of the states
|xi , x = 0, 1, .., 2n 1 occur at any time during the algorithm – it is as if space
was discretized and finite with only the above values of x allowed. Moreover,
the transform need not be the Fourier transform which occurs in standard
interferometry, it could be any other appropriately chosen transform which is
useful to solve the problem (although we know that the Fourier transform is
used in some of the most powerful quantum algorithms). What do we mean
by a transform here?P It is a unitary evolution which evolves any state |xi to
a superposition k cx,k |ki with non-zero complex amplitudes cx,k for several
k 6= x} (in other words, the evolution is non-diagonal in the |xi basis).

3 Bit query to Phase query black-box

In classical computing, any black-box which evaluates a function works by
outputting f (x) given an input x as shown in Fig.2(a). In order to compare
the complexity with respect to the “numbers” of usages of a black-box (BB)
or oracle in a classical and a quantum algorithm, we need to design a quantum
version of the oracle. Here we assume that the classical and quantum versions
of the oracle are implemented with equal ease – the quantum version is
not more complex to implement. By quantum version, here we mean that
we are looking for a BB which is implemented by a Unitary operation on
the relevant qubit inputs and any number of acillae. A unitary operation
essentially takes an orthonormal set of input states to an orthonormal set

3
 Classical
x BB for f(x)
f(x)

(a)

x A Quantum x A
BQBB for
b B
f(x) b ⊕ f (x) B

(b)

x Quantum (−1) f ( x ) x
A
BQBB for
A
Quantum
1
2
(0 B
−1 B ) f(x)
1
2
(0 B
−1 B ) ≡ PQBB for
f(x)
(c)

Figure 2: Figure showing the various types of Black-Boxes (Oracles) for

function evaluation.

of output states. However, a generic function can be a many to one map,

such that for inputs xi 6= xj , f (xi ) = f (xj ). Thus for a generic function, a
quantum BB cannot have |f (x)i as the sole output to an input |xi as for
two orthogonal inputs |xi i and |xj i (hxj |xi i = 0) it may output the same
|f (xi )i = |f (xj )i (hf (xj )|f (xi )i = 1). Thus at the minimum, we have to
add another ancilla as an input where f (x) can be encoded so that the input
|xi cab be retained. The unitary should also have orthogonal outputs for
orthogonal states of this added ancilla. The above considerations constrain
us heavily in the definition of a quantum generalization of a BB. We will first
define a Bit Query Black-Box (BQBB), which provides the function output
as a bit string f (x), much as a classical computer does, except for the fact
that the bit string is encoded as a qubit string in the computational (z) basis,
depicted as |f (x)i. The BQBB, which satisfies all the above requirements, is
defined as (Fig.2(b))
BQBB
|xiA |biB ! |xiA |b f (x)iB , (2)

where the modular addition guarantees the orthogonality of outputs for or-
thogonal input states of the ancilla B.
However, as described in the last section, for several quantum algorithms,

4
the function f (x) is encoded in the problem in terms of phases (x) imparted
to the states |xi. Thus we will need a way to convert the information given
as a bit string (more precisely as a string of qubits in computational basis
states) to an information given as a phase acquired by the |xi states. Let
us temporarily restrict to f (x) 2 {0, 1} as we will only need this case for
the algorithms of this lecture. Then the conversion to a phase is done most
conveniently by assuming the ancilla to be a single qubit, and feeding it to
the BQBB in the state | iB = p12 (|0iB |1iB ). The evolution of the BQBB
with this input is thus (Fig.2(c))
1 BQBB 1
|xiA p (|0iB |1iB ) ! p {|xiA |0 f (x)iB |xiA |1 f (x)iB }
2 2
1 ¯ ↵ }(where f (x)
= p {|xiA |f (x)iB |xiA f (x) ¯ stands for the complement of f (x);
B
2
¯ = 1, f (x) = 1 =) f (x)
f(x)=0 =) f (x) ¯ = 0)

1
= |xiA p (|0iB |1iB )for f (x) = 0;
2
1 1
= |xiA p (|1iB |0iB ) = |xiA p (|0iB |1iB )for f (x) = 1.
2 2
The above two steps can be summarized as
BQBB
|xiA | iB ! ( 1)f (x) |xiA | iB .

Integrating the qubit B in | iB state as a part of the Black-Box machine

(Fig.2(c)), we have a definition of a Phase Query Black-Box (PQBB)
P QBB
|xiA ! ( 1)f (x) |xiA , (3)

which we will use in the algorithms we describe below.

4 Deutsch Algorithm, 1985

Historically, the Deutsch algorithm was the first example of a quantum al-
gorithm showing a clear speedup over what is classically possible. It is a toy
problem, of course, just to illusrate speedup. Given: An oracle that, given
an input bit x 2 {0, 1}, outputs a function f (x) 2 {0, 1}.

Task: Find whether f (x) is even/constant (i.e. f (0) = f (1)) or odd/balanced

(i.e. f (0) = f (1)).

Classical Algorithm: It is quite intuitive that you require at least 2

evaluations of f (x) (2 calls to the oracle), one by inputting x = 0 to get

5
f (0), and the other by inputting x = 1 and getting f (1). Then we can com-
pare f (0) with f (1) to conclude whether the function is constant or balanced.

Quantum Algorithm: It is the magic of quantum interferometry that

only 1 evaluation of f (x) suffices! It can be described as an algorithm with
a single qubit on which we use the PQBB described above. In fact, it is
equivalent to a double-slit interferometry in the sense described in section
2, with spatial slit states |0i and |1i (more appropriately a Mach-Zhender
interferometry, because, as stressed in section 2, no other spatial states take
part – the systems spatial variable is discretized to the dichotomic possibil-
ities |0i and |1i). Of course, as you will see, f (x) for both possible inputs
are indeed being computed during this single evaluation of the function (a
single usage of the PQBB), but imparted as phases to the states |0i and |1i.
Then their “relative” phase, which holds the information of the comparison
between f (0) and f (1), a↵ects where the peak of the interferometry falls
(whether |0i or |1i) after the relevant transform (here simply a Hadamard
on the qubit). Let us describe the algorithm concretely
1 PQBB evaluatingf (x) 1
p (|0i + |1i) ! p (( 1)f (0) |0i + ( 1)f (1) |1i)
2 2
1 1
= ± p (|0i+|1i) for constant function, ± p (|0i |1i) for balanced function.
2 2
H
! ± |0i for constant function, ± |1i for balanced function.
Thus simpy by measuring the qubit in the computational basis, one can
find whether the function was constant or balanced. Note that only one
usage of the PQBB was needed above as opposed to the classical case which
requires two evaluations of the function, and hence two usages of the function
evaluating black box.
Thus the Deutsch algorithm demonstrates a 2 : 1 speedup over the clas-
sical algorithm.

5 Deutsch-Jozsa Algorithm, 1992

Deutsch and Jozsa generalized the Deutsch algorithm to multiple qubits to
explicitly demonstrate that quantum algorithms could also provide an expo-
nential speedup over classical algorithms.
Given: An oracle that, given input bit strings x 2 {0, 1}⌦n (alternately,
x = 0, 1, ..., N 1, with N = 2n ), outputs a function f (x) 2 {0, 1} which
satisfies the condition that it is either constant (all f (x) = 0 or all f (x) = 1)
or balanced (i.e. for exactly half of the possible values of x, f (x) = 0 and the
remaining half f (x) = 1).

Task: Find whether f (x) is constant or balanced.

6
 Classical Algorithm: The natural strategy will be to take each value of
x one by one and use the oracle to evaluate the corresponding f (x). As soon
as we find a f (x) which has a di↵erent value from all the previous evalua-
tions, we infer that the function is not constant (i.e.it is balanced). It is quite
intuitive that in the worst case you will require N2 + 1 evaluations of f (x) to
ascertain whether it is constant or balanced. This is because all the first N2
evaluations may unluckily coincide even if the function is balanced, but the
N
2
th evaluation has to show a di↵erence. This is an exponential number of
evaluations as N = 2n .

Quantum Algorithm: We start from the starting state of all quantum

algorithms Eq.(1), and then proceed as described below.
N 1 N 1
1 X PQBB evaluatingf (x) 1 X
| i= p |xi !p ( 1)f (x) |xi
N x=0 N x=0
?
↵
= ± | i (for f (x) = Const), ± (for f (x) = Balanced),
where X X
?
↵ 1
=p ( |xi |xi).
N x with f (x)=0 x with f (x)=1

It is easy to verify (satisfy yourself by thinking about this for a moment) that
from the condition on the function (either ↵constant or balanced) it follows
that h | ? i = 0, and thereby | i and ? can be fully distinguished in a
quantum measurement. Thus a single usage of the PQBB has sufficed to
distinguish between a constant and a balanced function irrespective of the
case – works equally well in all possibilities of the function – no best case
or worst case. Thus over the classical algorithm’s worst case, the quantum
algorithm has a N2 + 1 : 1 speedup or an exponential speedup.

Exercise .1
Show that the starting state of all quantum algorithms can be generated as
follows by acting by a Hadamard on n qubits, each in a state |0i, i.e., show that
N 1
⌦n 1 X
H |00..0i = | i = p |xi .
N x=0

6 Hadamard Transform
The Hadamard transform is one of the unitary operations which is used in
some quantum algorithms to implement the giant multiparticle interferom-
etry over the 2n states of n qubits. It is also the unitary operation used to
generate the large equal superposition over all the 2n states in the first place.

7
Let us recall that
1
H|0i = p (|0i + |1i) (4a)
2
1
H|1i = p (|0i |1i) (4b)
2
The above two equations can be written in a compact form as
1 X
H|xi i = p ( 1)xi yi |yi i (5)
2 y 2{0,1}
i

The Hadamard transform is simply the Hadamard on each of the n qubits,

i.e., H ⌦n . Thus, if we denote a general bit string quantum state |x1 i ⌦ |x2 i ⌦
.... ⌦ |xn i (where xi 2 {0, 1}) by the shorthands |x1 x2 ...xn i and |xi (where x
takes values 0, 1, ..., N 1, where N = 2n ), then the action of the Hadamrd
transform on this state is

H ⌦n |xi = H|x1 i ⌦ H|x2 i ⌦ .... ⌦ H|xn i (6a)

1 X 1 X 1 X
= p ( 1)x1 y1 |y1 i ⌦ p ( 1)x2 y2 |y2 i ⌦ .... ⌦ p ( 1)xn yn |yn i
2 y 2{0,1} 2 y 2{0,1} 2 y 2{0,1}
1 2 n

1 X X X
= n ... ( 1)x1 y1 +x2 y2 +...+xn yn |y1 y2 ...yn i
2 y 2{0,1} y 2{0,1} y 2{0,1}
2
1 2 n

N 1
1 X
= p ( 1)x1 y1 +x2 y2 +...+xn yn |y1 y2 ...yn i
N y=0
N 1
1 X
= p ( 1)x1 y1 x2 y2 ... xn yn
|y1 y2 ...yn i (6b)
N y=0
N 1
1 X
= p ( 1)x.y |yi, (6c)
N y=0

where in Eq.(6b) we have used the equivalence of modular (module 2) sum

and simple (non-modular) sum when appearing as a power of -1, and where
in Eq.(6c) x.y = x1 y1 x2 y2 ... xn yn .

7 Bernstein-Vazirani Algorithm, 1993

This is a toy problem which demonstrates unambiguously a quantum speed-
up over classical. The speedup is with respect to the “number of usages”
of an oracle or Black-Box which evaluates a function. For a n bit input,
we will show that there is a quantum algorithm that achieves the task in a
single query to the oracle, while for the classical case there seems to be at
least n queries which are required. We do not go into the problem of how the
oracle is constructed, or the complexity needed for its implementation as a
quantum unitary operation with inputs and outputs encoded in qubits. Of

8
course, we will assume, as discussed in section 3, that the Black-Box operates
as a phase query Black-Box (PQBB) in the quantum algorithm. The task at
hand is described below:

Given: An oracle that, given an input bit string x = x1 x2 ...xn , outputs

a function f (x) = a.x = a1 x1 a2 x2 .... an xn , where a = a1 a2 ....an is an
unknown bit-string.

Task: Find a.

Classical Algorithm: We do not go into the inticacies of proving what

is the very best one can do classically. That would have been proven in
Bernstein-Vazirani’s original paper [1]. Indeed it can be proven that at least
n queries of the oracle are needed. However, we are going to argue, what is
naively the most natural approach classically, and show that it requires at
least n queries. Essentially, to determine a you have to determine all its n
bits a1 , a2 , ..., an . So one can:
Step 1: Give the input x = 10...0 to the oracle to get output a.x = a1 .
Step 2: Give the input x = 01...0 to the oracle to get output a.x = a2 .
.
.
.
Step n: Give the input x = 00...1 to the oracle to get output a.x = an .
Thus classically, we have n queries needed to the oracle to obtain all the n
bits of the string a.

Quantum Algorithm: PWe1 start with the usual starting state of quan-
tum algorithms | i = p1N N
x=0 |xi. This, as shown before, is easily gener-
⌦n
ated by H on the qubit state |00...0i.
N 1 N 1
1 X PQBB evaluating a.x 1 X
p |xi ! p ( 1)a.x |xi
N x=0 N x=0
N 1N 1
H ⌦n 1 XX
! ( 1)a.x ( 1)y.x |yi (7a)
N x=0 y=0
= |ai. (7b)

How does the astonishing equivalence between Eq.(7a) and Eq.(7b) follow?
To understand that, consider the amplitude of the state |y = ai in Eq.(7a):
N 1
1 X
( 1)a.x ( 1)a.x = 1. (8a)
N x=0

As the entire quantum algorithm uses unitary operations only, the normal-
ized input state | i must have evolved to a normalized output state at the
end of the algorithm. As the amplitude of the state |y = ai is unity, and it
is itself a normalized state, thus the amplitude of all states |y 6= ai must be

9
zero in the output state. Thus the output state must be |ai (i.e. Eq.(7a)
is equivalent to Eq.(7b)). Eq.(7b)) implies that we can simply readout the
value of a from the output state. In all this procedure, there has been only
one application of the Black-Box, as a phase query black box evaluating a.x.
Thus,

Speedup: The quantum algorithm achieves a n to 1 speedup over its

classical counterpart. This is a polynomial speedup, but it is demonstrable,
and, unlike Deutsch-Jozsa, it is not just a speedup over the worst case or
only when we determine that the classical algorithm be deterministic, but a
speedup in all possible cases.

8 Simon’s Algorithm, 1994

Simon presented a problem which showed a quantum algorithm can have an
exponential speedup over the classical algorithms even in a general case sce-
nario of the problem. Again, here the speedup is with respect to the “number
of usages” of an oracle or Black-Box which evaluates a function. For a n bit
input, we will show that there is a quantum algorithm that achieves the task
in O(n) runs of the algorithm, with each run querying the oracle once. On
n
the other hand, a classical algorithm, requires on average O(2 2 ) queries (so
there is an exponential advantage). In this case, in contrast to previous al-
gorithms, we are going to use a bit-query Blac-Box (BQBB).

Given: An oracle that, given an input bit string x = x1 x2 ...xn , outputs

a function f (x) with the promise that f (x) = f (y) if and only if y = x a
where x a = x1 a1 x2 a2 ... xn an . In other words, x a is a bit string
obtained by modular (modulo 2) addition of each bit of x with the corre-
sponding bit of a. The bit string a can therefore be thought of as a special
type of ”period” of the function f (x), with the promise that any given value
of f (x) is obtained only from two inputs x and x a.

Task: Find a.

Classical Algorithm: We do not go into the inticacies of proving what

is the very best one can do classically. Simon himself proved that a ran-
n
domized classical algorithm of O(2 4 ) does not suffice. You can find a proof
n
that one cannot do better than O(2 2 ) for a significant ( 34 ) probability of suc-
cess in [2]. Indeed it can be proven that at least n queries of the oracle are
needed. However, we are going to argue, what is naively the most natural
approach classically, and show that it requires and exponentially large num-
ber of queries. Essentially, you have to go in sequence and evaluate f (x) for
various inputs x, say starting with x = 0 and going up to x = N 1. As
soon get a coincidence (or, in computer science jargon, what is called a “col-
lision”), i.e. you get f (x) = f (y) you can obtain x y = a. But the chance

10
of a collision between any two evaluations is exponentially small (because x
and x a can be any two arbitrary values among an exponentially large set
of N = 2n possible values of x). Thus classically, we have to have an expo-
nentially large number of queries in the average case to determine the string a.

Quantum Algorithm: Unlike the previous algorithms, this requires

2 registers (collections of qubits). The first register is in the usual starting
state of quantum
P algorithms (as generated by H ⌦n on the qubit state |00...0i)
N 1
| i = p1N x=0 |xi, while the second register (also n-bit long) is in the state
|0i = |00...0i. Then the algorithm proceeds as follows:
N 1 N 1
1 X BQBB evaluating f (x) 1 X
p |xi|0i ! p |xi|f (x)i
N x=0 N x=0
Measure 2nd register to find f (x = b) 1
! p (|bi + |b ai)|f (b)i.
State re-normalized after Meas. 2
N 1
1 H ⌦n 1 X 1
p (|bi + |b ai) ! p p (( 1)b.y + ( 1)(b a).y
|b ai)
2 N y=0 2
N 1
1 X 1
= p p ( 1)b.y {1 + ( 1)a.y }|yi.
N y=0 2
2 X
= p ( 1)b.y |yi. (8ba)
N a.y=0

Eq.(8ba) implies that if we measure the first register now and find a bit string
y = y (1) (where we have used superscript and brackets to indicate that y (1)
is a bit string), then this bit string y (1) satisfies the linear equation

a.y (1) = 0. (8ca)

Now one repeats the whole algorithm from the start O(n) times and obtains,
by measuring the first register at the end, another set of distinct bit strings
y (2) , y (3) , ...., y (n) so that

a.y (2) = 0. (8da)

a.y (3) = 0. (8db)
. (8dc)
. (8dd)
. (8de)
(n)
a.y = 0. (8df)

In the case that one of the y (j) s coincide with the outcome of a previous
measurement (whose chance is exponentially small anyway) the algorithm
must be repeated again to obtain another distinct y (j) . In this way, by
O(n) repeatitions, one can obtain n linearly independent linear equations,
Eqs.(8ca)-(8df), from which a can be obtained. Thus,

11
 Speedup: The quantum algorithm, which uses O(n) runs of the algo-
rithm (hence O(n) uses of the oracle) achieves an exponential speedup over
n
its classical counterpart which requires O(2 2 ) queries. This is an exponential
speedup, and it is not just a speedup over the worst case but a speedup in
the average case.

References
[1] E. Bernstein and U. Vazirani, Quantum complexity theory, SIAM Jour-
nal on Computing, 26(5):1411-1473, 1997.

[2] R.Cleve, Lecture Notes (2011),

https://cs.uwaterloo.ca/ cleve/courses/F11CS667/SimonClassicalLB.pdf.

12
 Quantum Search & Introducing Quantum
Fourier Transform
Sougato Bose
March 2, 2021

We will now proceed to discuss quantum algorithms which speed up prob-

lems of practical interest. We will study two classes of algorithms – the first
algorithm, which we study in this part, gives a quadratic speedup, while the
latter give an exponential speedup. In conjuction with the quantum search
algorithm, we will also exemplify two important alternative implementations
of quantum algorithms beyond the usual circuit model of a series of gates
– namely the adiabatic quantum computation and the quantum walk based
quantum computation models.

1 Grover’s Algorithm (Quantum Search), 1998

The problem is search an item from an unsorted data-base. For example
suppose there is a phone directory where names of the entries are in a certain
order (alphabetically sorted), but their phone numbers aren’t. Then, given a
phone number, to search the person to whom it belongs is a very lengthy task.
You have the phone number as a “marker” for the element (called the marked
element) to be searched. But to find where precisely the ”marked” element
is, we have to go on looking at phone numbers one by one till we find a match.
Say we have a machine which has the number stored in it and we scan the
phone numbers one by one through it. The machine goes “beep” as soon as
the right number is found. This machine can be regarded as an oracle. When
we find the number, we read-out the name of the person. So we will typically
need to search O(N ) times through the unsorted data-base. This means that
the oracle which goes ”beep” when the right match is found, has to used
about O(N ) times, each time scanning one of the numbers.
p Grover’s quantum
algorithm can, however, can accomplish
p this in O( N ) steps in the sense that
the oracle has to be queries O( N ) times. Of course, we will need a quantum
oracle and a quantum data-base to accomplish the quantum algorithm! The
latter makes the task of actually implementing
p quantum search in a useful
regime i.e. a large enough data-base for N advantage to be useful (that
too a quantum data-base! – phone numbers and names stored in quantum
states) very very hard [But you can never overestimate technological progress
– so who knows?]. However, it can still be useful presumably earlier in
problems where some special marked element/s naturally arises as quantum

1
states, such as a solution to a Boolean satisfiability problem, for instance
using quantum methods. These can then be amplified by the methodology of
Grover’s search algorithm. Thus it has an important usage as a subroutine
of various quantum algorithms.

2 Quantum Search Algorithm Description:

Given: A function f (x) 2 {0, 1} is defined over a set of elements x 2
{0, 1, ..., N 1}. There is a specific marked element m 2 {0, 1, ..., N 1}
such that
If x 6= m, f (x) = 0,
If x = m, f (x) = 1.
Task: Find m.

Classical Algorithm: Using a classical oracle, one has to go on evaluat-

ing the function for each x till one chances upon the marked element m and
evaluates f (m) to find that it is 1 (i.e., the machine goes beep). As this will
require one to evaluate the function, in the typical case, a number of times
which is the same order as the total number N of possible values of x. The
classical algorithm requires O(N ) applications of the oracle.

Ingredients required for the quantum algorithm, and their im-

plements: The quantum algorithm firstly requires an unsorted quantum
database and a quantum oracle that evaluates the function which identifies
the matching element, i.e., in terms of a PQBB,
P QBB
If x 6= m, |xi ! |xi ,
P QBB
If x = m, |xi ! ( 1) |xi .

Exercise .1
Verify that the action of the above PQBB is given by the operator

Ôm = 1 2 |mi hm| ,

i.e.,
Ôm |xi = |xi if x 6= m,
Ôm |xi = |xi if x = m.
We will discuss the implementation of the database and a BQBB version
of the above quantum oracle in the next section (essentially a quantum circuit
which notifies the match of an input bitstring x with a marked bit string m),
as well as a version where f (x) is the solution to a decision problem.
Secondly, the algorithm requires another unitary operator

Ô = 2 | i h | 1,

2
 PN 1
where | i = p1 |xi. The unitarity of Ô is proven in exactly the same
N x=0
manner as that of Ôm above. Grover’s search algorithm is implemented
iteratively by repeatedly applying the operator Ô Ôm on to the quantum
register (meaning will become clear below).

Exercise .2
Show that
H ⌦n Ô0 H ⌦n = Ô .
The above exercise shows that Ô can, in turn, be implemented by a
PQBB with marked element x = 0, i.e., Ô0 .

Quantum Algorithm:
The quantum algorithm is simply
p the application of Ô Ôm on the state
1
PN 1
| i = pN x=0 |xi about O( N ) times. In other words, the claim is

(Ô Ôm )k | i ⇡ |mi ,

p
for k = O( N ). The ⇡ sign above means that the state becomes the marked
element with a very high probability – there is a very small probability for
it to be one of the other states. As a specific example, you can work out the
algorithm for N = 4 (implementable by a 2 qubit register).

Exercise .3
Making your own choice of a marked element (any of 0, 1, 2 or 3) among four
possibilities, show that a single application of the Ô Ôm operator implements
the Grover search perfectly for a 2 qubit register (i.e., evolves the state exactly
to the marked element).

To understand why the algorithm works it is best to draw a geometric

picture (Fig.1) and analyse the evolution of the state under repeated appli-
cations of Ô Ôm . We rewrite the initial state | i in the following way
N 1
r r
1 X N 1 ?
↵ 1
| i= p |xi = m + |mi ,
N x=0 N N

with
N
X1
?
↵1
m =p |xi.
N 1 x=0,x6=m
↵
Note that hm? |mi = 0. Thus {|mi , m? } can be used as a complete basis in
a 2-dimensional Hilbert p and the state | i makes an
↵ space as shown in Fig.1
angle ✓ with the m? such that sin ✓ = 1/ N . In this picture, the actions
of the two operators are
↵
Ôm reflects states about the m? axis,

3
 m k
(
ψ (k ) = Ôψ Ôm ) ψ
2
(
ψ (2) = Ôψ Ôm ) ψ

ψ (1) = Ôψ Ôm ψ

2θ
2θ ψ
θ m⊥
θ
2θ Ôm ψ

Ôm ψ (1)

Figure 1: Figure showing the angle rotations due to each application of the
grover operator Ô Ôm . Note that the angles and the lengths of the vectors
as shown in the figure are not to scale.

(as the amplitude of the state |mi becomes negative while keeping the same
magnitude)
Ô reflects states about the | i axis,
(as the amplitudes of all states other than | i becomes negative while keep-
ing the same magnitudes).

Using the above actions, the evolution of the angles during the interations
of Ô Ôm take place as follows (read these lines while comparing with Fig.1):
↵
Ôm | i makes an angle ✓ with m? ,
↵ ↵
(1)
= Ô Ôm | i makes an angle 3✓ with m? ,
↵ ↵
Ôm (1) makes an angle 3✓ with m? ,
↵ ↵
(2)
= (Ô Ôm )2 | i makes an angle 5✓ with m? ,
.
.
.
↵ ↵
(k)
= (Ô Ôm )2 | i makes an angle (2k + 1)✓ with m? .

4
Thus each iteraction Ô Ôm rotates the state by an extra angle 2✓ anticlock-
wise starting from the initial state | i. When the rotation angle reaches ⇡/2,
the rotated state is approximately |mi and our algorithm is finished (marked
state has been reached). The number of iterations k required for this is
⇡
(2k + 1)✓ ⇡ .
2
If N is large, ✓ ! 0, sin ✓ ⇡ ✓ = p1 . Thus we have
N

1 ⇡
(2k + 1) p ⇡
N 2
⇡p
=) k ⇠ N.
4
p
Thus, in k ⇠ O( N ), iterations of Ô Ôm (usages of the oracle), the ampli-
tude of the marked state, which was initially p1N has been amplified to near
unity (this is thus also often called amplitude amplification), and we would
find the marked state with a very high probability if we measure.
p
Speedup: Thus Grover’s search algorithm o↵ers a O( N ) speedup over
classical algorithms in finding a marked element from an unsorted database.

3 Oracle construction for quantum search/amplitude

amplification
A somewhat artificial way to be convinced that Grover’s algorithm is doing
something nontrivial is if you imagine that the Oracle was sealed – it had
m encoded inside, but you had no way of knowing the relevant m without
querying
p the oracle. Using the quantum algorithm you can get to learn m in
O( N ) uses of the oracle, as opposed to the classical one of O(N ) queries.
How do we construct an oracle that accomplishes Ôm ? As a simple ex-
ample, we take two-bit strings x = x1 x2 which the oracle has to match with
a chosen string m = m1 m2 (what we have called the marked element above).
A circuit for this is given by the 3rd-9th qubits from the top of Fig.2. The
working of the quantum oracle is easy to understand. It compares x1 with
m1 and x2 with m2 in terms of standard To↵oli gates or CCNOT (those with
black-filled spheres at the controls) and the To↵oli conditioned on both the
controls being 0 (those with un-filled spheres at the controls). If both x1 and
m1 match (both 0 or both 1), the 7th qubit from the top is set to |1i, while
if both x2 and m2 match, the 8th qubit from the top is set to |1i. By the
CCNOT action from these 7th and 8th qubits, the 9th qubit, in turn, is set
to |1i. Thus the 9th qubit becomes |1i only when x = m. Thus the circuit
is the BQBB of the required oracle that matches x with m, with the 9th
qubit outputting |f (x)i. This can then be converted to a PQBB using the
technique of the last lecture, so that we have Ôm .

5
 a1 a1
a2 a2

x1 x1
x2 x2 If
If

f(x)=1
m1 m1 meas
a1 a2
m2 m2
0 X X X X 0
0 X X X X
0

0 X f (x)

Figure 2: Figure showing the construction of Ôm (qubits 3rd to 9th from the
top). Two qubits are added to the top to make the first 4 qubits a quantum
database e.g, name, phone number combinations.

How does it fit in with the original motivation of searching over an un-
sorted database? Let us thus extend our simple example above to an un-
sorted database encoded in quantum states. Each entry to the database
is |a1 a2 x1 x2 i. Consider, as above, only 4 entries to the database, but now
labelled by two bit strings a = a1 a2 (these are essentially equivalent to the
names of the people in the database), and two bit phone numbers represented
by strings x = x1 x2 . We know a specific phone number m = m1 m2 , but do
not know the “name” of the person a1 a2 to whom the number m belongs. Our
task is to find a1 a2 using a quantum algorithm – so we construct a quantum
oracle as shown in Fig.2. Note that the |a1 a2 i part of the input state does
not seem to have been used for anything in the circuit. It just maintains the
correspondence of names with phone numbers. When a match of the phone
number is found i.e., f (x) = 1 is obtained, one merely measures them to find
out the name of the person to whom the phone number m belongs. To clarify
a bit more, in the usual starting state of all quantum computation | i, each
state |xi would actually stand for |a(x), xi where a(x) is the bit string that
gives the name of p the person who has the telephone number x. When |mi is
amplified after O( N ) search iterations, one can simply read o↵ |a(m)i.
The above usage, the literal search of an unsorted database is, of course,
very difficult precisely because of the need to prepare the quantum database
and the initial state | i including the information of the names a(x) to which
each x belongs. Although the circuit for Ôm is easy, as shown above, and so

6
will the circuit for Ô0 , but the circuit for Ô may not be easier in this case.
Thus the quantum search algorithm, in the sense of amplitude amplifica-
tion is more useful for cases where the oracle gives |f (x) = 1i for the affirma-
tive instance of a decision problem, otherwise |f (x) = 0i. Here the entries are
solely the bit strings |xi with no extra labels such as name entries, so that the
algorithm described in the previous section can be implemented just as de-
scribed. In these circumstances, the amplitude of the bit strings |xi for affir-
mative case/s can be amplified by the quantum algorithm and then measured
to find those x with give f (x) = 1. For a neat example of this oracle construc-
tion for 3-SAT, please see question, answer and circuit (see all 3 circuits as
they progressively build) at: https://cstheory.stackexchange.com/questions/38538/oracle-
construction-for-grovers-algorithm
The 3-SAT problem itself has a best known exponential O(K n ) classical
complexity (K > 1 is some base, which decreases with better the algorithm
you find), which can be reduced to O(K n/2 ) by the application of the square
root speedup given by amplitude amplification. In short, any classical oracle
computing a function f (x) efficiently for any given entry x is, in the end made
from a circuit composed of AND, OR, NOT. These can all be replicated as
classical reversible (and hence quantum) circuits build from Fredkin and/or
To↵oli gates. Then, if it is a decision problem with f (x) 2 {0, 1}, we can
always convert it to a PQBB to give a ( 1)x phase to those x entries which
give f (x) = 1. Then those values of x can be thought as marked elements
(marked by the decision problem you are solving), which can all be amplified
by Grover’s amplitude amplification algorithm.

4 Quantum Walk and Adiabatic Quantum Com-

puting Implementations of Quantum Search
Quantum search can also be regarded as a model example to study other
implementations of the search algorithm which are not the circuit model of
several gates. These are a continuous time evolutions through a Hamilto-
nian. The solution to the problem is encoded in terms of a Hamiltonian Hp .
If a Hamiltonian Hp + Hd is suddenly switched on (a quantum quench) which
comprises of the problem Hamiltonian added to a some kind of transform (or
driver) Hamiltonian Hd which has matrix elements between di↵erent compu-
tational basis states and held constant, and the system time evolves to the
solution with a high probability, it is called a quantum walk. If the Hamil-
tonian is slowly varied as (1 s(t))Hd + s(t)Hp , with s(t) slowly varying
between 0 and 1 so that the rate of change of the Hamiltonian is slower than
the smallest energy gap between the lowest energy state to the first excited
state, it reaches the solution near perfectly following the quantum adiabatic
theorem. The ideal quantum search problem described earlier in this lecture
can do both these processes perfectly.
P 1
Quantum Walk Search: Consider Hd = | i h | where | i = p1N N x=0 |xi.
There is a physical way to imagine Hd as the driver of a quantum walk of

7
 0
2

1
3

4
Figure 3: A fully connected graph of sites on which a single particle can hop,
along with a defect site |2i of di↵erent energy.

a single particle on a fully connected graph. Every element |xi represents

one vertex
⌦ 0 of the graph where this single particle can be, and the elements
1
|xi x of Hd represent the terms which make the particle hop from the
0↵
N
site |xi to the site x . There is exactly one marked vertex |mi on the graph
which has a di↵erent energy (say, 1), with all the other vertices having zero
energy. The scenario is depicted in Fig.3, where the vertex |2i is the marked
vertex. We do not know which vertex has lower energy and the task is to
find it out with the particle at hand. The classical strategy will be to place
the particle in turn in each vertex and find out its energy, which is O(N )
operations. However, the quantum particle can be placed in an initial state
which is a superposition of all states with equally low amplitude p1N as we
have no idea which site is the marked site |mi with di↵erent energy. Then,
at t = 0 we suddenly switch on the Hamiltonian

Hw = Hd + Hp = | i h | + |mi hm| .

It will be a problem of the problem sheet 3 (with appropriate hints) to

show that the initial state | i deterministically evolves to the state |mi in

8
 p
time t = ⇡2 N . Essentially the problem can again be solved by converting it
to an e↵ective problem ↵in a 2-dimensional Hilbert space with states expressed
in the basis {|mi , m? }. Thus without knowing which vertex has di↵erent
p
energy apriori, quantum mechanics can find that vertex in O( N ) time.

Quantum Adiabatic Search: For this, the slowly time-varying Hamil-

tonian
Ha (t) = (1 s(t)) | i h | s(t) |mi hm|
is used with s(t) growing slowly from 0 to 1. At t = 0 the system is initialized
in its ground state | i. If the change is slower than the minimum gap, the
system continues to be in its ground state, which gradually evolves to |mi
when s(t) = 1.

Exercise .4
q q
↵
N 1 ? 1
Using | i = N
m + N
|mi and writing the Hamiltonian in the
↵
{|mi , m? } basis, show that the minimum gap of Ha (t) is p2N .
Duepto the result of the above exercise, we can conclude that in time
t ⇠ O( N ) one can reach the marked state |mi via the quantum adiabatic
algorithm.
The above implementations are often called a spatial search for the ob-
vious reasons (e.g. see Fig.3). We will next proceed to a di↵erent class of
quantum algorithm, which gives an exponential speedup over known classical
algorithms. For that we require to use the quantum fourier transform, which
we introduce in this lecture, with its algorithmic applications discussed in
the next lecture.

5 Quantum Fourier Transform

Quantum Fourier Transform (we denote by F) is a unitary transformation
defined by its action on the computational basis (bit-string) states |ji ⌘
|j1 2n 1 + j2 2n 2 + ... + jn i ⌘ |j1 j2 ...jn i as
N 1
1 X i 2⇡ jk
F|ji = p e N |ki. (1a)
N k=0

In the above, |ki are also bit-string states as defined for j above, jk means
straightforward multiplication of the decimal values of j and k (i.e. j1 2n 1 +
j2 2n 2 +p
... + jn and k1 2n 1 + k2 2n 2 + ... + kn respectively), i is the complex
number 1, and, as usual N = 2n where n is the number of qubits.

5.1 Exercise:
PN 1 PN 1 i 2⇡ jk
Show that F = p1 |kihj|. Hence prove that F is a unitary
k=0 e
N
N j=0
operation.

9
5.2 Exercise:
Show that F|110i is a product state of 3 qubits.

10
 Quantum Fourier Transform – Circuit &
Applications
Sougato Bose
March 9, 2021

In this lecture we will first demonstrate that the Quantum Fourier Trans-
form is an easy unitary operation to implement. We will then describe its
classic applications – Shor’s algorithm for factorization of a large number to
its primes, as well as quantum phase estimation or eigenvalue estimation (the
latter being a problem in the 3rd problem sheet, we will skip over some of
the mathematics).

1 Circuit for Quantum Fourier Transform

We require to demonstrate that the Quantum Fourier Transform F is an
operation which can be done with a polynomial number of gates. This will
make its application in, for example, Shor’s algorithm for factorization use-
ful (give an exponential advantage). Thus we write the quantum Fourier
transform in a factorizable way as follows
N 1
1 X i 2⇡ jk
F|ji = F |j1 i |j2 i ... |jn i = p e N |ki
N k=0
1 1 1
1 X X X i2⇡( j21 + j22 +... 2jnn )(k1 2n 1 +k
22
n 2 +...+k
n)
= p ... e 2 |k1 k2 ...kn i
N k1 =0 k2 =0 kn =0
(In the above step, we have divided j by N )
1 1 1
1 X i2⇡ jn k1 1 X i2⇡( jn 1 + jn )k2 1 X i2⇡( j21 + j22 +..+ 2jnn )kn
= p ( e 2 |k1 i) p ( e 2 4 |k2 i)... p ( e 2 |kn i).
2 k1 =0 2 k2 =0 2 kn =0
(1)
Using the above expression one can draw the circuit for this problem. An
example with n = 4 qubits (i.e., N = 16 and j, k = 0, .., 15) is given in Fig.1
in terms of Hadamard operations H and Controlled Rotations

1 0
CR2l = 2⇡ .
0 e i 2l
Looking at that circuit, but considering a general n, note that the input to
the circuit is a specific bit-string state |ji = |j1 j2 ...jn i, with qubits ordered

1
j1 H RH22 R2H3 R2H4 4

j2 H RH22 RH
23 3

H RH22 2
j3

j4 H 1

Figure 1: Circuit for Quantum Fourier Transform on 4 qubits.

2
in ascending order from top to bottom, while the output to the circuit is
the factorizable state of Eq.(1) with qubits labelled as 1, 2, ...n in descending
order from top to bottom (reverse of the order of the qubit labels in the
P j1 j2 jn
input). Essentially, the circuit evolves |j1 i to 1kn =0 ei2⇡( 2 + 22 +..+ 2n )kn |kn i,
P j2 j3 jn
|j2 i to 1kn 1 =0 ei2⇡( 2 + 22 +..+ 2n 1 )kn 1 |kn 1 i, and so forth. To understand the
operation of the circuit consider, in Fig.1, the conversion of |j1 i through the
circuit (where the output qubit states are labelled as k4 = {0, 1}),
1
X 1
X
H j1
j 1 k4
|j1 i ! ( 1) |k4 i = ei2⇡ 2 k4 |k4 i
k4 =0 k4 =0

1
X
CR22 j1 j2
! ei2⇡( 2 + 22 )kn |k4 i
k4 =0
1
X
CR23 j1 j2 j3
! ei2⇡( 2 + 22 + 23 )k4 |k4 i
k4 =0
1
X
CR24 j1 j2 j3 j4
! ei2⇡( 2 + 22 + 23 + 24 )k4 |k4 i .
k4 =0

Thus for each qubit state of the output, there is one block (dotted box
in Fig.1), with the number of operations in each block depending on how
many qubits are below that qubit in the circuit. Considering the general n
version of the circuit in Fig.1, we will thus have l operations (including the
H) for the evolution of |jn l+1 i to the output qubit l. Thus the total number
of operations needed for a n qubit Quantum Fourier Transform (QFT) is
n(n+1)
2
⇠ O(n2 ), which is a polynomial scaling in n implying that it is an
easy unitary operation to implement.

2 Factoring and Modular Exponentiation

Suppose we want to factor a large number N which has been obtained (by
someone else) by multiplying two large prime numbers. No easy (i.e., op-
erating with polynomial time in n = log2 N ) classical algorithm is known
for this task to date. If one can accomplish that, one can break the popu-
lar RSA public key cryptosystem. Shor’s (1995) quantum algorithm, on the
other hand, does accomplish this task using a number of gates that sclaes
polynomially in n. It uses a classical part: the reduction of the problem of
computing factors to that of finding the period (or, as it is often called in
computer science, the order) of a function. This latter problem of finding
the period is then accomlished using QFT. We will describe the quantum
algorithm shortly, but here we discuss the classical reduction of the problem
to period finding. Given N to factorize, one chooses an integer a coprime
with N and computes f (x) = ax mod N for x = 0, 1, ...N 1. If a period r
is found for f (x), i.e., f (x + r) = f (x) then ax mod N = ax+r mod N implies
a

3
 mod N =1,

r r
=) (a 2 + 1)(a 2 1) mod N = 0.
In other words, there is a potential for finding prime factors of N of the form
r
a 2 ± 1. It is very easy to check whether something is a factor by using the
gcd algorithm.

Exercise .1
Choosing N = 15 to factorize, choose a = 2 (coprime with N ) and compute
(and plot, if you think that helps you to picturize) f (x) = ax mod N for x =
0, 1, ..., 15 to show that f (x) has a period of r = 4 and is monotonic (continually
r
increases) within one period. Hence show that a 2 ± 1 finds the prime factors.
So which part of the above is hard classically? It is not computing the
function f (x) = ax mod N as powers can be very easily done if you have
multiplier circuits, which in turn, require adder circuits (you compute a.a =
a2 , then a2 .a = a3 etc). It is, in fact, finding the period of the function.
For large domain of x, when N = 2n is exponentially large in n, typically r
can also quite (exponentially) large, so if we find a f (x0 ), finding its partner
f (x0 + r) can be very difficult.

3 Quantum Arithmetics for Modular Expo-

nentiation
Before proceeding to the description of Shor’s algorithm, we need to describe
how to compute the function f (x) = ax modN through a quantum circuit
and convince you that the type of resources required for it are also polyno-
mial. This quantum circuit will then act as the black-box or oracle for the
evaluation of f (x) and used in the quantum algorithm. Instead of presenting
a full circuit (students can look up various resources on the web, but not
strictly required for this module) we just the qualitative idea of the order of
the number operations required will be discussed below). Firstly we require
quantum adders. As an example, consider the half adder depicted in Fig.2.

Exercise .2
Verify that for computational basis inputs, the circuit of Fig.2 accomplishes
the SUM and CARRY operations of binary addition in its second and third out-
puts.
Note we required 2 fundamental gates for the half adder (if the To↵oli
is designed in terms of fundamental 2 qubit gates, then slightly more) for
adding two bits. Adders for 2 n-bit string states can also be constructed as
similar circuits and require O(n) gates.

Exercise .3
Check for yourself that usual long multiplication/column multiplication rule
learnt long ago in your primary school days also works for binary numbers, e.g.,

4
 a a

b
X SUM = a ⊕ b

CARRY = ab
0 X
Figure 2: Circuit for Quantum Half Adder.

just square a number 1101 (13 in decimal numbers) to get the binary number
for 169.
Using the usual long multiplication rule, multiplying any n-bit number
a = a1 a2 ...an with another, say, b = b1 b2 ...bn should thus take n2 bit by bit
(bn with an , then bn with an 1 and so on till bn with a1 , and then repeat
starting with bn 1 etc.) multiplications (To↵oli gates with the target going
to state aj bk ) and then another O(n2 ) operations for adding the columns.
Totally, thus multiplying two n-bit numbers requires O(n2 ) multiplications.
There are alternative quantum circuits for multiplying, but still requiring
O(n2 ) operations. We are being a bit loose here in that we are skipping the
fact that it is also possible to accomplish the mod N multiplications with
O(n2 ) operations – such a multiplier is called a modular multiplier (making
multipliers modular additionally require subtractors, which are adders ran
backwards, and a check of overflows).
Then we use the formula that for a bit string x = x1 x2 ...xn ,
n n 1
ax mod N = (a2 modN )x1 (a2 modN )x2 ...(amodN )xn .
Each of the factors in the above decomposition are accomplished by con-
ditional mod N multipliers (conditional on state xj ) as shown in the circuit
is given in the Fig.2 of https://arxiv.org/pdf/1207.0511.pdf (that figure de-
picts the full Shor’s algorithm; the modular exponentiation is accomplished
by the part with controlled modular multiplier gates between the H ⌦n and
inverse QFT). Firstly note that in going from modular multipliers to con-
trolled modular multipliers the circuit complexity is still of the same order
(as you have seen in the quantum circuits lecture, it is simple to go from uni-
taries to controlled unitaries). So each of the controlled modular multipliers
require O(n2 ) operations. However, there are n such controlled modular mul-
tipliers, one for each factor of the above expression for ax mod N , so totally
O(n3 ) operations to achieve a black-box circuit (say, a bit query black box)
for computing f (x) = ax mod N .

5
4 Shor’s Algorithm 1995
As we have explained above, Shor’s algorithm operates by first converting the
number theoretic porblem of factorizing a large number N into two primes
to choosing a number a = 2, ..., N 1 coprime with N and finding the period
(or order) r of a function f (x) = ax mod N . This function is monotonic
inside each period as you would have seen in the exercise example above.
It classically a hard task as after one has found f (x0 ), he/she has to find a
f (x0 + r) among an exponentially large number of possibilities.
From here on, we will thus think of the problem as one of finding the
period r of a function defined over a large domain. We may draw intuition
from the fact that quantum mechanics of a single particle acomplishes Fourier
transforms quite naturally. For a freely propagating particle, position kets
becomes their quantum fourier transforms (momentum kets) in infinite time.
Thus imagine the output of a di↵raction grating with slits separated by an
unknown distance r. This is a superposition of equally position separated
slits |x0 i + |x0 + ri + |x0 + 2ri + ... +↵|x0 + (N 1)ri, which is, in turn, a
superposition of momenta states m Nr (m = 0, 1, .., N 1). Unfortunately,
if you think of the position basis as the analog of the computational basis
(we generally always measure positions!), you cannot measure any of the
above momenta states to find m Nr directly. At a far distance from the slits,
after the quantum fourier transform, these momenta states are converted
to position states. You can then simply measure them to find m Nr and,
knowing N , deduce r from it. This is exactly how the Shor’s algorithm
works, albeit, the position basis, which is not exponentially large, is replaced
by the exponentially large computational basis, and the QFT on a perodic
superposition as above is accomplished by the circuit of Fig.1.
Let us now discuss Shor’s algorithm for period/order finding below.

Given: A function f (x) is defined on x 2 {0, 1}n = {0, 1, ..., N 1}(N =

2n ) such that f (x + r) = f (x) and f (x) is monotonic within each period.
We do not need to specify the range of f (x) (assuming a large enough quan-
tum register is available to hold its value outputted by a quantum black-
box), although, for the specific application of factoring f (x) = ax mod N 2
{0, 1, ..., N 1}.

Task: Find r.

Classical Algorithm: We consider the cases when r is itself large O(2p ),

where p is a large number < n – otherwise even a classical algorithm is easy.
We use a classical black-box to compute f (x) for various x chosen randomly
or in some sequence till we get a match f (x0 ) = f (x0 + r). Essentially x has
to be searched an average over half of the period r to obtain a coincidence
of values of f (x).
Quantum Algorithm: As in Simon’s algorithm, this requires 2 registers
(collections of qubits) and a BQBB for evaluating f (x). The first register is
in the usual starting state of quantum algorithms (as generated by H ⌦n on

6
 P 1
the qubit state |00...0i) | i = p1N N x=0 |xi, while the second register (also
n-bit long) is in the state |0i = |00...0i. Then the algorithm proceeds as
follows:
N 1 N 1
1 X BQBB evaluating f (x) 1 X
p |xi|0i !p |xi|f (x)i
N x=0 N x=0
Measure 2nd register to find f (x = x0 ) 1 N
!p (|x0 i+|x0 +ri+...+|x0 +( 1)ri)|f (x0 )i.
State re-normalized after Meas. N/r r
Then,
1 N QFT circuit applying F to first register
p (|x0 i + |x0 + ri + ... + |x0 + ( 1)ri) !
N/r r

N 1
1 X i 2⇡ x0 k
1 2⇡ 2⇡ N
= | final i = p p {e N + ei N {x0 +r}k + ... + ei N {x0 +( r 1)r}k
}|ki
N/r N k=0
p N 1
N
1
r X i 2⇡ x0 k Xr
2⇡
= e N { ei N lrk } |ki
N k=0 l=0
r 1
1 X N
=p m .
r m=0 r

The identity used in the last step can be understood by considering k = m Nr

in the sum
N N N
1 1 1
X
r
2⇡
X
r
2⇡ N
X
r
N
i N lrk i N lr r
e = e = ei2⇡l = .
l=0 l=0 l=0
r

As there r states of the form k = m Nr (with m = 0, 1, .., r 1), each with

amplitude p1r in | final i, they make up all the amplitude of the state, so that
the amplitude of all k 6= m Nr in | final i is zero.
Thus now by measuring the first register we find a value of m Nr with a
random m = 0, .., r 1. As we know N , running the algorithm just a few
times, it is possible to deduce r from this.

Speedup Only a few repeat runs of the quantum algorithm, each requir-
ing one QFT (O(n2 ) gates) and one query to the BQBB (O(n3 ) gates), it has
been possible to find r. In the classical algorithm about O(r) = O(2p ) appli-
cations of the function evaluating black-box will be required. Thus there is
an exponential speedup.

5 Quantum Phase Estimation

Another classic application of QFT is quantum phase estimation or eigen-
value estimation. Given any unitary matrix U with an eigenstate | i such
that
U | i = ei | i ,

7
we can use QFT to estimate to any desired precision. A phase is define
modulo 2⇡. Suppose we want to estimate the phase to a precision 2⇡/N (in
units of 2⇡/N ), where N = 2n is very large. Say, in these units, = 2⇡ N
j,
where di↵erent values of are given for di↵erent j = 0, .., N 1. Then, we
P first
run a circuit on a register of n qubits prepared in the state | i = p1N k |ki
l
with several controlled unitaries CU 2 (with l = 0, 1, ..n) going from the
qubits of this register to a second target register. Let us call the Unitary
enacted by this circuit as V . After providing enough hints in the problem,
designing the circuit for V will be given as a problem in problem sheet 3 such
that it performs
V
| i | i ! | ( )i | i
where
N 1
1 X i k
| ( )i = p e |ki .
N k=0
Once V is accomplished, we use the inverse quantum Fourier transform op-
erator F † on the first register. From the definition of F given in the last
lecture, and substituting = 2⇡ N
j we get

F † | ( )i = |ji .

By measuring j we can determine = 2⇡ N

j. As far as quantum metrology
is concerned, here we say that we have Heisenberg scaling ⇠ N1 , as N = 2n
n
is the proportion of time devoted to implementing CU 2 , instead of classical
shot noise scaling, which scales with ⇠ p1N .
In general, we may not, have in our disposal, an exact eigenstate of U .
Then the whole algorithm runs in a superposition over multiple eigenstates
| m i of U and, in the end, any one of the eigenvalues are obtained when the
first register is measured.
X V
X
| i cm | m i ! cm | ( m )i | m i .
m m

X F † on first register
X
cm | ( m )i | mi ! cm |jm i | mi .
m m

Thus by measuring di↵erent jm values, di↵erent eignevalues m can be in-

ferred. In the simulation of quantum Hamiltonians, if U = e iHt (the efficient
implementation of U is an entirely di↵erent problem, called Hamiltonian sim-
ulation, to which we are not going), then di↵erent eigenvalues Em = m /t
can be inferred. If variationally we try to prepare the lowest energy state,
2⇡
this energy can be read out to a high precision ⇠ N t
.

8
 Decoherence – The main enemy of Quantum
Computation
Sougato Bose
March 10, 2021

As we noted at the very start of discussing quantum algorithms, and

also explicitly when we read these algorithms, that imparting relative phases
between computational basis states and maintaining the information of these
phases on the states is crucial for quantum information processing. However,
no quantum system in the world is truly isolated and the system interacts
and becomes entangled with its environment. In these cases the phase is
encoded in the joint state of the system and ceases to be retrievable from
the reduced density matrix of the system alone. This phenomenon is called
quantum decoherence. We will illustrate this phenomenon with help of a
specific toy model below.

1 Central Qubit in a spin bath model

We consider a central qubit Q, which is part of our quantum informa-
tion processing device, interacting with a bath/environment of n inaccessi-
ble/unobservable qubits as shown in Fig.1. To have a clear distinction of ter-
minology, we are going to refer to Q as the qubit and the environmental qubits
as spins (such a bath can be called a spin bath). The bath/environmental
spins are labelled E1 , E2 , ..., En and each of them interact with the central
qubit with strength gj via an Ising Hamiltonian

HQ,j = gj ZQ ⌦ Zj ,

where Zj is the Z operator of qubit Ej . The total Hamiltonian acting on the

system is thus X
H= HQ,j .
j

Consider the initial state of the qubit to be

1
| (0)iQ = p (|0iQ + ei |1iQ ),
2
where a phase is present in the state. This phase can be extracted by
measurements in appropriate bases. Note that the density matrix for the

1
 E6

g6 E1
g5
E5 g1
Q g2
g3 E2
g4
E4 E3
Figure 1: A central qubit in a spin bath.

above state of Q is
1 1 e i ei
⇢Q (0) = |0i h0|Q + |1i h1|Q + |0i h1|Q + |0i h1|Q ,
2 2 2 2
from which the phase is fully retrievable. We can say that can be read o↵
from the o↵-diagonal terms in the density matrix. Let us assume the bath
spins to be initially in the state
n
Y
|⇠(0)iE1 E2 ...En = |+iEj .
j=1

The initial joint state of Q and its environment is thus

Yn
1
| (0)iQE1 E2 ...En = p (|0iQ + ei |1iQ ) |+iEj .
2 j=1

To find the evolution of the above state under H, note that

HQ,j |0iQ |0iEj = gj |0iQ |0iEj ,

HQ,j |0iQ |1iEj = gj |0iQ |1iEj ,

HQ,j |1iQ |0iEj = gj |1iQ |0iEj ,
HQ,j |1iQ |1iEj = gj |1iQ |1iEj .

2
Thus, final state of the joint system
iHt
| (t)iQE1 E2 ...En = e | (0)iQE1 E2 ...En

Yn
1 1 igj t
= p |0iQ p (e |0iEj + eigj t |1iEj )
2 j=1
2
Yn
ei 1
+ p |1iQ p (eigj t |0iEj + e igj t
|1iEj )
2 j=1
2
1
= p (|0iQ |⇠0 (t)iE1 E2 ...En + ei |1iQ |⇠1 (t)iE1 E2 ...En ),
2
where we have defined
Yn
1 igj t
|⇠0 (t)iE1 E2 ...En = p (e |0iEj + eigj t |1iEj ),
j=1
2

Yn
1
|⇠1 (t)iE1 E2 ...En = p (eigj t |0iEj + e igj t
|1iEj ).
j=1
2
Note that as |⇠0 (t)iE1 E2 ...En 6= |⇠1 (t)iE1 E2 ...En , the state | (t)iQE1 E2 ...En is not
factorizable between the qubit and its environment. Thus, due to the Ising
interaction, the qubit has become entangled with its environment. This en-
tanglement leads to the phenomenon of decoherence. From earlier lectures
on reduced density matrices, you would thus immediately note (do this ex-
ercise by yourself and verify) that the reduced density matrix of the qubit at
a time t is
1 1 e i ei
⇢Q (t) = |0i h0|Q + |1i h1|Q + |0i h1|Q h⇠1 (t)|⇠0 (t)i+ |0i h1|Q h⇠0 (t)|⇠1 (t)i.
2 2 2 2

Exercise .1
Qn
2igj t 2igj t Qn
Show that h⇠0 (t)|⇠1 (t)i = j=1 e +e 2
= j=1 cos 2gj t.
Thus is matrix form, the density matrix is given by
" Qn #
ei
1 1 2 j=1 cos 2g j t
⇢Q (t) = i Qn .
2 e2 j=1 cos 2g j t 1

Now let us examine the behaviour of the o↵ diagonal terms of the density
matrix. If there was a single environmental spin (n = 1), the o↵-diagonal
terms of the density matrix would initially decrease in magnitude as a cosine
with time, and become zero at t = 4g⇡1 t . Thus at this particular instant of
time, the density matrix has lost all its information about as ⇢Q (t = 4g⇡1 t )
has no in its expression! However, this single environmental spin case is
not a true decoherence, as the o↵ diagonal terms containing start reviving
as soon as t increases, reaching the original magnitude again at t = 2g⇡1 t ,
albeit becoming negative. However, for very large n, the magnitude of the

3
o↵ diagonal terms of the density matrix are less that 12 for any general time
t 6= 0 as long as the interaction strengths gj are incommensurate (they cannot
all revive at the same time!) and quite uniformly and densely distributed.
Moreover, the o↵ diagonal terms, being a product of many cosines of incom-
⇡
mensurate frequencies, are typically very small after t 4gj t
for the fastest
frequency gj . As t ! 1, it is unlikely that at any instant of time all of
the cos 2gj t terms will become large enough to give a significant non-zero o↵-
diagonal term – for several frequency/frequencies they will remain very small
(including exactly zero for some), and moreover, it is a product of several
such terms. So we can safely say,
" # 
1 ei 1
1 t!1 1 0
⇢Q (0) = e i
2 ! ⇢Q (t) = .
2 2
1 2 0 1
The above phenomenon of the o↵-diagonal terms going to zero is called de-
coherence. Note that has completely disappeared from the state – so any
quantum algorithm with a problem encoded in for example, or the di↵er-
ence between the states |+i ( = 0) and | i ( = ⇡) in QKD for example, or
the di↵erence between | + i and | i in quantum dense coding or teleporta-
tion for example, will not work any more. Decoherence is thus the principal
enemy of quantum information processing.

Exercise .2
Repeat the above
Qn calculations for environmental spins in the initial states
⇢(0)E1 E2 ...E n = j=1 (|0i h0|Ej + |1i h1|Ej ), which can be thought of as an
infinite temperature state of the environment. Give a clever logic as to why the
calculations give exactly the same result as in the case we have considered above.

2 Realistic environments, Markovianity and

Non-Markovianity
While our toy model illustrates the essential features of decoherence, it is
worth pointing out ways in which realistic environments will di↵er. Firstly,
the environmental spins may have self Hamiltonians acting on them HEj =
⌦j XEj terms for example, which do not commute with the Hamiltonian con-
sidered. The interactions may also have more than one term, such as the
Heisenberg model H = gj (XQ ⌦ XEj + YQ ⌦ YEj + ZQ ⌦ ZEj ) instead of
the Ising model. Moreover the spins may interact among themselves with
interaction strengths gij XEi ⌦ XEj , for example. Such new frequencies ⌦j
and gij in the system and new non-commuting terms, inroduce even more
incommensuracies and make it generically even more impossible for the den-
sity matrix to revive the o↵-diagonal terms. The environment may also have
a finite temperature and may, in fact, be a bath of quantum harmonic os-
cillators rather than a bath of spins. The latter is the situation when one
describes the interaction of a qubit with a phonon bath, for example.
The type of environment we have considered is realistic (except for some

4
neglected interaction terms) when the environment itself is well isolated from
its surroundings, such as the nuclear spin bath of an electronic spin in a
nanocrystal – a realistic initial state of the environment is that of the exer-
cise problem rather than the case we have worked out above. Here the phase
information is contained in the qubit-environment system under considera-
tion, and not leaked out to a larger environment outside – the considered
environment is hardly interacting with its wider environment outside over
the time scales considered. Such an environment is an example of a non-
Markovian environment. In our model, for example, at short times, the o↵
diagonal terms decay as
n
Y n
Y Pn
t!0 2 2 2
cos 2gj t ! (1 2gj2 t2 ) ⇠ e j=1 gj t .
j=1 j=1

Such Gaussian decay in time at the start is regarded as a non-Markovian

behaviour.
Most importantly, typically, the considered environment of spins also in-
teracts with further (their own environments). In many systems it is a good
approximation to regard the evolution as described by our model only hap-
pens for a very short interval of time t at the end of which the state of the
environment of spins is instantly swapped out to their larger outside envi-
ronment from which it never comes back, while our environment is instantly
refreshed to its starting state (which in our model was |+i⌦n ). So it is same
as a new identical environment getting entangled with qubit Q at each short
t interval with the previous environment having escaped to infinity – not
interacting with Q any more. When t is so small that the environment
instantly refreshed as far as the time-scales over which we can measure are
concenrned, we call the environment a Markovian environment. Thus in m
steps of t (a total time t = m t) the o↵ diagonal terms will decay as
Pn 2
2 j=1 gj ( t)2 m
(h⇠0 ( t)|⇠1 ( t)i)m = e =e t
,
Pn 2
with = j=1 gj ( t). The above exponential decay of the o↵-diagonal
terms is the hallmark of Markovian environments in which the density matrix
evolves as " #
1 e t ei
1 2
⇢Q (t) = e te i .
2 2
1

3 Dynamical decoupling on non-Markovian

environments
There is a clever way to protect a qubit in the type of non-Markovian en-
vironment we considered – the refreshing time of the environment is long
enough for us to do measurements and control on the qubit. In our toy
model, for example, we can perfectly get back the information of in our
density matrix at time 2t by flipping the state of Q (acting with XQ on it)
at time t!

5
 Exercise .3
Show that ⇢Q (2t) = ⇢Q (0) in the toy qubit-environment model studied by us
if at time t an operation XQ is applied to Q.
The above procedure is called dynamical decoupling and is widely used in
preventing dephasing (the type of decoherence considered here, where phase
information is lost) in various qubits. Repeated pulses are given at regular
intervals to delay the dephasing. In contrast to our toy model, realistically,
the dephasing can only be delayed and not perfectly reversed as informa-
tion still gradually leaks from our environment of spins directly interacting
with the qubit to their own wider environments and, additionally the actions
of noncommuting terms in the environmental spins, including their interac-
tions with each other, make even a partial cancellation more difficult as time
progresses.

4 Markovian decoherence and quantum chan-

nels

Exercise .4
Show that for Markovian decoherence as described above,
t t
1+e 1 e
⇢Q (t) = ⇢Q (0) + ZQ ⇢Q (0)ZQ
2 2
.
The above result has implications on how to treat decoherence on a qubit
in a discrete way. We say that at any time (or in any process that takes
some time, such as a quantum gate or the propagation of a qubit through
a quantum channel or a qubit simply sitting in a memory) the process of
dephasing can be described in terms of probabilities of a “phase flip” (the
application of a ZQ operator). System evolves as
⇢Q ! (1 P )⇢Q + P ZQ ⇢Q ZQ .
The above is said to be the action of a phase-flip quantum channel on a
qubit. While we had a model with ZQ ZEj interactions, it is easy to imagine
a model with other interactions e.g., XQ XEj , YQ YEj etc. Thus we also have
the possibilities of a “bit-flip” channel
⇢Q ! (1 P )⇢Q + P XQ ⇢Q XQ ,
and both bit and phase flip combined channel
⇢Q ! (1 P )⇢Q + P YQ ⇢Q YQ .
When a polarized photon encoding a qubit passes through a fiber, all the
above 3 processes could occur with equal probabilities. We then say that we
have a depolarizing channel given by
P
⇢Q ! (1 P )⇢Q + (XQ ⇢Q XQ + YQ ⇢Q YQ + ZQ ⇢Q ZQ ).
3
6
How to counter such forms of decoherence when it is a↵ecting quantum com-
munication, was discussed when we studied entanglement distillation. How
to counter such decoherence in a general setting in any quantum information
process, particularly quantum computation, is called quantum error correc-
tion, which will be discussed in the next lecture.

7
 Quantum Error Correction
Sougato Bose
March 16, 2021

From the decoherence example of the previous lecture, it is evident that

various possible errors can occur to a qubit with various probabilities when
its inaccessible/uncontrollable environment interacts with it. Even if you
isolate your qubit so well that these errors are very small, they would accu-
mulate in large scale (long circuit depth – many gates in succession quantum
circuits) quantum computation and make it unfeasible. The task of quantum
error correction is to fight this. It is accomplished by building in redundancy.
Instead of using a single physical system (such as a single spin) as a qubit, we
now encode a single qubit (which we now call a logical qubit) into multiple
physical qubits, so that if any error takes place on a certain number of phys-
ical qubits, it can be ascertained and corrected. Several researchers thought,
in the early days of quantum computing, that such a quantum error correc-
tion is impossible because of the continuous (analog) nature of the variables
describing general quantum states (e.g., ✓ and for a single physical qubit).
0 0
How will you correct, if ✓ became ✓ and became ? Yet it is a wonderful
fact that quantum errors are still digital (only of 3 possible types for each
qubit), and this is exploited to design quantum error correction codes. In-
deed, the first quantum error correction code by Peter Shor (yes, Shor again!)
in 1995, was really a surprise to many. Fundamentally, it is very interesting,
and counterintuitive (till you see it) indeed that quantum mechanics permits
the correction of arbitrary errors. Practically, it keeps the prospects of future
large scale quantum computation alive, once the isolation improves enough
(errors get below a certain threshold).

1 The digital nature of quantum errors

In the last lecture, we only saw specific instances of system-environment
dynamics. Let us thus first see what can happen in the most general instance
of a quantum system interacting with its environment.
Xp
| iQ |⇠iE ! Pk ei✓k | k iQ |⇠k iE
k
Xp
= Pk ei✓k U (k)Q | iQ |⇠k iE ,
k
where in the upper equation, we have written the right hand side with com-
plete generality in terms of a set of orthogonal states |⇠k iE of the environment.

1
To clarify, we just choose an orthogonal basis of the environment |⇠k i and
write the joint state of Q and E in terms of them by taking them out as com-
mon factors and grouping the states of Q that correspond to them. These
states of Q corresponding to each |⇠k i are then normalized (these represent
states | k i, p
which are, in general, non-orthogonal) so as to yield appropriate
amplitudes Pk ei✓k . In the lower equation, we have then introduced unitary
matrices U (k) which map the normalized state | iQ to the various normal-
ized states | k i (i.e., U (k) | iQ = | k i). Thinking about the system only (as
the environment is inaccessible) the above evolution can be written in terms
of the reduced density matrix of the qubit as follows
X
⇢Q = | i h | Q ! Pk U (k)Q ⇢Q U (k)†Q .
k

An alternate way of stating the above evolution of a qubit in an environment

is

With probability Pk , the unitary operator U (k)Q acts on the qubit Q.

As each U (k) can be completely arbitrary for arbitrary environments, and

characterized by continuous parameters, it may lead you to thinking that
correcting their random applications to be impossible. Fortunately, for any
2 ⇥ 2 unitary U ,

i↵ a b
U =e ⇤ = ei↵ {iIm(a)1 + Re(b)X + Re(a)Z + iIm(b)XZ}.
b a⇤

Thus any unitary error can be thought of di↵erent as a combination of no

error 1, a bit-flip error X, a phase-flip error Z and a bit and phase-flip
error XZ with di↵erent complex amplitudes. If one can devise a clever
scheme of performing a measurement which detects “which” of the above
four possible occurences happened, then one can correct it. However, you
would immediately react that the measurement will collapse the state to some
state in which the original quantum superposition state that we were trying
to protect is disturbed. Indeed with a single physical qubit that is the case
(by a single physical qubit we mean systems such as a single spin or single
atom). However, this problem can be solved for logical qubits, if we encode
logical qubit states |0L i12...n and |1L i12...n as a state of many physical qubits
1, 2, ...n. Then the detection of errors (via a syndrome measurement) and its
correction can take place schematically as follows (assuming a certain U (k)
to have acted on one of the physical qubits, and one of the possible error
syndromes detected in the measurement):
Unknown Error U (k)j on jth qubit
↵ |0L i12...n + |1L i12...n !
↵U (k)j |0L i12...n + U (k)j |1L i12...n
Syndrome Measurement, Outcome Xj
! Xj ↵ |0L i12...n + Xj |1L i12...n
Application of Xj
! ↵ |0L i12...n + |1L i12...n .

2
Of course, you require convincing that the above type of syndrome measure-
ment, collapsing a state to something such as the outcome Xj ↵ |0L i12...n +
Xj |1L i12...n , in which the information inherent in the quantum state in
terms of ↵ and is still preserved, is possible. For that it is best to see
an explicit example of a quantum error correcting code – an explicit exam-
ple of |0L i12...n and |1L i12...n with the accompanying syndrome measurement
strategies.

2 Shor’s 9 qubit code

The encoded states in Shor’s 9 qubit code, which corrects for one qubit errors,
are given by (we have suppressed below the physical qubit indices 1, 2, ..9 –
it is understood that they are there):
1 1 1
|0L i = p (|000i + |111i) p (|000i + |111i) p (|000i + |111i),
3 3 3
1 1 1
|1L i = p (|000i |111i) p (|000i |111i) p (|000i |111i).
3 3 3
If you remember the GHZ state from an earlier lecture, the above are 3
repetitions of them. How, if given a single physical qubit in an arbitrary
state ↵ |0i1 + |1i1 can be converted to a logical state ↵ |0L i + |1L i encoded
in 9 qubits via a quantum circuit is given in Fig.1.

Exercise .1
Show that the circuit of Fig.1 converts |0i1 to |0L i and |1i1 to |1L i, from
which is follows that it will convert ↵ |0i1 + |1i1 to ↵ |0L i + |1L i.
In essence, the code is constructed as above so that a single bit flip error
can be detected via a majority voting among changes to |000i and |111i,
while a single phase flip error can be detected via a majority voting among
the phases ±1 between |000i and |111i in the 3 brackets. Thus the syndrome
measuring operators are

M (1) = Z1 Z2 , M (2) = Z2 Z3 , M (3) = Z4 Z5 ,

M (4) = Z5 Z6 , M (5) = Z7 Z8 , M (6) = Z8 Z9 ,

M (7) = X1 X2 X3 X4 X5 X6 , M (8) = X4 X5 X6 X7 X8 X9 ,
with M (1) M (6) operators measuring for bit flip errors and the last 2 oper-
ators measuring for the phase flip errors.

Exercise .2
Verify that |0L i and |1L i, and hence ↵ |0L i + |1L i are eigenstates of M (j)
with eigenvalues +1.
Let us check directly the action assuming a bit-flip error on the 5th phys-
ical qubit (X5 )

3
α 0 +β 1 H

0 X

0 X
0 X H

0 X α 0 L + β 1L

0
X
0 X H

0 X

0 X

Figure 1: Encoding circuit for the Shor 9 qubit code.

4
 X5 (↵ |0L i+ |1L i) = ↵ p13 (|000i+|111i) p13 (|010i+|101i) p13 (|000i+|111i),

1 1 1
+ p (|000i |111i) p (|010i |101i) p (|000i |111i).
3 3 3
Using the right hand side of the above equation, we find

M (1) X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),

M (2) X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),

M (3) X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),
(4)
M X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),
(5)
M X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),
(6)
M X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),
(7)
M X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i),
(8)
M X5 (↵ |0L i + |1L i) = X5 (↵ |0L i + |1L i).
In other words, X5 (↵ |0L i + |1L i) is still an eigenstate the syndrome oper-
ators M (j) except for the fact that M (3) and M (4) eigenvalues are now 1.
M (3) = Z4 Z5 compares whether the 4th and 5th qubits are both in the same
computational state, if they are, then M (3) gives eigenvalue +1, if they are
not, it gives eigenvalue 1. Likewise M (4) = Z5 Z6 compares whether the
5th and 6th qubits are both in the same computational state. Thus if both
M (3) and M (4) are 1, then it must be that the 5th qubit has been flipped
to mismatch with both the 4th and the 6th. The error is thus identified to
be X5 . We then apply X5 to correct

X5 {X5 (↵ |0L i + |1L i)} = ↵ |0L i + |1L i .

Now consider a phase flip error on the 7th qubit (Z7 ). Then, it is easy to
verify that
M (1) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (2) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (3) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (4) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (5) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (6) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (7) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i),
M (8) Z7 (↵ |0L i + |1L i) = Z7 (↵ |0L i + |1L i).
Thus a 1 eigenvalue of M (8) only (+1 for all the other syndrome operators)
indicates that the error was either Z7 or Z8 or Z9 . Either of these operators,
say, Z8 can be then applied to correct the state

Z8 {Z7 (↵ |0L i + |1L i)} = ↵ |0L i + |1L i .

5
 Exercise .3
Find the combination of syndrome operator M (j) eigenvalues to detect a X3
and a X6 Z6 error, and which operators can be applied to correct these errors.
We have shown above that the eigenvalues of the syndrome operators can
help you identify the specific error. But how does one actually measure these
eigenvalues without destroying the state? For example, measuring (say, by
a Stern-Gerlach for physical qubits which are spins) Z1 would immediately
collapse the first bracket of a no-error encoded state to |000i or |111i. In
the next section we thus speak in a more general manner as to how one can
measure syndrome operator eigenvalues without destroying the eigenstate.
But before moving to that issue, let us exemplify how single qubit quan-
tum unitary operations can be done on the encoded states. For this we choose
simply the logical Z and X operators, denoted by ZL and XL respectively.

Exercise .4
Show that for XL = Z1 Z2 Z3 Z4 Z5 Z6 Z7 Z8 Z9 and ZL = X1 X2 X3 X4 X5 X6 X7 X8 X9 ,

XL |0L i = |1iL , XL |1L i = |0iL , ZL |0L i = |0iL , ZL |1L i = |1iL .

As the Shor code correct for only single qubit errors, it is worth consid-
ering the probability p of single qubit errors below which the code will be
useful, i.e., the probability for it to fail to correct is very small. The proba-
bility of no errors is (1 p)9 , while the probability that single qubit errors
occur and are corrected is 9p(1 p)8 . Thus the probability for the code to
fail is (to the second order in a small p)

1 (1 p)9 9p(1 p)8 ⇠ 36p2 .

Thus p << 1/6 ensures that the probability of failure is low.

3 Circuit for Syndrome Measurements

Bearing in mind the example of the Shor code, consider an operator Z1 Z2 with
eigenstates | L i with only two possibilities for eigenvalues, namely = +1
or = 1. How to measure this operator while keeping its eigenstate | L i
intact is given by Fig.2 in terms of an ancillary qubit A. To understand that
consider its evolution

HA 1
|0iA | Li ! p (|0iA + |1iA ) | Li
2
CZA,2 CZA,1 1
! p (|0iA | Li + |1iA Z1 Z2 | L i)
2
1 1
= p (|0iA | Li + |1iA | L i) = p (|0iA + |1iA ) | Li
2 2
HA
! |0iA | Li for = +1, |1iA | Li for = 1.

6
 0 H H 0 A if Z1Z 2 = +1
A

1 A if Z1Z 2 = −1

Z
Z

ψL ψL

Figure 2: Quantum circuit for the detection of Z1 Z2 syndrome.

Thus by measuring the ancillary qubit A, we can measure the eigenvalue of

Z1 Z2 in its given eigenstate | L i without destroying the eigenstate.
Even if we use some other quantum error correction code (we will study
a few in the next sections) the above technique works as the eigenstate | L i
above has been generally defined – we did not use any explicit form. Only
the promise of the eigenvalues being ±1 was used. Moreover the syndrome
operators may not be the same. For example, for the Shor code itself we want
to measure other types of syndrome operators such as X1 X2 X2 X4 X5 X6 . In
the case of X1 X2 X2 X4 X5 X6 CNOTs should be used in place of the CZs of
our circuit, and 6 CNOTs should go to the first 6 physical qubits with the
ancillary qubit as control. In general, for measuring the eigenvalue of a string
of Xs and Zs constituting a syndrome operator, with an ancillary qubit as
control, a CNOT is used for each X and a CZ is used for each Z.

4 Minimum length of a quantum error cor-

rection code
We may wonder, given that the Shor code uses 9 physical qubits, what is
the minimum number of physical qubits needed to make a quantum error
correcting code. Of course, the length required depends on how many errors
we want to correct. In the case when we want to correct all possible single
qubit errors, this length turns out to be 5 because of the followig argument.
Firstly, let us assume the criterion that we require the state of the system to
be fully distinguishable for each of the errors so that they can be identified
and corrected. Moreover, note that the number of possible errors on each

7
physical qubit is 3 (X, Z and XZ), implying a total of 3n errors for n qubits.
Additionally there have to be a no error state. All these have to be doubled
up as we have both |0L i and |1L i. All these states have to be accomodable in
the total Hilbert space of n qubits. Thus the minimum number of physical
qubits n required for a code correcting any single qubit error is given by the
criterion
2(3n + 1)  2n .
As you can easily check, the above criterion is not satisfied for either of
n = 2, 3, 4. It is satisfied for n = 5, and indeed a 5 qubit code exists! We
will discuss this next.

5 Stabilizer language and the 5 qubit code

For most quantum codes, especially as they get larger in terms of physical
qubits, it becomes more and more difficult to really write down explicitly
their states – the number of computational basis kets that you have to write
down gets enormous. Even for smaller codes it might be difficult to re-
member a complicated entangled state of physical qubits which an encoded
state generally is. It is far easier to remember the syndrome measurement
operators. For some codes, called the stabilizer codes, that is all you have
to remember, and the code can be written down from that information, if
needed – although we can refrain from explicitly writing down the encoded
logical states. The 5 qubit code is such a stabilizer code, and thereby we will
start by writing down its syndrome measurement operators which are called
the stabilizer generators

M (1) = XZZXI, M (2) = IXZZX, M (3) = XIXZZ, M (4) = ZXIXZ.

It is very easy to remeber the above stabilizer generators as they are cyclic
permutations of XZZZI.

Exercise .5
⇥ ⇤
Show that M (j)2 = 1, M (j) , M (k) = 0. Hints: X 2 = Z 2 = 1 and
XZ = ZX (you will have to use this relation twice in each commutation).
In terms of the stabilizer generators, the logical qubit states are given by
1
|0L i = (1 + M (1) )(1 + M (2) )(1 + M (3) )(1 + M (4) ) |00000i ,
16
1
|1L i = (1 + M (1) )(1 + M (2) )(1 + M (3) )(1 + M (4) ) |11111i .
16
As a rule of thumb, given m stabilizer generators of any stabilizer code
with n physical qubits (which are generally easy to remember), the logical
qubit states are given by
m
1 Y
|0L i = p (1 + M (j) ) |0i⌦n ,
m
2 j=1

8
 m
1 Y
|1L i = p (1 + M (j) ) |1i⌦n .
m
2 j=1

Exercise .6
Using the results of the previous exercise and the definition of |0L i and |1L i
show that they are eigenstates of M (j) with eigenvalues +1.
Now, to show the error correction with the 5 qubit code, consider an error
X3 . Now consider the syndrome operator M (1) acting on the state with the
error

M (1) X3 |0L i = X3 M (1) |0L i = X3 |0L i .

In the above, the anticommutation of X3 with M (1) has been used (as
there is a Z operator on the third qubit in M (1) ) has been used in the mid-
dle step. Thus M (1) yields a negative eigenvalue in a state with X3 error.
Similarly, M (2) will yield a negative eigenvalue (it also has a Z operator on
the third qubit), but M (3) and M (4) will yield positive eigenvalues. Thus
M (1) and M (2) being negative identifies the error to be X3 , which can now
be corrected by applying a X3 operator.

Exercise .7
Show that a X1 error can be detected by only M (4) to have 1 eigenvalue,
while Z2 error may be detected by M (3) and M (4) having 1 eigenvalues.
In the same manner as the above exercise, you can show that all possible
single qubit errors can be detected by a combination M (j) attaining negative
eigenvalues.

Exercise .8
Show that XL = X1 X2 X3 X4 X5 and ZL = Z1 Z2 Z3 Z4 Z5 commute with
M (j ). Hence show that XL and ZL are the logical X and Z operators for the 5
qubit code.

6 Transversality for fault-tolerant operation

When we would perform operations (gates) using encoded states, it is impor-
tant that single qubit errors do no multiply to become two qubit errors. Thus
any controlled gates should be going from one physical qubit of one logical
qubit to at most one physical qubit of another logical qubit – a one to one
operation. In this way, if the control physical qubit has an error, it a↵ects
only one physical qubit of the target. If we are using codes that can correct
single qubit errors then this is still fine as this single error in the target logical
qubit can be detected and corrected. This mechanism of implementation is
called transversality. As an example, the transversal operation of a CNOT
between two logical qubits of the Shor code is given in Fig.3. To verify that
the given circuit works, note that H ⌦3 on the state in any of the brackets of
|0L i of the Shor code takes it to a state with an even number of 1s, while

9
 H H
H H
H H
H H
H H
H H
H H
H H
H H
Z
Z
Z
Z
Z
Z
Z
Z
Z
Figure 3: Transversal circuit for the implementation of a CNOT among two
encoded qubits in the Shor 9 qubit code.

it takes the state in any of the brackets of |1L i of the Shor code takes to a
state with an odd number of 1s (verify this fact yourself).
All fault tolerant quantum computation with the kinds of codes discussed
so far takes place by transversal operations so as to prevent the multiplication
of errors.

10
 Quantum Error Correction – Addendum
Sougato Bose
March 17, 2021

1 Fault Tolerant Computation, Concatena-

tion and Threshold
Consider the circuit for a given quantum computation as a series of local
gates, CNOTs etc. The approach towards fault tolerant quantum computa-
tion is to do a gate without error duplication (such as by using transversality)
on encoded qubits (as described, for example, for the CNOT on the Shor code
in the previous part of the lecture) and then do a round of error correction
i.e., syndrome measurements followed by the application of an appropriate
correction operator. Then we proceed to the next gate in the circuit. The
whole approach is schematically shown in Fig.1.
When operating in this fault-tolerant mode, what is the chance of errors
not being corrected? Let us think in term of codes that we have learnt,
namely those that correct single qubit errors. We can use a similar analy-
sis to that presented earlier on when a Shor code works. But that analysis
was based on a Shor code merely staying idle – in a memory state, without
undergoing computation through a circuit. The fault tolerant operation in-
volves several gates (the transversal encoded logic for example, the syndrome
detection and correction gates for example) and each of them are subject to
a single qubit error p. In such cases, as there are more processes in which
an error can occur, the chance of two errors, which cannot be corrected, is
more. If two errors have occurred to one encoded logical qubit, then it is a
failure, as we cannot correct for that.
For example, consider a part of a fault tolerant circuit in which a CNOT
is performed on two qubits encoded in the Shor code, and then syndrome
detection is performed on each of the encoded qubit outputs and corrected.
In the transversal CNOT, a total of 18 Hadamards and 9 CZs are used. Let
us look at the chance of two errors on the control qubit because of this. This
will be 27 C2 p2 = 702p2 ⇠ O(103 p2 ) if each gate has a p probability of error on
a single physical qubit involved in it. Further, in the syndrome detection, 2
CZ gates for each of the bit-flip syndromes and 6 CNOT gates for each of the
phase-flip syndromes are required as per the syndrome measurement method
pointed out earlier (note this is an undercount, as the syndrome measurement
is not transversal – one to one – for the ancillary qubit – one error in the
ancillary qubit can multiply – but for the time being assume a no error

1
 Encoded Encoded
qubit from qubit to the
earlier part of next part
circuit Syndrome of circuit
Detec:on
& Error
Correc:on
Fault Tolerant
(e.g. Transversal)
Gate
Encoded

Encoded
Encoded qubit to the
qubit from next part
Syndrome
earlier part of of circuit
Detec:on
circuit
& Error
Correc:on

Figure 1: Schematic of Fault Tolerant Quantum computation.

operation of the ancillary qubit). This is followed by 9 possible syndrome

correction operations. Thus the probability of 2 errors developing in one of
the encoded qubits (assume perfect ancilla) during the error correction stage
is 33 C2 p2 = 1056p2 ⇠ O(103 p2 ). The above count has been generally an
undercount, as there are many other possibilities for 2 errors to enter one
logical qubit e.g. chances of one error coming in form a previous part of the
circuit and one error developing during this stage of the circuit. In general
one can say that the probability that our error correction methods will not
work in the later stages of the computation by virtue of having two errors in
one logical qubit at the end of this CNOT and syndrome measurement block
is Cp2 with C > 103 . In reality, when everything is taken into account C can
be much larger. For example, for another quantum code (the Steane code),
you can see a full calculation in Nielsen and Chuang, which gives C ⇠ 104 .
The exact number can vary a lot from code to code, circuit to circuit – so
here you just remember that probability of the fault tolerant computation
to fail is ⇠ Cp2 , where C can be a very large number, such as those stated
above, but the details of the exact value of C is not needed (not examinable,
for example).
To perform arbitrarily long fault tolerant quantum computations, we will
need to be able to reduce this probability arbitrarily. This is achieved by
concatenation – replacing the physical qubits by a set of logical qubits and
then replacing the physical qubits at that level by logical qubits again, and
continuing this process. In this way, for the Shor code, for example, at the
kth level of concatenation there are 9k physical qubits. In the k = 2 level of

2
concatenation, when we have taken a logical qubit and replaced each of its
physical qubits by a logical qubit, the chance of a single uncorrected error
in each of those logical qubits is Cp2 –so this now replaces the previous p
as the chance of a single qubit error. Thus at this stage the probability
of uncorrected errors is C(Cp2 )2 = (Cp)4 /C. Continuing likewise, in the
kth stage of concatenation, if we obtain the probability of errors remaining
uncorrected to be
k
(Cp)2 /C,
which can be ensured to be small to any desired level – so that a circuit of any
depth (an arbitrarily long quantum circuit) may be carried out for p < 1/C.
Thus the value of the probability pthresh ⇠ 1/C is called the fault tolerant
threshold. We must reduce errors due to decoherence to lower than pThresh in
order to perform arbitrarily long quantum computations by concatenating a
given code a required number of times.

2 Surface Codes
The syndrome measurement operators, as well as the transversal realization
of quantum gates required very long range gates, such as between ancilla
qubit for syndrome measurement and the physical qubit 9 of a logical qubit.
However, it is difficult to have such long range interactions between distant
qubits (interactions between qubits typically fall o↵ with distance). This mo-
tivates a code which is local in terms of its stabilizer generators. An example
of this is the surface code. The surface code has additional advantages as
will be pointed out shortly. A surface code encoding a single logical qubit
is represented in terms of a 2D grid with physical qubits (filled circles) at
the edges as shown in Fig.2. Its stabilizer generators (i.e., syndrome mea-
surement operators) are labelled in terms of the vertex v they surround or
the plaquette p to which they belong (each square of the grid in the figure
supports a plaquette)

M (v) = XXXX, M (p) = ZZZZ.

Exercise .1
Argue why all the stabilizer generators commute with each other and square
up to the identity. Hints: Again use X 2 = Z 2 = 1 and XZ = ZX for the
first part.

Now we exclude one of the above stabilizers (e.g., the plaquette defined
by grey circles in Fig.2) to define error protected logical states as
nv np
1 Y 1 Y
| Li = p (1 + M (v) ) p (1 + M (p) ) |0i⌦n ,
2nv v=1 2 np p=1,p6=greyed

3
 Z
Z Z
Z

X
X
X
X

Figure 2: A surface code encoding a single logical qubit is shown with physical
qubits at the edges. The product of operators X shown around a given vertex,
and the product of Z operators belonging to a given square (these Zs are said
to form a plaquette) define the stabilizer generators.

4
where n is the number of phsyical qubits, np and nv being the number of
plaquettes and vertices respectively. It is straightforward that all the included
operators will have an eigenvalue +1 in the | L i state. As the excluded
plaquette operator can have ±1 eigenvalue, this corresponds to a doubly
degenerate space – there are two distinct states of the form | L i. A single
logical qubit can thus be encoded in these two degenerate states.
It is easy to check that when a X error occurs on a given physical qubit,
both the plaquette stabilizer generators which overlap with it change their
eignevalue to 1, while if a Z error occurs on a given physical qubit then
the two vertex operators which overlap with it change their eigenvalue to
1. Note that the stabilizer generators are all local as they contain only
4 operators of neighbouring qubits. The stabilizer generators can thus be
measured locally by placing syndrome measuring ancillae (called data qubits)
in each vertex and at the centre of each square.
For your knowledge only (not examinable): Two other advantages of the
surface code are that they can give much higher thresholds pthresh ⇠ 0.1 for
fault tolerant quantum computation. Each stabilizer generator term can be
converted to a Hamiltonian term to describe a many-body system where the
ground state is protected by an energy gap. More qubits can be encoded by
suppressing more of the stabilizer generators.

5
 Physical Implementations of Quantum
Computation I: Generic Qubit-Oscillator
Hamiltonians
Sougato Bose
March 24, 2021

In this lecture, we are going to move on to giving you an idea of how

quantum computation is implemented. So far, just to give you some sort of
handle to a physical understanding I have used spins, and touched upon the
basic idea of how to perform single and two qubits gates, how to measure
qubits, as well as how they decohere when coupled to environments in terms
of spins. Thus we described how magnetic fields can be used to perform sin-
gle qubit gates, Ising interactions were used to perform both CZ gates and
show how a qubit decoheres when coupled to bath, while measurements were
introduced in terms of the Stern-Gerlach e↵ect. However, qubits for quan-
tum computation can be realized in a much wider class of systems (any two
level quantum system is a qubit) as long as we can well isolate and control
them. Particularly, unlike spins in a zero magnetic field, a qubit can have a
fundamental energy di↵erence between its |0i and |1i. For example, if two
atomic energy levels are selected, they have a natural energy di↵erence, while
for superconducting transmon qubits the ground and the first excited state
of an anharmonic oscillator are used as a qubit states. Interactions between
qubits can also be of varied types – they need not be only of Ising type, but
may contain multiple terms in the Hamiltonian. We need to measure other
qubits in ways other than Stern-Gerlach-like methods if the qubits do not
have prominently detectable state dependent movements. Thus this topic
of exactly how a quantum computer with di↵erent types of hardware works
is important to study. At first we will introduce a few basic mathematical
results which are required to understand how qubits are controlled and some
possibilities to make them interact with each other when needed, but not
otherwise. Qubits are typically controlled by subjecting them to classical
elctromagnetic fields of certain frequencies (a classical harmonic oscillator)
and, either, directly couple electromagnetically with each other, or are cou-
pled via a quantized field mode (a quantum harmonic oscillator). To under-
stand how they evolve when coupled to a classical or a quantum harmonic
oscillator, we need to understand how to calculate evolutions of quantum
systems under perturbations.

1
1 Evolution of a quantum system under per-
turbations: the interaction picture and the
Dyson series
Consider the evolution of a quantum system under a Hamiltonian
H = H0 + V (t),
where H0 is a time-independent dominant part of the Hamiltonian and V (t)
is a perturbation, which may be time dependent. The ket in the standard
Schroedinger equation, which we will label as | S (t)i then follows
@| S (t)i
i = H | S (t)i ,
@t
where frequency units have been used for H (we have taken h̄ = 1). If we
define the interaction picture ket by
| I (t)i = eiH0 t | S (t)i ,

then it follows the equation

@| I (t)i
i = VI (t) | I (t)i ,
@t
in which
VI (t) = eiH0 t V (t)e iH0 t
.
The time evolution operator UI (t) of the interaction picture ket, as defined
by
| I (t)i = UI (t) | I (0)i ,
is then given by (we state without proof) the Dyson series
Z t Z t Z t0
00 00
UI (t, 0) = 1 i VI (t)dt + ( i) 2
dt0 dt VI (t0 )VI (t ) + ....
0 0 0

We will use the above first 3 terms for identifying e↵ective time-independent
Hamiltonians under which systems evolve. That will help us understand
how qubits are controlled and coupled by classical and quantum harmonic
oscillators respectively. Why does it suffice to calculate evolutions in the
interaction picture? In quantum mechanics, we are, in the end, interested
in computing correctly the amplitude of various states |mS i i.e, on hmS | S i.
But hmS | S i = hmI | I i, so that computing the evolution entirely in the
interaction picture suffices.

2 A qubit interacting with a classical har-

monic oscillator: one qubit gates
A Hamiltonian useful in the context of the control of single qubits for oper-
ating single qubit gates is
!0
H = Z + ⌦ cos (!t )X.
2
2
 1
Δ E0 cos(ω t − φ )
Ω ∝ E0 0 Ô 1
ω0
ω

Figure 1: Schematic of a qubit interacting with a classical field.

This is the coupling of a classical harmonic oscillator of frequency ! and a

phase lag to the qubit with a coupling strength parametrized by ⌦ << !0 .
We are discussing this Hamiltonian as, in practice, typically the classical os-
cillator will be a certain mode of frequency ! of the classical electromagnetic
field (such as that from a laser or a microwave), while the coupling depends
on the field strength (electric, magnetic etc) and a variable of the qubit that
couples to it (e.g., electric dipole, quadrupole, magnetic moment etc.). The
situation is depicted in Fig.1, in which the fact that the first term in the
Hamiltonian gives a di↵erence between the energies of the qubit states |0i
and |1i is depicted and the classical field impinging on the qubit is shown
with its frequency ! di↵ering from !0 by a detuning = !0 !. While
we have shown the strength of the field as E0 , it need not be an electric
field, it could also be a magnetic field or indeed other classical fields such
as a strain field, which in turn, couples electromagnetically with the qubit.
The qubit-classical oscillator coupling ⌦ is proportional to both the strength
of the field E0 , as well as the matrix element between states |0i and |1i of
the operator Ô of the qubit (e.g., the operator corresponding to the elec-
tric/magnetic dipole/quadrupole moment variable of the qubit) that couples
to the classical oscillator. We will consider specific cases later when we dis-
cuss specific physical systems, in which the strength ⌦ must be explicitly
written and better justified, as well as the origin of the Z and X operators
with the relevant terms in the Hamiltonian must be justified. As ⌦ << !0 ,
we can use H0 = !20 Z and V = ⌦ cos (!t )X so that defining ± = X ±iY
we get
⌦ i(!t )
VI (t) = (e +e i(!t ) )( + ei!0 t + e i!0 t ) (as eiH0 t + e iH0 t = + ei!0 t ).
4
Considering the first two terms of the Dyson series (the third term, being
even smaller than the second, being neglected), the unitary evolution is then
given by
⌦ i ei(!+!0 )t 1 i ei(! !0 )t 1
UI (t) = 1 i {e ++e
4 i(! + !0 ) i(! !0 )
ei( !+!0 )t 1 ei( ! !0 )t 1
+ei + + ei }
i( ! + !0 ) i( ! !0 )

3
 ⌦ e i t 1 ei t 1
⇡1 i {e i + ei + } (As !0 >> ⌦).
4 i i
Now let us choose ! ⇡ !0 (this is called resonance) so that = |!0 !| ! 0.
Thus t << 1/ for a substantially long time t, during which the above
unitary evolution reduces to
⌦ i
UI (t) = 1 i {e + ei + }t
4
⌦
=1
i (cos X sin Y )t.
2
The above unitary evolution in the interaction picture could thus be regarded
as being generated by the e↵ective Hamiltonian
⌦
VRot = (cos X sin Y ).
2
This Hamiltonian is called a rotating wave approximation of the interaction
picture Hamiltonian VI (t) and often heuristically justified as obtained by
neglecting the fast rotating terms in VI (t). The derivation presented here
using the Dyson series gives a more rigorous justification. It also justifies the
picture of resonance that you might know from before, namely that the right
frequency of a field !, only when it matches the qubit energy separation in
frequency units (!0 ), it drives a transition between the |0i and |1i states in
the strongest possible manner.
It is clear that by choosing (i) resonance, and (ii) the appropriate ,
VRot can be used to implement any rotation in the Bloch-sphere about any
axis in the XY plane, including both X and Y gates and arbitrary rotations
about these axes. Thus arbitrary unitary operations on the qubit are already
possible (remember, that 3 operations about 2 axes in the Bloch sphere suffice
for any SU (2) operation). However, there is also a di↵erent way of performing
the Z operation directly by using a large detuning field satisfying >> ⌦,
but still << !, !0 . In that case, as you can see from the above, the second
term in the Dyson series goes to zero. Thus the third term is the important
one. The unitary evolution thus becomes (setting = 0, and neglecting
⌦/(! + !0 ) << 1 terms)

Z t i t0
⌦ i!t0 i!t0 i!0 t0 i!0 t0 e 1
UI (t) = 1 ( )2 { (e +e )( +e + e )(
4 0 i
t0
ei 1 0
+ + )dt }
i
Z t i t0 i t0
⌦ t0 e 1 i t0 e 1
=1 ( )2 { + e i
+ +e }dt0
4 0 i i
2
⌦ ⌦
=1 i( )2 [ +, ]t (Neglecting 2
terms)
4
⌦2
=1 i Zt.
4
4
 The above unitary is induced by an e↵ective Hamitonian
⌦2
VDet = Z.
4
Thus a Z gate and arbitrary Z rotations of a qubit are possible by ap-
plying, for an appropriate time t, the e↵ective Hamiltonian VDet which arises
by choosing ⌦ << << !, !0 .
The above e↵ective Hamiltonian also gives the condition for no quantum
gate on a given qubit even when a classical harmonic oscillator interacts with
it with a strength ⌦. The condition is to choose such a large detuning
2
such that even this third term of the Dyson series is zero, i.e., ⌦ t << 1
so that for times t satisfying this, essentially no evolution is obtained (the
fourth term onwards in the Dyson series will have even lower contribution
to the evolution than the third term). This condition is needed if there are
several qubits on which a single classical field is incident, but we want only
one of them to undergo a quantum gate. We can then very far detune the
frequency of the field from the energy separations between the states of all
qubits but the given one. On the given one, we fix and appropriately to
have any single qubit gate.

3 Qubits interacting with a quantum harmonic

oscillator: two qubit gates and qubit state
measurements
When a classical mechanical harmonic oscillator (a particle of mass m in a
harmonic well of frequency !) is replaced by a quantum harmonic oscillator,
one replaces its position by the operator x̂ = x (a + a† ), where †
q a, a are
h̄
harmonic oscillator creation/annihilation operators and x = 2m!
is its
ground state position uncertainty. Similarly, when one replaces a classical
field mode oscillator by its quantum counterpart, its field strength E0 is
replaced by Ev (a + a† ) where Ev is the uncertainty in the field when it
is in its ground state (which is called the vacuum state). The coupling
strength g of such an oscillator to a qubit is then dependent on Ev (replacing
the E0 of the classical oscillator) and other appropriate matrix elements of
operators of the qubit. Two of the examples of the coupling of a qubit
to a quantum harmonic oscillator are in: (i) Ion traps – Here the qubit is
coupled to a quantum harmonic oscillator which is a common vibrational
motion of the collective of ions in the ion trap; in this way, by coupling two
qubits to a common oscillator mode, gates can be implemented on them, (ii)
Superconducting qubits – Here two superconducting qubits can be coupled
to the same quantum microwave field mode in a cavity in order to accomplish
gates, as well as to measure the quantum state of the superconducting qubit
via the change in the phase of a microwave field. The total Hamiltonian of a
qubit coupled to a quantum harmonic oscillator is
!0
H = Z + g(ae i!t + a† ei!t )X.
2
5
You can see that you get the same qualitative form for the classical oscillator
by substitution a complex number ampitude |↵|ei for the quantum operator
a and its complex conjugate for a† (⌦ of the previous section can be written
in terms of g|↵| of this section). We set = 0 in this section for simplicity.

Exercise .1
Repeat the calculations of the previous section with H0 = !20 Z and VI =
g(ae i!t + a† ei!t )X for = ! !0 ⇡ 0 and using g << !, !0 , to get, from
the second term of the Dyson series, an e↵ective Hamiltonian

VJCM = g(a + + a† ).

Once you see the above form of VJCM , which is called the Jaynes-Cummings
Hamiltonian, it is easy to interpret it as one inducing a flip-flop process of
energy between the qubit and the oscillator. As the frequencies of the oscil-
lator and the qubit are matched (! ⇡ !0 ), a quanta of energy !0 goes from
oscillator to qubit via a + term while a quanta of energy !0 goes from qubit
to oscillator via a† term.
Now consider the case of is nonzero but still << !, !0 . If you cleverly do
not complete the integration over t0 in the second term of the Dyson series
0
for the terms with e±i t dependence (assuming they would be finite and
remain relevant), but performs the integration over the terms e±i(!+!0 )t and
subsequently neglect these terms as g << !, !0 , you will see that the unitary
evolution can be regarded as being generated by the e↵ective Hamiltonian
i t †
VJCM-Det = g(ei t a + +e a ).

VJCM-Det is called the detuned Jaynes-Cummings Hamiltonian.

3.1 Qubit state measurement by quantum harmonic

oscillator
Next we consider also the case g << << !0 , ! so that the second term
in the Dyson series is very small and we can consider the third term. In
complete analogy with the calculations of the last section leading to VDet , we
find that here the only qualitative di↵erence is that + gets replaced by a +
while gets replaced by a† + so that we have the e↵ective Hamiltonian,
whose qubit-oscillator interaction term (neglecting constant terms and terms
only containing qubit operators) is

VDisp = n̂Z, (using aa† = 1 + a† a)

which is called the dispersive Hamiltonian, in which n̂ = a† a is the number
2
operator of the quantum harmonic oscillator and the strength = 4g . This
dispersive term can be used to make quantum measurements by preparing

6
 P θ (t) = (ω + χ )t for 0 Q

mω m !
δp ~
2
α θ (t) = (ω − χ )t for 1
Q
θ
δx
X
!
~
2mω m

Figure 2: A coherent state and its evolution due to the dispersive interaction
with a qubit.

the quantum harmonic oscillator in a coherent state

X ↵n
|↵|2 /2
|↵i = e p |ni ,
n n!

where |ni are the di↵erent number states of the harmonic oscillator. Coher-
ent states of oscillators are most easily prepared in the laboratory and have
a representation in phase space as a circle about a centre x = 2 x Re(↵), p =
2 p Im(↵) as shown in Fig.2. The ↵coherent state of an isolated oscillator
evolves in time uniformly as |↵|e✓(t) with ✓(t) = !t due to the action of its
own Hamiltonian !n̂. However, as can be understood by applying the Hamil-
tonian VDisp to the coherent state, the rate of evolution of ✓(t) is a↵ected by
the state of the qubit. For the state |0iQ of the qubit it is ✓(t) = (! + )t,
while for the qubit in the state |1iQ it is ✓(t) = (! )t (we have introduced
the qubit label Q here to di↵erentiate from oscillator number states). Thus,
after some time measuring the position/momentum of the oscillator, one can
deduce whether the qubit was in the state |0iQ or |1iQ . Such a measurement
is called a quantum non-demolition measurment as the computational basis
states of the qubit are una↵ected. In case when a qubit is coupled to a quan-
tum electromagnetic field oscillator, the position/momentum get replaced by
electric/magnetic fields (these measurements are equivalent to determining
how much the phase of the field has changed). So the appropriate variable
of the field can be measured to determine the ✓ and thereby the qubit state.
This method is used to measure the state of a superconducting qubit by

7
allowing it to shift the phase of a quantum microwave field coupled to it.

3.2 Two qubit gates via quantum harmonic oscillator

bus
(1) (2)
Now we consider two qubits 1 and 2 interacting via VJCM-Det and VJCM-Det with
the same harmonic oscillator, but with equal detunings 1 = 2 = !0 ! >>
g (1) , g (2) . The second term in the Dyson series thereby becomes negligible,
but the unitary evolution up to the third term (not writing individual qubit
terms and single-qubit oscillator terms) is

Z t Z t0
(1) (2) (1) 00 (2) 00 00 0
UI (t) = 1 (VJCM-Det (t0 )+VJCM-Det (t0 )) (VJCM-Det (t )+VJCM-Det (t ))dt dt
0 0

g (1) g (2) (1) (2) (1) (2)

=1 i ( + + + )t + ... (using [a, a] = 1)

The two qubit interaction part is thus described by the e↵ective Hamiltonian

g (1) g (2) (1) (2) (1) (2) 2g (1) g (2)

VFlip-flop = ( + + + ) = (X (1) X (2) + Y (1) Y (2) ).

Because of the last form is is also sometimes called a XY Hamiltonian.

Exercise .2
Starting from a state 01 of two qubits show that time evolution due to
VFlip-flop can be used to maximally entangle two qubits. Write down the
full unitary operation corresponding to the gatepat this ideal time when it
entangles the qubits maximally (this is called a iSWAP gate).
The above method is used to perform a two qubit gate on superconducting
qubits coupled by a microwave cavity bus – this enables keeping the qubits
at some separation and gives more flexibility in wiring so that diverse archi-
tectures of connected qubits can be generated! You 2D wire a set of qubits
through microwave cavities which can be thin strips of metal in arbitrary
shapes. Of course, superconducting qubits can be made to interact directly
as well when placed adjacently and coupled through the charges of the qubit
states (Capacitive coupling) or the fluxes of the qubit states (Inductive cou-
pling).
There is another type of two qubit gate which can be generated when the
qubit levels |0i and |1i have an energy separation !0 << g. In this case, the
X operator in interaction picture hardly have a time-dependence and thereby
remains as X, while the oscillator operators have all the time dependence so
that
(j)
VI (t) = g(ae i!t
+ a† ei!t )X (j) .
If ! >> g the second term in the Dyson series can again become negligible,
so that we concentrate on the third term to get

8
 Z t Z t0
(1) (2) (1) 00 (2) 00 00 0
UI (t) = 1 (VI (t0 ) + VI (t0 )) (VI (t ) + VI (t ))dt dt
0 0

g 2 (1) (2)
= 1+i X X t (omitting constant terms),
!
so that an e↵ective Hamiltonian is

g 2 (1) (2)
VMS = X X .
!
We know that the above is identical in form to the Ising Hamiltoninan /
Z (1) Z (2) studied earlier, so up to a basis change, it can also be used to perform
a CZ gate between two qubits. The above type of gate is called the Moelmer-
Sorensen gate. It is used for ion trap qubits where the qubits are encoded in
ionic levels and a common mode of vibration of the ions acts as the quantum
haronic oscillator. This gate has the advantage (as you can see above) that
its strength is independent of the quantum state of the mediating oscillator –
no variable of the mediating oscillator is present in VMS . Thus it is incredibly
robust to thermal heating of the oscillator mode.
In the next part of the lecture, we are going to discuss in more detail the
ion-trap implementation of quantum computation.

9
 Physical Implementations of Quantum
Computation II: General Criteria and Ion
Trap Implementation
Sougato Bose
March 25, 2021

We first start by laying down the DiVincenzo Criteria to be satified for

any physical implementation of quantum computation. DiVincenzo in 1998
introduced 5 criteria, but an extra one has been added since. I will also stress
the flexibility (broadening) possible on each criteria. We will then present ion
trap quantum computing clarifying how each of the criteria are met therein.

1 DiVincenzo Criteria
I label the criteria by letters, rather than numbers, so that they are easier to
remember:

Q: Qubits We need well defined qubits. What does this mean? A valid
qubit can be made by using any two orthogonal states of a quantum system
as |0i and |1i as long as we can stay within the subspace defined by these
two sates during our entire computation. For example, a spin-1/2 system is
a natural qubit – no matter what we do to it, we will never get beyond the
states defined by superpositions of |#i = |0i and |"i = |1i. However, we may
sometimes want to use higher dimensional systems, indeed even continuous
variable systems, as qubits. For example, atoms. With the right frequency
and polarization it is possible to choose to work solely in the subspace de-
fined by a certain pair of atomic states |gi = |0i (g standing for ground)
and |ei = |1i (e standing for excited) while having a vanishing/insignificant
amplitude of involving any other states of the atom. The number states of a
harmonic oscillator, on the other hand, cannot be used a qubit, as any field
which induces a transition between number states |0i and |1i also induces
a transition between |1i and |2i. However, an anharmoic oscillator can be
used as a qubit, with the classic example being superconducting transmon
qubits, where the anharmonicity enables the states |0i and |1i to addressed
by a di↵erent frequency than the states |1i and |2i.
This criteria can obviously be somewhat relaxed in the sense that one
can use qudits defined in any system and use multiple qudits (again defined

1
according to the criterion that one should not go out of the subspace defined
by the d states of the qudit). One can even directly use an exponentially
large Hilbert space of any system even if there are no “localized” qubits is
them. The typical example of that is topological quantum computing which
is done by braiding anyons, but the anyons themselves are do not encode
qubits locally in them. The global state evolves in an exponentially (in the
number of anyons) large subspace when the anyons are braided.

I: Input We need an ability to initialize our system, say to a fiducial

⌦n
|0i state for quantum computation based on qubits, or other known state.
It can be accomplished either by cooling everything around including the
system – such as in cryogenics (for example in a dilution fridge), or cooling
specific degrees of freedom (those that would do the computation, such as the
ions in the ion trap) as in laser cooling or optical pumping, where entropy is
essentially selectively thrown out of these degrees of freedom to the environ-
ment, or by measurement and feedback (also called feedback cooling in some
fields). The measurement already purifies the system (von Neumann entropy
zero) and then the feedback just takes it to the desired state. Say the qubit
states are measured in the computational basis and then rotated to the |0i⌦n
state, or an encoded state by measuring stabilizers and then correcting.

P: Processing The ability to perform arbitrary unitary operations on

the system. Originally it was couched in the language that we need to be
able to perform a universal set of gates, such as arbitrary single qubit gates
and an entangling two qubit gate. However, more generally, we may not need
a universal quantum computer – we may have a specific quantum simulation
problem or a specific optimization problem, so that some natural many-body
Hamiltonians working for fixed amounts of time may suffice. More generally,
universal quantum computation may also in principle be possible with a time
continuous evolution by some (in general time varying) Hamiltonian without
a clear separation to single and two qubit gates. In topological quantum com-
putation, the braiding performs a large SU (2n/2 ) operation directly rather
than decomposing into individual gates.

O: Output The need to measure, with high accuracy, the outputs of a

quantum computation – could be individual qubits, or appropriate state in
a large dimensional Hilbert space.

N: Noise We need to have methods to reduce noise rate during the

processing down to as low a level as possible in comparison to the rate of
processing information. A benchmark for qubit based processing is the num-
ber of quantum gates possible within the decoherence time. The noise can be
reduced either passively by better and better isolation or information stabi-

2
 Quantum processors in the near future will be
small!
--- bus mode, fabrication, efficiency

Qubits/Entanglement

Usually the use of photons are envisaged for making the links
Figure 1: A larger quantum computer being formed from several smaller
quantum processors, with common bus of each processor shown as blue thin
rectangles. Qubits or entanglement needs to flow among the processors to
make it a larger multi-processor quantum computer.

lizing interactions or by active quantum error corrections, or if the situation

permits, protocols such as dynamical decoupling, decoherence free subspaces
(I have not taught you this) etc.

S: Scaling One must be able to enlarge the Hilbert space present for
processing to a large amount. Typically it means the ability to increase the
number of qubits taking part in a quantum computation. Typically each
individual processor of a quantum computer is limited in size in terms of
numbers of qubits. This is because they often work by means of a common
bus (as in the case of ion-trap quantum computing) which gets more sluggish
when there are more ions connected to the same bus. Alternatively quantum
computers some times work through local interactions between neighbouring
qubits (such as spin-exchange based, which happens only between proximal
spins). Then how to do long range gates remains open. Thus it seems that we
need to network multiple quantum processors together to make an e↵ective
larger quantum computer as shown in Fig.1. This makes it necessary to be
able to do gates between qubits in one register and those of another register.
For that one either needs to transfer qubits between these processors or needs
to share nearly perfect entangled states (e.g., Bell-states) between them so
that qubits can be moved by teleportation. In order to move, the usually
static qubits of one register must be transformed to mobile qubits – thus this
criteria of scaling is often stated as the ability to interconvert between static
and flying qubits.

3
 One can remember the DiVincenzo criteria in terms of the acronym QIPONS,
which in turn can be remembered through the phrase quantum information
processing overcoming noise sources (note that certain words of this phrase,
particularly overcoming and sources do not correspond to their meaning in
QIPONS).

2 Ion-Trap Quantum Computation

We will now see how each of the above DiVincenzo criteria are satisfied
for the ion trapped implementation of quantum computers. Firstly, though
we need to present the general architecture of ion traps (specifically of the
Paul-trap type, which we will discuss). Trapping ions is nontrivial as the
Earnshaw theorem says that it is impossible to trap (to get a stable poten-
tial) via electrostatics alone – thus time-varying voltages are necessary to
create e↵ective potentials. The arrangement is shown in Fig.2(a), where we
can see four elongated electrodes with sinusoidal alternating voltage applied
accross them (labelled rf voltage – rf standing for radio frequency). Cross
section diagram in Fig.2(b) shows the lines of force. Positive ions feel a sad-
dle potential at every instant of time with the ions being unstable towards
the instantaneous negative electrode and being in a well in the direction of
the instantaneous positive electrodes. As this voltage rotates in time very
fast (much faster than the motion of the ion in response to the instanta-
neous potential) an e↵ective bowl shaped potential is created for the ions in
the centre where they are trapped. Along the axis many ions are linearly
trapped – which is why it is often called a linear ion trap. By their mutual
repulsion, the ions are arranged in a line being about micron separated from
each other so that they can be separately addressed by lasers (although lasers
can be replaced by voltages and microwaves if required to prevent heating
in a cryogenic setting, although we will not discuss that here). To prevent
the ions from repelling each other and falling out of the two ends of the line,
positive static voltage end-caps are applied (not shown). Moreover, recently
there are surface trap versions of the same as shown in Fig.2(c) which is more
convenient for making integrated chips.

Q: Two of the chosen internal levels of each ion is used as a qubit. These
are typically chosen, as shown in Fig.3, as two hyperfine levels labelled as |ei
and |gi respectively of the ground state manifold – there are no other states
below to which these states can spontaneously decay through purely a single
photon emmision, so that these are stable on their own (without the action
of external fields). When all fields except ⌦1 and ⌦2 are switched o↵, then
the qubit’s evolution remains within the subspace spanned by |ei and |gi, as
for a large detuning , the intermediate level |ri does not get populated (see
the point P on processing for further clarity on this point) so that we have
an ideal two level system.

4
Figure 2: The architecture of a linear ion trap, showing the cross section
fields as well as surface trap versions.

5
 r a2
a3 Δ
a1

Ωf
Ω2
Ω1

δ
e
g

Figure 3: The level configuration for an ion trap qubit and all the transitions
between them that are necessary for initialization, processing and readout
(for clarity more levels have been shown than necessary; some levels can be
used for dual purpose). The levels |ei and |gi serve as the relevant qubit
levels.

6
I: The initialization is done through a process called optical pumping. In this
process, we assume that at first the atom is with equal probabilities in both
the states |ei and |gi, both being states of the ground state manifold (after
say all spontaneous decays have taken place). Now two lasers of appropriate
frequencies and polarizations are applied to the atom for the |ei level to go
to the level |a2 i via the level |a1 i as shown in Fig. 3. The level |a2 i, in
turn, selectively spontaneously decays via a single photon transition to the
level |gi (wiggly line in the figure). It cannot decay spontaneously to any
other level |g 0 i, say. However, once in |gi, no extra processes are happening
to the atom – thus the probability starts collecting here – it is called a dark
state. Thus all probability in |ei can be converted to a probability of |gi.
The longer duration for which the two lasers doing the |ei ! |a2 i transition
are kept on, higher the certainty of intialization to |gi, which can serve as
the |0i qubit state. In principle, the motional states of the collection of ions
should also be cooled as much down as possible – this can be accomplished
by a procedure called side-band cooling, which will become clearer in point P
below (though this cooling is not pivotal; as we have seen in the previous part
of this lecture, the Moelmer-Sorensen gates are independent of the cooling).

P: To understand the processing part we consider, from Fig.3 only the 3

levels |gi , |ri and |ei, along with their couplings ⌦1 and ⌦2 and the detun-
ings of their frequencies from the transition frequencies, and . First let
us understand the origin of the couplings ⌦j . The electric field of a laser
applied to an atom interacts with the atom so that the matrix element of
the atomic dipole operator is involved, and the laser’s electric field amplitude
E is involved so that ⌦j , called the Rabi frequency, are given by (we state
here without proof, stems from the fundamental coupling of a charge with an
electromagnetic field under the approximation that the wavelength is much
larger than the size of the atom)
2 hr| dˆ |gi .E
⌦1 = ,
h̄
and similarly for ⌦2 (in the RHS of the above equation energy units have been
used in the numerator). Now consider the case of = 0, but >> ⌦j . The
interaction picture Hamiltonian of this ⇤ level configuration system (named
such in view of the shape of the level configuration) is
V⇤ (t) = ⌦1 (ei t
|ri hg| + e i t
|gi hr|)
+⌦2 (ei t
|ri he| + e i t
|ei hr|).
The e↵ective Hamiltonian from the third term in the Dyson series (second
term becomes negligible) is then
⌦1 ⌦ 2
VQ = (|ei hg| + |gi he|) = ⌦⇤ XQ ,

with ⌦1 ⌦2 , which can be used for qubit manipulation (we have introduced
the subscript Q for qubit). By introducing relative phases of the lasers, as in

7
the earlier part of this lecture, any rotation axis in the equator of the Bloch
sphere is possible, and by using only one of the lasers (say, by inducing just
⌦1 ) and with >> ⌦1 a rotation about the z axis is also possible. Thus
arbitrary single qubit gates are possible.
What about two-qubit gates? For that we need to consider the Hamilto-
nian including the spatial profile of the Electric field of the laser. The spatial
profile (for which we expand eikx = 1 + ikx + ..., where k = 2⇡/ is the wave
vector of the laser along the trap axis and x is the position of the ion for the
case in which is confined well within the wavelength – this is called the
Lamb-Dicke regime) gives a position dependent coupling strength between
the ion’s qubit states; if the position is then quantized then e↵ectively the
ion’s position, and through its Coulomb interactions with other ions, the
common vibrational modes of all the ions, are the quantum harmonic os-
cillators which couple to the qubit. Considering just the common centre of
mass mode of all the ions (all the modes are uncoupled to each other under
the harmonic approximation), the position of the ion can be taken as the
variable denoting the position coordinate of the centre of mass of all ions,
and accordingly quantized as

x̂ = x (a + a† ),
q
h̄
with x = 2m! m
where m is the collective mass, and !m the centre of mass
frequency, of all the ions. The Hamiltonian in the interaction picture, using
the fact that now we use 6= 0, so that it is the e↵ective detuning of the
qubit transition (|ei hg| = + , |gi he| = ), and quantizing, is

VQ-Osc (t) = ⌦⇤ ⌘(ei t

+ +e i t
)(ae i!m t
+ a† ei!m t ),

where ⌘ = k x is called the Lamb-Dicke parameter (in all honesty, we have

not done the complete/rigorous proof of the above Hamiltonian here – it
requires slightly more careful consideration of two electric fields oppositely
polarized incident from opposite sides on the atom: for more clarity see,
for example: https://tf.nist.gov/general/pdf/1399.pdf). Note that now by
setting the detuning = !m (called red-detuning), we have the e↵ective
Hamiltonian, from the second term in the Dyson series as

VIon-JCM = ⌦⇤ ⌘(a + + a† ),

which is e↵ectively the JCM model, and setting = !m (called blue-

detuning), the e↵ective Hamiltonian

VIon-AJCM = ⌦⇤ ⌘(a + + a† ),

which can be called the anti-JCM model. Note that the JCM Hamiltonian
annihilates a phonon (quanta of energy of the motion) from the common
motional mode everytime the atom goes from |gi to |ei. This process can
be exploited to cool the common motional mode through a process called
sideband cooling. Just as discussed in the pumping based atomic state ini-
tialization, the two lasers performing the |ei ! |a2 i transition are switched

8
on, so that each time the atom performs a |gi to |ei transition and thereby
grabs a phonon, it is immediately sent to |a2 i from which it comes back to
|gi by spontaneous emission, so the process can be repeated again, to grab
more phonons and cool the centre of mass motional state further. Now note
that if we switch on both VIon-JCM and VIon-AJCM simultaneously (that will
require four lasers), we will have
VIon-MS = ⌦⇤ ⌘X(a + a† ),
which we know, can be used with two ions i and j to construct a Molmer
Sorensen two qubit gate equivalent to the action of a X basis Ising Hamil-
tonian of the form Xi Xj for a certain interval of time [Note: The gate can
also be done in the non-perturbative limit using VIon-MS of two ions alone,
in which the motional mode entangles and subsequently disentangles from
the qubits after one oscillation period 2⇡/!m , which is what is traditionally
called the Moelmer Sorensen gate].

O: For measuring the trapped ion qubits states, we use the phenomenon
of resonance fluorescence. Consider no laser applied, and we only want to
measure whether the state of the atom is |ei of |gi. We apply a laser to the
atom so that a transition from |gi to |a3 i takes place (strength ⌦f ), which
immediately spontaneously decays down to |gi emitting a photon (wiggly
line in Fig.3). This will again be excited by the applied laser to emit again.
In this way a lot of photons come out of the atom in all directions if it was
initially in the |gi state (it fluoresces), while it remains dark if it was in the
|ei state as no lasers are applied to it. After collecting n photons in directions
di↵erent from the original laser direction, your uncertainty that a fluorescing
atom was in the state |gi is reduced by 1/sqrtn (shot noise limit), so that
by observing for a required amount of time you can reduce your inaccuracy
of your state measurement as much as you require.

N: To control the noise, researchers cryogenically cool the trap electrodes

so that there is not heating of the ions motion (while the gates such as
Moelmer Sorensen are immune to the initial thermal state, they will su↵er if
thermalization is going on). Much of the electrostatic noise (the part which
is thermally activated) is cooled by this method. Dynamical decoupling is
frequently used to improve the coherence time of qubits. The very reason
that we used a 3-level ⇤ configuration of two ground states is so that there are
no spontaneous decays to any other levels or spontaneous bit flips between
the qubit levels (you would require the vacuum to provide spontaneously
two photons of opposite polarizations to be coincidentally incident on the
atom to do such a bit flip – in other words, the protection is coming from
the fact that the two states |ei and |gi are not related by an electric dipole
transition (the type which requires one photon only), which makes it a very
low probability to happen spontaneously as it is a two photon process. If
the two atomic states are di↵erent spin states, then we require magnetic
(mumetal) shielding. Quantum error correction can also be implemented –
for example a way to implement surface codes in surface traps is shown in

9
Fig.4 which shows the shuttling of data qubit ions to bring close to measure
qubit ions.

S: A single line of ions cannot be made arbitrarily long because the couplings
are / 1/sqrtm (see point P) where m is the total mass of ions. Thus it is
envisaged that multiple registers of several tens of ions, each a linear one,
as shown as the horizontal zones in Fig.4. These can then be connected by
“shuttling” ions, where an ion from one of these registers is taken and phys-
ically moved, by changing voltages among successive flakes of the electrodes
(each linear electrode is made of several flakes). This still su↵ers from being
a sluggish method. The other approach is to use entanglement swapping: we
generate ion-photon entangled states in each register and jointly detect the
photons in a Bell state to entangle the ionic qubits. This also su↵er from low
entanglement generation efficiency, partly to do with the collection efficiency
of photons (imporvable by incorporating cavities).
This ends our description of ion trap quantum computation as one of the
examples of the physical implementations of quantum computation. I hope
that the challenges are clear to you.

10
 Taken from: https://advances.sciencemag.org/content/3/2/e1601540

Figure 4: Figure showing both the surface code realization in ion trap arrays,
as well as multiple registers being connected by the shuttling of ions in 2D
surface traps.

11