>> Welcome to Quantum Computing
for Computer Scientists.
Happy Valentine's Day.
We will learn about
this most romantic of
all subjects, Quantum Computing.
This is a talk aimed
at Computer Scientists.
We will not go over very much,
if any, physics
during this talk.
We won't go like
for the Double-Slit
Experiment or
Uncertainty Principle.
We're not learning
about any of that.
We're going to cover
the Computation Model
which you'll all be finding,
fairly intuitive I think,
is a state machine.
And we will run
a Quantum Algorithm on it,
show that it outperforms
a classical Computation Model,
and then we'll end
with some demos,
including a running program
in Q-sharp, Microsoft's
quantum language.
This is the Gate Quantum
Computation Model.
It looks a lot
like the classical
Computation Model
where you have bits,
and you send them
through the logic gates,
and transformations
are applied to them.
There's another
Computation Model called
the Quantum Annealing Model
which is used by D-Wave,
if you've heard of that.
That's something
different from what
we'll be going over but
people think they
might be equivalent.
The jury is still out on that.
Anyway, I'm sure you'll
have a great time.
So, I'm sure all of you have
your reasons for being
here but here are
three reasons I've come
up with if you need some
additional convincing
why you should learn
Quantum Computing.
The first is that
quantum supremacy is
expected this year,
this very year.
Quantum supremacy means we have
a real problem running on
a real quantum computer
which in real-time,
runs faster than
the same problem
on a classical computer.
So, Google has announced
they think they'll
do it this year.
If they do, it's
a really big thing.
So, it might be in
your future. Who knows?
Five, 10 years, we
could all be running
some really tricky problems
on quantum computers.
So, we have lots
of large companies,
Microsoft, Google, Intel, IBM,
they're all investing
billions of dollars
in quantum computer
developments.
There are lots of
really exciting applications.
This is the one that everyone's
heard about, Shor's algorithm.
When this paper came out,
it lit the world on fire.
People were like, "Wow,
quantum computers could
actually have real
economic impact."
We could factor RSA,
and undermine our
global financial system,
which is pretty cool.
Here's one that
programmers will I
think appreciate which is
we can search an unordered list
in square root N time.
So, you think for
an unordered list,
you have to check
every element. That's ON.
You can just get
a nice speed-up,
just square root n queries
on a quantum computer,
which is pretty, pretty
nifty, generally useful.
And here's the one
which, I think,
probably is the best probability
of changing the world.
Sorry, Programmers scroll and
search probably won't
[inaudible] too much.
Which is, we might
be able to have
an exponential speed-up in
simulating quantum
mechanical systems.
So, things like drug design,
if you simulate like
biological molecules
interacting, things like that,
it could massively speed
up a lot of our
biological research,
and everyone talks about
nitrogen fixation for this.
That's like part of
the main Microsoft sales pitch.
But this is the one
that actually motivated
me, the bottom one,
which it's, I think,
from talking to couple of
you before the presentation,
we can also motivate you.
It's intellectually
interesting, and it's
interesting because it's just
kind of outside my intuition.
Like I think all of us, at
this point in our careers,
can basically look at any
digital or mechanical system,
and have like a ballpark idea
of how it works, right?
But if you look at
a quantum computer,
like how can a quantum computer
outperform classical
computation?
It doesn't make any sense.
Like there's no way
I could even start to
guess how it would work.
And so, I really
wanted to learn it.
And I think there's a reason
for this, and this is
kind of getting
a bit philosophical.
But our language,
our informal
language that we use
developed in
very classical world.
It is simply not equipped to
deal with the quantum world,
and this is why
any pop science article
you've read on
quantum phenomena,
it doesn't really ring true.
All the metaphors,
they don't really make
sense because we're trying to
express it in
this language which
is developed in
the classical world.
We need to learn
a new language which is
the language of mathematics,
and that is the only thing
which will actually let us
understand quantum mechanics is
to learn it mathematically.
All metaphors and analogies
will lead you astray.
There's a famous quote
here by a physicist
named David Mermin which
is "Shut up and calculate",
with regard to
quantum mechanics.
So, some grad students,
maybe they lean back
in their chair and
they're like, "Oh, what
does this all mean?"
Shut up and calculate.
Just trust the math.
Math is the only thing which
will not lead you astray.
Okay, here's how this
presentation will break down.
First, we're going
to learn how to
represent computation using
super basic linear algebra,
matrices, vectors,
matrix multiplication.
Then we will generalize
that to learn about Qubits,
superposition, and
quantum logic gates.
And finally, we will use
all those tools we've developed
to go over the simplest problem
where quantum computer
outperforms a classical computer.
This is called the
Deutsche Oracle problem.
I mean, there are
a bunch of problems,
but this is the simplest.
And finally, it'll be almost
negligent to let you get out
of here without learning
about Quantum Entanglement and
Teleportation just because
with the tools we'll develop,
they're so easy to understand.
So, I'll have bonus topics,
and then we'll have some demos.
All right, let's get to it.
You'll become very, very
familiar with these two vectors.
This is how we
represent a 0 and a 1,
the two values of one bit
in classical terms.
So, the top one,
it's just 1 over 0, and
the bottom one is just 0 over 1.
You can also write them in that
weird angle bracket thing.
That's called
Dirac Vector Notation.
So, you have a zero
in there. That means
this is the value
of that vector.
If you have trouble
remembering this,
just think of it like
an array indexed from 0,
and so, there's a
1 in the 0th index,
that means it's a zero.
There's a 1 in the first index,
that means it's a 1.
Okay, everyone's fine with this?
You'll be very
familiar with this by
the end of the presentation.
We're going to go over
matrix multiplication
really quickly.
So, the way to
think about
matrix multiplication,
just to review for you.
Most of you will have
gone over this in your
Linear Algebra courses
the first or second day.
So, if we have a matrix
multiplied by a vector,
you kind of take
this horizontal row,
and then flip it,
and multiply it
point-wise with
these vector values.
So, a times x, b times
y, and that's how
you get the top one.
And you do the same thing
in the bottom row.
C times x, d times y,
and you get a two vector.
The same thing happens
with three-by-three matrix.
A times x, b times y,
c times z, and you
get this matrix.
This vector, you can also
multiply matrices together.
We won't really be
doing much of that.
And there's a very
special matrix called
the Identity Matrix which
has zeros everywhere,
except for ones along
the main diagonal,
and anything multiplied by
the Identity Matrix is itself.
It's just like multiplying by 1.
In fact, usually, you refer to
the Identity Matrix
by the symbol 1.
Now thankfully, for simplicity,
a lot of the matrices we'll be
using look a lot like this.
They're mostly 0s
with just some 1s,
and you can notice, it's
a nice rule of thumb,
that relative to
the identity matrix,
this matrix has the middle
two rows flipped, okay?
And that's actually
the action it
has on anything it multiplies.
So, it flips
the middle two rows.
It's a nice sort
of rule of thumb
to remember how
matrix multiplication works.
Does anyone have
any trouble with this?
Because you really need to know
this in order to go ahead.
You got to know it. Okay, great.
Operations are actually, I'd
like to make this a quiz.
Can anyone tell me what are
the four operations on
one bit? There's four of them.
>>One bit.
>>One bit.
>>AND, OR, exclusive-or.
>> That's around two bits.
>>Not identity.
>>Identity not.
>>Set to 0, set to 1.
>>Set 0, set 1. There we go.
Good. Yes. So, we have identity,
just f of x equals x.
Negation fx equals not
x. Constant-0, it's
always set to 0.
Constant-1, it's
always set to 1.
You can see with a diagram
how it kind of looks, okay?
And we can write
these as matrices.
So, the identity is
just the Identity Matrix.
This, remember, is
our symbol for zero.
Identity multiplied by 0 is 0.
Identity multiplied by 1 is 1.
Here's negation. You flip
it from 0 to 1, and 1 to 0.
Same thing for
constant-0, constant-1.
So, I hope I've
convinced you we can
represent very simple
functions at least,
with matrices multiplied by
our 0 and 1 vectors, okay?
And remember
these four functions
because I will quiz
you later on them.
They'll come back up. So, let's
talk about Reversible Computing.
Reversible Computing is
a neat sort of buzzword.
It if you've read the popular
sci-fi book Accelerando,
it talks about
Reversible Computing,
and basically it means
that if I tell you
the operation I did and
the output of that operation,
you can always tell
the input of that operation,
if the operation's reversible.
So intuitively, operations
that just shuffle bits around,
like permute them,
they are reversible.
But operations that erase
bits and then overwrite
them are not reversible.
And in our previous slide,
identity and negation are both
reversible because I
say the output is one,
and I put it through
the negation gate.
That means the input was zero.
You can always tell that.
But if I say the output was 1,
and I put it through
the constant-1 operation,
you can't tell
what the input was.
It's not reversible.
It erases information.
And the nice thing
about Quantum Computing,
which you're going to remember,
is that one of
the computers only use
reversible operations.
Those are the only ones
we care about.
So, the only operation we
actually care about on
this slide is really negation.
Like also identity but it's
the same as doing nothing.
A further fun fact about
chronic computers is
they actually only use
operations which are
their own inverses.
So, not only are they
reversible but if you apply them
twice you'll just get
back the same input value.
And we're going
to go in a little,
this is kind of like going
into pop science but whatever.
There's something called
the Von Neumann Vander Limit,
which is the smallest amount of
energy physicists
have calculated
is necessary for the simplest
possible calculation,
which raises is non-reversible.
And reversible computing might
eventually lead us
go beyond that limit,
more efficient than
that theoretical limit.
Now, currently, processors needs
millions of times more energy
than the Von Neumann
Vander Limit but,
you know, 5,000 years
from now, who knows?
Pretty nifty. All right.
This is something you
probably did not go over in
linear algebra but don't worry
it's still pretty simple.
It's called the tensor product.
So if you have the tensor
product of two vectors,
it's kind of like you take
the second vector and you
tile it for each element
in the first vector.
So, X0 gets its own copy
and X1 gets its own copy.
And then, you multiply it
out so you get eventually X0,
Y0, X0, Y1, et cetera.
It's maybe easier to look
at this with real numbers.
Here we have one times three,
one times four, two times three,
and two times four to get this.
Here's how it looks
like with three vectors.
You get this like giant array.
Don't worry about it too much.
And I'd like to point out
that if we use R0 and one values
you end up with a vector
which has a one in
only a single position.
Okay. Does anyone have
any real trouble
with this concept?
If I gave you
two vectors you could
probably calculate
the tensor product.
It's not entirely
difficult. All right.
But, the final point
animate leads
into how do we represent
multiple classical bits?
And we represent them
by their tensor product.
So, 00 remember we tensor,
this is a zero symbol.
0 tensor with 0 is this,
product state, we call it,
01 is this product state
10 is this product state,
like 0 times 1, 0,
0 time 0, 0, 1 time 1, 1.
One times 0, 0. Okay. And 11
is this product state
and similar
to just a single bit
you can think of
this is an index in
this vector array.
So, this is 0. There's a one
at the zero position.
This is one.
There's value with
the first position
coming from zero and,
this is two value of
the second position,
three value of
the third position.
This is the only time
I will tenser
three bits together thankfully,
because they us humus.
They grow exponentially in
size but it works for this.
So, four is 100 you have
01234 is where the one bit is.
Okay. Yeah. So, we call
this the product state.
We can always factor it out into
its individual states and
the product state of n bits
is a vector of size
of two to the n. Here,
we see a sort of whisper
of the power of
quantum computing in
this exponential term but
hold that thought,
we'll get back to it.
So, we're going to learn
a very important operation,
very fundamental to
reversible computing
and quantum computing
is called CNOT or
conditional not.
It operates on a pair of bits.
You designate one bit,
the control, bit the other bit
is the target bit.
So, the control bit if it's
one it flips the target bit.
If it's zero it
leaves the target bit
alone and the control bit
is always left alone.
So, if we have
the most significant bit
of a 2-bit system as control,
the least significant
bit is target,
then 00 since this is
the most significant bit,
it's the target bit, and just
goes to 00, 01 goes to 01.
Now, 10, since
the control bit is
one maps to 11 because
it flips the other bit,
and 11 since it again flips,
the target bit goes to 10.
And this matrix, you can
actually kind of write it,
you see there's a sort
of correspondence
here we flip
the bottom two rows,
which is the identity matrix,
and this I claim
which I will show in
the next couple slides,
will change our product states
according to
the semantics of CNOT.
So, does everyone get
the semantics here?
We have a control bit
and a target bit,
control bit one, we flipped
the other bit. Pretty good?
Now, this is a lot of math
but don't panic we're
gonna go over step-by-step.
If we apply the CNOT gate to 10,
remember that this is
the control bits one,
so we're going to
flip the other bits,
so we expect it to go to 11.
Now, let's expand this
out just step-by-step.
So,10 corresponds to
this tensor product.
This is the matrix
from the previous slide
and we're applying it
to our product state.
Remember, it's
just going to flip
the bottom two rows so we
get to this product state,
which when we factor it out,
indeed gets us 11.
Now, let's do it
with 11, same thing,
we have our familiar matrix,
multiply by this product state,
we go to here, which
we factor into 10.
So, I hope I've convinced
you at this point that we
can use matrices to represent
more interesting logical
operations than just a bit flip.
Has anyone eventually, yes?
>> Is that factoring always
possible or practical
for larger vectors?
>> It is practical, yes.
Not always possible,
which we'll get into
that when we get into
quantum entanglement,
basically, but good question.
So, this is fine for everyone?
Nobody's lost in
the gigantic equations here?
Okay. We're gonna go over
10 then, or sorry, 00.
So, the control bit 0
that means we're going to leave
the other bit alone, right?
And we see that indeed
this is what we do
and same with for 01.
Okay. So, everyone, well,
maybe familiar with
how classical computers
are like real CPU's
there they're all
built on the, sort of,
NAND gate, like everything is
fundamentally built on NAND
and CNOT is kind of
the analogous NAND for
reversible computing.
It's like a really basic thing
that is used to build
up larger and more complicated
logical statements.
So, I'm sure if I
gave you a task,
like build some more complicated
logical formula with CNOT,
you'd probably be able
to do it at this point,
you just like stick
them all together
and eventually comes out.
I will note that it's
not actually universal.
You can't make every logical
function with the CNOT gate.
You need something
called a Toffoli Gate,
but we won't see that
in this presentation.
And we've learned everything
we need to know about how to
use linear algebra to represent
classical computation,
and we can now go on
to quantum computing.
So, to recap, we
learned that we can
represent classical bits
in vector form is 10
for 0 and 01 for 1.
We can represent
operations on bits
by multiplications
on their bit vectors.
We know that quantum
computers only use
reversible operations and in
fact the operations
are their own
inverses and multibit states,
we write is the tensor product
of our single bit states.
Finally, learned
about CNOT which is
a very fundamental gate
in reversible computing
and quantum computing.
So, everyone's
following along so far?
This is pretty simple,
right? And it's not that bad.
Okay. Let's make
the jump, qbits.
And I will surprise
you, we've been learned
using qbits all along actually.
The cbits are just
special cases of qbits.
And we represent
the qbit in general
by a vector of two elements a,
b where a and b are
complex numbers.
Don't worry. We'll only use
real numbers for
this presentation.
We're keeping it simple.
Only using real
numbers. And we have
the constraint that
a squared plus b squared is one.
So, (1,0) and (0,1) fit
this definition because
one squared plus zero squared is
one and zero squared plus
one squared is one, right?
Now, here are
some example qbit values.
This is one with which
you'll become very familiar.
It is one over root
two, one over root two.
Can anyone tell me what one
over root two squared is?
>> One half.
>> One half exactly.
one half plus one half is
one. So, this is a qbit.
What about one half and
root three over two?
What's one half
squared? One quarter.
So, one quarter plus
three quarters is one.
Here's an interesting thing.
We can actually use
negative numbers
now because the negative number
squared is a positive number.
So, negative one squared is one.
One plus zero is one.
And the same thing here,
it's just the same
as this first matrix,
but one of the values is
negative. Pretty neat.
Not bad so far, right?
Okay, but you might say
this is kind of like
saying that a qbit has a value
which is not zero or one,
but actually both zero
and one at the same time.
This is called superposition.
Everyone's probably heard of
the Schrodinger's cat
being both alive and dead.
That's just like a pop science
the way of articulating
this concept sort of.
And the interesting thing
about a qbit being
in superposition,
it means we can kind of,
I want to really qualify
this kind of compute with
the values of both zero
and one at the same time,
which again is the sort of
whisper of some
quantum speedup power.
Okay? Now, how this works is,
when we measure this qbit,
it collapses to
our familiar values
of zero and one with
some probability.
And this is what we
usually do at the end of
a quantum computation
to get the final result.
We send it through
the measurement gate,
we see what the result is.
So, how the
probability works is,
if you have a value (a, b),
it collapses to zero
with probability
a squared mand one with
probability b squared.
So, if we look at
our familiar qbit from previous
slide, one over root two,
one over root two, it has
a one half chance of
collapsing to zero,
and one half chance of
collapsing into one.
It's like a coin-flip. Now, if
we just measure
our classical qbit,
our classical cbits the (1,0)
has a 100 percent chance
of collapsing to zero,
and (0, 1) has a 100 percent
chance collapse into one.
So, it's sort of item
put in that way.
And I found it useful here to
give people sort of physical
intuition about
what we're doing,
what bit is or a qbit is.
If you've heard of polarization,
you've probably bought
fancy sunglasses,
says that they're polarized.
So, polarization is actually
sort of quantum phenomenon.
You can be polarized like
this way or this way,
and your glasses will only
be polarized a certain
way so only let light
polarized in this way
through basically.
It turns out that qbits,
you can think of this, yeah,
a photon being polarized
this way is a zero,
and photon being polarized
this way is a one.
Superposition means it's
actually like both, right?
So, it could actually go
through both gradients.
And then if you measure it,
and a way to measure
it is just to
fire it through grating and
see whether it goes through,
then you can collapse
it to zero or one.
So, that's our intuition
pinning this to
a physical concept.
Of course, modern, we
found that photons
actually make very,
very poor qbits, they tend
to collapse to easily.
So, we don't use those, but
you can maybe think of that.
Does anyone have
any confusion here, really,
about how this measurement
process collapse
probability works?
Okay, great.
We will learn about
multiple qbits.
The same is multiple cbits.
We represent them by
the tensor product.
Why is it doing that?
Okay, hold on, laser pointer.
Okay, there we go.
Nope, that's not.
Okay. So, if we have two qbits,
and we multiply them,
the sum of squares identity
actually is maintained.
And so, if we consider
our perfectly balanced 50
percent coin-flip qbit.
And we tensor with
another coin-flip qbit,
we get this four vector with
one half in every single column,
and one half squared is
of course, one-quarter.
So, one-quarter plus one-quarter
plus one-quarter plus
one-quarter is one.
This maintains the property.
And the way to read this is
when you measure
these two qbits,
it has a one-quarter chance
of collapsing to (0,
0), (0, 1), (1, 0), and (1,1).
This is sort of the probability
of when you measure it,
finding a one there,
and zero everywhere else.
So, we could find,
it's a one-quarter probability
of finding one in
this position and
all zeroes everywhere else.
Does that make sense
for multiple qbits?
Okay great.
You guys are just trucking
along and no problem.
Should be super easy. Yes?
>> I have a question.
>> Absolutely.
>> So, there's only
going to be one,
one left in the vector?
>> Yes.
>> There couldn't be two ones?
>> There could not two ones
because that would
actually violate
our a squared plus b squared
equals one constraint.
>> Okay.
>> But yeah, after measurement
there'll only be one,
one here in this in four vector,
which we can then factor
into two bits actually.
Okay. Yes?
>> You also find collapsing
for that longer vector?
>> Yeah, yeah.
So, if you measure
these two qbits at once,
you can think of this product
state vector is collapsing.
And then that's
just the probability of
finding a one here and
a zero everywhere else.
It'll become useful in
the future when we can't
actually factor out the product
state, but that's anyway.
Okay. How about
operations on qbits?
We have these qbits, how do
we actually manipulate them?
The same way we do with
the classical bits.
And all the matrix
operators we've
learned also work with qbits.
So, for example, negation.
If we have our qbit that has
a 25 percent chance
of collapsing to zero,
75 percent chance
collapse into one,
if we run it through
the bit flip operator,
now it has a 75 percent chance
of collapse into zero,
and 25 percent chance
of collapse into one.
So, we can manipulate
these probabilities actually
called amplitudes with gates.
And you can think of gates,
they correspond to some
device scientists have created
which is like manipulate
the qbits with a gentle touch.
Not enough to collapse them,
but enough to
change their state.
So, pretty neat.
And there are also a couple
important matrix operators,
which we haven't learned
yet because they only
really make sense in
the quantum context.
Okay, all right. We're good.
Then the most important one
is the Hadamard gate.
And what it does is, it
takes a zero or one qbit,
and it takes it to
the coin-flip state
where it's in exactly
equal superposition.
The matrix looks like this.
It as one over root two in
every single entry except
for a negative in
the bottom right corner.
So, if you multiply
that by this,
you get one over root
two, one over root two.
If you multiply this by one,
we get one over root two,
negative one over two.
Pretty neat. So, this is how we
actually get into superposition.
We use the Hadamard device,
which scientists have developed,
and we can make much use of.
So, quiz time.
Can anyone tell me why
we need a negative one in
the bottom right corner?
Why do we need
a negative sign here?
>> It's like a matrix
on bigger provision.
I don't know exactly why,
but it is too big.
>> Well, the answer basically
has to be reversible.
So, if we didn't have
this negative number here,
then both zero and one
would map to the same value,
and it would not be reversible.
So, we need this negative sign.
Yes, correct. Okay.
>> Question.
>> Yes?
>> Review of superposition,
what does that mean exactly?
>> Superposition, yeah.
So, superposition
means that a qbit is
in both states zero and
one at the same time.
>> Okay.
>> And I want to be really
clear about something here.
This doesn't mean
the qbit is secretly
zero or secretly one,
and we don't know.
It means it's actually
in both at the same time,
this is just quantum weirdness.
This is just like what
happens at the very,
very small level of our world,
which is that things don't have
definite values until
we measure them.
>> Here you have (0,
1) in superposition
is one over root two,
one over root two.
And one and superposition
one over root two minus one.
>> Yes.
>> So, we seem to have
different values but they're
representing conceptually
the same thing.
>> Right. So, this
comes down to the distinction
between the quantum
and classical world,.
Which is that from
the classical perspective,
these two qbits are the same.
Both have 50 percent probability
of collapsing to zero or one.
But, if we stay within
the quantum realm,
this sign information is
preserved as long as
we don't measure it,
and it can affect
our computations.
>> So, it's got a 50-50 chance,
but it has a sense that
it used to be a one?
>> Has a sense that
it used to be one?
Not really, it just
ends up in this state,
which is different within
the quantum realm
than this state.
These are two different states.
>> Okay.
>> Yes.
>> Both for the 50-50 chance.
>> Yes, exactly. Both when you
measure it and convert it into
the classical world come
down with a 50-50 chance.
Yes. But they are different,
and they have different
computational properties.
Okay. Now, I'm going
to show you something
really cool about
the Hadamard gate,
which actually takes us out of
superposition into
the classical bits.
This should be unsurprising.
Everything is
its own inverse, right?
If we just apply the Hadamard
gate to our value here,
our coin-flip
value, we get zero.
And for this one, we get one.
So, this suggests to us
a quantum computation structure.
We can start with
our classical bit values.
We put them into superposition,
do a bunch of
quantum stuff to them,
and at the end if we're clever,
we can transition
them to zero or one
so that our whole computation
was deterministic.
Pretty neat, right? Okay. Now, I
should say that not all
algorithms work this way.
There are algorithms
like Shor's algorithm,
which only gives
the right answer
of 50 percent of the time.
You can't be clever and
always get the right answers,
just not doable.
But the one, the problem
we will look at does
give this
deterministic property.
So, does anyone have
trouble with this concept?
We transition out
of superposition
without measurement,
pretty interesting.
>> Can you go over
this transition from
a classical computation to
quantum and then
converting it back?
>> Yes.
>> That's correct.
Let's say two plus two,
how would that look like in?
>> How-?
>> Just the simplest
type of math.
>> The simplest type of math.
What we're going to go
over that basically,
we're going to go
over a problem.
There are certain problems
where computers
are better than classical.
Addition is not one of them.
It works the exact
same way in both.
It should also be said that
all classical computation
can be done on
a quantum computer,
all you do is just restrict
all the values to zero and one,
and it works, but it's
kind of a waste because
you can also use
all the extra values
that we found.
Okay, and we've actually
sort of define
a state machine here,
which I am sure many
of you will appreciate
if you're software engineers
or computer scientists.
This is the unit circle which
many of you will remember from
high school trigonometry, right?
It's a circle of radius
one around the origin.
Here's the X axis,
this is the Y axis.
You can think of
the top value is the value of
the x-value and
the bottom one is the y-value
so our zero value
is at position one,
zero which is along the X axis.
Our one value is position zero,
one which is along the Y axis.
And this is
the bit flip operator,
it defines transitions
around this unit circle.
So zero goes to one,
one goes to zero,
zero negative one
goes to negative one,
zero which when
you collapse them,
this is zero, this is
one, and vice versa.
And if we look at the
superposition values, here's
something interesting.
The bit flip operator
really kind of has
no effect on them.
For this one, if you
flip it upside down
it's stays itself same
with this over here.
This one's kind of interesting
and that it transitions
you all the way
across the unit circle
and we'll make use of that.
But yeah, this is pretty much
the full action of the bit
flip operator on
the unit circle.
I should mention here that if we
were using complex numbers,
this would actually be a sphere.
Much more difficult to sort
of intuitively graphically
represent so we're sticking with
real numbers, they
suit us just fine.
But it's nice to know that
additional dimension is always
available to us if we want to
make our computation
even more powerful.
And then here's the action
of the Hadamard gate,
which we saw in
the past couple slides.
It takes us from
zero to one over two,
one over two, one, two,
one over two negative
one over two,
and kind of symmetrically,
it also works in
this way over here.
So, we have a nice state machine
that we've developed and
now we can start running
things on the state machine.
Very nice intuitive
sort of representation,
you don't need to do matrix
multiplication all the time.
Everyone kind of gets this?
Okay, great. So here's
an example of something we
could run through
the state machine.
Here, I'm introducing
something called
quantum circuit notation.
You can think of
the cubit traveling along
this line has these
operations applied to it,
is it goes through the boxes.
So X is bit flip,
H is Haddamard, and then
so we go a bit flip,
Haddamard, and
bit flip, Haddamard,
bit flip and if
we start out here,
we go bit flip, Haddamard,
bit flip, Haddamard, bit flip.
So we start off at one,
zero and get to zero,
one, we got to cross the circle.
And note, this is
reversible so we can
also go this way and get back.
So this is kind of how we'll
be doing all of our computations
like this basically,
just hopping around
the unit circle.
It's pretty simple,
pretty intuitive, right?
It's just a state machine.
We use this in classical
computing all the time.
Just has a bit of
weird rules with
the claps and whatever
but don't worry.
Okay, now we have everything we
need to learn
the simplest problem
where a quantum computer
outperforms
a classical computer.
We learn that Cbits are
just a special case of Qbits,
and Qbits are two vectors of
complex numbers such that
a squared plus b
squared equals one.
Within the Qbits is going
to be in superposition,
they're probabilistically
collapsed
to Cbits by measurement.
Multi-Qbits systems we
learned are tensor products of
single Qbit systems
same as with Cbits.
Matrices, again, represent
operations on Qbits,
and we learn about
the Hadamard gate,
very important which takes
our zero and one bits to
superposition and back.
And finally, we learned
that we can think of Qbits
in their operations is
forming the state machine
on the unit circle or
unit sphere if we're
using complex numbers.
It's actually called
the bloch sphere,
if you want to look that up
for the full complex numbers,
but unit circle,
just fine for us.
Okay, so we're gonna
learn about something
called the Deutsch oracle.
This is originally proposed
by David Deutsch in,
was it like 83 or
something like that?
And the problem is this.
Imagine I show up at
your doorstep and I
give you a package,
the package is
just this black box,
it's just horribly present.
It's a black box which
has a function on one bit.
There's one of
those four functions
on one bit, do you
remember what those are?
I said I would ask you
about them. Set zero,
set one, identity, indication.
Exactly. So one of
those four functions,
I don't tell you which one
is inside this black box.
There's a wire going in and
a wire going out so you can
send in values see
where it goes out,
but you can actually look
inside the black box, okay?
So how many queries
on a classical computer
would it take to figure out
which function is inside
the black box? Two, exactly.
You send in zero,
see what comes out,
you send in one,
see what comes out.
So that will uniquely
identify which function it is.
Now, how many queries
do you think it
takes on a quantum computer.
You're wrong, it's two.
I say this to illustrate
an important point,
which is quantum computers,
they don't really compute
with all value simultaneously.
At the end of
the day, you collapse
your Qbit to a single bit
of information,
and a single bit of
information is not enough to
uniquely identify one of
four functions, right?
You need two bits at least So
this actually takes two queries
on a quantum computer.
Well I'm not too
exciting so far.
Now, what if instead
of not wanting to know
which function it is,
we just want to know
whether the function
is constant or variable.
The constant functions are,
constant zero, constant one,
they're always mapped to
0, always mapped to one.
The variable functions
our identity and negation.
So how many queries would this
take on a classical computer?
>> Two.
>> Two. You put in zero,
if you get zero you
don't know whether
it's identity or constant zero.
If you get one, you don't
know whether it's bit
flip or constant one,
symmetrically with
one, so it always takes
two queries on
a classical computer.
Even though there
are two categories,
so really we only
need a single bit
of information to tell us
which category it's in.
But how many queries
do you think it takes
on a quantum computer?
I kind of burned you last time
so maybe you're a bit shy.
>>I'm going for a one.
One, you are correct.
We can do this in a single query
on a quantum computer.
We can tell whether
its constants or variable.
This like undeniably outperforms
a classical computer and
we're going to learn how.
Okay, we do with the magic
of superposition.
But first we have to define
which each of
those four functions
look like on a quantum computer.
We have an instant
obvious problem
with the constant functions.
Can anyone tell me what it is?
>> Not reversible.
>> They're not reversible,
how are we going to write
these non-reversible functions
on a reversible computer?
This is actually a really common
problem in quantum computation.
You really often
have to deal with
non-reversible functions if you
have to write them in
an irreversible way,
and the hack we do is this.
So originally we
had this, right.
We add an input and an output,
a single wire going through.
And we just imagine
that you put in
the value and you
get the function
applied to that value, right?
But the hack that you always
do on quantum computers
is you add an
additional output Qbit.
So you actually have two Qbits.
We have to rewire our black box.
So you have your input
Qbit, which is unchanged,
and then the value of
the function on the input
Qbit is written to
the output Qbit.
Does everyone kind of get this.
I think this the thing
that people have
the most trouble with,
this is necessity.
The reason we have to do this,
is so we can write
non-reversible
functions in a reversible way.
And the way you do that is to
have a separate input
and output qubit.
So when you see
larger quantum computations,
instead of having all the bits
go in and have transformations
applied to them and
then being measured.
You usually have
a separate set of output bits,
so the input bits go in,
they have their value sort of
written to the output bits,
and you measure the output bits.
This is a very standard way
of doing quantum computation.
So does anyone have
any trouble with this?
This is a very difficult
concept. So, yes?
>> I didn't get it.
>> Okay.
So, do you understand
this model basically,
this is what we have now, okay?
So we need to rewire it
so there are two wires
going through the box now.
And one of those wires
we call the input wire,
one of those wires we
call the output wire.
We assume the output wires just
initialize to zero,right?
It's always zero.
Now our input wire is what we
actually give our input in.
Like it'd be like zero or
one or whatever value
you want to give
input to the function.
So, it goes to the box,
it's just unchanged.
We don't touch the value
of the input wire,
but we calculate
the function in here,
on this input and then we write
its value to
the output wire, okay?
>> Black box?
>> Yes, we are
rewiring the black box.
We have to rewire
the black box in
order for the black box
to really work.
So the black box I gave
you has to be rewired. Yes.
>> Did you use the first input,
which is the output of zero?
>> Did I use the first input?
>> Yeah, because one of them
was kind of identity, right?
You put the X out, and
then it was the F or X.
>> One of them was
X and the other was
>> You need the X out.
>> Say we only have this,
right? This is
the old way of doing it.
We can't have a non-reversible
function in here, right?
For it to be on
the quantum field.
>> No, that I get, right?
>> Okay, yes.
>> Because when that thing
is on the right side,
you have two going
in, two going out.
>> Yes, two going in,
two going out, yes.
>> I get why two going out.
>> Yes.
>> I don't get why we have
that zero is also going in,
It doesn't seem that
you're actually using
it to produce any of the others.
>> You're correct,
it's just we need.
>> Symmetry?
>> Not really symmetry,
it's just like how we would
write the quantum circuit,
we would need
two qubits in general.
So, you're correct that
this algorithm value
isn't really used.
>> Is it like we
don't care a pen off?
>> No, we do want it to
be zero because the way
that we write
the circuit assumes that
this value coming in
is always zero. Yes.
>> Why is it ingoing
output wire called output.
>> What?
Yeah. So, this is
kind of weird that
the output of the input
is called input.
But, we basically only really
look at this value here,
is the basic idea.
This is like the real output.
The input will
always be unchanged.
>> Question. So if I have
multis two black
boxes in series,
the upper input which
you have labeled Alvap.
>> That's smart,
that's a good one.
>> And the second stage
would be the F of
X output of the first stage?
>> Okay, so you're
saying if you had
these in series
rather than sort of in
parallel to what we're doing
is that what you'resaying?
>> Yeah I want to
do two operations
one and then another one.
And the black box is
doing some operation.
>> The black box is
doing some operation.
You can have as many
operations as you want
in here inside
this black box basically.
>> True, but I'm trying to
conceptually
understand whether I
would take the F of X is
the output upper right.
And that will be the input.
>> The input, the next one.
>> Absolutely and in fact I
said that this black-box
assumes this value is zero,
this isn't maybe throw
in a bit much of you,
but actually we can break
that assumption and send it
some other value which maybe
will get us more information
which is in fact
what we'll be doing.
So, the working of black box
assumes that the
output input is zero,
but we can break
that assumption and be tricky.
>> My way of
thinking was I didn't
have any other value
for the first stage,
but for subsequent inputs
I do have one.
So I could use it if I want?
>> Yeah you could, yeah and you
might get some interesting
values which actually well.
Okay I swear, this is
the most difficult part
conceptually of
this entire presentation.
So if anyone has any trouble
with it please let me know.
Ask any questions you can spend
as longer time on
this as we want. Yes
>> As we go ahead, is there
some additional clarifications
because I didn't get it.
>> Okay. Well we'll
go over all each of
the four functions in this way,
so maybe that will help.
So, for example, constant
zero, here's how it would look.
X goes in, X goes
out it's unchanged.
Now, the output is always
going to be zero, right?
That's just what
the constant zero does.
So we always want this value
in the upper right to be zero.
If we assume zero goes in,
this is our circuit diagram,
neither of the two wires make
any modifications, right?
It's a straight wire.
Does that sort of makes sense?
We will see the next slide,
what about for constant one?
We want one to go
out here, right?
This is our function
output value.
And we assume zero
is the input here.
All we do is we do
a bit flip right here,
and that gets us
the semantics we want.
Is anyone having any trouble
with this so far?
I swear this is
the most difficult part.
So if you get this
you're golden. Yeah.
>> So these labels
output, input,
would you call them something
like computations and its spare?
>> Sure yeah, you could.
You can call it the
compute and the spare fit.
Yeah, that also
works.They might reduce
some confusion about there being
an open output and input output.
>>Why is it called output?
>> Why is it called output?
We call this the upper
qubit because it's
just the place that we write
the output of the function.
But we could call
it like compute
and spare or something like
that, like he suggested.
Like this would be
the spare sort of bit that we
write the function number 2. Yes
>> We need this to do
a reversible computation,
right why is this?
>> Reversible?
>> Can we compare
the reversibility of
this likewise the right
one reversible one?
>> Absolutely, okay.
So let's consider this one
right here, right?
We have our black box with
a single wire and
say we want to do
the bit flip operator.
So, that would just be.
Sorry not with
bit flip operator,
a bit flip operator
is reversible.
So we want to do
the constant zero operator.
We always want to
map this to zero.
So you need some operation right
here, that would
map this to zero.
But it'll be the matrix
1100 but this is
not a valid operator
in a quantum computer,
because it's not reversible.
So, does that kinda makes sense?
It's just we can't construct
a device which does this.
It's just not permitted
by physical reality.
All this math and
stuff I'm showing you,
it's not like special it's just,
we found that it corresponds to
the semantics and workings
of a quantum system,
and so it's a nice way to
reason about it basically.
Okay. Of course if we
want to write constant
zero here with
their two inputs are
the two wire model it
would just be blank, right?
Or if we want to do this is
constant one always maps to
one we saw that this
has an X gate here.
And this is reversible, right?
Okay. So we managed to write
a non-reversible function
in a reversible way.
If you've got
this congratulations,
this is the trickiest part.
It took me awhile to
figure out why we needed to
do this staring at the textbook.
Does anyone have
any confusion here?
Okay. So remember constants
zero is just blank.
Constant one has
a single X gate. Yes.
>> There's a point
you always end up with
a four by four reversible matrix
by doing this in black box?
>> Yes. Black box
is always a four by
four reversible
matrix applied to
a product state, you're correct.
Although we will be not going
into the math in that way
we'll just be using
the state machine to look at it,
but the math is very easy
for you to do it yourself.
Okay. So let's look at
identity this is a bit more
complicated this is
the CNOT gate, okay?
Where this is the control,
and this is the target.
So we'll end up with,
so input again is unchanged.
We want output we
assume it zero we
want to end up with
a value X, right?
So if zero is sent in here,
then this is the control bit,
so the target bit is
just left unchanged,
right? So zero comes out.
If one is here, one is sent in,
and the control bits
one so we flip thright?
Is bit, and we end up with one.
Does this make sense?
This is kind of
tricky it is a big step up
in complexity of our circuit,
but everyone's fine with this?
Wow okay. Can anyone guess
how will do negation?
>> You can hardset
the control bit to one.
>> How can we hardset
control bit to one?
>> Two controlled NOTS. They're.
>> Not two controlled NOTS,
we just have an X gate there.
So, up to here it's
equivalent to identity, right?
And then we just
flip the output bit
and then we got NOT X.
So, those are
the four circuit values.
Okay. Everyone's good so far?
Everyone knows how we
write our four functions?
Are you ready to
see how we solve
it on a quantum
computer? We use this.
So, we're going to
break the assumption
that this value goes into
the black-box as zero.
We put, first, we initialize
both in putting up
a qubits to zero.
We bit flip them so
now they're both one.
We put them through the
Hadamard gate to put them into
equal superposition then we
send them into the black-box.
One of those four
circuits is applied.
Then we do the post-processing,
we send them through
the Hadamard gate again
and we measure them.
This is measurement.
And I claim, and I will
show it to you that if
the black-box function
is constant
the system will be in state
one-one after measurement.
Like this will have value
one, this will have value one.
We're using input as the most
significant bit by the way.
And if the black-box function is
variable and the system
will be in state zero-one
after measurements.
So this will be zero,
this will be one.
And we will know whether
the function is constant or
variable in a single query.
Pretty nifty, right? I'm going
to show you how it's done.
First the preprocessing.
Remember, we start
with zero then
we'd been flipped both in
the Hadamard gate both.
So we start here, bit flip
takes us up to here,
Hadamard gate down here.
So this is the value that
is sent into the black-box.
Just remember it's in
the bottom right
on the unit circle.
This is the value
right before we send
it through one of
those four circuits.
Okay? Now, let's look
at how we do constant-0.
So constant-0 remember,
it's just blank on
both and the post-processing
is a single Hadamard gate.
So since no gates are
applied they stay in
this bottom right value,
and since the Hadamard gate is
applied as part of
the post-processing,
we flipped back up here.
When we measure this,
this is one-one.
Remember I said
the value would be
one-one if it were
a constant function.
So we're one for one, okay?
Seem okay so far? All right.
Let's add a bit flip
because we're going to
go over constant-one now.
So this is the other
constant function.
Now remember, if
we do a bit flip in
this state we flip across
the unit circle over here,
and the Hadamard gate
then takes us down to here,
zero and negative one.
When we measure it
we again get one-one.
Okay? So we're two for two.
Not bad, right? Okay. Things
get a bit more complicated.
Does anyone have any trouble
with this so far?
And then, yes?
>> I just didn't get like
why it turns out to one-one?
>> Why it works out to one-one?
>> Yes.
>>That's a good question.
Okay. So we're up here, right?
If we measure this
then what value do we
get? This is just one.
Remember, this is
the value of the one bit.
So if you measure
one, we get one.
Yes. Now down here,
if we measure this we also get
one because negative one
squared is one.
So is 100% probability
of collapsing to one.
And so, we can say
this is one-one.
This is like
the most significant bit
and this is the least
significant bit.
So we end up with one-one.
Does that answer your question?
>> Yeah.
>> Okay. Great. All right.
Let's go on to something more
complicated, which is CNOT.
This is going to get a bit weird
but this is how we
do identity remember?
The input bit is
the control bit,
the output bit is
the target bit.
And don't panic,
I'm going to show you why
this is on the next slide.
But the action of
CNOT is to take
our input qubit up to here.
That's the green line. This
is weird for two reasons.
One is that the CNOT
is supposed to leave
the control bit unchanged.
Right? But here this is
the only thing that control bit,
like the qubit it's
the only thing that's changed.
And, this sort of
action is a bit odd,
but don't worry I'm going
to show you the math,
the reason why this
works on the next slide.
But just for now,
so we flip from here up to here,
and then when we do
the Hadamard gate
to post-process we
end up in state zero.
So zero-one, pretty neat.
Okay, here's how the math works.
We're applying the CNOT gate
to the state one over root two,
negative one over root two,
and one over a two, negative one
over root two, right?
When we tensor these together,
we get this ridiculous matrix
which I'm going to
factor out one-half,
just to make it readable.
So, we have the matrix one,
or a spectra is at 1-1-1,1.
Right? Now, we remember
this familiar matrix
from the CNOT slide.
When we apply this matrix
to this vector we get this.
Right? We flip
the bottom two rows.
Now, when we factor this,
remember the products
that we can
factor it into
the individual state,
we get this tensor product.
If you ignore everything
in the middle and just
compare our start values
to our end values,
this is the output or
least significant bit.
This is unchanged.
Right? This is
still one 1/2 -1/2.
The input bit which
started out as
1/2 -1/2 ends up as
1/ 2 1 over root two.
This is just the action
of the gate.
So this is kind
of a limitation of
our visualizer that
we can't really show
the state transition
but I hope I've
convinced you that this arrow
is in fact what happens.
Does anyone have
any questions about this?
Okay so we're three
for three right.
I said the measure value
would be zero-one,
if it were a
variable function and
indeed it is as I said.
So for three-three.Three
for three.
Let's go over the very last one
which is negation.
It's a CNOT and then a bit flip.
Right? Let's see how that works.
Again we have this arrow.
Taking us up to here and
the bit flip takes us
across the unit circle
and we do the Hadamard
post-processing to
get us down to here.
When we measure these,
we get zero-one.
Four for four, huh?
Single query, outperformed
classical computation,
pretty nuts, right?
Pretty nuts. Okay, so we did it.
We now, we have outperformed
classical computing.
Classical computing
is in the dust.
It's done, it's dead.
So we might think like,
yeah I see how the math works
and what's the intuition?
I'm going to tell
you the intuition.
The intuition is the difference
within the categories was
a single negation gate.
So if we go back to here,
so we have constant
zero and constant one.
The only difference
between them is
a single negation gate.
When you apply negation gate
in a superposed state,
it doesn't really
have any effect.
Right? So we kind of
neutralize the effect
of the negation gate.
So we neutralize
the difference within
the categories and
then we magnify
the difference between
the categories which is that
the variable functions
have a CNOT
and the constant
functions do not.
So we magnify the effect of
the CNOT and minimize
the effect of the negation.
And that's a
powerful thing about
quantum computing which
is that you can change
the action of
various logic gates
by putting yourself in
superposition in different sorts
of states and stuff.
So that's pretty
neat. And this problem
you may say like,
"Okay well yeah.
Great. Whatever."
It's really contrived.
When do I ever do
this in real life?
That's a good
question and it was
contrived back when
it was announced,
I think was 1993, but
then a generalized version of
this function was found
which it takes n bits as
input, not a single bit.
And the n bits either all
map to the same value, sorry,
like that's two to
the n possible values,
they all map to the same value
or they equally
map to zero or one.
They're constant or
balanced it's called.
And so it's kind of just
generalized version of this.
It turns out we can still
solve that on a single query.
Exponential speedup, huh?
Exponential speedup.
A single query versus on
a classical computer you
have to try all two to
the n values before you know
whether it is constant
or variable. Pretty nuts.
Okay? Then there's a variant
of that problem building
everyone's kinda like
building on top of each other,
it's called Simon's
periodicity problem.
It's again you have
like a black box and
you're trying to figure
out some properties of
the function and
then once that came
around Shor he looked at
this and he's like, "Oh!
We can use this to
factor large integers."
And so he came up with
Shores algorithm and
that's when the whole field
really caught fire.
So I hope I've
convinced you that well
this individual problem is
kind of contrived
and not that useful,
it's the base, like
the foundation of
some very interesting
computational properties.
Did that make sense?
Anyone have any questions?
You're all like
convinced that we
just crushed a classical
computer right here? Yes?
>>On the Microsoft site
there's an article where
the girl was saying,
with quantum computers
you can take programs that
take billions of years to run
and run them in
a week. Is this...
[Croostalk].
>>This could be
that. I mean yeah.
We have an exponential speedup.
If you have like, I don't know.
What it would take something
like a billion years to run?
Like if you have
an 80 bit function,
like to the power of 80 versus
like a single query that's
probably a billion years
versus a week
something like that. So.
>> A question. So I
understand speedup but this is
the speedup in answering
this question from
the output coming
to get the input.
Right? Whether the function
was a constant function or.
>>Yes.
>> Right? But in
what context is
that question unimportant?
>>Great question. Why do
we care about
this sort of thing?
So for example in
Shor's algorithm you
can construct a question like
does this integer have
a certain factor in
structure basically?
And you can tell a property
like whether it has
that property or not basically
which will allow you to,
and if it does have
that property you
can factor it pretty much.
It's very very hand-waverly
explaining how
Shor's algorithm works.
So you can construct
a lot of problems in terms
of does this function have
a certain property or not,
which you can find
efficiently on
a quantum computer. I hope, Yes?
>> Do you mean
this decision helps?
>> Mainly decision problems.
Although, as we know from
theoretical computer science,
decision problems can be
usually be turned into
like generally
finding the answer
to problems and vice versa.
So, yeah.
Okay, pretty good so far.
To recap the whole presentation,
we learned how to model
classical computation with
basic linear algebra,
we learned about qbits,
superposition, and
the Hadamard gate,
and finally we learned about
the Deutsch Oracle problem,
where quantum outperforms
classical, pretty nifty?
Okay, now the bonus topics.
With all the tools we have
these will be a breeze for you.
You'll never have to read
some pop science articles on
quantum entanglement
and like try
and muddle through there
a horrible metaphor.
You'll actually know
the math, all right?
You'll know the math,
that is incredible.
And we'll go on quantum
teleportation, which is super,
super nifty like
it is mind-blowing.
Okay, quantum entanglement.
You asked a great question,
a very impressing question
earlier which is,
"Can we always factor
the product state
into the qbit state?"
When we cannot do that,
that means that
the qbits are entangled.
For example this state,
if we have qbits in this state
which is one over, two,
001 over root two,
if we try and
factor this, we can.
So let's try and factor this.
If we can factor it,
we should be able to write it as
a tensor product of
two matrices, right?
Where A times C is
one over root two,
A times D is zero,
B times C is zero,
and B times D is
one over root two.
So we have this set
of equations right?
Now, A times D equals zero that
means A or D has to equal zero.
If A equals zero then
AC will be equal
zero and it doesn't,
so A cannot equal zero.
If D equals zero then BD would
equal zero but it doesn't,
so D cannot equal zero.
So the only solution is there is
no solution. We
cannot factor this.
This is an percent
unfactorable state.
And what this means is we
cannot separate these qbits.
They have no individual value,
their value only make sense
together, they're
called entangled.
And the way we might
think of this is
that if we measure this state,
it has a 50 percent chance
of collapsing to zero,
zero and 50 percent chance
of collapsing to one,one,
so the qbits are
coordinating, right?
Does anyone have
any confusion with
this sort of mathematical
representation?
Okay, let's talk
about what it means.
Well, let's not talk
about what it means
yet, you might be like, "Well,
Andrew I can sling
any old value into
the vector how do you
actually entangled
qbits?" It's really simple.
If we have two qbits,
we just put one qbit through
the Hadamard gate to
put in superposition,
and then that qbit is
the control bit in C naught.
Two gates, that's all we need.
Here's how it works
mathematically.
We started with zero zero,
we put the most significant bit
in superposition, right?
And then here's our familiar
matrix, seen our matrix.
If we apply it to
the product state, we get this.
This is the state from
the previous slide.
So really simple
to entangle qbits.
Okay? What does this mean?
I mean they seem
to be coordinating,
or like communicating,
or something
in some way, these two qbits.
And if you measure one qbit,
it collapses the other
in coordinated state.
Now the weird thing,
here's how we're going do
really weird stuff here, okay?
This happens across
huge distances.
China just this year,
managed to do this between
Earth and a satellite in space.
They entangled qbits, put
one half on the satellite,
it was launched into space.
When they measure them,
they're the same value.
It happens across
huge distances.
It happens faster than
light, it is instantaneous.
A 2013 experiment
entangled qbits,
moved them very far apart,
synchronizing with
an atomic clock,
they measured them
very close together.
So close together and time
that it would have taken
like 10,000 times longer
to travel between them.
So they aren't communicating
with any sort of
radiation anything
like that, okay?
They are instantaneous,
it's faster than light.
And you might be like "Well,
it's pretty obvious
what's going on here.
When the qbits were entangled,
they just decided ahead of
time what they're
gonna do, right?"
Well I got to
explain everything,
but that's called
hidden variable theory,
this is hidden variable theory.
It's the same reason that
when a qbits in superposition,
it isn't secretly zero,
or secretly one, it's
both, it's the same thing.
Hidden variable
theory, we're not
going to over the proof
why it doesn't work,
but basically here's
this guy named John Bell,
and he showed that if hidden
variable theory were true,
it had some really
weird implications,
and therefore it's unattainable.
This is just the state, this
is how the universe works.
They coordinate
faster than light,
they just do and that's nice.
And you might be like, "Well,
I've been told
my entire life there's
a universal speed limit,
the speed of light, right?
Like what's up with that?
We can't just chuck it all out."
And this is in fact a big source
of consternation to Einstein,
the idea that
locality wasn't true,
and then it was discovered
that there's a really
important qualifier.
You can have faster-than-light
coordination,
but you cannot have
faster-than-light communication,
so information cannot be
communicated. So think about it.
If I entangle two qbits,
I give you one,
we go to opposite ends of
the universe, if
I collapse mine,
all I know is that
you collapse yours,
and when you collapse yours,
you will see the same thing.
That there's no information
that can be communicated
there really.
So, faster than
light coordination is okay,
faster than like light
communication, not okay. Yes?
>> Coordination does not
involve communication?
>> It does in a way,
but communication here is
a technical term
which means like,
I have a bit of information
that I can transfer
to you, pretty much.
So I use the term
coordination to try and
give a name to something
which is not that,
but still involves
like some kind
of coordination I guess.
Like I said, there is
a limitation of our language,
all we can do is look at
the math and see what it does,
and our language it was
not developed for this.
Anything I try and tell you is
fundamentally a lie,
except for the math.
>> I have a question.
>> Yes.
>> So let's say I have
two entangled qbits.
>> Yes.
>> And I measure one
and I know its value.
Does that mean
that the other one
is could potentially
still not be measured,
but when it is measured it
will have the same value?
>> Right, when you measure one
it instantly
collapses the other.
>> I'm sorry, that was
my question earlier.
>> Yeah, good question.
I said that's
a simplification again of
language but you can
think of it that way.
Yes, sorry you had a question.
>> So there's no way to tell
that something has been
collapsed or not then.
>> Excellent question. If you
could tell whether something's
been collapsed or not,
you could measure one and
use that as synchronization,
faster than light
synchronization, right?
Yeah you can't. The process of
telling whether something is in
superposition or not
would just collapse it.
>> It seems like you will
be able to tell through
some of the sort of
quantum computation,
like you do some computation
on that, they was collapsed,
they would only be
this state and if
it wasn't it would sometimes
do this, sometimes do that.
>> You would think so, but
in fact it is not the case.
>> I believe you I was
just creating imaginations,
is there any intuational ways
about the case?
>> Is there intu can I say intu?
>> Shut up and do the math?
>> Shut up and calculate,
that's a good like a way out.
I'm not sure I can't
say it intuitively,
I can say that if you do put
a pencil and paper
it, try it yourself,
try and come with
some sequence of
operations you can do on
the other qbit
which would reveal
it as having being collapsed
or not then maybe but, yes.
>> Doesn't this coordination
communication conversation
that we're having
violate causality or it doesn't?
>> Yes, this is
the critical thing,
it does not violate causality.
If we could communicate then
it would violate causality,
but since we coordinated
does not violate causality.
>> But instead
what you said was,
if you measure
the other one is going
to be that as well, right?
>> Yes.
>> The act of measurement
is in your control, right?
>> Yes.
>> So how can that happen
on the other side of
the qbit if you don't have
communication because that's.
>> Well let's define
what communication is.
Communication is I have a bit,
either zero or one and I'm
able to send it
to you in someway.
>> Somehow yeah.
>> Yes.
>> The state that
is not collapsed,
be communicated to
the other state,
this is what I'm saying.
>> Yeah I mean this
is a language problem.
Qbits are like communicating but
we can't get information
through them basically.
You might be able to say that.
I use that term coordinating
to try and avoid this problem.
Other times in literature
you'll just see
the word correlated.
Which tries to avoid
that whole problem.
>> Coordination, it state
the word here when you are
using it, it has an action
that you have performed.
>> Yes, you control when
you measure in qubits
it collapses the other.
But there's no way
you can change
causality in
that other qubits frame.
Basically, there's no way
you can get information from
your frame into that frame
which would affect
their causality.
All we can know is,
we have generated
the same random numbers
basically, yeah.
>> It's kind of like
pre-coordination so these are.
>> I want to avoid that,
pre-coordination is
the qubits decided ahead of
time which is not the case.
>> Until you measure.
>> Yeah.
>> Or until these.
>> At the time they measure they
decide whether they're going
to zero or one and they somehow
communicate that coordinate,
correlate, whatever,
to the other qubits
and it goes in the same. Yes.
>> So, if you cannot communicate
what's the practical
application of quantum?
>> Great question.
We're going to get into
quantum teleportation
on the very next slide.
First, I want to tell
a funny story about this.
So, you may have
heard the phrase spooky
action at a distance.
This is Einstein coin that
he was referring to this.
So, Einstein,
Podolsky and Rosen are
three physicists who actually
came up with the idea
of quantum entanglement.
They call it the EPR paradox,
there like the workings of
quantum mechanics
result in this.
This is obviously
absurd therefore,
quantum mechanics is garbage,
was the basic argument.
But then the experiments came
out and they're like nope,
this is how it works,
the universe is in fact absurd,
locality is broken
and so it's kind of
funny that a deep
pair of paradox
is originally designed to
discredit quantum mechanics,
it turned out to be the actual
way that the universe works,
I think it's
a great little story.
Okay. Any other questions
about entanglement, yes.
>> Let's say the same
problem, the qubits.
>> Yes.
>> If we say that
this has a certain probability
collapsing to zero
collapsing to one,
and then we observe that
it collapses to one.
>> Yes.
>> How can we justify that
our presumption that it had
a probability of collapsing
to zero was valid?
>> Excellent question.
The answer is used a whole bunch
of times and you see
that you get a 50 percent
distribution of values.
>> Exactly they won't be
occurring at the same time.
>> Experimentally, we know
that they occur
at the same time.
With the 2013 experiment.
It entangled qubits took
them far apart it used.
>> No, I mean the same qubits.
>> Yes.
>> It happened at time X.
>> Yes.
>> And now you take
another pair of qubits
and this is another pair of
qubits but not
necessarily the same ones.
>> Yes.
>> So, until it
happened at that time,
that space or whatever,
you can't really tell that
this was happening
with probability.
>> One half.
>> Yes.
>> You're questioning, okay so,
they could have
decided ahead of time
for example maybe or.
>> Yeah, or probably
the language of probability
itself is not active.
>> It works. Probability
works I mean,
it's just the amplitude
squared gives
you the classical
probability of it
collapsing on
zero or one I guess.
I'm not a 100 percent sure
what you're driving at, so.
>> So, The question is once
observed then we rationalize.
>> Once observed then
we rationalize, yes.
And then if we do the experiment
a whole bunch of times we
see that it's about
a 50 percent chance
of them both being
zero or both being one.
Which in fact, I will
show that to you live on
a quantum computer
that we do that, okay.
All right, let's move on
teleportation This is
the actual use which you
asked about and you've
probably read about
quantum teleportation
again in pop science articles.
Needless to say, their
explanation was complete trash,
made no sense at all,
but now it will make
sense to you, okay?
It's the process by
which we take
an arbitrary qubit state,
and transfer it across space
and time somewhere else.
So, you use entangled
qubits as a sort of
bridge to send a qubit
from one place to another.
And here's a very
important thing
it's called the
no-cloning theorem.
You can transfer qubit states
so you can cut and paste them,
but you cannot copy them,
you cannot copy and
paste a qubit state,
you cannot clone it.
This is called the
no-cloning theorem.
It's actually pretty simple
to prove you just show that
any off-such operation would not
be reversible or
its own inverse,
but we're not going
to go do that.
And, here's an
important thing, the
teleportation despite using a
faster than light phenomenon
of entanglement,
is not itself the whole protocol
is not itself faster than light
for communication because you
actually must exchange
two classical bits.
So, if I'm teleporting
my qubit to you in addition,
to us having
an entangled qubit pair,
I also have to send you
two bits of information
and we'll show why that
is in the next slide.
So, everyone kind of
conceptually grasp
the purpose of
quantum teleportation?
Okay. So, here's what
the circuit looks like.
We're not going to go
over the math, there
are appendices to
this slide deck
which you can see
after the class to
go over the math
but it gets a bit
complicated so we're
not going to do it.
So, we have the qubit
that we want to teleport
here we call it T
and its value is phi,
is just this generic qubit value
can be any value.
And then, we have
these two qubits A and
B which are both
initialized to zero.
Now, you will recall this
is the entanglement circuit.
So these two qubits are
entangled, all right?
Now after they're entangled,
we'll say we have Alice and Bob.
Alice wants to send her
entangled qubit to Bob.
So, Alice has these two qubits,
Bob has this qubit.
And these two qubits
are entangled.
So, the qubits are like
these two qubits
are separated right
after being
entangled, basically.
Now, Alice then entangles
her qubit she wants
to teleport with
the other two qubits.
So it's a three qubit
entangled system.
If you were to write out
the product state you
wouldn't be able to factor
it into three qubits.
Then she puts this qubit
through the hadamard gate.
Finally, Alice measures
both qubits in her possession,
and this results in
two classical bits.
These are the two bits that
Alice has to send to Bob,
and the measurement result of
this bit determines whether Bob
has to run his qubit through
an X or bit flip gate.
And the measurement result of
this qubit to controls whether
Bob has to run this qubit
through a new type
of gate which we
haven't seen before
is called the phase
flip gate or Z and this is
what the matrix looks like.
And basically, once Bob has
applied those two gates
or neither gate,
if both of these end up been
zero Bob doesn't have
to apply anything,
he'll end up somewhat magically
with Alice's qubit value
she wants to teleport.
Pretty nifty. And you might
be like while we already
exchanging a qubit here
why do we even care
like we're obviously just
giving a qubit to Bob,
can't Alice just give
her a qubit right there?
So, what you can do is you can
pre-entangle a whole bunch of
qubits a few billion
qubits or something.
And then you ship them by mail
they're called EPR halves.
You ship them by mail or
something so Alice and Bob
have a big repository of
these entangled qubits,
and then anytime Alice
wants to send to a qubit to
Bob she can just use up
one of the EPR pairs.
And at that point,
that EPR pair has been collapsed
can no longer be used so
it's non-renewable resource.
But Alice can just send
as many qubits as she
wants over to Bob.
Okay? Now, you might be saying,
"Well I don't really get this."
The math is in the appendix if
you really want to go see it.
It gets pretty complicated,
but I think I did
an okay job of explaining it.
Okay, you might be like "Okay."
Oh by the way, I forgot to
say, really important thing.
You may have heard
that we can simulate
quantum computers on
a classical computer
but it takes exponential
slowdown or exponential memory.
This is the reason,
if two qubits
become entangled you have to
keep their full
product state around.
So, if N qubit with
become entangled
you have a vector of size
two to the N you have
to keep in memory.
And that is why, it takes
exponential memory to simulate
a quantum computer on
a classical computer.
Pretty nifty, okay.
So maybe you're like,
"Okay this is all pretty
interesting, further
learning goals."
You can learn the
Deutsch-Jozsa algorithm that's
the one with N bits
that I talked about,
and also Simon's periodicity
problem which is another,
I figured out some property
about this function.
We're not going to talk about
the complexity stuff but
anyway you can also learn
Shor's algorithm,
Grover's algorithm,
Quantum cryptographic
key exchange,
that one's actually
pretty simple
I recommend looking at that.
You can learn how
they're actually
implemented in physical terms,
if you care about that.
An important thing quantum
error correction since
these systems are so small
like a spare cosmic gray could
just come out of
nowhere and just wreck
your entire computation you
need very very stringent
error Correction Schemes.
So, I think
theoretically it takes
five physical qubits for
a single logical qubit like
we've been operating that.
In practice, is looking
more like we'll need one
or two hundred to get a qubit
of 100 percent probability
like we've been
using pretty much.
So that's something
to keep in mind.
When we see Google's
coming out with
a 30 qubit computer that
maybe doesn't mean
as much as we'd hope.
We've made only guys like
two or three really
high-quality qubits.
And also quantum programming
language design which
I will go over
because I'll show you
a Q sharp example but anyway,
recommended textbooks.
This one is
my absolute favorite,
has the same title,
has the name of the talk,
Quantum Computing for
Computer Scientists.
This algorithm is by
our friend David Mermin,
the shut up and calculate guy.
It is a meat grinder of
a textbook but I started
out with this one.
It was horrifying,
it was just like,
but it skips a lot
of steps basically.
It's more symbolic manipulation.
You won't see as many
vectors and matrices.
I like to write
out the vectors and
matrices to see what's
going on which gets
really unwieldy when
you're writing out like
a 64 by 64 vector or matrix.
But I like to have
both of these.
So, I'll use this to fill
in the gaps with this.
This has more interesting sides,
stuff like that.
This is also in the MS library.
There's another one called
Quantum Computing
Gentle Interaction,
also in the MS library.
I've heard mixed reviews or
semi decent reviews of it. I
haven't looked at it myself.
There is also Mix of
Quantum Development kit.
They have the docs.
They're actually
pretty nice thing called
the Quantum Computing Simulator
and Q Sharp as we'll see.
Now, I said I would
end the talk on
some skepticism which
there's an article,
came out I think was
Quantum Magazine pretty
prominent recently,
interview with
a mathematician who believes
that physically realizable
quantum computers cannot exist.
His basic argument simplifying
is that the amount of
noise in the system grows
exponentially with
the number of qubits.
So we cannot get a really
large qubit system because
our computation will
just keep collapsing
in the middle of it and
it's just like
an exponential term.
And so, I'll be very
sad if this happened.
I'd feel like the universe
is against me.
It'd be really,
it'd be very sad if
we could not realize
the benefits of
Quantum Computing,
like cosmetically sad.
But anyway, you can't argue with
the universe and yeah
you can read that article
for some skepticism.
I think his name is Gil Kali,
is the mathematician.
There's some appendices but
I'm going to do some demos now.
Okay, the first demo is
just the Doge Oracle
problem in Q sharp.
So Q sharp is based on F-Sharp
and we have this function
I've written,
IsBlackBoxConstant.
You've taken a black box
and they tell
you whether it's constant.
Oh, gosh, sorry.
Here, of course.
Okay. We have our function
IsBlackBoxConstant
where it takes in
a black box and it just
returns the Bool. Is
it constant or not?
And it just uses
this same protocol we went over.
It allocates two qubits,
calls one input one
output, clears them,
sets them both to zero,
does the preprocessing,
flips them, puts them
through the Hadamard gate.
Then it sends them
into the black box.
Afterward, it again
put some through
the Hadamard gate
and then it measures
both of them and again if
the input results is one,
then it's constant
otherwise its variable.
Okay? We have our black boxes
defined here. So, ConstantZero.
Again, remember it's nothing.
For ConstantOne we
flip the output bit.
For Identity we run
a CNOT gate with
input control up it is target
and Negation reducing
our next, okay?
And we just have these,
like IsZeroConstantZero I call.
Is BlackBoxConstant
with ConstantZero?
And then we have
our classical driver.
Any quantum computation
will have a sort of
classical computer to
tell it what to do,
and so I ask
for each of those four,
well, what's going on?
And we can run it and it
runs on a simulator and we
see the output,
IsConstantZero constant?
True. ConstantOne constant?
True. Identity constant?
False. Negation constant?
False. So there you go.
Yeah we wrote the Doge article,
ran it on a real
quantum simulator,
you saw that it worked out.
Okay, the final demo of
the day and then I'll
let you get out of
here is here we go.
This is called the IBM
quantum experience.
There is a real like
world quantum computer
that IBM has built.
It only has five qubits but
they just let you online
just drag gates onto
this quantum circuit diagram and
run it on a real
quantum computer.
So I thought it'd be pretty
nifty if we demonstrated
entanglement live for
you on stage. Let's see.
So, if you remember
the first thing we do
is we drag a Hadamard gate onto
one debt and then we use
the control not, oh no, okay.
So, the way that
quantum computers are
constructed you can only
usually put CNOT between
certain debts basically
it's just kind of,
otherwise it's just
mechanically impossible to see.
Can we do that? Nope, okay.
How about, success.
Okay, we did it.
This is the CNOT gate.
You can see varying
representations
of it. It's like the opass.
And I say we'll run it on
a quantum computer, oh
right, measurement gates.
I forgot. We need to add
the two measurement
gates obviously.
So we're measuring
both these qubits
after entangling them.
And what we expect is to
see them predominantly been
0-0 and 1-1 right?
Well, let's test it.
We'll call it that and
we can save the result from
cache but I want to do
it live for you guys,
so I'm going to run
a new execution.
And you can imagine right
now deep at IBM Research Lab
nestled within
a dilution refrigerator
operating at slightly
above absolute zero,
we have real qubits being
entangled and
measured thousands of
times for our entertainment.
That's pretty cool.
>> It is.
>> That's pretty cool.
Okay, let's see if it's,
oh here we go, we
got the results.
And executions
it's pending, okay.
So it might take
a couple minutes.
We're going to see now.
Does anyone have
any questions while we're
waiting for this? Yes.
>> I don't know what question.
You said this experiment where
this sentiment tangled qubit
to space and the satellite?
>> Yes.
>> Are we good at storing
like qubits for a long time?
I'm really surprised
they were able to
do that. I thought
they kind of...
>> Yeah, yeah, that
was actually a lot.
They will manage to send
the entangled qubit up
file laser but, yes.
>> Okay.
>> I don't think
we're that good at
storing qubits for awhile.
I think they're
fairly short-lived.
>> [inaudible]
>> Yeah, they actually,
this Chinese
satellite experiment,
they teleported
a qubit up there.
So they sent one EPR half up
by a laser and then they use
that EPR half to teleport
the qubit up there. Pretty cool.
>> That's awesome.
>> Yeah.
>> So we can send
entangled qubits by laser?
>> You can send entangled
qubits by laser, yes.
>> Okay, that's even cool.
>> Yeah. Let's see,
it's still not.
Okay, that's fine. Anyway, yes.
>> You mentioned that there's
this new article by
the mathematician that says
the noise has grown faster.
>> Yes.
>> What is the whole purpose of
a topological quantum
computer resist that.
>> Of course.
Any corner computer will
have issues with noise.
The topological quantum computer
is supposed to be better than
its IBM counterparts in
terms of noise but it'll
still grow exponentially.
Like it can still
be better but it
still runs into
exponential barrier.
And so the next couple of years
are really sort of
make or break for
quantum computing because
we'll now have the ability to
create computers which run into
this exponential term if
it exists, if it exists.
And so we will see with
the next couple of years whether
quantum computing is
really possible or not.
It's nervous and it makes
me nervous but yeah,
because we'll run into
this limit probably
like this year.
If Google does not
manage to demonstrate
quantum supremacy
it'll be a bit scary
I guess but yeah.
Let's see, we don't have, I'm
just going to refresh this.
>> Question.
>> Yes.
>> Do we know what Google
uses Quantum theorem
for, like what?
>> What they use it for?
>> Yeah.
>> I don't believe we do.
I think they just have...
>> Is it experimental mostly?
>> Actually no.
They haven't announced
what they use it for.
My manager is actually
playing around with
the D-Wave simulator to...
>> The Canadian company.
Is it the Canadian company?
>> D-Wave is Canadian company.
Yeah, everyone out there is
like really scammy
and not really
quantum but everyone
kind of believes
that they're quantum but
it's a different paradigm.
It's like optimization basically
but it uses quantum computing.
They have a simulator
you can use.
My manager has been using it to
kind of play around with
finding routes in a network.
It has general applications like
that. Well, this
is taking a lot.
>> The data is publicly
available somewhere?
>> Yeah, it's in the invitation
and I think it'll
probably be posted
on their resonant website
or posted online.
>> So that application is like
a requesters type
of application?
>> Yeah, yeah, it's like...
It's optimized.
You're able to express
the network graph
in terms that like
an optimization result
would be like
the least energy path
in terms of like
the least cost path
through the graph sort of.
That's different than
the way the [inaudible].
>> Open Shortest Path.
>> Come on, why isn't it going?
Pending. I'll be
really sad if this
doesn't finish in time. Oh well.
>> So on D-Wave,
how are presentations
centered you could do
classically faster than
when they were doing.
So, they've improved in that or?
>> I don't know actually I
haven't looked into that.
They're probably about
comparable I would say.
Because given that
it's just like
optimization and especially
with the explosion of
machine learning there's been
a lot of development in
making optimization better.
Optimization is like you
have a surface and you're
trying to find the highest point
or the lowest point.
So there's been a lot of
research that goes into that.
We'll just run it
from cache and okay.
Here we go, okay. So here's
the results from cache.
Unfortunately our real execution
didn't finish yet but.
So we see that indeed
they entangled some different
qubit than ours but we
end up with 0-0 and 1-1 almost
exclusively but then
there are some in
the middle because of
the error rate, right?
So this is on
a real quantum computer.
We have some error rate where it
doesn't exactly
work according to
our model all the time
but pretty cool,
these are entangled and they're
measured and we have that.
That's the
experimental data right
there that entanglement
is a real thing.
Yeah. Okay, that concludes
the presentation.
Thank you very much. I hope you
all feel as though you
followed the whole thing,
no real confusion and
feel that you could
keep on learning.
This isn't like
mad genius science.
This is very accessible science.
So, thank you very much.
