[MUSIC PLAYING]
As we indicated earlier,
a quantum computer
is not necessarily an
easy thing to make.
Indeed, it appears that it's
a very hard thing to make.
As a result, we can't quite say
exactly what a quantum computer
would actually look like.
But as we said, it
would almost certainly
work in a very
different way from
our current digital computers.
Here's one basic idea
of how it could work.
We would have some collection
of quantum elements, possibly
electrons with spins or atoms.
To start the computer
on some problem
we would have to prepare
those spins or atoms
in specific starting
quantum states.
That would be part of the
programming of the machine.
We would also design
the machine to give
particular kinds of interactions
between these quantum elements.
When we turn the
computer on, whatever
that means in
practice, we would be
letting the quantum mechanical
state of the whole machine
evolve in time using the
designed interactions
between the different
quantum systems.
Possibly, running the machine
could involve shining pulses
of light into specific quantum
elements at specific times.
We could think of
this, loosely, as being
analogous to a kind of
clocking of the system,
possibly triggering various
required quantum operations.
Then, finally, we would
read out the state
of some part of the system.
That readout is a quantum
mechanical measurement.
Necessarily then, because of the
state collapse in the quantum
measurement process,
we would throw away
some of the information
about the final quantum
state of the system.
That loss of information
is one of the issues
in using quantum computers.
Hopefully, however, what we do
read out from the final quantum
mechanical state of these
quantum elements of the system
does give us some
useful information
for the problem we
wanted to solve.
There could be many different
ways in which a quantum
computer could work in practice.
One view is that
we could be using
kinds of quantum
computing gates that
are loosely analogous
to the gates we use
in conventional
digital machines,
though we should emphasize
that analogy is very loose.
So let's see what kinds of gates
a quantum computer might use.
A qubit itself can be
written, as we've seen,
as a two-element
vector such as we
could use to represent a
spin state for example.
So here, a vector like
this, two components to it.
The necessary basic operations
for a quantum computer
can be written as four
different operations.
Three of these are
operations on a single qubit.
We can write these
operations as 2
by 2 matrices representing
the corresponding unitary
operators.
One possible set of single qubit
operations is this set here.
These three unitary operators
are known, respectively,
as a Hadamard
operator-- so that's
this one-- a Z operator-- so
that's this one-- and a NOT X
operator-- so that's
this one, here.
Using the Bloch
sphere that we've
seen before for
looking at spin states,
we can represent a qubit as
a vector, such as the spin
polarization vector we
looked at before, pointing
from the center of a
sphere to its surface.
Single qubit
operations correspond
to rotations of the
vector on the sphere.
Single qubit operations can
be achieved, in practice,
for spins, for example,
by appropriate pulses
of magnetic fields, for
two-level atomic systems
by appropriate pulses of
electromagnetic fields,
and for photons, by simply
changing the polarization
state of the photons.
Two-qubit gates, the
fourth required operation,
involve the interaction
of two cubits
in what we call a
Controlled-NOT, or C-NOT, gate.
One qubit in this
C-NOT configuration
is called the control.
The other is called the target.
If the control is
in the state 0,
then what is supposed
to happen here
is that the target qubit should
be passed through unchanged.
If, on the other hand, if the
control is 1, the target qubit
is to be inverted.
A target qubit of state 0 is to
be changed to one of state 1.
And a target qubit
of state 1 is to be
changed to one of state 0,
hence the name Controlled-NOT.
So only if the control is
what we could call high
is the target flipped.
If the control is
low, the target
is not flipped,
hence Controlled-NOT.
A two-qubit state is a vector
in a four-dimensional Hilbert
space-- that is,
like a state of two
photons on different paths--
so as we've written before,
something like this kind of a
state, which we could rewrite
in the notation
that we see here.
So we're not necessarily
talking about
horizontal and
vertical polarizations.
But we could be.
This is just a generalization
of this kind of state here.
So we have, just as we had
here, four c coefficients.
So we have them here.
We've just labelled them
a little differently.
And we can also choose to
write those as a column vector.
So this is a column vector
with four coefficients in it,
because we need
four coefficients
to specify the state
of the two qubits.
The corresponding operator, in
this four-dimensional Hilbert
space, for this
C-NOT gate can be
written in the following form.
So we want the C-NOT to
express this operator.
And we're going to show why
this operator would work.
For example, the input state
with the control as logic 0--
that is low-- and the
target as a logic 1,
when written in our
form here, would
correspond to the following
set of coefficients.
So this coefficient would be
1 because that corresponds
to control being logic 0
and target being logic 1.
And all the other coefficients
would be 0 in that case.
So we could write this
state as a column vector.
And this would be
what it looks like.
Well, starting with
this state and operating
with our proposed
unitary operator
that we wrote done before
gives the following piece
of matrix algebra.
So here's our state with
control low and target high.
So that happened to be
a 1 in this element.
Here is our matrix.
And the result is that the
target remains unchanged.
It started out
control 0, target 1.
It ends up as
control 0, target 1.
That's just the state
we started with.
As intended, the target qubit
passes through unchanged
if the control qubit is logic 0.
So that's what this corresponded
to as a starting state
of the system--
control qubit logic 0
and target qubit logic 1.
That was the coefficient
1 we had in here.
Alternatively, we could
choose an input state
where the control qubit is logic
1 and the target is logic 1.
That would be this state,
control qubit logic 1 target
qubit logical 1.
And so this
coefficient would be 1
and all the others would be 0.
Then our input state could be
written in the following form.
c11 is to be 1 and all the
other three are to be 0.
Acting on this input
state with our matrix
gives the following
matrix algebra.
So we come in with this vector.
We multiply by this matrix.
But note, now, that this
is the non-zero operation,
the multiplication of these two.
And that means we
get a 1 in here.
This output state is
therefore the one with a 1
in this part in the column.
That means c10 was 1.
Now the target
qubit is a logic 0.
It has been flipped.
And the control qubit
remains at logic 1.
And we could check
this out, also,
for the other two possibilities
of starting states
for the target qubit.
To implement such a
gate, the two systems
representing the two
qubits must interact.
If the system representing
the control qubit
is in its 1 state, we want it to
affect the system representing
the target qubit.
To understand this,
we can look at
a hypothetical and
simplified system.
So let's look at our
hypothetical two-qubit gate.
We could imagine two different
two-level systems, a control
system and a target system.
We imagine that we shine
a clocking light pulse
at the target system.
If the control qubit
is in its 0 state,
then this clock
pulse, we presume,
does nothing to the
target qubit system.
So it leaves it either in
its lower state, like this--
so here's our photon coming
past and doing nothing--
or in its upper
state, like this.
So here's our photon coming
past and doing nothing.
If the control qubit
is in its 1 state,
perhaps it somehow changes
a transition frequency
in the target qubit system.
These two might be atoms
that are interacting
in some way, for example.
And when this atom is
in its upper state,
it influences the upper
state of the other atom
through some interaction
between these two systems.
With this presumed change
in transition energy,
we now presume we've designed
this system so that the target
qubit system could then be
sensitive to the clock pulse.
Perhaps it's now closer to being
in resonance with this clock
pulse.
And so this clock pulse will
then flip the target qubit
state, implementing
the C-NOT function.
So our photon comes along.
And now it flips from the
low state to the high state.
And if we started out
in the high state,
it flips from the high
state to the low state.
This above example
was hypothetical
and somewhat simplified.
Example systems for
real two-qubit gates
include ions in ion traps,
superconducting flux and charge
qubits, quantum dots, and spins
in semiconductor impurities.
A major challenge
for quantum computing
is that it's difficult
to isolate the quantum
mechanical systems enough
from their environment.
Consequently, the phase of
the quantum mechanical system
keeps being disturbed,
which destroys
the fidelity of the quantum
mechanical states being used.
Quantum computing
relies on the phase
of the quantum
mechanical states being
undisturbed for
sufficiently long times.
Essentially, we need
systems with long dephasing
or decoherence times.
One possible solution is to
use some kind of quantum error
correction to restore the state.
Though that, itself, requires
quantum computing gates.
And to run that quantum
error correction process,
it would still need to be able
to get above some threshold
number of quantum operations
without dephasing.
Avoiding dephasing remains a
substantial practical challenge
in many approaches
to quantum computing.
[MUSIC PLAYING]
