>> Good morning, everybody.
And it's an honor for us to have Edward Farhi
with us today.
Edward Farhi is the director of Center for
Theoretical Physics at MIT and by training
and by heart at this part of his physicist
but that didn't prevent him from becoming
one of the most influential syncers in quantum
computing.
Edward is the inventor of the Quantum Adaiabatic
Algorithm which simple folks like me who work
in a machine-learning pattern recognition
is probably the most enticing entrance way
to quantum computing.
People who are familiar with concepts like
[INDISTINCT] even though it is, at it's core
different algorithm sort of the flavor, how
you present data and how you get results out
of it, a very similar and easy for us to get
into.
So Edward today will present his newest work
and I'm very curious, too, to hear this talk.
>> FARHI: Thank you.
Am I--am I on?
Okay.
Thanks very much for having me.
Let me get my thing up and--where's my talk?
Wait a second.
Option, command L, and then I go back.
Okay.
So my talk is really about what I called Physics
Based Approaches to Quantum Computing.
What I want to talk about is using physics
to design algorithms and I'm going to do this
really by example to show you that we can
use physics to design algorithms and the example
that I want to focus on has to do with games,
determining who wins the game and let--let's
begin with that.
I want to imagine we have a game, and the
game I--I'm going to abstract the game down
to a game where we just have two players,
each of which we could make two moves and
the game is a finite game and after M moves
the game is over.
So what I have up here is a depiction of--this
kind of confusing, these are the same.
Okay.
Right.
There's a natural tendency to think that this
is the next slide, but it isn't.
It's the same.
I have to deal with this.
Okay.
That's the same slide.
So I--you have--I have a two-person game and
each person can make one of two possible moves
in their M rounds.
So I'm going to represent the history of the
game by a tray.
So we start right here at the bottom and it's
my move and I kind either go left or right.
Then it's your move and you can either go
left or right.
And then, it's my move and I can go left or
right.
So as we go up to the tree, we have a depiction
of the possible histories of the game and
at the very end of the game, every final position
is either a win or a loss for me depending
on the rules of the game.
That's what defines the game.
The game is to find by the definite--the rules
that say whether a final position is a win
or a loss for me.
Please ask questions if it's not clear, okay?
And the way the game is going to be given
to us is if you know the final position if
you could look up on a table or make a query
and see whether that final position is a win
or a loss for me.
Now, so and I--really, almost any game can
be put in this form.
Chess can be put in this form or checkers.
On a limit--I just don’t have draws that
I make in the end after a fixed numbers of
moves.
Okay, any questions so far?
Now, in this situation, it's determined at
the beginning who wins the game if we both
played best possible and I would like to show
you that.
Let me show you why that is.
I just copied over that game tree from the
previous page and at the top I had wins or
loses for me.
Well, let's look down here where it's your
move.
At this point, suppose we reached this point
in the history of the game and it's your move,
well, both places that you can go are wins
for me.
So you lose.
I hope that's clear that you lose because
either place you go is a win for me.
If we reached this point in the history of
the game, then if you--it's going to be a
win for you because you're going to go to
the place that's a lose for me.
If we--if we go down one more--a layer in
the tree, if we see--if it's--if it's now
my move and I see that if I go here you lose,
well, it’s a win for me.
And if you recourse down the tree to the very
bottom, using all the information from the
top, you can determine at the bottom who wins
or loses by recoursing down the tree.
So this is a general property of all games
that if both players played best possible,
it's determined at the beginning who wins
or loses.
Now, it may be very complicated to figure
that out because if you play chess, there
are so many possibilities down here that it's
impossible practically the recourse down but
in tic-tac-toe, we all know that at the beginning,
you know, one of us is going to win and you
can usually figure out who it is.
So this is the general structure of a game
and like I said, it's a term of the beginning
who wins.
Now--but you can ask yourself the following
computational question; "Do I need to look
at all the final positions to determine who
wins or looses?"
"Do I have to query every final position?"
The answer is no.
You don’t have to look at every final position.
Let me show you why.
Let's go back to this corner which I have
been focusing on.
In this little corner, if we--if we'd look
at these two wins for me, that produces a
lose for you.
And it that means that at this point it's
a win for me regardless of what this is.
It doesn’t matter what these oppositions
are.
If we reach this point in the game and I go
here, you lose.
So it doesn’t matter whether this is a win
or a lose for you.
I win if that is a lose, okay?
So in fact, you don’t need to query all
the final positions to determine who wins
the game.
You--and there is a--classically, there is
randomize algorithm for determining who wins
the game and it requires N to the point 753
queries.
A query means a check of a final position
to see whether it’s a win or a loss at N
to the point 753.
Now, where does that come from?
Well, the way get the N to the point 753 is
there is a recursion you can write down for
the number of queries when you look at a sub
tree.
So you write down the number of queries you
need to evaluate this, the number of queries
you need to evaluate here and then you use
that to refer there number of queries you
need to get there.
And when you solve that recursion, you get
a quadratic formula and this point 753 involves
the square root of 33.
So I'm not going to show you this algorithm.
This is classical.
But this algorithm is N to the point 753 is
best possible--what?
>> [INDISTINCT] is that worse case [INDISTINCT]
>> FARHI: Yeah, it's--yes.
This is the original better algorithm than
this.
It’s a randomized algorithm and it's best
possible.
So what we are going to now show you is that
the quantum computer, we're going to do better
than this, than the N to the point 753, okay?
So we're going to--I'm going to show you eventually
a quantum algorithm that outperforms the best
possible classical algorithm to this problem.
Now another--just one word on notation here,
this thing--game tree evaluation is equivalent
to something called NAND Tree Evaluation because
if you look at the rule of the game the way
I had it in the tree, the rule for evaluation
of the tree, if there were two loses above
you, there is a win below.
A loss and a win above you, it's a win below.
A win and a loss for your opponent is a win
for you below where two wins for your opponent
is a loss for you.
But if you look at the NAND gate, that is
exactly the same thing if you're placing L
by a zero and a W with a one.
So this is sometimes called NAND Tree Evaluation
and in all paper, it's called NAND Tree Evaluation.
So NAND tree is a tree where I put a string
of zeros and ones on the top, that's the input.
And at every vertex below, you have the NAND
of the two things above that.
And then the question becomes, "What's the
NAND at the bottom given the input?"
So it's exactly the same problem, the game
tree, as NAND Tree Evaluation.
But NAND tree is--the NAND is a universal
gate for computation and NAND Tree Evaluation
is related to circuit evaluation of moving
formula evaluation.
So this is not just an exercise for games,
okay?
Now, I--what we're going to now do is I'm
going to switch to quantum mechanics.
And I assume some of the people who want [INDISTINCT]--I--maybe
I should even ask.
How many of you had an undergraduate class
in quantum mechanics?
Okay, that's a lot.
Good--uh-hmm?
>> Just a graduate one.
>> FARHI: Just a graduate one.
Okay.
That's--this is so good.
Okay.
Did you get good grade?
>> Uh-hmm.
>> FARHI: Okay, good.
I'm just checking.
Okay.
So I want to give you a little refresher.
So let's just walk fast on refresher.
I'm going to summarize everything we need
to know about quantum mechanics.
If you--quantum system is described by finite
dimensional Hilbert Space.
The reason I'm only--I'm only going to be
really interested in finite system, so I'm
going to use an infinite system as an approximation,
but we have finite systems.
And the way a quantum system is described
is by Hilbert Space, a complex Hilbert Space,
and we have vectors which live in this Hilbert
Space, and we depict the vectors just so we
get my notation by these things called Cats.
And the thing inside the cat is the name of
the vector.
So this is the vector whose name is Si.
If we have two vectors, there's an inner product
which we denote like this.
And we can have a basis for this Hilbert Space.
So we could have a set of vectors which span
the space, a linearly independent set where
A goes from one to the dimension.
And then A sized the component of Si in the
spaces.
If this is an author normal basis for example,
that means the inner product today with B
is Delta AB.
That means that this--they're orthogonal.
Every vector is normalized.
They're orthogonal to the others, that's called
an orthonormal basis and the inner product
of Si with Si if they'd written as the sum
over the component squared of the vector--of
this quantity.
Okay.
Everyone know this much quantum mechanics.
Now, if we continue just a little bit more,
all quantum systems obey this equation.
This is what I call the Schrodinger equation.
I [INDISTINCT] bought a one which means that
there is the time--this is the time evolution
equation of the system.
It says that given the state in one time,
I can determine the next time by solving this
differential equation.
This is the Schrodinger equation.
It's never been violated.
There's never been a violation of this equation
ever seen.
It's consistent with relativity.
We need to got--do a relativistic quantum
field theory, just get a nice relativistic
Hamiltonian.
But this is the basic law of quantum mechanics.
And note that the evolution is deterministic
because I know the way function at early time,
I solve this differential equation, I get
the way it function at late time.
When you make a measurement though, probabilities
can arise and the way measurement works in
quantum mechanics is you associate with observables
which the things you measure, operators which
are permission operators and every absorbable
corresponds to Hermitian operator.
And these operators have Eigenvalues.
And Eigenvalues means the operator acting,
or matrix if you wish, acting on a vector
is the number times the vector.
So the way we read this equation is this cat
is--has its--it's name is given by its Eigenvalue.
So this is the cat whose Eigenvalues is lambda
sub I, which is an--if an Eigenvector corresponding
to the Eigenvalue lambda sub I and it--according
to the rules of quantum mechanics, when you
make a measurement you only [INDISTINCT] Eigenvalues.
And if you're in the state Si, the probability
to got this particular Eigenvalue is the inner
product of your normalize way of--of your
normalized state vector with the Eigenvector
squared.
And that--these are the rules of quantum mechanics.
And these rules had never--no violation has
ever been seen.
Okay.
And so when we do quantum computing, we’re
just basically going to assume these rules
since they are--they are God-given and never
been violated.
And then try to turn--see whether we can design
computers which we use these rules as suppose
binary arithmetic and see whether we can turn
into computation advantage.
Any question?
Okay.
Now, in quantum computation, there is something
called the Conventional Quantum Computing
Paradigm.
And let me try to tell you what that is.
Again, I told you that every quantum system
will base the Schrodinger equation.
Which means at your time evolution is given
by this.
But what that actually implies is that you
have your state vector than early time, the
vector that later time is given by a linear
transformation on, the state your full name
and spell your last name factor of early time.
And that linear transformations happens to
be unitary.
And what unitary means basically is inner
product preserving.
Now, the reason--and an inner product preserving,
and this implies your norm preserving which
means you don’t lose probability.
So you can view evolution quantum mechanically
either as continuous time evolution with a
Hamiltonian or you might think that what you’re
doing is applying a sequence of unitary transformations
which take you from here to there.
And in a conventional gate model of quantum
computation, the algorithm designer designs
a sequence of unitary transformations which
the designer thinks of as gates.
And the sure algorithm, for example for prime
number factorization, is presented as a sequence
of unitary transformations which he identifies,
he says, do this, this, this, this and out
come the factors of the number.
We are going to take a different approach.
What we're going to do is physicist has designed
the Hamiltonian not the unitaries.
Obviously, these things are equivalent in
some way but when you’re searching for new
algorithms, this--the difference in approach,
might help you in the discovery of new things.
I’m not being--I’m not going to be philosophical
about which is a better approach.
I’m just going to do it by example.
You know, if you can--if you could find something
in this approach, it’s the value, okay?
So in this context, I would like to talk about
what is the general quantum algorithm?
What is a quantum algorithm?
Well, the first thing to have a quantum algorithm
is you need a problem to solve because quantum
computation, at least in the stage it’s
in now, is not universal computation.
It’s not internet searched.
What it is is it’s solving special problems
like factorization or game tree evaluation
or--and new--and so you have to have a special,
you know, it’s not an all purpose computer
yet.
It’s something which is designed to solve
problems.
So the first thing you need is a problem.
Then what you do--and by a problem, I don’t
mean, of course, I don’t mean a factor or
number, I mean design a program which will
factor for any input because we’re computer
designers here.
We’re not looking for answers.
We’re looking algorithms which provide answers.
Okay?
So, when you have a problem design--to solve,
then what is the quantum computer algorithm
designer do?
Well, the designer then picks a Hamiltonian
because that determines the evolution of the
system.
The designer then picks an initial state of
the quantum system.
The designer picks a runtime of the algorithm.
The designer says the run--the quantum algorithm
is going to run for a certain amount of time,
capital T. He or she didn't let the system
evolve, according to the Schrödinger equation,
no choice here.
So you start your initial state, you evolve
in the time T, you then end up in the way
function at time, capital T because you evolved
with your Hamiltonian from your initial state,
the time, capital T. You then measure some
operator.
You make a measurement and what you get out
from that measurement is a number which you
then--or a string of numbers and which you
then called the solution to your problem.
So that’s the view of quantum computation
that I wish to take; general Hamiltonian time
evolution, according to a designed Hamiltonian,
followed by a measurement, which encodes the
solution to the problem.
Now, is this as good thing to do or not?
Well, that depends on how the run time of
your algorithm scales with problem size.
And that depends on how the resources needed
to build the Hamiltonian scale with the problem
size.
So this is good, if you can discover, like
for example with the factoring algorithm,
which I assume some of you have heard about,
that the run time scales rate favorably in
terms of the number of digits, this is a success.
So we're going to--that’s our standard here.
And, of course, I’m going to show you in
the game tree that the--it’s a success.
We’re going to de better than the classical
algorithm.
Okay.
Any question about that, about the general
quantum setup?
Yes.
>> So, do we care about, like for the person
today, like how to actually implement things?
>> FARHI: No.
No, no, no.
These are the question--I’m supposed to
repeat the question because there are people
who are far away.
The question was, do we care about implementing
quantum computers?
Not at this part of the talk.
I--you can ask me that at the end.
But for the sake of this, I would like to
assume that we have a perfectly functioning
device at our disposal.
We have endless engineering capability.
We just must two things consistent with the
laws of physics.
That's our only restriction.
And after we--if we first see whether according
to the laws of physics we have advantages
and we worry about engineering later.
Okay.
Okay.
Now, in order to--I need to take you in a
little aside which hopefully some of the people
who know about like computer science know
a little bit about.
This has to do with what an Oracle is.
The people on an Oracle, I know Oracle is
the other company.
But I mean the people that know what an Oracle
is in computing.
You do?
Some of you, yeah.
Okay.
But I'm going to go over it for what an Oracle
is.
I would like to consider what I called the
conventional classical Oracle.
So, the classical means we're not doing quantum
computing for a minute.
And I want to apply this to a particular thing
which I called global search.
I would imagine--I want you to imagine we
have a function f(x).
And this function is defined on the integers
from one to capital N, okay?
And this function outputs one for all the
inputs, except for one of them which I call
the winner.
And it outputs a minus one at the winner.
All the other inputs it outputs a one.
And this function is Oracular in the sense
that you know nothing about the function other
than at one place it outputs a minus one.
You have no other information about this function,
except that at one place it outputs a minus
one.
And if I give you code for this function which
evaluates it.
I will allow you to quarry the function, in
other words, I will allow you to save at 72
what's your value of function.
But I will not allow you to read the code
that generates the function because if I--if
you read the code that generates the function,
you might see the if statement that says,
"If x is 999 output the minus one."
So, by not allowing you to read the code I've
made it into an Oracle which you only can
quarry.
Now, your task then is to write code which
can call F which will determine the winner.
And what strategy do you have, well, you really
don’t have no strategy than other than to
call F at 1, F at 2, F at 3, F at 4, until
you find the winner.
And you don’t know anything about the function
and you go in random order it's not going
to help you.
So, clearly this problem takes a border an
Oracle calls to solve.
Now, if I go to the conventional quantum--if
I take this code for this function though.
And I go to a quantum computer which is executing,
which is works on quantum system.
I can turn this function call into a phase
multiplication, in other words, I now have
basis--remember I told you what a basis was.
Now, I have a basis vectors for a Hilbert
space where x goes from one to N and my function
call takes the little basis vector x and leaves
it alone if x is not the winner because f(x)
is one if it's not the winner.
But put some minus one if front of it if x
is the winner, okay?
And I can--I'm not giving you class here on
elementary quantum computations, so you have
to trust me that this can be done.
But you can turn this function call into this
with very little effort.
Now, if you do that, I mean make function
calls quantum mechanically using the classical
function actually.
It turns out that you can solve this problem
with an N to the one half calls.
And this is algorithm as possible.
This is one of the big results in quantum
computing because this is provable speed up.
Because if you--what does that mean?
It means that if you’re--the computed time
has to scale with the number Oracle calls.
Of course if I copy the code, I can run it
on two computers, but it doesn’t reduce
the number of calls.
So, we just have one computer.
So, the computed time scales with the number
of quantum calls, so if I have a fast classical
computer which is represented by this because
that's slow--it's very fast because the time
is very small because the slope is very little
on my scale.
The slope is supposed to be very small, but
I don’t want to draw it like that because
it'll look bad.
Whereas the slow quantum computers starts
out like this, but they will be an N beyond
which any constant times the square root of
N will fall below, any constant times N. And
this is what we mean by algorithmic speed
up and that's what quantum computing is about.
It's not about running it chip fast.
It's about taking fewer steps to achieve the
answer than you do on a conventional computer.
And this is called--and this is provable algorithmic
speed up because the quantum computer has
out performed the classical for this problem.
And this is you know, okay, I'm not--this
is just a known result in quantum computer.
Yeah?
>> Could you briefly share what is the physical
reason for that speed up for that N to the
one half.
Does it have to do with probably ballistic
nature of the way function work?
>> I don’t know actually I don’t have
a good intuition for that.
First of all, I would say you have to able
to do two things.
You have to be able to act on super positions
which quantum mechanics allows and the other
thing is you have to introduce minus signs
into the problem, you have to use interference.
If you don’t have interference it will never
fly and did you notice when I--when I told
you the Oracle call in the quantum set, it
puts the minus sign in front of the state.
And you know the amazing thing quantum mechanically
is that you can have something happen with
the coefficient one and the coefficient A
and the square of that is A squared, and you
have something happen with the coefficient
minus A and the square of that is A squared.
But if I add them I get zero and the probability
is zero.
You can have interference quantum mechanically
and you need that.
But I don’t have much intuition beyond that.
The other thing I should say about this is
the best possible, you can--there's no quantum
algorithm that'll be better than that.
Yeah?
>> To prepare--to prepare a problem on the
data set for this interference, does that
take, it's primarily [INDISTINCT] amount of
time...
>> Well...
>> ...or it just [INDISTINCT]
>> No, if it's data set it could take time,
in other words if it was a phonebook it might
take time then.
But if it was a function, if it was some you
know, hard to invert function which existed
on the computer for its satisfied ability
problem and you know, an output, a yes, if
it's satisfiable then no--not, I could--that
would take very a little time to encode.
So, you--it depends on how I give you the
problem, yeah?
>> But the total size of computer is scaling
with them?
>> Probably like Login.
>> [INDISTINCT]
>> Yeah, Login.
Login, I'll talk about that too, okay?
So, now, we're going to have to switch language
though because I'd talked to you about the
conventional oracle.
But I want to do things in the--with Hamiltonians.
So, I have to introduce a new--I'm going to
have introduce two concepts before we solve
our [INDISTINCT] entry problem before we solve
our [INDISTINCT] the first is the Hamiltonian
oracle, because we're comfortable with the
conventional oracle but now I want Hamiltonian
oracle.
I'm not--we're going to--put like this, I
have a Hamiltonian which is a diagonal matrix
and some basis.
And all the entries on the diagonal is the
same but one entrance is--entries is different.
And I want to find the spot where that is
different, and in the Oracle model, I can't
look at the Hamiltonian and figure that out.
But what I can do is apply the Hamiltonian
to a quantum state, so I can evolve with it.
And in this rule--according to the rules of
this game, I'm allowed build the Hamiltonian
to sum up two terms, the Oracular part which
you can't look at and the driver which you
designed.
And we have evolve according to the [INDISTINCT]
of your equation.
So, we take this--so we evolve a quantum system
with a piece which is kind of hidden from
us.
Which we want to find out about is I'm parallel--I'm
trying to make a parallel to the Oracle model.
And another piece which we design and we pick
an initial state and we evolved according
to the [INDISTINCT] of your equation and it
turns out that you can design a driver Hamiltonian
which will always take an initial state which
is a uniform super position of all amplitudes
and at the N of time N the one half, that
state will be 000 and have a one at the winner's
spot and be all zero's, okay?
And in that sense it identifies the spot and
the time there takes into the one half.
And the reason I'm telling you this is because
this is very analogous to what we just saw
in the global problem there the number of
calls was N to the one half.
Here I mean continuous time and the time is
N to the one half.
And so what I'm trying to argue here is that
Hamiltonian Oracle is like the quantum Oracle
and time is like the number of Oracle calls.
Yes?
>> Maybe this isn't a question but okay you
just said, great, we started with this [INDISTINCT]
and end up with the expected the wrong [INDISTINCT]
do you think [INDISTINCT] which has one and
all the rest are zeroes.
Isn't the whole point of this problem is for
us to find the one thing that's one and all
the rest are all zeroes?
>> Well, no, but that’s what you find after
time N to the one half.
Yes, the thing is...
>> How do you find it in the thing...
>> Oh, no then you can just make a measurement
and then, you then get this vector and then
you make a measurement and that--then it'll
pop out.
Yes, once you have that vector then you know
it's 0001000 you make a measurement and then
and you know where you are.
I didn’t say that.
You make a measurement on that factor.
Yes?
>> The original--like your own data [INDISTINCT]
>> In a way, yeah.
>> Well, it looks like the same operator.
>> It does but I'm a--it's very analogous
that’s right.
Uh-hmm.
Yes.
I'm trying--yeah, I want you to see the connection,
good.
So, I--yes?
>> In regards to [INDISTINCT] so, in the dimension
in time is that--it's totally different units.
So, why would you define time in [INDISTINCT]
>> Because the Hamiltonian it--well, yeah.
You know, I said [INDISTINCT] part of one
here and it basically, if I normalized that
Hamiltonian type of one in it and that sets
the unit of time.
Because time is measured in inverse energy.
In the units that I used.
So, I have--I have fixed something.
I fixed HW to have a one in it.
And that sets my units.
>> You said one [INDISTINCT] is that what
you mean?
>> A one.
In other words, if I made this--if I multiply
everything in this Hamiltonian by a constant
factor, I would decrease the time evolution
by that factor up because if you go back to
the show of the equation, you see there, if
we multiply the Hamiltonian by seven, you
evolved in time one-seventh.
So, that’s not fair to do.
So, I have to--so, this one means it's in
some units I have normalized things.
>> Isn't it for [INDISTINCT] warm or of age
or...
>> No.
It's just...
>> ...[INDISTINCT] I mean...
>> Yeah.
I don’t know--I don’t know.
The biggest aggregate value.
>> Okay.
>> Anything you want--any norm you want.
The biggest aggregate value or anything would
be fine.
I normalized it so, that’s what I mean.
So, I have set the units here.
It's all hidden though because of my choice
of [INDISTINCT] equals one.
Because it, you know, once you have [INDISTINCT]
equals one.
You know, the uncertainty principle is delta
[INDISTINCT] is delta [INDISTINCT] so, if
[INDISTINCT] is one then, time and energy
are in inverse units.
Okay.
So, allow me to introduce one more concept
which is called Quantum Walk in continuous
time.
And what is a Quantum Walk?
I want you to imagine you have a graph.
A graph is a bunch of nodes connected by edges.
So, I want you to think this is an abstract
thing and have a graph.
It's a bunch nodes connect to--I assumed people
here know what graphs are, probably.
Google network is a graph or something, I
don’t know.
So, you have a bunch of nodes connected by
edges and now we have to find a Hilbert space,
who's dimension is the number vertices in
the graph.
And I'm also going to define the basis where
each corresponding to every node is a basis
element.
So, I have a basis for this Hilbert space.
And now we define the Hamiltonian.
And I'm going to tell you, the AB matrix element
to this Hamiltonian is minus one if there's
an edge between A and B, a single edge.
And otherwise, it's zero.
So, what that means is that the Hamiltonian
is called the adjacent C matrix of the graph.
The adjacent C matrix of the graph is a matrix,
when you look at the AB spot, if you see a
non-zero entry, then there's an edge between
A and B.
If you see a zero, there isn't.
And what I mean then by Quantum Walk is--I'm
just going to evolve with this Hamiltonian.
Say, if you solved the [INDISTINCT] location,
I guess, I didn’t do that.
If the Hamiltonian is time independent, then
this is the solution to the shrouding equation--just
exponentiate--you exponentiate the matrix.
So, [INDISTINCT] is just [INDISTINCT] of zero
and we call this Quantum Walk because If you
put all your amplitude here in the beginning,
what happens is, in the short amount of time,
you go to the connected nodes and then you
start to spread out to the graph.
There's nothing random about it thought because
it's deterministic evolution.
So I don't call it random, I call it Quantum
Walk.
And this isn't the way an analogue to what
it's called--classical walk--classical random
walk, okay?
So, I--now, given a graph, there is a Hamiltonian,
given by my rule.
The half--you look at the graph, you built
the Hilbert spaces, dimension is equal to
the number of vertices and that rule tells
you the Hamiltonian and there's the time evolution.
Now, I'm going to show you the algorithm for
the Hamiltonian NAND Tree.
I call it the Hamiltonian NAND Tree because
we are evolving in a Hamiltonian model.
Yeah?
>> Sir, for the last slide for the [INDISTINCT]
what's this [INDISTINCT] can you tell you
[INDISTINCT] like [INDISTINCT]
>> I can the two general question, he ask,
what is it, to tell you in general, I don’t
know.
>> Okay.
I just want to go [INDISTINCT] to get out
of the previous slide.
>> Just the--an understanding that allow you
to understand this slide.
Nothing else, okay.
I lead you to [INDISTINCT] you know?
In fact, I was criticized by my students last
term because they said I use the surprise
method of teaching.
Which means that I don’t tell them in advance
where we're going.
And then, I lead them along and then I say,
"This is where we got."
And I was told that that was not a good thing
to do.
But I actually think that it is the good thing
to do because you have to trust the guy in
front to lead you to something interesting
instead of telling you in advance what's happening.
So there's no outline and we just proceed.
Okay, so here we go, so here's the Hamiltonian
NAND Tree Algorithm, first of all there's
a graph so that means I have a Hamiltonian,
what is this graph consist of?
Well, first of all it has a perfectly bifurcating
part which is this, this is, this is not,
this--it looks like the NAND Tree from before
but it this is a graph, if node is a node
in the graph and there's a Hamiltonian which
is--connects nodes in a Hilbert space, there's
a Hilbert space where--which it was the basis
that corresponds to each of these little dots.
There are two--there are three parts to this,
there's this piece which is perfectly bifurcating,
there is an infinite line of nodes at the
bottom which really isn't infinite just very
long which I've connected.
And at the top, for every node on the top,
there's another node on the top a parallel
set of nodes and some of them are connected
and if there's a connection I want you to
think that there's a one, in coming in to
a NAND Tree and if there is no connection,
it's a zero.
So if I have a NAND Tree, I would put a connection
if there is a one and no connection if there
isn't and I want to know what that NAND Tree
evaluation is.
Is it, is it one or zero at the bottom.
And this is the algorithm, I'm going to build
a packet which means, I'm going to build an
initial state which is a super position of
amplitude over here, that's I'm going to tell
you what that is on the next slide for that
initial status.
I am going to let it go, meaning is I'm going
to evolve and put it to the Schroder equation.
Yes, first of all the size of it, the packet
on the left, is going to have a length, gamma
N to the one half where gamma's an independent
constant which we'll talk about later but
think of gamma as a thousand, so the some
number I put here, a thousand N to the one
half.
Then I build this packet and then I'll let
it go and I evolve time gamma N to the one
half.
And then I'll make a measurement here, I want
to make a measurement here, I need to find
amplitude here or I do not it's a yes, no
measurement.
I either find, I, I ask, I make a measurement
on all this notes and I say, is my quantum
system there?
And then the answer is yes or no.
And then it turns out that if the answer is
yes, the NAND to the tree is one and if the
answer is no the NAND to the tree is zero.
So in this whole thing fits in the context
of the, of my general set up for Hamiltonian
Algorithm, I, I have an initial state which
I'll specify, I have a measurement after a
short amount of time and it tells me the answer
to the problem but I don't expect that you'll
understand this, I'm going to try to explain
that as we go, I guess, I do have one question
which is what is my real cut off time?
What is my actual cut off time?
I mean what time did they, you know, shoot
me, at 12 o'clock?
>> N to the squared?
Square root of N?
>> FARHI: Square of N, that yes.
At 12 o'clock?
>> Yes 12 o'clock its pretty safety.
>> FARHI: Pretty I should really should 10
to 12 o'clock.
>> As you see to the conference it might stop
[INDISTINCT] you can go and [INDISTINCT] a
little bit longer.
>> FARHI: Okay.
A little bit longer?
Okay, I just want to know, okay, so, so let
me just say a few more things, the Hamiltonian
has really two parts to it, there's a oracular
part which comes at the top which depends
on the instance and then it has a driver part
which is independent to the instance and again
this is not to be viewed as physically laid
out in space and the reason is, is because
if you have a sites you encode that in log
base 2 of its cubits.
So cubits is, is a spin half particle and
it's spin half particle has dimension to,
two spin half particles dimension for three
dimension eight, four dimension 16.
So if you use--spin half particles to build
your quantum computer, you only need log as
spin half particles to encode something like
this so the actual quantum computer is not
used just as a log base to--of these things.
Well, what I'm now going to show you is a
couple of things--I need to start to go really--okay,
what I'm going to do is I'm going to do a
writing Quantum lesson, I want, I really want
to do is prove this to you but I don't quite
have enough time, so I'm going to shoot through
these slides, I don't really expect you understand
them but if you know a little bit about quantum
mechanics, it'll, it'll help, I have this
infinite line at the bottom and I want to
talk about it for a minute.
I want to look for the eigenstates so that
the energy eigenstates--well, the Hamiltonian
connects me to nearest neighbors.
So H on A is minus A, minus one, minus A plus
one because I’m connected.
And the energy eigenstates in the position
basis--in other words, if I--if I have an
energy eigenstate, H on E is EE, then the
energy eigenstates of the form--you know the
I theta A, those are plain waves.
If you’ve had a little quantum mechanics,
these are just plain waves and the energy
is minus two cosine deo.
And I proved that here in these lines which
I’ll skip.
Now, for every energy there are two thetas
that correspond to it.
One is positive and one is negative because
cosine theta--you know, theta is pi over nine
and theta is minus pi over nine has the same
energy.
And what these plain waves correspond to as
a right mover and a left mover.
These are the analogs.
Even the IK dot X which are right movers and
left movers, if you remember a little continuum
quantum mechanics.
And the zero energy, the way I’ve normalized
things, corresponds to theta equals pi over
two.
That’s zero energy right mover.
And what we’re going to take--if I have
an infinite line of nodes with the face be--you
know the I pi over two A, I have a super position
which lives forever which this property, with
theta with pi over two, that would a zero
energy state.
But I really want to have a finite system
because I don’t want to have an infinite
number of nodes.
I don’t want to have infinite resources.
So to make a finite system, what I’m going
to do is take that zero energy state and I’m
just going to chop it.
But if I chop it...
>> Yes.
>> FARHI: So if A is less than minus out or
more than what minus one, it’s not there.
If I just chop it, this state is a packet.
A square packet which is near--very near zero
energy.
And it’s actually right moving with speed,
too.
And I want--I could show--I want to show you
movie--moving but I don’t know if I get
that.
So what I’m going to do is I’m just going
to shoot through my slides.
What we really want to do is send in a pack--a
state here which is going to bounce off this
tree and come back.
And in order to do that, we’re going to
do a little Quantum Scattering Theory where
I send in something with unit flux and it
can reflect.
And then the other side, I can transmit.
And when you do--this is a standard Quantum
Scattering Theory.
And what it tells you is that if you could
find this thing called T, it is the probability
that if you have one unit of flux coming in,
you get to the other side.
It’s called the transmission coefficient--T
is the probability, excuse me.
T squared is.
And this is called the reflection amplitude.
Its square is the probability that you reflect.
R square plus T square equals one because
you have to either reflect or go through.
And it turns out that this transmission coefficient
can be related to the ratio of amplitudes
between this node and this node in the tree.
Again, I’m not going to do this because--everything
is here if you followed it.
So the transmission coefficient is related
to the ratio of amplitudes between here and
here.
The key ingredient to understanding this is
that the ratio of amplitudes in the tree is
determined recursively down the tree.
So, if I take three nodes--and I tell you
the ratio of amplitude here to here--four
nodes, excuse me, is Y double prime, the ratio
of amplitudes here to here is Y prime and
the ratio of amplitudes here is Y, it turns
out that Y has this recursion relation.
In other words, if I know the ratio of amplitudes
here to here and here to here, I get it below.
I show that in more detail on the next slide
which proves this recursion which I won’t
do.
But what it tells you is that when--if you
recurse--if you know the ratio of amplitudes
above you, you get it below.
I’m actually going to be--I then do one
other thing.
I look at E equals zero because my state is
very, very close to E equals zero.
And what I show is that if you go to the top
of the tree--this is just a little bit of
math.
It’s very elementary.
If I--if I have 15 minutes, I could go through
slowly enough that you would see it.
But there’s a little bit of elementary math
that shows that at the top of the tree, at
zero energy, the ratio of amplitude here to
here is infinite because if this has amplitude
A, I have to have zero here.
So the ratio of amplitudes is infinite.
Whereas if I have a thing sticking up and
I look at the ratio of amplitudes here to
here, it’s zero.
So at the top of the tree at zero energy,
the ratio of amplitude is either zero or infinity.
And if you look at the top of the tree, you
even get a zero or a minus infinity but inside
the tree I have this recursion at equal zero
Y is minus one over Y prime plus Y double
prime.
And that means that, if two amplitude--if
two ratios above you are zero the one below
you is minus infinity.
If one above you is a zero and other is minus
infinity it's a zero and if both above you
a minus infinity you got a zero below.
So what that proves actually, is that the
amplitudes recurs down the tree according
to the NAND for--according to the NAND, that's
what I'm trying to say.
So there's a recursion for the ratio of amplitudes
which is the NAND.
And then at the bottom, what happens is, since
everything was determined by the very last
one at the bottom.
If that one was zero then the transmission
coefficient was one and if there was infinite
to transmission coefficient was zero--so this
act--those three slides actually just prove
that the transmission coefficient and energy
zero is the NAND.
So the key to this was seeing somehow--another
to that the recursion for the ratio of amplitudes
follow the same logic as the NAND.
And given that we have an algorithm because
it's not enough to look just an E equal to
zero because E equals zero is something infinitely
big.
So you have to say to yourself over what range
in energy is this relationship essentially
true and it turns out that this relationship
that T [INDISTINCT] the other NAND is true
as long as the energy is within a region about
one over N to the one half.
It takes a bit more work to show this.
>> [INDISTINCT]
>> That's the only rules work in the paper
beyond what I already showed you is showing
that this is true over a little range and
energy.
And you can get this range and energy if I
make my packet big enough and so if L is gamma
N the one half the packet is now enough in
energy and the time of the algorithm goes
L goes like gamma into the one half.
And the failure probability of this algorithm
is an out of order one over the square of
gamma independent of NAND and the gamma is
the constant.
So I know I did that too fast for anyone to
follow but--so what this really tells you
is that you build this packet on the--on the
left, it's right mover.
It hits the tree and it transmits if the NAND
is a one and it doesn't take the NAND as a
zero.
I can show you a computer simulation after
if anyone wants to see that.
I have a little Matlet program that evolves
this.
So, that's that.
Now, what's interesting here is that I showed
you this in this Hamiltonian model but then
if you go back to the conventional Oracle
model it was immediately shown that the discrete
quarry Quantum amount for the--for NAND trees
would also have a N to the one half.
Robert Spalek was here at Google now wrote
a paper with Charles who was my student who've
been were caught him saying, every NAND formula
of size N can be evaluated in time order N
to the one half at a Quantum computer.
There was paper by Bynus showing it--a nearly
optimal discrete algorithm for evaluating
NAND formula.
It's been allowed for the possibility that
the input or the fan out of the NAND doesn't
have to be two and the tree could be trimmed
and there's been more work on this, including
evaluating mid max trees.
So this Hamiltonian approach was the first
idea but then it led to a whole series of
papers in the discrete quarry model which
really showed that a Quantum computer can
do something that a classical computer can
not do.
This N to the one half is also best possible.
Let me try to explain why that is.
If--well, I'll--let me try to give you a little
sense of this.
Remember that growth of problem were we have
the function f(x) which is one or minus one
or all these integers.
Now, I want you to imagine now that I opened
this function up and I just let it be one
or minus one every--anywhere it wants, it
just all over the map one and minus one.
Let's consider the parity of the function.
The parity of the function is the product
of all inputs of f(x).
Now, how many times you have to call the function
to get the parity classically?
We have to call it N times because if you
don't, the last call could change the parity.
You don't know anything about the parity of
a function unless you call it on every single
input.
Well, it turns out that Quantum mechanically,
we and others show that there can be no speed
up for evaluation of the parity function.
That this is a function which is so sensitive
that there is essentially there's a fact of
two speeds up but that's not algorithmic for
the evaluation of parity and it turns out
that using that you could show that if you
could evaluate a NAND tree faster than N to
the one half you could parity faster than
N which is what's on this slide.
So, in parity--so, that means that the algorithm
we found not only beats the best classically
but it also is best possible.
So, this was my talk about game trees and
using ideas from physics for that.
Afterwards I'll anyone the movie of the thing
on scattering.
I want to talk for a few minutes about another
physics-based approach to Quantum--to Quantum
computing which is called Quantum Computation
by Adiabatic Evolution.
This was introduced by me and Jeffrey Goldstone,
that's the same as the Goldstone boson guy.
Oh, he was my co-author in the other paper
too.
I should have told you that, I'm sorry, and
Samuel Gabby who's my friend and Michael Sipser
who's a peculiar scientist.
But anyway this--they're all my friends but
this is Quantum Computation by Adiabatic Evolution
and this is general approach to Combinatorial
Search problems and why we're interested in
this?
Well, one reason is because it is a general
approach to Combinatorial Search problems
and I think maybe some people at Google are
going to--might be interested in having a
general approach to Combinatorial Search.
It's also universal which means that any ordinary
computation can be written as a Adiabatic
and it's also a possibly a good design for
building a quantum computer in fact the company
D-wave which claims its--were trying to build
a quantum computer and uses Adiabatic Algorithm
as its--for its architecture.
So, I want to just spend a couple of minutes
explaining what this is.
I want to imagine we have a time dependent
Hamiltonian H of T. And this Hamiltonian has
eigen values so as the energies and they vary
in time because the Hamiltonian changes and
one of them here is the ground state energy
which I call EG of T. The ground is E. The
G means ground.
Ground means lowest quantum mechanics.
The ground state energy it depends on time.
A minicule from zero to zero I don't know
why.
Now, at any given time there's also a state
which is the instantaneous ground state that
is the state the eigen vector of the Hamiltonian
with this eigen value which I write in this
formula.
So EG of T with the [INDISTINCT] around is
the eigen vector with this eigen value.
Now, I want to imagine that I just have a
quantum system and I start that quantum system
at time zero in the instantaneous ground state
of the Hamiltonian with time zero and then
I evolve with the Schroden equation.
With the Adiabatic theory says that if I evolve
slowly enough then the actual state side of
T will remain near the instantaneous ground
state.
>> [INDISTINCT]
>> And slowly enough is actually determined
by--well, what if you want a little help with
that.
Think of having the time, independent Hamiltonian.
If I have a time independent Hamiltonian,
I'll put a quantum system in the ground state.
All--the only thing that happens is the phase
changes.
>> [INDISTINCT]
>> You stay in the ground state.
If the Hamiltonian changes slowly enough then
you swap the state along with the Hamiltonian.
It's almost like imagine you have a potential
and you put a bowl in the bottom.
And then you kind of move it very, very slowly
with the bowl that stay in the bottom, it's
that kind of thing.
So, this is the Adiabatic theory which I'm
not going to prove both--with slowness is
determined by is actually this basic which
is the minimum distance between the first
excited state and the ground state.
Now, what we're interested in this context
is something called Combinatorial Search,
so you're computer scientist so I can summarize
this in the second.
Combinatorial Search is a problem where you
have N bits which you can take two of the
N values, X one through XN, HXI is zero one
and we have a system of clauses which are
truth tables acting on subsets of the bets.
And an example might be clause evolving but
799 and 103 and it's true if it only affects
seven plus 99 plus X 103 is one.
And mother of all computational problems is
find the assignment of the bits that minimizes
the number of violated clauses.
Finding in general, if I give you constraints
on bits and I say, find the, you know, the
global--the actual assignment that violates
the fewest clauses, that's NP hard and I hope--I'm
not going to define that but that means it's
really, really hard and that's why this is
the mother of all computation problems.
And this is considered intractable on a conventional
computer almost all computer scientist believe
that P does not equal NP which means that's
a Mathy way of saying, there's no path of
fast algorithm for that.
How could you think about that thing?
Well, imagine you have a cost function.
One approach to it would be to build a cost
function.
You have a cost function which depends on
the bit string input and the cost function
simply the number clauses violated by the
bit string.
So if you could define a cost function which
is the number violated clauses and you minimized
it, if you found the minimum it would answer
your combinatorial search problem of watch
configuration violates the fewest clauses.
So clearly, cost function minimization is
equivalent to that problem and there are no
general algorithms which you guarantee to
find global minimum of functions.
Okay.
Sorry.
So this my last slide, almost by--the second
to the last slide.
So the quantum approach to this is the following
thing.
We define Hamiltonian which in some basis
has the cost function at on the diagonal.
We define a Hamiltonian which in this basis
X1 through XN has a cost function which is
equal to that previous one.
And our problem now becomes find the ground
state of that problem Hamiltonian.
And our approach to that is the following
thing.
What we're going to do is construct the Hamiltonian
which a time zero is an easy to construct
Hamiltonian whose ground state we know.
And we're going to part the quantum system
in that ground state and then we're going
to morph this Hamiltonian into the problem
Hamiltonian.
And by the 80 batik theorem, if we morph it
slowly enough, if we started in the ground
state of the--which we know, we're going to
do schlap the state along and at the end of
the evolution, we're going to be in the ground
state of the Hamiltonian who's ground stating
codes, the solution to the problem, we seek.
And this is called--this is the method of
quantum computation by the adiabatic evolution,
Si FT will be near the ground state of HP
if T is big enough.
So the compute--the real question becomes,
how big does the time have to be for this
to be efficacious?
How does that time scale in order to make
this an effective algorithm?
And the point is that if this approach works,
quantum computers will have pawl beyond factoring
in game trees.
And that would make this a general interest
in all areas of computation.
And I think for those of us who are interested
in quantum adiabatic algorithms and maybe
people at Google, I think what we need to
do is study the performance of the quantum
adiabatic algorithm in specific cases because
if we could identify places where the quantum
adiabatic algorithm could clearly outperform
classical algorithms, I think that would a
huge thing.
So what I have shown you, I hope is that by
doing the game tree I use one set of ideas
from physics involving scattering theory.
Here, I'm using a different set of ideas from
physics involving adiabatic.
I didn’t really expect you to follow that,
I just wanted you to see it because I think
it’s a general interest.
And I think quantum computation benefits from
physics because there are ideas that the physicists
have which show sometimes value.
And that’s basically what I want to say.
Thank you.
