[MUSIC PLAYING]
To interpret a quantum
mechanical calculation
so that we can predict the
result of a measurement,
we say that, if the quantum
mechanical calculation says
the state of the system is
psi, then the average value
we will measure
for some quantity
A is given by the
expectation value of A, which
we write using this form
so we can calculate it.
And here, A with the hat
over it is the operator
associated with the quantity A.
The measurement is a
statistical process.
We must repeat the experiment
many times from the start,
including the process that
puts the system into the state,
and take the average answer.
We also find that every
measurement we make
returns a value corresponding
to one of the eigenvalues
A n of the operator A.
Not every measurement
returns the same value.
If we decompose the state
into a linear combination
of the normalized eigenstates
psi n of the operator A--
that is, a
decomposition like this,
a superposition of
coefficients a n times
psi n added up over all of the
possible eigenstates-- then
we find that the
probability of measuring
a particular eigenvalue is given
by the modulus squared of a n.
This probabilistic result
is known as the Born rule.
If no external influence
is applied in the meantime,
any subsequent
measurements on this system
will always give the
same answer, A n,
on measuring the quantity
A. This behavior is
called the collapse
of the wave function.
Measuring a quantity
A appears to force it
into one of its eigenstates.
And as far as we
know, this collapse
is totally random with
those probabilities
given by the Born rule.
We can use this randomness for a
specific practical application,
which is the secure
distribution of information.
Conventional
cryptography generally
relies on it being
very difficult
mathematically to
decode some information
if one does not have the key.
But quantum cryptography relies
on fundamental properties
of quantum mechanics, allowing
the exchange of information
with apparently
absolute security.
To see how this
works, we first show
that it's impossible to clone
a quantum mechanical state
reliably.
The security of
quantum cryptography
relies on it being
impossible to make
an exact replica of an arbitrary
quantum mechanical state
of a system.
For example, we might want
to take an electron that's
in a particular spin state
and make another electron have
exactly the same spin state,
leaving the first electron
in its original state.
Equivalently, we
might want to take
a photon in a particular
polarization state
and make another photon with
exactly the same polarization
state, leaving the first photon
in its original polarization
state.
In the case of photons, the
two polarization basis states
can be, respectively,
horizontally
and vertically polarized.
A general linear combination
of those two states
is an elliptically
polarized photon.
Remember that an elliptically
polarized light beam
has some specific
ratio of amplitudes
of horizontal and
vertical polarization
and some phase difference
between the amplitudes.
In both these cases of electron
spins and photon polarizations,
we can, if we wish, write the
state as a simple two element
vector with complex elements.
So let's look at the proof of
the no-cloning theorem then.
We can show that, starting
from the first system being
in an arbitrary state-- so
here's the first system,
that's the 1, and the arbitrary
state we'll think of first
would be a, we'll call it here--
and the second system in some
prescribed starting state--
so the second system is the 2,
and the s means this very
specific starting state,
it always starts out in the same
state here-- then we cannot,
in general, create the second
system to be in the state a.
So we can't put
the second system
into the state psi
2 a, in general,
while still leaving the first
system in, also, the state a.
This is called the
no-cloning theorem.
In this proof of the
no-cloning theorem,
our initial state
of the two systems
is therefore the direct
product state system 1
being in state a
and system 2 being
in its prescribed
starting state s.
And we then imagine we
have some operation that,
over time, turns this
state into the state
where system 1 is
still in state a
but system 2 has also
been put into state a.
And this operation is just
some time evolution operation
that we can describe by some
unitary linear operator-- we'll
call it T-- such
as this one here.
This is a kind of
unitary operator
that describes the time
evolution of a system when
we have a Hamiltonian
in here that does not,
itself, explicitly
depend on time.
And this is the difference
between the finishing
time and the starting time.
So whether it's
this formula or not,
whatever the machine is that
takes the starting states
and turns them into
the final states
is something that, since it is
presumably quantum mechanical,
is just described by some
linear operator corresponding
to the time evolution of this
whole system-- the measurement
apparatus and these two
systems, 1 and 2, all considered
as one entire system.
We presume, then, we've
engineered our cloning system
to give T the
required properties.
And we know for sure that we
need at least two properties
for T. First, we want T to
perform the operation that,
if we start out with system 1
in state a and system 2 in state
s, then we will end
up with system 1 still
in state a and system
2 also in state a.
Second, if we choose
some orthogonal state
for system 1,
another state b, we
also want this machine,
this cloning machine,
to put system 2 into state b.
So if system 1 starts
out in state b,
system 2 stars out in its
prescribed starting state,
we want the ending state to
be that system 1 is still
in state b and system 2
has been put into state b.
There's no problem, in
general, with constructing
such a T, such a
machine, that would
do this kind of operation.
The problem comes when we want
to clone a linear superposition
state.
Suppose the initial
state of system 1
is the linear
superposition that is
an equal superposition,
for example,
of state a and state b.
These are two possible
orthogonal states of system 1.
So for example, we'll
put this system 1
into this equal
linear superposition.
Hence the initial state
of the pair of systems
is this total state here.
System 1 is in this
state and system 2
is in the prescribed
starting state.
We can also multiply
that out here.
By postulation in
quantum mechanics,
the operators are linear.
Operating on a
linear superposition
must give the
linear superposition
of the operations.
That is, operating on a
linear superposition like this
must be the linear superposition
of the operations considered
separately-- that
is, T operating just
on this state plus the effect of
T operating just on this state.
And we've got our
1 over root 2 out
here, because we had it here.
Now that is going to give
us the following result,
because the effect of T
operating on this state we
looked at before was indeed
to put system 2 into state a,
and the effect of T
operating on this state
was indeed to put
system 2 into state b.
We know that, at
least, the machine
has to do those two
operations if it's
going to be a cloning machine.
But this state is
not the one we wanted
for our cloning operation.
What's wrong with it?
We wanted our cloning
operation to take the system 1
superposition state and change
system 2 from its initial state
into that superposition state.
We wanted this to be the
final state of system 2,
because that would be a clone of
this initial state in system 1.
And we also want
it to be a clone
so it has to leave system
1 also in this state.
Well, that overall state
would be the following one.
It would take the initial state
here and turn it into this one.
It would therefore have system
1 in this superposition state--
the one it started off
with-- and system 2 put
into that superposition state.
We would have 1/2 out of here
because of these two root
2 factors multiplied
on the bottom line.
But we did not get that
state from our machine.
We got this state.
So if we designed
our machine correctly
to perform these operations
that we've seen before,
the individual operations on
cloning state a and state b,
then it does not correctly
clone the superposition state.
The linearity properties of
the quantum mechanical operator
have determined that if we
got the cloning properties we
wanted for the individual
states a and b,
we did not get the
cloning result we
wanted for the superposition.
This result is not special to
the particular superposition
we chose.
Any other superposition would
give us a similar wrong answer.
Hence though we could, in
principle, make a device
to clone specific basis
states, that device
could not clone superpositions
of those basis states.
And hence we cannot make
a device that will clone
an arbitrary quantum state.
We can use this
no-cloning property
to ensure the security
of communications
through quantum cryptography.
[MUSIC PLAYING]
