>> NEVEN: Thanks for coming to the first part of the three part TechTalk on quantum computing.

The first is about introduction to quantum computing. And actually what I'm trying to

do is to take an unusual look at quantum computing. We want to take a look from the vantage point

of synthetic intelligence. Essentially a notion I would like to promote is the idea that in

order to create artificial intelligence, and by this I mean, tasks like pattern matching,

machine learning, has a lot to gain from employing quantum computers. Actually what I would claim

is if you were to have a working quantum computer of sufficient size on your table today, the

business of doing, let's say a machine with a learning algorithm, would entirely change.

And since this has such dramatic effect you might want to know, "Okay, do I have to bother

or worry about quantum computing before I retire?" Actually is another thing I would

like to get across. Working quantum computers will may--are probably or may be only a few

short years out. Actually in the next talk, we would go as far as this computer here,

this little laptop, has actually a MATLAB program on it that ties via Webservice and

Java and Webservice into a quantum chip that is admittedly still small, but despite of

what you have maybe read in the blogs or popular press, this is a real quantum chip that exists

today. And actually what we have done with it is take a human level task, object recognition,

and build a pipeline, a mix of classical and quantum algorithms to break this task down,

map it unto the quantum chip and bring it all the way back. And I think this type of

task will--I have a feeling that quantum computing might be the missing link that brings true

human level intelligence to machines. So, [INDISTINCT] this--my idea are not very farfetched,

as so does the brain have anything to do with quantum computing? So actually today the answer

would be bluntly, no. Neurobiology as the current paradigm has it that in order to understand

higher brain function, all we need to look at is an organizational level above the single

neuron and beyond. So essentially looking at neurons as classical devices that cooperate

or compete with each other, bringing about the neuro-dynamics that this is all you need

to understand higher cognitive function. But something I would like to predict is that,

sort of the pipeline of the nature I have described before and our increased understanding

how we might harness quantum processes to perform meaningful computation, this paradigm

might get challenged or is ripe for review. So probably, quantum computing will inform

our search for the quantum box as John Ekards [ph] would call it. Okay. So, after this introduction

to the introduction, let me jump to the first part, the basics of quantum mechanics. Again,

the intended audience is computer scientists and I realize it's a tall order to bring the

base concepts of quantum mechanics across in less than an hour which normally is taught

within a semester. But, let me try. First, let's look at a few base experiments. And

I kind of assume that everybody of you knows to various degrees about quantum mechanics.

I'm sure you have seen something on TV or read a book. You're an educated audience.

So first thing, an experiment from which--which likely shows the property of nature from which

quantum mechanics got its name, the so called Stern-Gerlach Experiment. And how this works,

and I'll try to use the mouse instead of my hands. You have a little furnace out of which

silver atoms come. And silver atoms have a magnetic moment so you can think of it classically

as a little, sort of compass needle coming out of your furnace. And of course they are,

sort of randomly organized, so there's this cloud of little compass needles flowing out

of your furnace. And then there this big inhomogeneous magnet that pulls and pushes on these magnets

depending on their orientation. And then, what you would expect because it's random,

some get pulled up, some get pushed down but it's essentially a random mix. So what you

see here on a classical prediction, if you put a photo plate behind it, this elongated

patch is what you would expect to see. Now what you really find is you only see two patches.

So this is, if you would have a little compass would mean, if you look at it you will only--two

things, compass needle up or compass needle down. So this is contrary to our, sort of

microscopic experience, and shows sort of first fundamental effect or a fact. Physical

observables are quantized. So it's like money, it comes sort of, in the smallest denomination,

as you one cent of nature. Actually this is--typically this cent of nature is typically denoted by

h--hbar, the Planck constant. And this [INDISTINCT] observable, it's like quantized is true for

energy, for angular momentum, for many important physical observables. So first effect. But

this effect has an important impact on how we observe nature. So let's look at something

that physicists do all day long, speed measurement. Essentially you can think of a speed measurement

in the following way: I have a little radar gun here in my example, and you shoot little

photons towards a car to measure its speed. So if you think about it, really those photons

have momentum and they push the car a little bit. But you would agree, you will not get

away with the excuse saying, "Hey officer, I wasn't that fast. [INDISTINCT] really pushed

my car." The reason you won't get away with this excuse is obviously the momentum of the

photons is so small that it doesn't really affect the system on the observation. But

now assume we want to observe something microscopic. So the car gets smaller and smaller, and given

that nature is quantized, I cannot always--or I do not always have the luxury of having

a probe fine enough that it is much smaller than the system on the observation. Or a different

way of looking at it, if sort of your probes would get larger, and here in this example

you would shoot bowling balls at the car, then obviously this measurement will affect

the state of the system, yeah? And this is in the microscopic world generally true that,

"observation affects the state of the system," okay? Second important fact. The third important

fact, here's sort of the quintessential experiment in quantum mechanics, is the double-slit experiment.

I'm sure you have heard of it in various ways. Now think of it in the following way, there's

a light wave coming through the first screen here, screen one, and it spreads out, think

of it like a water wave and now you have thrown a stone into a lake that was calm before.

So this wave spreads out, reaches the second screen and then, sort of two waves, come out

from there. So it's like throwing two stones into a lake. And we all know that the effect

in sort of these waves interfere, they can be superimposed and you have constructive/destructive

interference. And it creates an interference pattern like shown here, these black and white

stripes. But now if you would take a closer look, essentially again realized by a photo

plate, and you look at this picture here on the right side, the abc, and we look, we--it

gives a photon stream, make it very weak so that only one photon per time unit comes through.

Then we see a build up like this, sort of, you get little impacts on the photo plate,

and essentially you get this wavy pattern here. So essentially what we see if you take

closer look, that this wave pattern only gives us a probability where we might find the impact

of a particle. And this is also called the wave particle duality. And you can do this

with photons, meaning with light, or you can do the same thing with electrons. And again,

you can do it even if only one electron at a time goes through the slits. So it interferes

with itself. So the important lesson here, in superposition, a sort of a fancy word of

this wavelike behavior is that you can superimpose the states. So superposition, again it worked

for electron and photons, is a general principle in nature. Those three important facts. So

here comes the big jump, I don't want you to go home without formulas. So the philosophy

of these talks will always be give some intuitions and then jump to the formulas and I cut out

the middle piece. So here's pretty much all quantum mechanics, the kind of we'll ever

need, or you can derive the rest from this one single sheet. So how does quantum mechanics

formalism describe nature? First, if you describe the system, you want to know what its state

is. So, its state is here denoted by psi and these funny brackets around psi and the so

called Dirac Notation. So, this is just a way how a quantum physicist denote a vector.

So psi is just a vector and the funny thing around is the vector sign. And the state of

a system lifts in a Hilbert space. A Hilbert space, essentially for all purposes you can

think of it as a linear vector space with a scalar product over it. It's a complex vector

space. And moreover, we wanted to norm of the state vector is 1. And we will see in

a second why this is. Okay, now we know what a state is in quantum mechanics. Next thing

you want to know; how does my state change? So how the temporal evolution--fancier word

for it--comes about is essentially in non-relativistic contacts through the so called SchrÃ¶dinger

equation. You see, the SchrÃ¶dinger equation is basically a differential equation that

shows his changes--the first derivation according to time of the change of your state dependent

on whatâ€™s here on the right side, and what's on the right side is called an operator acting

on the state and this operator is called the Hamiltonian. The Hamiltonian essentially has

to do with the overall energy that's in your system. So depending on how much energy is

in your system and how it's structured spacial temporally, the state will change in different

ways. And actually, there's an equivalent way of writing it. If you go here to the right

side, essentially here the Hamiltonian is put into evolution operator. So basically,

you have a state here, psi as in time to zero. Then you--evolution operator think as a black

box and now you push your state in at time T and then you get the state at time T out

of there. So, state and temporal evolution. Now, it's important to see the differential

equation here was linear, the states base is linear, so we have a linear theory. And

this allows for an important fact that in particular means, if I have two possible states,

psi 1 and psi 2, then any linear combination, for example, like psi 1 plus psi 2 is a solution

as well. So here you see the super position reflect it. So two states, I can superimpose

them and again I have a valid state. Now comes the third part, how do I measure the state?

And here in classical mechanics you wouldn't find much, you know, as the position of the

car, yes sure I measure the position of the car. So there's the state of the system and

what you observe is kind of the same thing. But earlier in the speed measurement example,

we discussed that in quantum mechanics this is more involved. So in quantum mechanics

you describe an observable, like energy, magnetic momentum, through a matrix your A, an operator,

and this operator self-adjoined which basically means it allows for a spectral decomposition

into eigenvalues of this nature, that where the eigenvalue is m as a possible measurement

outcomes. And because this operator is self-adjoined, it guarantees that those measurement outcomes

are real numbers. Remember, everything before was complex numbers and you don't really see

complex number too observable to nature. You only see real numbers. The fact that this

observable is described by self-adjoined operator ensures this. So basically--and it has a complete

basis. So the eigenfunctions of A are complete basis for the Hilbert space where the state

lives in. So you can express any state in a decomposition like this, as sum c i over

the difference states. So again, as a large linear com--super position of the individual

eigenstates of your operator under consideration. And then the probability of finding a measurement

outcome is essentially the modulus square of the coefficient in front of the eigenstate

where you find your system, okay? This is called the Boen rule. And after the measurement,

your system would be in state a i corresponding to what you measured, okay? So that's my--the

trickiest part to understand. Observable corresponds to self-adjoined operator meaning it has a

set of revalued eigenvalues. These are the possible measurement outcomes and essentially,

if you decompose a state the way itâ€™s written here the Boen rule gives you the probability

of finding the system in a certain state. Okay. So the last part that traditionally

was not taught as an important fact is how do you compose two quantum systems? You have

one and you have a second. But you can imagine if you want to build a quantum computer this

will often happen that it would be built or composed out of subsystems. So subsystem composition

is actually not that difficult. What you do is you take two Hilbert spaces, H1 and H2,

and you form the outer product of those Hilbert spaces. So this is now the total space your

system lives in and then you can--and the simplest way, take a state out of--one of

those two spaces and, like here, it says psi, and then you take a second state out of the

second system and you build the outer product, the tensor product of these two vectors and

you get a new state. So these special states are called separable states. But again, we

can build super positions; we can put a sum in front of sub states and get what this so-called

entangled state. So just in case--so here's sort of an important off ramp, if you ever

have heard about the Einstein Prodosky Rosen South Experiment or about quantum teleportation,

the ingredient you need to do things like quantum teleportation are entangled states

and we're not going to explain those today just sort of, if you study literature this

is sort of the off ramp. You have to get to--you have to understand what an entangled state

is, then you can proceed understanding what is quantum teleportation is. Okay. So, wow,

this--might be a little bit too much on this one sheet. Let's try to break it down. I think

in the next slides it will, sort of--I see a lot of shocked faces. I hope, sort of applying

this a little bit will make things simpler. So letâ€™s a look at a very simple situation,

letâ€™s take what's called a potential well. We take a particle that's an electron and

we put it into a box and we don't want to let it out. And here's a classic analogue

would be, let's say you go into a hole or let's say you have a large bucket and you

put a basketball in there and it bounces around, in such a situation you want to look at. So

the SchrÃ¶dinger equation for this situation is written up here, and again, you recognize

it here was the Hamiltonian we have to use in this. And the Hamiltonian was, sort of

associated with the total energy of the system and you might know if you have something like

a bouncing ball, you have essentially two types of energy, the kinetic energy, how fast

this ball is flying around, and the potential energy, how high is it above the ground. So

these two terms together make up the total energy of this particle. So here we have now

differential equation. At first glance for the non-mathematicians thinks, "Oh, damn it.

Looks difficult to solve," but from here on, it's only mathematics. And it's a little bit

simplified by the fact that because the potential doesn't change in time, the Hamiltonian is

time independent. And then this allows for a solution that's down here, where the main

thing I want you to look at, is that this solution is again, a linear superposition

of this states psi, and psi are the eigenstates to the Hamiltonian. So this is how you can

compose a general solution for your SchrÃ¶dinger equation. And here let's look at a special

case where our potential, you know, is sort of infinitely large then what you see here,

you know, in your little box, the wave functions, was the name for those solutions, for different

eigenvalues E, different amount of energy your particle can have. So that is how they

look, you know, you little bend it like a parabola, wavy, sort of wave with a shorter

wavelengths. So these are solutions. So now, more interesting, let's go to a situation

where the box is not infinitely high, it's not an infinitely deep well but itâ€™s only

finitely deep well. So this is here shown in the right side. So what you see here is

something very important and we get the first sense of how this can help us in computation.

You see that the wave functions don't go down to zero right away where the border of the

potential well is. Actually they--there is still a finite probability of finding your

particle outside of the well and this is called the tunnel effect. So then I could use it--imagine

it would not be in the well but just sort of a barrier. So essentially, a potential

well but with a thin barrier. So then this particle could escape there even though it

doesn't have enough energy to jump over the barrier, it goes through, hence tunnel effect.

So think of it, here's this basketball, denotes a situation classically. If this basketball,

if I throw it in, if it doesn't have enough kinetic energy at that point to jump over

this wall, it will never get out of this potential well. So now for--and this is for computer

science. Everybody of you who has worked let's say with optimization problems will know that

getting stuck in a local energy minimum is a major curse whenever you express your problem

as an energy optimization problem. So, I think you will have a taste for the fact, "Hey,

I have a new mechanism here to get out of a local minimum." And that's indeed an effect

that we will harness for computation. Actually, adiabatic quantum computers do basically this;

they help you finding the global minimum and then the energy function by exploiting the

tunnel effect. Okay. So, let's sort of go through this one more time. Again, we have

learned that a state of the quantum system described at T-zero by a state function psi

of a T-zero, and then we have essentially two ways how this state can change. The first

one is continuous severe unitary evolution or via the Schrodinger equation, sort of a

continuous change over time of your state. And then, some nasty physicist comes along

or any human and will do a measurement. And then, oops, after this measurement, sort of

I drastically disturb my state and I come out in this state a i one of the possible

measurement outcomes in my measurement. And then, from there on, if nobody interferes

again, it will continue to evolve again like a unitary evolution via the Schrodinger equation.

So, that's basically what's--was on the cheat sheet, but as--it's like an ugliness this

is, you wonder when does a measurement really occur? Shouldn't the measurement instrument--I

mean, those are part of reality, too. It's a box with some pointers and some iron and

cables; shouldn't this obey quantum mechanics as well and shouldn't it sort of, follow an

unitary evolution along Schrodinger equation also? So, what does really constitute a moment

where measurement happens? And as the original--so when quantum mechanics came up, the first

complete formulation, the Copenhagen formulation of quantum mechanics, unfortunately failed

to do--give a clear definition of what is a measurement. And this--and at least, in

two cases, you can imagine that this yields problematic or paradoxical results. One is

a closed system. So, you have a box and you have some things in there, like let's say,

decaying nucleus and a cat. And we saw that when the state evolves--actually, we didn't

show this, but the Schrodinger equation sort of likes your preposition. So, it takes a

clean state and sort of spreads it out and then creates those super-positions we saw

about. So, what does this then exactly mean for a cat when it's in a superimposed state,

in particular if we would just think of it as a cat that is alive or dead. So, I'm sure

you have heard about the Schrodinger paradox. In this situation, essentially a cat in the

box and no observer involved. And this essentially has to do with the fact that we don't have

a clear prescription of what a measurement is. And this leads us to--and this is a key

question when it comes to interpreting quantum mechanics. What constitutes a measurement?

And again, in 1927, when the Copenhagen interpretation was formulated, again, it unfortunately failed

to give a clear definition of what is a measurement. So--and in '32, for Von Neumann came and said,

"You know what, I do it much cleaner. I also treat the measurement apparatus as a quantum

mechanical object. And I use only quantum mechanics to describe the whole thing end-to-end;

essentially of my state, I have my measurement device and I have sort of an observer that

looks at it. And then I analyze it in those terms." And essentially, what you see and

you have a state here in a superposition, a general situation, then you bring it in

contact--please remember existing composition. You bring it in contact with the measurement

apparatus here--and let's say and the state ready and you also bring them in contact with

an observer, again, in state ready. And now, here is this little arrow. Arrow essentially

denotes Schrodinger evolution again. Then, what will happen? What Schrodinger equation

does, it will bring about--it's like a zipper. Anything that the state touches goes into

a superposition as well. So, as soon as the system we want to observe, which is in a superposition

gets in contact with the measurement device, causes the measurement device to go into a

superposition as well. And then even worse, if the observer looks at it, it will go into

superposition as well. So, this is contrary to our everyday experience. Let's say, here's

this water bottle, it seems to be only at one position. It's not in a superposition

of multiple states, and we rarely see somebody in a superposition between life and death.

So, essentially the Von Neumann program, depending on how you look at it, failed. Essentially,

the way out that Von Neumann suggested is to say the final wave function collapse so

that you get sharp real states measurement outcomes as we experience them, this only

occurs--this final measurement occurs in the observer's mind. And I just--so, what happened

at that point is that essentially the observer's mind becomes a primitive notion that is foundational

to constructing physical reality. And I'm just mentioning this. This was '32. So Von

Neumann is not a new age kind of guy, you know. He was a very--I mean, as you are really

familiar with his career. What I want to point out is that quantum mechanics by its very

nature is very suggestive of bringing, of giving the observer special status, you know.

And this will of course be very important in the third talk when we look at the brain

in quantum mechanics. So, the last way to deal with what constitutes a measurement and

a very radical one, but one that's very popular among people who do quantum computing is Hugh

Everett's many world interpretation. So, what he essentially said is essentially a very

beautiful and very symmetric idea of it. Heâ€™d say, "You know what? It's not only one measurement

that comes out. There are thousand possibilities. All possibilities will occur eventually. Just

they happen in different parallel universes, in different classical universes." So, in

this notion to give you a feeling for this, I tried to use this, a time-proven allegory

of Plato, where Plato discusses human perceptual abilities in a situation where you have a

fire and prisoners in the cave only watch sort of two-dimensional projections of really

a three-dimensional world. And he discusses their limitations and how--what--picture of

realities that would construct, you know. So, in the "Many Worlds" or maybe better called

"Many Minds Interpretation," is a similar situation. The wave function psi is this enormously

high-dimensional beast. And what we seem--and this is sort of reality. However, what we

perceive as reality are low-dimensional projections. So essentially, our classical world as we

see it in this view would be only a tiny sliver of the much richer reality. So, this is the

Many World/Many Minds Interpretation which from an epistemological--or sort of an internal

consistency view, if it is correct that quantum mechanics is a linear theory, then this is

probably the cleanest interpretation of quantum mechanics. Okay. So, these were the basics

of quantum mechanics. So, you can take a ten seconds breathing. And we go now to quantum

computing. How can we use this now to build better mousetraps for our trade? Let's quickly

review classical computing. I don't have--I think this audience doesn't need any explanation

what a Turing machine is as a model for computing. And you probably know that any Turing computable

function can essentially be brought into form, where you have a function f that goes from

a binary, an n dimensional binary space to an m dimensional binary space. And basically,

you have the option for a physical, logical realization. That's those gates like Ngates,

Orgates, Notgates. And basically a program on its lowest level can be broken down as

you have a bunch of zeros and ones. And then you push those through a set of gates. And

at the output side, you--essentially here in the space, and the n-dimensional binary

space you look at your result. And you also know that I don't really need all those gates.

Subsets are enough to construct everything like, for example, a FANOUT gate and a NAND

gate as a universal set of gate. So this is pretty much all you need to represent any

Turing computable function. And so this is essentially the gate model using logical gates

for classical computation. Now letâ€™s look how this looks in quantum computing. Actually

very similar. You start with a state. Here, denoted 100. This is actually--I simplified

from [INDISTINCT] notation. I had explained what a composed system is using this tens

of product symbol. I sometimes leave it out and just concatenate the individual vectors

like this or just write a vector like this. So these are all just different ways of notation.

So the main story here is you start with a state and you push it into a gate--actually

in quantum mechanics, the way to think of a gate is just SchrÃ¶dinger equation doing

its job for, let's say, a fraction of a second. Now, again--or as a way of saying it, you

have an evolution operator that acts for a finite time on the state and then you get

some result. It's a very analogous in a way to a classical computation. And now comes

the--a trick. Let's replace the state by a superposition state. And if I had, let's say,

three cubits acting here, you can, let's say, use a state like this and push it through

the gate. And the gate doesn't care. The gate again is represented by a unitary operator

that it doesn't care whether it got just sort of a single basis state or a superposition

state like this. It will do its same job. And hey, that's cool. So it was one gate operation.

I can act on all these guys with one clock cycle. And I need to do this more. So you

go make a more radical superposition and you realize if you had sort of in binary notation

and digits, then the number of basis states that you have available grows as two to the

power of N. In one clock cycle, you can act on two to the N basis states. Now, it's fun.

I think it's obvious that you can expect some computational gains from this. Unfortunately,

superposition states, as you make larger, they're fragile. They tend to break. This

is one of the engineering challenges and we'll discuss on the next talk how to keep this

decaying of superposition states at bay. We have some of the intuition phase. A different

way of understanding the power quantum computers is as follows. And I mentioned it earlier.

You know that many problems can be expressed as finding sort of the minimum in some objective

function, you know. Or if--in the physics context, if this would be some energy landscape,

I want to find the minimal point. And again, doing this--now this is some computationally

expensive proposition--and doing this with classical [INDISTINCT] like--probably familiar

with gradient descent or simulated annealing or genetic algorithms; they are essentially

all flavors of gradient descent and they're all bound in some way or the other to get

stuck in a local minimum because there's this fundamental limitation. But remember the tunneling

effect, this can help us in certain conditions to get out of this local minimum and find

the deepest. In some ways, the quantum mechanical particle can see, if you want to allow this

metaphor, where the lowest state is and has--you have--in a gradient descent approach essentially

gets its quantum boost that comes from tunneling. And this is the second model of quantum computing.

There was gate model we looked at earlier, the adiabatic quantum computing principle,

which I will show actually in the second talk. They're equivalent, the adiabatic quantum

computing. So thinking about quantum computing in this picture and the gate picture we looked

at before, so those are equivalent. >> MAN: Remind us what adiabatic means.

>> NEVEL: Adiabatic means slow. And I will--the next talk will be extensively about adiabatic

quantum computing. So we'll explain this why the term slow enters there. Last, intuition.

And I actually wanted to take this slide out initially and take it with a grain of salt.

But still, I find it a powerful metaphor. That's not too wrong. Let's put it like this.

If you--again you know that many problems can be posed in form of a decision tree. And

if you are sort of a person confronted with decisions, so you have a classical particle,

then finding, let's say where the longest branches in your decision tree. The way how

you go, you go down one branch and check its length and then you go back and to take the

next branch down. And we have all these different algorithms how to do this in a smart way.

But at the end of the day, you have to always try one branch and come back. A quantum mechanical

particle, again by virtue of exploiting super positions, has a much easier time sort of

grasping all possible states a system can be in and sort of explore this decision tree

in a much more economic way. So this is--again, with a grain of salt. But I gave you--the

two first intuitions were exact and this is sort of a little bit metaphorically speaking.

So, now again, jump in to the calculus. At first, introduce this qubit, which the name

suggests it's a quantum bit. It's a quantum generalization of a bit. And the--like sort

of the bit in classical computation, it's a simple two-level system you can think of.

Essentially it--we are in a Hilbert space that is isomorphic. Meaning it looks like

C2, C being the complex numbers. So basically, I have two states here denoted as zero and

one. These are two linearly independent states. And again, you have heard it again, super

proposition, super position, super position. We can have a general state psi, you using

a general linear superposition of these two base vectors. And then what you heard earlier

also was that a state vector needs to be normalized; meaning the norm of this vector, which is

shown here, needs to be one. Actually, I still owe you the explanation why this is--you heard

me talking several times about the Born Rule and how quantum mechanics, the calculus essentially

doesn't tell you exactly what's the outcome is, in general. It only gives you probabilities.

But in order to properly speak about probabilities and have a probability calculus, it just needs

to be normed. Then hence sort ofâ€”-quantum mechanical states need to be normalized so

that probability interpretation makes sense. And then there's one more thing. So actually,

when you look at the state, you would say, "Okay, my quantum bit basically is described

by a complex number alpha and the complex number beta." And, you know, each complex

number can be represented with two real numbers. You would say, "Okay, I get this qubit. It's

essentially equivalent to four real numbers." Not quite. Again, we had already one knocked

out of this equation here. It takes one of the four out. And there's actually a second

one that goes out and you cannot understand why. As we said earlier, all measurements

results are always modulus square of the coefficients in front of a state. So essentially a phase

factor whose modulus square is one just makes it to be multiplied by one, so it has no physical

meaning in the sense it wouldn't change you're measurement outcome. So you can take any quantum

state and multiply it by a phase factor of this form and your measurement predictions--that's

all what quantum mechanics does; gives you measurement predictions--wouldn't change.

So actually there's a second parameter that goes down to drain. So once we've realized

this, we can essentially express by doing some--bit of massaging and expressing the

complex numbers by angles. And you see that the general state--it's actually a general

qubit psi can be represented like this with two angles; theta and phi. And essentially

qubit hence can be visualized as a unit vector moving on a sphere. And this sphere is called

the Bloch Sphere. So maybe another thing to take away from here is that a qubit instead

of--is not an analogue nor a digital thing. It's something in between. Before it's measured,

the state itself is obviously an analogueue entity but when I measure it, I will only

get two outcomes, it's in state zero or one which is eminently digital. So this is something

beyond digital or analogue. It's not either or; it has properties of both. So, going to

the general gate model of quantum computing, I think you can already imagine how this goes.

Again, various--we looked at it already. It's just sort of repeat. Essentially, how it works,

you have--you prepare your state with--let's say you have a bunch of qubits here, those

of size, initial qubits and you have gates, single qubit gates or multi qubit gates. Again,

these are little evolution operators acting for some finite time and they massage your

qubits into some final state of your qubit and then you measure it and, hopefully, you

get the result you are looking for. So now let's--and one more time, three steps for

a quantum computer. First, prepare your quantum computer in a well-defined state like, let's

say, 000 and a bunch of qubits. Then manipulate the state using unitary transformations and

it will lead to some final state, psi F, and then you measure the state F and read out

the result. And that's how quantum computer works. So now let's see what you're kind of

probably waiting for, show us that the quantum computer does something more powerful than

a classical computer. So the first algorithm to illustrate is the so-called the Deutsch

Josza Algorithm. It's a very artificial example. It doesn't do anything beyond showing. Actually,

historically, it was the first example where it could show that quantum computer does something

faster with less clock cycles than a classical computer. So the problem goes as follows.

You have a so-called function F that goes from zero one to zero one. This function happens

to be called an oracle. So you have the oracle function F. And essentially, here's a little

table that shows there are only four possible functions. If you give it a binary variable

X which can be a zero or one, then this oracle function you have four realizations of it.

Two of them was a function that's constant, so whether the input is X or one, its output

is zero and here F0 and F3 are constant oracles and F1 and F2 are not constant or in this

context called balanced. So the think about it, classically, how many runs of the oracle

would you have to do in order to find out whether your function is constant or balanced

now then? >> Four?

>> NEVEN: Four? That's actually only two, you know? You apply your oracle to zero and

you apply oracle to one and then you can see which of the four functions it is. So classical,

two runs. But now shows that with the quantum algorithm, we can do with only one run. And

this works as follows; here's our gate model. We prepare two qubits, one in state zero and

one in state one. And we have some gates here, two types of gates, one is called the Hadamard

gate and one is called the oracle gate and they bring those qubits into new states. Actually,

we're ignoring what's happening down here. We are only interested in what happened to

the first qubit here, then we will measure it. And even though we present these two qubits

only once, we go through this algorithm only once; we nevertheless get to know whether

F, the oracle, is balanced or constant. And I will show this here. So first, I have to

explain you what a Hadamard oracle gate is. Again, those are just unitary operators acting

on qubits. So essentially, here the--you see how the Hadamard gate acts on a state zero.

Basically, these guys produce superpositions. It takes zero and brings it over to zero plus

one, and as the Hadamard gate acts on a state one, then you get to superposition zero minus

one. So we create superposition, and you saw earlier that it's helpful to have superpositions

because you push one superimposed state through your gates and the eight gates act on all

basis states. And then there's the oracle gate which you see we have put the F in there,

so essentially the oracle gate takes a qubit XY and brings it over to X and here on the

right side, you have Y, X or FX. So if you verify it, the oracle gate is a unitary operator

and we are not concerned at this point how we can physically realize it. And so letâ€™s

assume because it's a unitary operator there's some physical realization for it. Whether

thatâ€™s easy or not, different story? So now, let's run it. We start with zero one,

we, let's say [INDISTINCT], so the Hadamard gates act on our state 01, and produce this

state. Then the oracle gate acts on those and you can just punch in those formulas and

you see you get this unwieldy expression here. Then I massage this a little bit and then

I get this expression here, sorry, like here, you see where the mouse is moving? And then

we ignore this portion here. We only look at the first qubit which is in this superposition

state. Actually I pull this out, this piece here, and then we apply a Hadamard gate one

more time, and then we get a state that's down here, that's the state for first qubit,

it's a superposition of zero and one which is here in the last line. And now, if you

take a closer look, you'll see in the exponent F of the value zero, X OR F of the value one.

And this X OR operation if you go back here, if you look at the truth table, this X OR

can only be--will be zero for the constant functions, and will be one for the balance

functions. And then if you, plug this in here, you see that if it's constant, then itâ€™s

zero, then essentially the second term here disappears, and the output of my first qubit

will be zero, and if the function is balanced then this here will cancel itself out and

you get as a result, one. So, itâ€™s either zero or one depending on whether the function

is balanced or not, and again, we have done this by only a single run.

>> Why is it important whether it's balanced or constant?

>> NEVEN: It's not necessarily important. It's a guinea pig problem. It's just an illustrative...

>> [INDISTINCT] possibilities of itâ€™s own? >> NEVEN: Yes, this is just how the problem

is posed. As I have said, it's an artificial, very simple problem, has no application. So,

probably what you think now, "Oh, Hartman is doing a poor job here. This is, oh Jesus,

I mean I cannot get it. We used unitary functions and we go just work off the calculus and then

we get a result. But really, intuitively I don't quite get this." Actually this is part

of the lesson. The lesson is that, the gate model of quantum computing I personally also

don't find terribly intuitive and inventing new algorithms as a framework is not all that

easy. However, in the next lesson, we will talk about adiabatic quantum computing which

has a much nicer geometric meaning, where itâ€™s much easier to design algorithms. It's

a question of taste. I think for people who have a good algebraic mind, they will come

up with good algorithms in this word, but sort of, it is--using the gate model is tricky.

And there are only a few known algorithms that do something useful in the gate model;

might have to do with the fact that it's a bit unwieldy. I'm only a few minutes left,

so we'll rush through the next example which is quantum search. And again, in posing the

problem is very similar. Again, we have an oracle function F but right now it's from

the binary space n dimension binary space to zero and one. Essentially what this function

does, it marks one item in the input space, let's call this item X zero, and it marks

it as one. And this function as zero for all other input possible input values and the

goal is to find X zero. So that's already more meaningful, you know, quantum search.

And, we will just study a very simple case, where we assume that N is two. So finding

one item marked out of four, this is what we would like to do. And in order to calculate

it, I assume that the marked item is--is 1-0, the binary number 1-0, okay? So, finding one

marked item out of a number is a quantum search, and it's solved--its called--solved this so

called Grover Algorithm. Again you have--here's this gate model where you have Hadamard gates,

you have this oracle gate again, you know these guys already. And then there's this

ugly big D-gate in there and if you look closer it gets even uglier, but it does something

very simple. So we will look at this in a second. Again, think about it classically;

if you want to find one marked item in N, then basically, you have not--any of the best

algorithm you cannot come up with will be of big O-N. Basically you have to look at

all your items. With the quantum algorithm you can do this in square root of N. And again,

as the proof of this, all it needs is you construct an oracle gate where again you put

your function F in there, and then you prepare your state, an initial state like 0-0-1, and

then we will go through this now only in a superficial way; we apply the Hadamard gates

that generate a superposition, then I evaluate my function by using the oracle gate, and

then I get the result here. So, in the, before last line, this one here, and you see, what

this did already, out of the four states, remember I have assumed that F marks the state

1-0, you can see after those massages, the state 1-0 is marked with a minus--Oh, I have

marked it already. But unfortunately I haven't marked it good enough because minus one; again

modulos square if you measure it, is the same as one. So I cannot really discriminate minus

one from one here as a pre-factor. So, what this ugly big D does is nothing but essentially

changing the phase factor into amplitude and what--if you apply D, what you get as a result

is the end result, 1-0, okay? And again, what you can show for a larger N, this algorithm

finds a marked item out of N with big O and square root of N. Okay. So here's the last

slide which is another famous quantum algorithm, Shor's Algorithm, this actually is a crowning

achievement so far. And what Shor's Algorithm does it finds the prime factors in a composite

integer. And you have, maybe read in the press about it--this is important because if you

can do this well, many cryptography codes are actually based on the fact that it's hard

to find the prime factors in a large integer. And the best known classical algorithm if

you have a number N is actually exponential in lock N, this more complex expression. And

Shor's Algorithm does the same thing getting, rid of the exponential. So it's essentially

an exponential speed up over what you can achieve classically. And rather than going

against your lengthy how this works is, maybe let's conclude with what's today believed;

it's not proven but it's believed that this is sort of how the complexity classes relate.

You're probably familiar with the class NP which is essentially a complexity class of

problems which I can verify, not solve, but verify in polynomial time. And this class

NP has of course a sub-class; these are the problems I can solve in polynomial time. And

then there are these nasty [INDISTINCT] NP complete problems. These are sort of the hardest

problems in the space. They are essentially characterized by the fact that any other problem

in NP can be mapped in polynomial time onto NP. And then this whole thing is embedded

in P space, this is the complexity class for all algorithms that have polynomial space

requirements. And then here is what we care for, BQP, Bounded Error Quantum Polynomial,

so these guys--he is factorizing. So essentially this class seem--is probably--is believed

to be larger than P but it doesn't necessarily cover NP. And that's also a lot of the controversy

and some of the misunderstandings, so you cannot say that a quantum computer solves

NP complete problems. And so, this is the overall lay of the land, summarizing the computational

gains, you get from a quantum computer over a classical computer. Okay, that was it for

the first session. You might have seen I realized, again, in one hour cramming all this material

and this is tough to follow but there's a lot of literature on quantum computing. You

can see in the talk announcements, there's a list on fish, you can link to this and maybe

I finished with the shameless plug what we going to do next time. Next time, we will

show the image recognition algorithms we have realized on an adiabatic quantum computer.

And the main topics will be decoherence theory, this essentially deals with how do superposition

states, you have seen superposition states were so crucial, but unfortunately they are

fragile. So decoherence is essentially is the process of the superposition state breaking

apart. So we need to understand this if you want to build quantum computers. Then, you

asked it earlier, we will look at the adiabatic quantum computing principle more, then we

will look at a special or hardware implementation of this, done by D-wave. Actually next week

I will be joined by Geordie Rose who is the CTO of D-Wave, and who has built this first

adiabatic quantum computing chip. And then we will show how we did image matching using

this chip, and then I want to conclude with some implications it has for machine learning

and I want--I haven't solved it yet, but I want to entice you looking at some machine

learning problems that I think we should map onto a quantum computer because it's what

yield huge gains for this field. Okay, thank you. That's it.