Waching daily May 14 2018

>> Welcome to Quantum Computing for Computer Scientists.

Happy Valentine's Day.

We will learn about this most romantic of

all subjects, Quantum Computing.

This is a talk aimed at Computer Scientists.

We will not go over very much,

if any, physics during this talk.

We won't go like for the Double-Slit

Experiment or Uncertainty Principle.

We're not learning about any of that.

We're going to cover the Computation Model

which you'll all be finding,

fairly intuitive I think, is a state machine.

And we will run a Quantum Algorithm on it,

show that it outperforms a classical Computation Model,

and then we'll end with some demos,

including a running program

in Q-sharp, Microsoft's quantum language.

This is the Gate Quantum Computation Model.

It looks a lot like the classical

Computation Model where you have bits,

and you send them through the logic gates,

and transformations are applied to them.

There's another Computation Model called

the Quantum Annealing Model

which is used by D-Wave, if you've heard of that.

That's something different from what

we'll be going over but

people think they might be equivalent.

The jury is still out on that.

Anyway, I'm sure you'll have a great time.

So, I'm sure all of you have

your reasons for being here but here are

three reasons I've come up with if you need some

additional convincing

why you should learn Quantum Computing.

The first is that quantum supremacy is

expected this year, this very year.

Quantum supremacy means we have

a real problem running on

a real quantum computer which in real-time,

runs faster than the same problem

on a classical computer.

So, Google has announced

they think they'll do it this year.

If they do, it's a really big thing.

So, it might be in your future. Who knows?

Five, 10 years, we could all be running

some really tricky problems on quantum computers.

So, we have lots of large companies,

Microsoft, Google, Intel, IBM,

they're all investing billions of dollars

in quantum computer developments.

There are lots of really exciting applications.

This is the one that everyone's

heard about, Shor's algorithm.

When this paper came out, it lit the world on fire.

People were like, "Wow, quantum computers could

actually have real economic impact."

We could factor RSA,

and undermine our global financial system,

which is pretty cool.

Here's one that programmers will I

think appreciate which is

we can search an unordered list in square root N time.

So, you think for an unordered list,

you have to check every element. That's ON.

You can just get a nice speed-up,

just square root n queries on a quantum computer,

which is pretty, pretty nifty, generally useful.

And here's the one which, I think,

probably is the best probability of changing the world.

Sorry, Programmers scroll and

search probably won't [inaudible] too much.

Which is, we might be able to have

an exponential speed-up in

simulating quantum mechanical systems.

So, things like drug design,

if you simulate like biological molecules

interacting, things like that,

it could massively speed

up a lot of our biological research,

and everyone talks about nitrogen fixation for this.

That's like part of the main Microsoft sales pitch.

But this is the one

that actually motivated me, the bottom one,

which it's, I think,

from talking to couple of you before the presentation,

we can also motivate you.

It's intellectually interesting, and it's

interesting because it's just

kind of outside my intuition.

Like I think all of us, at this point in our careers,

can basically look at any digital or mechanical system,

and have like a ballpark idea of how it works, right?

But if you look at a quantum computer,

like how can a quantum computer

outperform classical computation?

It doesn't make any sense.

Like there's no way

I could even start to guess how it would work.

And so, I really wanted to learn it.

And I think there's a reason for this, and this is

kind of getting a bit philosophical.

But our language,

our informal language that we use

developed in very classical world.

It is simply not equipped to deal with the quantum world,

and this is why any pop science article

you've read on quantum phenomena,

it doesn't really ring true.

All the metaphors, they don't really make

sense because we're trying to

express it in this language which

is developed in the classical world.

We need to learn

a new language which is the language of mathematics,

and that is the only thing which will actually let us

understand quantum mechanics is

to learn it mathematically.

All metaphors and analogies will lead you astray.

There's a famous quote here by a physicist

named David Mermin which is "Shut up and calculate",

with regard to quantum mechanics.

So, some grad students,

maybe they lean back in their chair and

they're like, "Oh, what does this all mean?"

Shut up and calculate. Just trust the math.

Math is the only thing which will not lead you astray.

Okay, here's how this presentation will break down.

First, we're going to learn how to

represent computation using super basic linear algebra,

matrices, vectors, matrix multiplication.

Then we will generalize that to learn about Qubits,

superposition, and quantum logic gates.

And finally, we will use all those tools we've developed

to go over the simplest problem

where quantum computer outperforms a classical computer.

This is called the Deutsche Oracle problem.

I mean, there are a bunch of problems,

but this is the simplest.

And finally, it'll be almost negligent to let you get out

of here without learning about Quantum Entanglement and

Teleportation just because with the tools we'll develop,

they're so easy to understand.

So, I'll have bonus topics,

and then we'll have some demos.

All right, let's get to it.

You'll become very, very familiar with these two vectors.

This is how we represent a 0 and a 1,

the two values of one bit in classical terms.

So, the top one,

it's just 1 over 0, and the bottom one is just 0 over 1.

You can also write them in that

weird angle bracket thing.

That's called Dirac Vector Notation.

So, you have a zero in there. That means

this is the value of that vector.

If you have trouble remembering this,

just think of it like an array indexed from 0,

and so, there's a

1 in the 0th index, that means it's a zero.

There's a 1 in the first index, that means it's a 1.

Okay, everyone's fine with this?

You'll be very familiar with this by

the end of the presentation.

We're going to go over

matrix multiplication really quickly.

So, the way to

think about matrix multiplication,

just to review for you.

Most of you will have gone over this in your

Linear Algebra courses the first or second day.

So, if we have a matrix multiplied by a vector,

you kind of take this horizontal row,

and then flip it, and multiply it

point-wise with these vector values.

So, a times x, b times

y, and that's how you get the top one.

And you do the same thing in the bottom row.

C times x, d times y,

and you get a two vector.

The same thing happens with three-by-three matrix.

A times x, b times y,

c times z, and you get this matrix.

This vector, you can also multiply matrices together.

We won't really be doing much of that.

And there's a very special matrix called

the Identity Matrix which has zeros everywhere,

except for ones along the main diagonal,

and anything multiplied by the Identity Matrix is itself.

It's just like multiplying by 1.

In fact, usually, you refer to

the Identity Matrix by the symbol 1.

Now thankfully, for simplicity,

a lot of the matrices we'll be

using look a lot like this.

They're mostly 0s with just some 1s,

and you can notice, it's a nice rule of thumb,

that relative to the identity matrix,

this matrix has the middle two rows flipped, okay?

And that's actually the action it

has on anything it multiplies.

So, it flips the middle two rows.

It's a nice sort of rule of thumb

to remember how matrix multiplication works.

Does anyone have any trouble with this?

Because you really need to know

this in order to go ahead.

You got to know it. Okay, great.

Operations are actually, I'd like to make this a quiz.

Can anyone tell me what are

the four operations on one bit? There's four of them.

>>One bit.

>>One bit.

>>AND, OR, exclusive-or.

>> That's around two bits.

>>Not identity.

>>Identity not.

>>Set to 0, set to 1.

>>Set 0, set 1. There we go.

Good. Yes. So, we have identity,

just f of x equals x.

Negation fx equals not

x. Constant-0, it's always set to 0.

Constant-1, it's always set to 1.

You can see with a diagram how it kind of looks, okay?

And we can write these as matrices.

So, the identity is just the Identity Matrix.

This, remember, is our symbol for zero.

Identity multiplied by 0 is 0.

Identity multiplied by 1 is 1.

Here's negation. You flip it from 0 to 1, and 1 to 0.

Same thing for constant-0, constant-1.

So, I hope I've convinced you we can

represent very simple functions at least,

with matrices multiplied by our 0 and 1 vectors, okay?

And remember these four functions

because I will quiz you later on them.

They'll come back up. So, let's

talk about Reversible Computing.

Reversible Computing is a neat sort of buzzword.

It if you've read the popular sci-fi book Accelerando,

it talks about Reversible Computing,

and basically it means that if I tell you

the operation I did and the output of that operation,

you can always tell the input of that operation,

if the operation's reversible.

So intuitively, operations that just shuffle bits around,

like permute them, they are reversible.

But operations that erase

bits and then overwrite them are not reversible.

And in our previous slide,

identity and negation are both

reversible because I say the output is one,

and I put it through the negation gate.

That means the input was zero. You can always tell that.

But if I say the output was 1,

and I put it through the constant-1 operation,

you can't tell what the input was.

It's not reversible. It erases information.

And the nice thing about Quantum Computing,

which you're going to remember,

is that one of

the computers only use reversible operations.

Those are the only ones we care about.

So, the only operation we

actually care about on this slide is really negation.

Like also identity but it's the same as doing nothing.

A further fun fact about chronic computers is

they actually only use

operations which are their own inverses.

So, not only are they reversible but if you apply them

twice you'll just get back the same input value.

And we're going to go in a little,

this is kind of like going into pop science but whatever.

There's something called the Von Neumann Vander Limit,

which is the smallest amount of

energy physicists have calculated

is necessary for the simplest possible calculation,

which raises is non-reversible.

And reversible computing might

eventually lead us go beyond that limit,

more efficient than that theoretical limit.

Now, currently, processors needs

millions of times more energy

than the Von Neumann Vander Limit but,

you know, 5,000 years from now, who knows?

Pretty nifty. All right.

This is something you probably did not go over in

linear algebra but don't worry it's still pretty simple.

It's called the tensor product.

So if you have the tensor product of two vectors,

it's kind of like you take the second vector and you

tile it for each element in the first vector.

So, X0 gets its own copy and X1 gets its own copy.

And then, you multiply it out so you get eventually X0,

Y0, X0, Y1, et cetera.

It's maybe easier to look at this with real numbers.

Here we have one times three,

one times four, two times three,

and two times four to get this.

Here's how it looks like with three vectors.

You get this like giant array.

Don't worry about it too much.

And I'd like to point out

that if we use R0 and one values

you end up with a vector

which has a one in only a single position.

Okay. Does anyone have

any real trouble with this concept?

If I gave you two vectors you could

probably calculate the tensor product.

It's not entirely difficult. All right.

But, the final point animate leads

into how do we represent multiple classical bits?

And we represent them by their tensor product.

So, 00 remember we tensor, this is a zero symbol.

0 tensor with 0 is this,

product state, we call it,

01 is this product state 10 is this product state,

like 0 times 1, 0,

0 time 0, 0, 1 time 1, 1.

One times 0, 0. Okay. And 11

is this product state and similar

to just a single bit you can think of

this is an index in this vector array.

So, this is 0. There's a one

at the zero position. This is one.

There's value with the first position

coming from zero and,

this is two value of the second position,

three value of the third position.

This is the only time I will tenser

three bits together thankfully, because they us humus.

They grow exponentially in size but it works for this.

So, four is 100 you have 01234 is where the one bit is.

Okay. Yeah. So, we call this the product state.

We can always factor it out into

its individual states and

the product state of n bits

is a vector of size of two to the n. Here,

we see a sort of whisper

of the power of quantum computing in

this exponential term but

hold that thought, we'll get back to it.

So, we're going to learn a very important operation,

very fundamental to

reversible computing and quantum computing

is called CNOT or conditional not.

It operates on a pair of bits.

You designate one bit,

the control, bit the other bit is the target bit.

So, the control bit if it's one it flips the target bit.

If it's zero it leaves the target bit

alone and the control bit is always left alone.

So, if we have the most significant bit

of a 2-bit system as control,

the least significant bit is target,

then 00 since this is the most significant bit,

it's the target bit, and just goes to 00, 01 goes to 01.

Now, 10, since the control bit is

one maps to 11 because it flips the other bit,

and 11 since it again flips,

the target bit goes to 10.

And this matrix, you can actually kind of write it,

you see there's a sort of correspondence

here we flip the bottom two rows,

which is the identity matrix,

and this I claim

which I will show in the next couple slides,

will change our product states

according to the semantics of CNOT.

So, does everyone get the semantics here?

We have a control bit and a target bit,

control bit one, we flipped the other bit. Pretty good?

Now, this is a lot of math

but don't panic we're gonna go over step-by-step.

If we apply the CNOT gate to 10,

remember that this is the control bits one,

so we're going to flip the other bits,

so we expect it to go to 11.

Now, let's expand this out just step-by-step.

So,10 corresponds to this tensor product.

This is the matrix from the previous slide

and we're applying it to our product state.

Remember, it's just going to flip

the bottom two rows so we get to this product state,

which when we factor it out,

indeed gets us 11.

Now, let's do it with 11, same thing,

we have our familiar matrix,

multiply by this product state,

we go to here, which we factor into 10.

So, I hope I've convinced you at this point that we

can use matrices to represent

more interesting logical operations than just a bit flip.

Has anyone eventually, yes?

>> Is that factoring always

possible or practical for larger vectors?

>> It is practical, yes.

Not always possible,

which we'll get into

that when we get into quantum entanglement,

basically, but good question.

So, this is fine for everyone?

Nobody's lost in the gigantic equations here?

Okay. We're gonna go over 10 then, or sorry, 00.

So, the control bit 0

that means we're going to leave

the other bit alone, right?

And we see that indeed

this is what we do and same with for 01.

Okay. So, everyone, well,

maybe familiar with how classical computers

are like real CPU's

there they're all built on the, sort of,

NAND gate, like everything is fundamentally built on NAND

and CNOT is kind of

the analogous NAND for reversible computing.

It's like a really basic thing that is used to build

up larger and more complicated logical statements.

So, I'm sure if I gave you a task,

like build some more complicated

logical formula with CNOT,

you'd probably be able to do it at this point,

you just like stick them all together

and eventually comes out.

I will note that it's not actually universal.

You can't make every logical function with the CNOT gate.

You need something called a Toffoli Gate,

but we won't see that in this presentation.

And we've learned everything we need to know about how to

use linear algebra to represent classical computation,

and we can now go on to quantum computing.

So, to recap, we

learned that we can represent classical bits

in vector form is 10 for 0 and 01 for 1.

We can represent operations on bits

by multiplications on their bit vectors.

We know that quantum computers only use

reversible operations and in

fact the operations are their own

inverses and multibit states,

we write is the tensor product of our single bit states.

Finally, learned about CNOT which is

a very fundamental gate

in reversible computing and quantum computing.

So, everyone's following along so far?

This is pretty simple, right? And it's not that bad.

Okay. Let's make the jump, qbits.

And I will surprise you, we've been learned

using qbits all along actually.

The cbits are just special cases of qbits.

And we represent the qbit in general

by a vector of two elements a,

b where a and b are complex numbers.

Don't worry. We'll only use

real numbers for this presentation.

We're keeping it simple.

Only using real numbers. And we have

the constraint that a squared plus b squared is one.

So, (1,0) and (0,1) fit this definition because

one squared plus zero squared is

one and zero squared plus one squared is one, right?

Now, here are some example qbit values.

This is one with which you'll become very familiar.

It is one over root two, one over root two.

Can anyone tell me what one over root two squared is?

>> One half.

>> One half exactly.

one half plus one half is one. So, this is a qbit.

What about one half and root three over two?

What's one half squared? One quarter.

So, one quarter plus three quarters is one.

Here's an interesting thing.

We can actually use negative numbers

now because the negative number

squared is a positive number.

So, negative one squared is one.

One plus zero is one. And the same thing here,

it's just the same as this first matrix,

but one of the values is negative. Pretty neat.

Not bad so far, right?

Okay, but you might say this is kind of like

saying that a qbit has a value which is not zero or one,

but actually both zero and one at the same time.

This is called superposition.

Everyone's probably heard of

the Schrodinger's cat being both alive and dead.

That's just like a pop science

the way of articulating this concept sort of.

And the interesting thing

about a qbit being in superposition,

it means we can kind of,

I want to really qualify this kind of compute with

the values of both zero and one at the same time,

which again is the sort of

whisper of some quantum speedup power.

Okay? Now, how this works is,

when we measure this qbit,

it collapses to our familiar values

of zero and one with some probability.

And this is what we usually do at the end of

a quantum computation to get the final result.

We send it through the measurement gate,

we see what the result is.

So, how the probability works is,

if you have a value (a, b),

it collapses to zero with probability

a squared mand one with probability b squared.

So, if we look at

our familiar qbit from previous slide, one over root two,

one over root two, it has

a one half chance of collapsing to zero,

and one half chance of collapsing into one.

It's like a coin-flip. Now, if

we just measure our classical qbit,

our classical cbits the (1,0)

has a 100 percent chance of collapsing to zero,

and (0, 1) has a 100 percent chance collapse into one.

So, it's sort of item put in that way.

And I found it useful here to

give people sort of physical

intuition about what we're doing,

what bit is or a qbit is.

If you've heard of polarization,

you've probably bought fancy sunglasses,

says that they're polarized.

So, polarization is actually sort of quantum phenomenon.

You can be polarized like this way or this way,

and your glasses will only be polarized a certain

way so only let light

polarized in this way through basically.

It turns out that qbits,

you can think of this, yeah,

a photon being polarized this way is a zero,

and photon being polarized this way is a one.

Superposition means it's actually like both, right?

So, it could actually go through both gradients.

And then if you measure it,

and a way to measure it is just to

fire it through grating and see whether it goes through,

then you can collapse it to zero or one.

So, that's our intuition

pinning this to a physical concept.

Of course, modern, we

found that photons actually make very,

very poor qbits, they tend to collapse to easily.

So, we don't use those, but you can maybe think of that.

Does anyone have any confusion here, really,

about how this measurement

process collapse probability works?

Okay, great.

We will learn about multiple qbits.

The same is multiple cbits.

We represent them by the tensor product.

Why is it doing that?

Okay, hold on, laser pointer.

Okay, there we go. Nope, that's not.

Okay. So, if we have two qbits, and we multiply them,

the sum of squares identity actually is maintained.

And so, if we consider

our perfectly balanced 50 percent coin-flip qbit.

And we tensor with another coin-flip qbit,

we get this four vector with

one half in every single column,

and one half squared is of course, one-quarter.

So, one-quarter plus one-quarter

plus one-quarter plus one-quarter is one.

This maintains the property.

And the way to read this is

when you measure these two qbits,

it has a one-quarter chance of collapsing to (0,

0), (0, 1), (1, 0), and (1,1).

This is sort of the probability of when you measure it,

finding a one there,

and zero everywhere else.

So, we could find,

it's a one-quarter probability of finding one in

this position and all zeroes everywhere else.

Does that make sense for multiple qbits?

Okay great.

You guys are just trucking along and no problem.

Should be super easy. Yes?

>> I have a question.

>> Absolutely.

>> So, there's only going to be one,

one left in the vector?

>> Yes.

>> There couldn't be two ones?

>> There could not two ones

because that would actually violate

our a squared plus b squared equals one constraint.

>> Okay.

>> But yeah, after measurement there'll only be one,

one here in this in four vector,

which we can then factor into two bits actually.

Okay. Yes?

>> You also find collapsing for that longer vector?

>> Yeah, yeah.

So, if you measure these two qbits at once,

you can think of this product state vector is collapsing.

And then that's just the probability of

finding a one here and a zero everywhere else.

It'll become useful in the future when we can't

actually factor out the product state, but that's anyway.

Okay. How about operations on qbits?

We have these qbits, how do we actually manipulate them?

The same way we do with the classical bits.

And all the matrix operators we've

learned also work with qbits.

So, for example, negation.

If we have our qbit that has

a 25 percent chance of collapsing to zero,

75 percent chance collapse into one,

if we run it through the bit flip operator,

now it has a 75 percent chance of collapse into zero,

and 25 percent chance of collapse into one.

So, we can manipulate these probabilities actually

called amplitudes with gates.

And you can think of gates,

they correspond to some device scientists have created

which is like manipulate the qbits with a gentle touch.

Not enough to collapse them,

but enough to change their state.

So, pretty neat.

And there are also a couple important matrix operators,

which we haven't learned yet because they only

really make sense in the quantum context.

Okay, all right. We're good.

Then the most important one is the Hadamard gate.

And what it does is, it takes a zero or one qbit,

and it takes it to the coin-flip state

where it's in exactly equal superposition.

The matrix looks like this.

It as one over root two in

every single entry except

for a negative in the bottom right corner.

So, if you multiply that by this,

you get one over root two, one over root two.

If you multiply this by one,

we get one over root two, negative one over two.

Pretty neat. So, this is how we

actually get into superposition.

We use the Hadamard device,

which scientists have developed,

and we can make much use of.

So, quiz time.

Can anyone tell me why we need a negative one in

the bottom right corner?

Why do we need a negative sign here?

>> It's like a matrix on bigger provision.

I don't know exactly why,

but it is too big.

>> Well, the answer basically has to be reversible.

So, if we didn't have this negative number here,

then both zero and one would map to the same value,

and it would not be reversible.

So, we need this negative sign. Yes, correct. Okay.

>> Question.

>> Yes?

>> Review of superposition,

what does that mean exactly?

>> Superposition, yeah.

So, superposition means that a qbit is

in both states zero and one at the same time.

>> Okay.

>> And I want to be really clear about something here.

This doesn't mean the qbit is secretly

zero or secretly one, and we don't know.

It means it's actually in both at the same time,

this is just quantum weirdness.

This is just like what happens at the very,

very small level of our world,

which is that things don't have

definite values until we measure them.

>> Here you have (0,

1) in superposition is one over root two,

one over root two.

And one and superposition one over root two minus one.

>> Yes.

>> So, we seem to have

different values but they're

representing conceptually the same thing.

>> Right. So, this

comes down to the distinction

between the quantum and classical world,.

Which is that from the classical perspective,

these two qbits are the same.

Both have 50 percent probability

of collapsing to zero or one.

But, if we stay within the quantum realm,

this sign information is

preserved as long as we don't measure it,

and it can affect our computations.

>> So, it's got a 50-50 chance,

but it has a sense that it used to be a one?

>> Has a sense that it used to be one?

Not really, it just ends up in this state,

which is different within

the quantum realm than this state.

These are two different states.

>> Okay.

>> Yes.

>> Both for the 50-50 chance.

>> Yes, exactly. Both when you

measure it and convert it into

the classical world come down with a 50-50 chance.

Yes. But they are different,

and they have different computational properties.

Okay. Now, I'm going to show you something

really cool about the Hadamard gate,

which actually takes us out of

superposition into the classical bits.

This should be unsurprising.

Everything is its own inverse, right?

If we just apply the Hadamard gate to our value here,

our coin-flip value, we get zero.

And for this one, we get one.

So, this suggests to us a quantum computation structure.

We can start with our classical bit values.

We put them into superposition,

do a bunch of quantum stuff to them,

and at the end if we're clever,

we can transition them to zero or one

so that our whole computation was deterministic.

Pretty neat, right? Okay. Now, I

should say that not all algorithms work this way.

There are algorithms like Shor's algorithm,

which only gives the right answer

of 50 percent of the time.

You can't be clever and

always get the right answers, just not doable.

But the one, the problem we will look at does

give this deterministic property.

So, does anyone have trouble with this concept?

We transition out of superposition

without measurement, pretty interesting.

>> Can you go over this transition from

a classical computation to

quantum and then converting it back?

>> Yes.

>> That's correct. Let's say two plus two,

how would that look like in?

>> How-?

>> Just the simplest type of math.

>> The simplest type of math.

What we're going to go over that basically,

we're going to go over a problem.

There are certain problems where computers

are better than classical. Addition is not one of them.

It works the exact same way in both.

It should also be said that all classical computation

can be done on a quantum computer,

all you do is just restrict

all the values to zero and one,

and it works, but it's

kind of a waste because you can also use

all the extra values that we found.

Okay, and we've actually

sort of define a state machine here,

which I am sure many of you will appreciate

if you're software engineers or computer scientists.

This is the unit circle which

many of you will remember from

high school trigonometry, right?

It's a circle of radius one around the origin.

Here's the X axis,

this is the Y axis.

You can think of the top value is the value of

the x-value and the bottom one is the y-value

so our zero value is at position one,

zero which is along the X axis.

Our one value is position zero,

one which is along the Y axis.

And this is the bit flip operator,

it defines transitions around this unit circle.

So zero goes to one, one goes to zero,

zero negative one goes to negative one,

zero which when you collapse them,

this is zero, this is one, and vice versa.

And if we look at the

superposition values, here's something interesting.

The bit flip operator

really kind of has no effect on them.

For this one, if you flip it upside down

it's stays itself same with this over here.

This one's kind of interesting and that it transitions

you all the way across the unit circle

and we'll make use of that.

But yeah, this is pretty much

the full action of the bit

flip operator on the unit circle.

I should mention here that if we

were using complex numbers,

this would actually be a sphere.

Much more difficult to sort of intuitively graphically

represent so we're sticking with

real numbers, they suit us just fine.

But it's nice to know that additional dimension is always

available to us if we want to

make our computation even more powerful.

And then here's the action of the Hadamard gate,

which we saw in the past couple slides.

It takes us from zero to one over two,

one over two, one, two,

one over two negative one over two,

and kind of symmetrically,

it also works in this way over here.

So, we have a nice state machine that we've developed and

now we can start running things on the state machine.

Very nice intuitive sort of representation,

you don't need to do matrix multiplication all the time.

Everyone kind of gets this?

Okay, great. So here's

an example of something we

could run through the state machine.

Here, I'm introducing something called

quantum circuit notation.

You can think of the cubit traveling along

this line has these operations applied to it,

is it goes through the boxes.

So X is bit flip,

H is Haddamard, and then so we go a bit flip,

Haddamard, and bit flip, Haddamard,

bit flip and if we start out here,

we go bit flip, Haddamard,

bit flip, Haddamard, bit flip.

So we start off at one,

zero and get to zero,

one, we got to cross the circle.

And note, this is reversible so we can

also go this way and get back.

So this is kind of how we'll

be doing all of our computations like this basically,

just hopping around the unit circle.

It's pretty simple, pretty intuitive, right?

It's just a state machine.

We use this in classical computing all the time.

Just has a bit of weird rules with

the claps and whatever but don't worry.

Okay, now we have everything we

need to learn the simplest problem

where a quantum computer

outperforms a classical computer.

We learn that Cbits are just a special case of Qbits,

and Qbits are two vectors of

complex numbers such that

a squared plus b squared equals one.

Within the Qbits is going to be in superposition,

they're probabilistically collapsed

to Cbits by measurement.

Multi-Qbits systems we learned are tensor products of

single Qbit systems same as with Cbits.

Matrices, again, represent operations on Qbits,

and we learn about the Hadamard gate,

very important which takes

our zero and one bits to superposition and back.

And finally, we learned

that we can think of Qbits in their operations is

forming the state machine on the unit circle or

unit sphere if we're using complex numbers.

It's actually called the bloch sphere,

if you want to look that up for the full complex numbers,

but unit circle, just fine for us.

Okay, so we're gonna

learn about something called the Deutsch oracle.

This is originally proposed by David Deutsch in,

was it like 83 or something like that?

And the problem is this.

Imagine I show up at

your doorstep and I give you a package,

the package is just this black box,

it's just horribly present.

It's a black box which has a function on one bit.

There's one of those four functions

on one bit, do you remember what those are?

I said I would ask you about them. Set zero,

set one, identity, indication.

Exactly. So one of those four functions,

I don't tell you which one is inside this black box.

There's a wire going in and a wire going out so you can

send in values see where it goes out,

but you can actually look inside the black box, okay?

So how many queries

on a classical computer would it take to figure out

which function is inside the black box? Two, exactly.

You send in zero, see what comes out,

you send in one, see what comes out.

So that will uniquely identify which function it is.

Now, how many queries do you think it

takes on a quantum computer.

You're wrong, it's two.

I say this to illustrate an important point,

which is quantum computers,

they don't really compute with all value simultaneously.

At the end of the day, you collapse

your Qbit to a single bit of information,

and a single bit of information is not enough to

uniquely identify one of four functions, right?

You need two bits at least So

this actually takes two queries on a quantum computer.

Well I'm not too exciting so far.

Now, what if instead

of not wanting to know which function it is,

we just want to know whether the function

is constant or variable.

The constant functions are,

constant zero, constant one,

they're always mapped to 0, always mapped to one.

The variable functions our identity and negation.

So how many queries would this

take on a classical computer?

>> Two.

>> Two. You put in zero,

if you get zero you don't know whether

it's identity or constant zero.

If you get one, you don't know whether it's bit

flip or constant one,

symmetrically with one, so it always takes

two queries on a classical computer.

Even though there are two categories,

so really we only need a single bit

of information to tell us which category it's in.

But how many queries

do you think it takes on a quantum computer?

I kind of burned you last time so maybe you're a bit shy.

>>I'm going for a one.

One, you are correct.

We can do this in a single query on a quantum computer.

We can tell whether its constants or variable.

This like undeniably outperforms

a classical computer and we're going to learn how.

Okay, we do with the magic of superposition.

But first we have to define

which each of those four functions

look like on a quantum computer.

We have an instant obvious problem

with the constant functions.

Can anyone tell me what it is?

>> Not reversible.

>> They're not reversible,

how are we going to write

these non-reversible functions on a reversible computer?

This is actually a really common

problem in quantum computation.

You really often have to deal with

non-reversible functions if you

have to write them in an irreversible way,

and the hack we do is this.

So originally we had this, right.

We add an input and an output,

a single wire going through.

And we just imagine that you put in

the value and you get the function

applied to that value, right?

But the hack that you always do on quantum computers

is you add an additional output Qbit.

So you actually have two Qbits.

We have to rewire our black box.

So you have your input Qbit, which is unchanged,

and then the value of the function on the input

Qbit is written to the output Qbit.

Does everyone kind of get this.

I think this the thing that people have

the most trouble with, this is necessity.

The reason we have to do this,

is so we can write non-reversible

functions in a reversible way.

And the way you do that is to

have a separate input and output qubit.

So when you see larger quantum computations,

instead of having all the bits

go in and have transformations

applied to them and then being measured.

You usually have a separate set of output bits,

so the input bits go in,

they have their value sort of written to the output bits,

and you measure the output bits.

This is a very standard way of doing quantum computation.

So does anyone have any trouble with this?

This is a very difficult concept. So, yes?

>> I didn't get it.

>> Okay.

So, do you understand this model basically,

this is what we have now, okay?

So we need to rewire it

so there are two wires going through the box now.

And one of those wires we call the input wire,

one of those wires we call the output wire.

We assume the output wires just

initialize to zero,right? It's always zero.

Now our input wire is what we actually give our input in.

Like it'd be like zero or one or whatever value

you want to give input to the function.

So, it goes to the box, it's just unchanged.

We don't touch the value of the input wire,

but we calculate the function in here,

on this input and then we write

its value to the output wire, okay?

>> Black box?

>> Yes, we are rewiring the black box.

We have to rewire the black box in

order for the black box to really work.

So the black box I gave you has to be rewired. Yes.

>> Did you use the first input,

which is the output of zero?

>> Did I use the first input?

>> Yeah, because one of them was kind of identity, right?

You put the X out, and then it was the F or X.

>> One of them was X and the other was

>> You need the X out.

>> Say we only have this,

right? This is the old way of doing it.

We can't have a non-reversible function in here, right?

For it to be on the quantum field.

>> No, that I get, right?

>> Okay, yes.

>> Because when that thing is on the right side,

you have two going in, two going out.

>> Yes, two going in, two going out, yes.

>> I get why two going out.

>> Yes.

>> I don't get why we have that zero is also going in,

It doesn't seem that you're actually using

it to produce any of the others.

>> You're correct, it's just we need.

>> Symmetry?

>> Not really symmetry,

it's just like how we would write the quantum circuit,

we would need two qubits in general.

So, you're correct that

this algorithm value isn't really used.

>> Is it like we don't care a pen off?

>> No, we do want it to be zero because the way

that we write the circuit assumes that

this value coming in is always zero. Yes.

>> Why is it ingoing output wire called output.

>> What?

Yeah. So, this is kind of weird that

the output of the input is called input.

But, we basically only really look at this value here,

is the basic idea.

This is like the real output.

The input will always be unchanged.

>> Question. So if I have

multis two black boxes in series,

the upper input which you have labeled Alvap.

>> That's smart, that's a good one.

>> And the second stage would be the F of

X output of the first stage?

>> Okay, so you're saying if you had

these in series rather than sort of in

parallel to what we're doing is that what you'resaying?

>> Yeah I want to do two operations

one and then another one.

And the black box is doing some operation.

>> The black box is doing some operation.

You can have as many operations as you want

in here inside this black box basically.

>> True, but I'm trying to

conceptually understand whether I

would take the F of X is the output upper right.

And that will be the input.

>> The input, the next one.

>> Absolutely and in fact I

said that this black-box assumes this value is zero,

this isn't maybe throw in a bit much of you,

but actually we can break that assumption and send it

some other value which maybe

will get us more information

which is in fact what we'll be doing.

So, the working of black box

assumes that the output input is zero,

but we can break that assumption and be tricky.

>> My way of thinking was I didn't

have any other value for the first stage,

but for subsequent inputs I do have one.

So I could use it if I want?

>> Yeah you could, yeah and you

might get some interesting values which actually well.

Okay I swear, this is

the most difficult part

conceptually of this entire presentation.

So if anyone has any trouble with it please let me know.

Ask any questions you can spend

as longer time on this as we want. Yes

>> As we go ahead, is there

some additional clarifications because I didn't get it.

>> Okay. Well we'll go over all each of

the four functions in this way, so maybe that will help.

So, for example, constant zero, here's how it would look.

X goes in, X goes out it's unchanged.

Now, the output is always going to be zero, right?

That's just what the constant zero does.

So we always want this value

in the upper right to be zero.

If we assume zero goes in,

this is our circuit diagram,

neither of the two wires make any modifications, right?

It's a straight wire.

Does that sort of makes sense?

We will see the next slide,

what about for constant one?

We want one to go out here, right?

This is our function output value.

And we assume zero is the input here.

All we do is we do a bit flip right here,

and that gets us the semantics we want.

Is anyone having any trouble with this so far?

I swear this is the most difficult part.

So if you get this you're golden. Yeah.

>> So these labels output, input,

would you call them something

like computations and its spare?

>> Sure yeah, you could.

You can call it the compute and the spare fit.

Yeah, that also works.They might reduce

some confusion about there being

an open output and input output.

>>Why is it called output?

>> Why is it called output?

We call this the upper qubit because it's

just the place that we write the output of the function.

But we could call it like compute

and spare or something like that, like he suggested.

Like this would be the spare sort of bit that we

write the function number 2. Yes

>> We need this to do a reversible computation,

right why is this?

>> Reversible?

>> Can we compare the reversibility of

this likewise the right one reversible one?

>> Absolutely, okay.

So let's consider this one right here, right?

We have our black box with

a single wire and

say we want to do the bit flip operator.

So, that would just be.

Sorry not with bit flip operator,

a bit flip operator is reversible.

So we want to do the constant zero operator.

We always want to map this to zero.

So you need some operation right

here, that would map this to zero.

But it'll be the matrix

1100 but this is

not a valid operator in a quantum computer,

because it's not reversible.

So, does that kinda makes sense?

It's just we can't construct a device which does this.

It's just not permitted by physical reality.

All this math and stuff I'm showing you,

it's not like special it's just,

we found that it corresponds to

the semantics and workings of a quantum system,

and so it's a nice way to reason about it basically.

Okay. Of course if we

want to write constant zero here with

their two inputs are

the two wire model it would just be blank, right?

Or if we want to do this is

constant one always maps to

one we saw that this has an X gate here.

And this is reversible, right?

Okay. So we managed to write

a non-reversible function in a reversible way.

If you've got this congratulations,

this is the trickiest part.

It took me awhile to figure out why we needed to

do this staring at the textbook.

Does anyone have any confusion here?

Okay. So remember constants zero is just blank.

Constant one has a single X gate. Yes.

>> There's a point you always end up with

a four by four reversible matrix

by doing this in black box?

>> Yes. Black box is always a four by

four reversible matrix applied to

a product state, you're correct.

Although we will be not going

into the math in that way we'll just be using

the state machine to look at it,

but the math is very easy for you to do it yourself.

Okay. So let's look at identity this is a bit more

complicated this is the CNOT gate, okay?

Where this is the control, and this is the target.

So we'll end up with,

so input again is unchanged.

We want output we assume it zero we

want to end up with a value X, right?

So if zero is sent in here,

then this is the control bit,

so the target bit is just left unchanged,

right? So zero comes out.

If one is here, one is sent in,

and the control bits one so we flip thright?

Is bit, and we end up with one.

Does this make sense? This is kind of

tricky it is a big step up in complexity of our circuit,

but everyone's fine with this?

Wow okay. Can anyone guess how will do negation?

>> You can hardset the control bit to one.

>> How can we hardset control bit to one?

>> Two controlled NOTS. They're.

>> Not two controlled NOTS,

we just have an X gate there.

So, up to here it's equivalent to identity, right?

And then we just

flip the output bit and then we got NOT X.

So, those are the four circuit values.

Okay. Everyone's good so far?

Everyone knows how we write our four functions?

Are you ready to see how we solve

it on a quantum computer? We use this.

So, we're going to break the assumption

that this value goes into the black-box as zero.

We put, first, we initialize

both in putting up a qubits to zero.

We bit flip them so now they're both one.

We put them through the Hadamard gate to put them into

equal superposition then we send them into the black-box.

One of those four circuits is applied.

Then we do the post-processing,

we send them through the Hadamard gate again

and we measure them. This is measurement.

And I claim, and I will show it to you that if

the black-box function is constant

the system will be in state one-one after measurement.

Like this will have value one, this will have value one.

We're using input as the most significant bit by the way.

And if the black-box function is

variable and the system

will be in state zero-one after measurements.

So this will be zero, this will be one.

And we will know whether the function is constant or

variable in a single query.

Pretty nifty, right? I'm going to show you how it's done.

First the preprocessing.

Remember, we start with zero then

we'd been flipped both in the Hadamard gate both.

So we start here, bit flip takes us up to here,

Hadamard gate down here.

So this is the value that is sent into the black-box.

Just remember it's in

the bottom right on the unit circle.

This is the value right before we send

it through one of those four circuits.

Okay? Now, let's look at how we do constant-0.

So constant-0 remember, it's just blank on

both and the post-processing is a single Hadamard gate.

So since no gates are applied they stay in

this bottom right value,

and since the Hadamard gate is

applied as part of the post-processing,

we flipped back up here.

When we measure this, this is one-one.

Remember I said the value would be

one-one if it were a constant function.

So we're one for one, okay?

Seem okay so far? All right.

Let's add a bit flip

because we're going to go over constant-one now.

So this is the other constant function.

Now remember, if we do a bit flip in

this state we flip across the unit circle over here,

and the Hadamard gate

then takes us down to here, zero and negative one.

When we measure it we again get one-one.

Okay? So we're two for two.

Not bad, right? Okay. Things get a bit more complicated.

Does anyone have any trouble with this so far?

And then, yes?

>> I just didn't get like why it turns out to one-one?

>> Why it works out to one-one?

>> Yes.

>>That's a good question. Okay. So we're up here, right?

If we measure this then what value do we

get? This is just one.

Remember, this is the value of the one bit.

So if you measure one, we get one.

Yes. Now down here,

if we measure this we also get

one because negative one squared is one.

So is 100% probability of collapsing to one.

And so, we can say this is one-one.

This is like the most significant bit

and this is the least significant bit.

So we end up with one-one.

Does that answer your question?

>> Yeah.

>> Okay. Great. All right.

Let's go on to something more complicated, which is CNOT.

This is going to get a bit weird

but this is how we do identity remember?

The input bit is the control bit,

the output bit is the target bit.

And don't panic,

I'm going to show you why this is on the next slide.

But the action of CNOT is to take

our input qubit up to here.

That's the green line. This is weird for two reasons.

One is that the CNOT

is supposed to leave the control bit unchanged.

Right? But here this is the only thing that control bit,

like the qubit it's the only thing that's changed.

And, this sort of action is a bit odd,

but don't worry I'm going to show you the math,

the reason why this works on the next slide.

But just for now,

so we flip from here up to here,

and then when we do the Hadamard gate

to post-process we end up in state zero.

So zero-one, pretty neat.

Okay, here's how the math works.

We're applying the CNOT gate

to the state one over root two,

negative one over root two,

and one over a two, negative one over root two, right?

When we tensor these together,

we get this ridiculous matrix which I'm going to

factor out one-half, just to make it readable.

So, we have the matrix one,

or a spectra is at 1-1-1,1.

Right? Now, we remember

this familiar matrix from the CNOT slide.

When we apply this matrix to this vector we get this.

Right? We flip the bottom two rows.

Now, when we factor this,

remember the products that we can

factor it into the individual state,

we get this tensor product.

If you ignore everything in the middle and just

compare our start values to our end values,

this is the output or least significant bit.

This is unchanged.

Right? This is still one 1/2 -1/2.

The input bit which started out as

1/2 -1/2 ends up as 1/ 2 1 over root two.

This is just the action of the gate.

So this is kind of a limitation of

our visualizer that we can't really show

the state transition but I hope I've

convinced you that this arrow is in fact what happens.

Does anyone have any questions about this?

Okay so we're three for three right.

I said the measure value would be zero-one,

if it were a variable function and

indeed it is as I said.

So for three-three.Three for three.

Let's go over the very last one which is negation.

It's a CNOT and then a bit flip.

Right? Let's see how that works.

Again we have this arrow.

Taking us up to here and

the bit flip takes us across the unit circle

and we do the Hadamard

post-processing to get us down to here.

When we measure these, we get zero-one.

Four for four, huh?

Single query, outperformed

classical computation, pretty nuts, right?

Pretty nuts. Okay, so we did it.

We now, we have outperformed classical computing.

Classical computing is in the dust.

It's done, it's dead.

So we might think like,

yeah I see how the math works and what's the intuition?

I'm going to tell you the intuition.

The intuition is the difference

within the categories was a single negation gate.

So if we go back to here,

so we have constant zero and constant one.

The only difference between them is

a single negation gate.

When you apply negation gate in a superposed state,

it doesn't really have any effect.

Right? So we kind of

neutralize the effect of the negation gate.

So we neutralize the difference within

the categories and then we magnify

the difference between the categories which is that

the variable functions have a CNOT

and the constant functions do not.

So we magnify the effect of

the CNOT and minimize the effect of the negation.

And that's a powerful thing about

quantum computing which is that you can change

the action of various logic gates

by putting yourself in

superposition in different sorts of states and stuff.

So that's pretty neat. And this problem

you may say like, "Okay well yeah.

Great. Whatever." It's really contrived.

When do I ever do this in real life?

That's a good question and it was

contrived back when it was announced,

I think was 1993, but then a generalized version of

this function was found

which it takes n bits as input, not a single bit.

And the n bits either all map to the same value, sorry,

like that's two to the n possible values,

they all map to the same value

or they equally map to zero or one.

They're constant or balanced it's called.

And so it's kind of just generalized version of this.

It turns out we can still solve that on a single query.

Exponential speedup, huh?

Exponential speedup.

A single query versus on

a classical computer you have to try all two to

the n values before you know

whether it is constant or variable. Pretty nuts.

Okay? Then there's a variant

of that problem building

everyone's kinda like building on top of each other,

it's called Simon's periodicity problem.

It's again you have like a black box and

you're trying to figure out some properties of

the function and then once that came

around Shor he looked at this and he's like, "Oh!

We can use this to factor large integers."

And so he came up with Shores algorithm and

that's when the whole field really caught fire.

So I hope I've convinced you that well

this individual problem is

kind of contrived and not that useful,

it's the base, like the foundation of

some very interesting computational properties.

Did that make sense?

Anyone have any questions?

You're all like convinced that we

just crushed a classical computer right here? Yes?

>>On the Microsoft site

there's an article where the girl was saying,

with quantum computers you can take programs that

take billions of years to run

and run them in a week. Is this...

[Croostalk].

>>This could be that. I mean yeah.

We have an exponential speedup.

If you have like, I don't know.

What it would take something like a billion years to run?

Like if you have an 80 bit function,

like to the power of 80 versus like a single query that's

probably a billion years versus a week

something like that. So.

>> A question. So I understand speedup but this is

the speedup in answering this question from

the output coming to get the input.

Right? Whether the function was a constant function or.

>>Yes.

>> Right? But in

what context is that question unimportant?

>>Great question. Why do

we care about this sort of thing?

So for example in Shor's algorithm you

can construct a question like

does this integer have

a certain factor in structure basically?

And you can tell a property like whether it has

that property or not basically which will allow you to,

and if it does have that property you

can factor it pretty much.

It's very very hand-waverly

explaining how Shor's algorithm works.

So you can construct a lot of problems in terms

of does this function have a certain property or not,

which you can find efficiently on

a quantum computer. I hope, Yes?

>> Do you mean this decision helps?

>> Mainly decision problems.

Although, as we know from theoretical computer science,

decision problems can be usually be turned into

like generally finding the answer

to problems and vice versa.

So, yeah.

Okay, pretty good so far.

To recap the whole presentation,

we learned how to model classical computation with

basic linear algebra, we learned about qbits,

superposition, and the Hadamard gate,

and finally we learned about the Deutsch Oracle problem,

where quantum outperforms classical, pretty nifty?

Okay, now the bonus topics.

With all the tools we have

these will be a breeze for you.

You'll never have to read some pop science articles on

quantum entanglement and like try

and muddle through there a horrible metaphor.

You'll actually know the math, all right?

You'll know the math, that is incredible.

And we'll go on quantum teleportation, which is super,

super nifty like it is mind-blowing.

Okay, quantum entanglement.

You asked a great question,

a very impressing question earlier which is,

"Can we always factor

the product state into the qbit state?"

When we cannot do that,

that means that the qbits are entangled.

For example this state,

if we have qbits in this state which is one over, two,

001 over root two,

if we try and factor this, we can.

So let's try and factor this.

If we can factor it,

we should be able to write it as

a tensor product of two matrices, right?

Where A times C is one over root two,

A times D is zero,

B times C is zero,

and B times D is one over root two.

So we have this set of equations right?

Now, A times D equals zero that

means A or D has to equal zero.

If A equals zero then

AC will be equal zero and it doesn't,

so A cannot equal zero.

If D equals zero then BD would equal zero but it doesn't,

so D cannot equal zero.

So the only solution is there is

no solution. We cannot factor this.

This is an percent unfactorable state.

And what this means is we cannot separate these qbits.

They have no individual value,

their value only make sense

together, they're called entangled.

And the way we might think of this is

that if we measure this state,

it has a 50 percent chance of collapsing to zero,

zero and 50 percent chance of collapsing to one,one,

so the qbits are coordinating, right?

Does anyone have any confusion with

this sort of mathematical representation?

Okay, let's talk about what it means.

Well, let's not talk about what it means

yet, you might be like, "Well,

Andrew I can sling any old value into

the vector how do you actually entangled

qbits?" It's really simple.

If we have two qbits,

we just put one qbit through

the Hadamard gate to put in superposition,

and then that qbit is the control bit in C naught.

Two gates, that's all we need.

Here's how it works mathematically.

We started with zero zero,

we put the most significant bit in superposition, right?

And then here's our familiar matrix, seen our matrix.

If we apply it to the product state, we get this.

This is the state from the previous slide.

So really simple to entangle qbits.

Okay? What does this mean?

I mean they seem to be coordinating,

or like communicating, or something

in some way, these two qbits.

And if you measure one qbit,

it collapses the other in coordinated state.

Now the weird thing,

here's how we're going do really weird stuff here, okay?

This happens across huge distances.

China just this year,

managed to do this between

Earth and a satellite in space.

They entangled qbits, put one half on the satellite,

it was launched into space.

When they measure them, they're the same value.

It happens across huge distances.

It happens faster than light, it is instantaneous.

A 2013 experiment entangled qbits,

moved them very far apart,

synchronizing with an atomic clock,

they measured them very close together.

So close together and time that it would have taken

like 10,000 times longer to travel between them.

So they aren't communicating with any sort of

radiation anything like that, okay?

They are instantaneous, it's faster than light.

And you might be like "Well,

it's pretty obvious what's going on here.

When the qbits were entangled,

they just decided ahead of

time what they're gonna do, right?"

Well I got to explain everything,

but that's called hidden variable theory,

this is hidden variable theory.

It's the same reason that when a qbits in superposition,

it isn't secretly zero,

or secretly one, it's both, it's the same thing.

Hidden variable theory, we're not

going to over the proof why it doesn't work,

but basically here's this guy named John Bell,

and he showed that if hidden variable theory were true,

it had some really weird implications,

and therefore it's unattainable.

This is just the state, this is how the universe works.

They coordinate faster than light,

they just do and that's nice.

And you might be like, "Well,

I've been told my entire life there's

a universal speed limit, the speed of light, right?

Like what's up with that?

We can't just chuck it all out."

And this is in fact a big source

of consternation to Einstein,

the idea that locality wasn't true,

and then it was discovered

that there's a really important qualifier.

You can have faster-than-light coordination,

but you cannot have faster-than-light communication,

so information cannot be communicated. So think about it.

If I entangle two qbits, I give you one,

we go to opposite ends of

the universe, if I collapse mine,

all I know is that you collapse yours,

and when you collapse yours, you will see the same thing.

That there's no information

that can be communicated there really.

So, faster than light coordination is okay,

faster than like light communication, not okay. Yes?

>> Coordination does not involve communication?

>> It does in a way,

but communication here is

a technical term which means like,

I have a bit of information that I can transfer

to you, pretty much.

So I use the term coordination to try and

give a name to something which is not that,

but still involves like some kind

of coordination I guess.

Like I said, there is a limitation of our language,

all we can do is look at the math and see what it does,

and our language it was not developed for this.

Anything I try and tell you is

fundamentally a lie, except for the math.

>> I have a question.

>> Yes.

>> So let's say I have two entangled qbits.

>> Yes.

>> And I measure one and I know its value.

Does that mean that the other one

is could potentially still not be measured,

but when it is measured it will have the same value?

>> Right, when you measure one

it instantly collapses the other.

>> I'm sorry, that was my question earlier.

>> Yeah, good question.

I said that's a simplification again of

language but you can think of it that way.

Yes, sorry you had a question.

>> So there's no way to tell

that something has been collapsed or not then.

>> Excellent question. If you

could tell whether something's been collapsed or not,

you could measure one and use that as synchronization,

faster than light synchronization, right?

Yeah you can't. The process of

telling whether something is in

superposition or not would just collapse it.

>> It seems like you will be able to tell through

some of the sort of quantum computation,

like you do some computation on that, they was collapsed,

they would only be this state and if

it wasn't it would sometimes do this, sometimes do that.

>> You would think so, but in fact it is not the case.

>> I believe you I was just creating imaginations,

is there any intuational ways about the case?

>> Is there intu can I say intu?

>> Shut up and do the math?

>> Shut up and calculate,

that's a good like a way out.

I'm not sure I can't say it intuitively,

I can say that if you do put

a pencil and paper it, try it yourself,

try and come with

some sequence of operations you can do on

the other qbit which would reveal

it as having being collapsed or not then maybe but, yes.

>> Doesn't this coordination communication conversation

that we're having violate causality or it doesn't?

>> Yes, this is the critical thing,

it does not violate causality.

If we could communicate then it would violate causality,

but since we coordinated does not violate causality.

>> But instead what you said was,

if you measure the other one is going

to be that as well, right?

>> Yes.

>> The act of measurement is in your control, right?

>> Yes.

>> So how can that happen on the other side of

the qbit if you don't have communication because that's.

>> Well let's define what communication is.

Communication is I have a bit,

either zero or one and I'm

able to send it to you in someway.

>> Somehow yeah.

>> Yes.

>> The state that is not collapsed,

be communicated to the other state,

this is what I'm saying.

>> Yeah I mean this is a language problem.

Qbits are like communicating but

we can't get information through them basically.

You might be able to say that.

I use that term coordinating

to try and avoid this problem.

Other times in literature

you'll just see the word correlated.

Which tries to avoid that whole problem.

>> Coordination, it state the word here when you are

using it, it has an action that you have performed.

>> Yes, you control when

you measure in qubits it collapses the other.

But there's no way you can change

causality in that other qubits frame.

Basically, there's no way you can get information from

your frame into that frame

which would affect their causality.

All we can know is,

we have generated

the same random numbers basically, yeah.

>> It's kind of like pre-coordination so these are.

>> I want to avoid that, pre-coordination is

the qubits decided ahead of time which is not the case.

>> Until you measure.

>> Yeah.

>> Or until these.

>> At the time they measure they

decide whether they're going

to zero or one and they somehow

communicate that coordinate,

correlate, whatever, to the other qubits

and it goes in the same. Yes.

>> So, if you cannot communicate

what's the practical application of quantum?

>> Great question. We're going to get into

quantum teleportation on the very next slide.

First, I want to tell a funny story about this.

So, you may have

heard the phrase spooky action at a distance.

This is Einstein coin that he was referring to this.

So, Einstein, Podolsky and Rosen are

three physicists who actually

came up with the idea of quantum entanglement.

They call it the EPR paradox,

there like the workings of

quantum mechanics result in this.

This is obviously absurd therefore,

quantum mechanics is garbage,

was the basic argument.

But then the experiments came out and they're like nope,

this is how it works,

the universe is in fact absurd,

locality is broken and so it's kind of

funny that a deep pair of paradox

is originally designed to discredit quantum mechanics,

it turned out to be the actual

way that the universe works,

I think it's a great little story.

Okay. Any other questions about entanglement, yes.

>> Let's say the same problem, the qubits.

>> Yes.

>> If we say that

this has a certain probability

collapsing to zero collapsing to one,

and then we observe that it collapses to one.

>> Yes.

>> How can we justify that our presumption that it had

a probability of collapsing to zero was valid?

>> Excellent question.

The answer is used a whole bunch of times and you see

that you get a 50 percent distribution of values.

>> Exactly they won't be occurring at the same time.

>> Experimentally, we know

that they occur at the same time.

With the 2013 experiment.

It entangled qubits took them far apart it used.

>> No, I mean the same qubits.

>> Yes.

>> It happened at time X.

>> Yes.

>> And now you take another pair of qubits

and this is another pair of

qubits but not necessarily the same ones.

>> Yes.

>> So, until it happened at that time,

that space or whatever,

you can't really tell that

this was happening with probability.

>> One half.

>> Yes.

>> You're questioning, okay so,

they could have decided ahead of time

for example maybe or.

>> Yeah, or probably the language of probability

itself is not active.

>> It works. Probability works I mean,

it's just the amplitude squared gives

you the classical probability of it

collapsing on zero or one I guess.

I'm not a 100 percent sure what you're driving at, so.

>> So, The question is once observed then we rationalize.

>> Once observed then we rationalize, yes.

And then if we do the experiment

a whole bunch of times we

see that it's about a 50 percent chance

of them both being zero or both being one.

Which in fact, I will show that to you live on

a quantum computer that we do that, okay.

All right, let's move on

teleportation This is the actual use which you

asked about and you've

probably read about quantum teleportation

again in pop science articles.

Needless to say, their explanation was complete trash,

made no sense at all, but now it will make

sense to you, okay?

It's the process by

which we take an arbitrary qubit state,

and transfer it across space and time somewhere else.

So, you use entangled qubits as a sort of

bridge to send a qubit from one place to another.

And here's a very important thing

it's called the no-cloning theorem.

You can transfer qubit states

so you can cut and paste them,

but you cannot copy them,

you cannot copy and

paste a qubit state, you cannot clone it.

This is called the no-cloning theorem.

It's actually pretty simple to prove you just show that

any off-such operation would not

be reversible or its own inverse,

but we're not going to go do that.

And, here's an important thing, the

teleportation despite using a

faster than light phenomenon of entanglement,

is not itself the whole protocol

is not itself faster than light

for communication because you

actually must exchange two classical bits.

So, if I'm teleporting my qubit to you in addition,

to us having an entangled qubit pair,

I also have to send you two bits of information

and we'll show why that is in the next slide.

So, everyone kind of conceptually grasp

the purpose of quantum teleportation?

Okay. So, here's what the circuit looks like.

We're not going to go over the math, there

are appendices to this slide deck

which you can see after the class to

go over the math but it gets a bit

complicated so we're not going to do it.

So, we have the qubit that we want to teleport

here we call it T and its value is phi,

is just this generic qubit value can be any value.

And then, we have

these two qubits A and

B which are both initialized to zero.

Now, you will recall this is the entanglement circuit.

So these two qubits are entangled, all right?

Now after they're entangled,

we'll say we have Alice and Bob.

Alice wants to send her entangled qubit to Bob.

So, Alice has these two qubits,

Bob has this qubit.

And these two qubits are entangled.

So, the qubits are like

these two qubits are separated right

after being entangled, basically.

Now, Alice then entangles

her qubit she wants

to teleport with the other two qubits.

So it's a three qubit entangled system.

If you were to write out

the product state you wouldn't be able to factor

it into three qubits.

Then she puts this qubit through the hadamard gate.

Finally, Alice measures both qubits in her possession,

and this results in two classical bits.

These are the two bits that Alice has to send to Bob,

and the measurement result of

this bit determines whether Bob

has to run his qubit through an X or bit flip gate.

And the measurement result of

this qubit to controls whether Bob has to run this qubit

through a new type of gate which we

haven't seen before is called the phase

flip gate or Z and this is what the matrix looks like.

And basically, once Bob has

applied those two gates or neither gate,

if both of these end up been

zero Bob doesn't have to apply anything,

he'll end up somewhat magically

with Alice's qubit value she wants to teleport.

Pretty nifty. And you might be like while we already

exchanging a qubit here why do we even care

like we're obviously just giving a qubit to Bob,

can't Alice just give her a qubit right there?

So, what you can do is you can

pre-entangle a whole bunch of

qubits a few billion qubits or something.

And then you ship them by mail they're called EPR halves.

You ship them by mail or something so Alice and Bob

have a big repository of these entangled qubits,

and then anytime Alice wants to send to a qubit to

Bob she can just use up one of the EPR pairs.

And at that point,

that EPR pair has been collapsed

can no longer be used so it's non-renewable resource.

But Alice can just send

as many qubits as she wants over to Bob.

Okay? Now, you might be saying,

"Well I don't really get this."

The math is in the appendix if

you really want to go see it.

It gets pretty complicated,

but I think I did an okay job of explaining it.

Okay, you might be like "Okay."

Oh by the way, I forgot to say, really important thing.

You may have heard that we can simulate

quantum computers on a classical computer

but it takes exponential slowdown or exponential memory.

This is the reason, if two qubits

become entangled you have to

keep their full product state around.

So, if N qubit with become entangled

you have a vector of size

two to the N you have to keep in memory.

And that is why, it takes

exponential memory to simulate

a quantum computer on a classical computer.

Pretty nifty, okay.

So maybe you're like,

"Okay this is all pretty

interesting, further learning goals."

You can learn the Deutsch-Jozsa algorithm that's

the one with N bits that I talked about,

and also Simon's periodicity problem which is another,

I figured out some property about this function.

We're not going to talk about the complexity stuff but

anyway you can also learn

Shor's algorithm, Grover's algorithm,

Quantum cryptographic key exchange,

that one's actually pretty simple

I recommend looking at that.

You can learn how they're actually

implemented in physical terms,

if you care about that.

An important thing quantum error correction since

these systems are so small like a spare cosmic gray could

just come out of nowhere and just wreck

your entire computation you

need very very stringent error Correction Schemes.

So, I think theoretically it takes

five physical qubits for

a single logical qubit like we've been operating that.

In practice, is looking more like we'll need one

or two hundred to get a qubit

of 100 percent probability

like we've been using pretty much.

So that's something to keep in mind.

When we see Google's coming out with

a 30 qubit computer that

maybe doesn't mean as much as we'd hope.

We've made only guys like

two or three really high-quality qubits.

And also quantum programming language design which

I will go over because I'll show you

a Q sharp example but anyway, recommended textbooks.

This one is my absolute favorite,

has the same title,

has the name of the talk,

Quantum Computing for Computer Scientists.

This algorithm is by our friend David Mermin,

the shut up and calculate guy.

It is a meat grinder of

a textbook but I started out with this one.

It was horrifying, it was just like,

but it skips a lot of steps basically.

It's more symbolic manipulation.

You won't see as many vectors and matrices.

I like to write out the vectors and

matrices to see what's going on which gets

really unwieldy when you're writing out like

a 64 by 64 vector or matrix.

But I like to have both of these.

So, I'll use this to fill in the gaps with this.

This has more interesting sides, stuff like that.

This is also in the MS library.

There's another one called

Quantum Computing Gentle Interaction,

also in the MS library.

I've heard mixed reviews or

semi decent reviews of it. I haven't looked at it myself.

There is also Mix of Quantum Development kit.

They have the docs.

They're actually pretty nice thing called

the Quantum Computing Simulator and Q Sharp as we'll see.

Now, I said I would end the talk on

some skepticism which there's an article,

came out I think was

Quantum Magazine pretty prominent recently,

interview with a mathematician who believes

that physically realizable

quantum computers cannot exist.

His basic argument simplifying is that the amount of

noise in the system grows

exponentially with the number of qubits.

So we cannot get a really large qubit system because

our computation will just keep collapsing

in the middle of it and

it's just like an exponential term.

And so, I'll be very sad if this happened.

I'd feel like the universe is against me.

It'd be really, it'd be very sad if

we could not realize the benefits of

Quantum Computing, like cosmetically sad.

But anyway, you can't argue with

the universe and yeah

you can read that article for some skepticism.

I think his name is Gil Kali, is the mathematician.

There's some appendices but

I'm going to do some demos now.

Okay, the first demo is

just the Doge Oracle problem in Q sharp.

So Q sharp is based on F-Sharp

and we have this function I've written,

IsBlackBoxConstant.

You've taken a black box and they tell

you whether it's constant.

Oh, gosh, sorry. Here, of course.

Okay. We have our function IsBlackBoxConstant

where it takes in a black box and it just

returns the Bool. Is it constant or not?

And it just uses this same protocol we went over.

It allocates two qubits,

calls one input one output, clears them,

sets them both to zero, does the preprocessing,

flips them, puts them through the Hadamard gate.

Then it sends them into the black box.

Afterward, it again put some through

the Hadamard gate and then it measures

both of them and again if the input results is one,

then it's constant otherwise its variable.

Okay? We have our black boxes

defined here. So, ConstantZero.

Again, remember it's nothing.

For ConstantOne we flip the output bit.

For Identity we run a CNOT gate with

input control up it is target

and Negation reducing our next, okay?

And we just have these,

like IsZeroConstantZero I call.

Is BlackBoxConstant with ConstantZero?

And then we have our classical driver.

Any quantum computation will have a sort of

classical computer to tell it what to do,

and so I ask

for each of those four, well, what's going on?

And we can run it and it runs on a simulator and we

see the output, IsConstantZero constant?

True. ConstantOne constant?

True. Identity constant?

False. Negation constant?

False. So there you go.

Yeah we wrote the Doge article,

ran it on a real quantum simulator,

you saw that it worked out.

Okay, the final demo of

the day and then I'll let you get out of

here is here we go.

This is called the IBM quantum experience.

There is a real like

world quantum computer that IBM has built.

It only has five qubits but they just let you online

just drag gates onto

this quantum circuit diagram and

run it on a real quantum computer.

So I thought it'd be pretty nifty if we demonstrated

entanglement live for you on stage. Let's see.

So, if you remember the first thing we do

is we drag a Hadamard gate onto

one debt and then we use the control not, oh no, okay.

So, the way that

quantum computers are constructed you can only

usually put CNOT between

certain debts basically it's just kind of,

otherwise it's just mechanically impossible to see.

Can we do that? Nope, okay.

How about, success.

Okay, we did it.

This is the CNOT gate.

You can see varying representations

of it. It's like the opass.

And I say we'll run it on

a quantum computer, oh right, measurement gates.

I forgot. We need to add

the two measurement gates obviously.

So we're measuring

both these qubits after entangling them.

And what we expect is to see them predominantly been

0-0 and 1-1 right? Well, let's test it.

We'll call it that and

we can save the result from

cache but I want to do it live for you guys,

so I'm going to run a new execution.

And you can imagine right now deep at IBM Research Lab

nestled within a dilution refrigerator

operating at slightly above absolute zero,

we have real qubits being

entangled and measured thousands of

times for our entertainment. That's pretty cool.

>> It is.

>> That's pretty cool.

Okay, let's see if it's,

oh here we go, we got the results.

And executions it's pending, okay.

So it might take a couple minutes.

We're going to see now.

Does anyone have any questions while we're

waiting for this? Yes.

>> I don't know what question.

You said this experiment where

this sentiment tangled qubit to space and the satellite?

>> Yes.

>> Are we good at storing like qubits for a long time?

I'm really surprised they were able to

do that. I thought they kind of...

>> Yeah, yeah, that was actually a lot.

They will manage to send the entangled qubit up

file laser but, yes.

>> Okay.

>> I don't think we're that good at

storing qubits for awhile.

I think they're fairly short-lived.

>> [inaudible]

>> Yeah, they actually,

this Chinese satellite experiment,

they teleported a qubit up there.

So they sent one EPR half up by a laser and then they use

that EPR half to teleport

the qubit up there. Pretty cool.

>> That's awesome.

>> Yeah.

>> So we can send entangled qubits by laser?

>> You can send entangled qubits by laser, yes.

>> Okay, that's even cool.

>> Yeah. Let's see, it's still not.

Okay, that's fine. Anyway, yes.

>> You mentioned that there's

this new article by

the mathematician that says the noise has grown faster.

>> Yes.

>> What is the whole purpose of

a topological quantum computer resist that.

>> Of course.

Any corner computer will have issues with noise.

The topological quantum computer

is supposed to be better than

its IBM counterparts in

terms of noise but it'll still grow exponentially.

Like it can still be better but it

still runs into exponential barrier.

And so the next couple of years

are really sort of make or break for

quantum computing because we'll now have the ability to

create computers which run into

this exponential term if it exists, if it exists.

And so we will see with the next couple of years whether

quantum computing is really possible or not.

It's nervous and it makes me nervous but yeah,

because we'll run into

this limit probably like this year.

If Google does not

manage to demonstrate quantum supremacy

it'll be a bit scary I guess but yeah.

Let's see, we don't have, I'm just going to refresh this.

>> Question.

>> Yes.

>> Do we know what Google

uses Quantum theorem for, like what?

>> What they use it for?

>> Yeah.

>> I don't believe we do. I think they just have...

>> Is it experimental mostly?

>> Actually no.

They haven't announced what they use it for.

My manager is actually playing around with

the D-Wave simulator to...

>> The Canadian company. Is it the Canadian company?

>> D-Wave is Canadian company.

Yeah, everyone out there is

like really scammy and not really

quantum but everyone kind of believes

that they're quantum but it's a different paradigm.

It's like optimization basically

but it uses quantum computing.

They have a simulator you can use.

My manager has been using it to

kind of play around with finding routes in a network.

It has general applications like

that. Well, this is taking a lot.

>> The data is publicly available somewhere?

>> Yeah, it's in the invitation

and I think it'll probably be posted

on their resonant website or posted online.

>> So that application is like

a requesters type of application?

>> Yeah, yeah, it's like...

It's optimized.

You're able to express

the network graph in terms that like

an optimization result would be like

the least energy path in terms of like

the least cost path through the graph sort of.

That's different than the way the [inaudible].

>> Open Shortest Path.

>> Come on, why isn't it going?

Pending. I'll be really sad if this

doesn't finish in time. Oh well.

>> So on D-Wave,

how are presentations centered you could do

classically faster than when they were doing.

So, they've improved in that or?

>> I don't know actually I haven't looked into that.

They're probably about comparable I would say.

Because given that it's just like

optimization and especially with the explosion of

machine learning there's been

a lot of development in making optimization better.

Optimization is like you have a surface and you're

trying to find the highest point or the lowest point.

So there's been a lot of research that goes into that.

We'll just run it from cache and okay.

Here we go, okay. So here's the results from cache.

Unfortunately our real execution didn't finish yet but.

So we see that indeed

they entangled some different qubit than ours but we

end up with 0-0 and 1-1 almost

exclusively but then there are some in

the middle because of the error rate, right?

So this is on a real quantum computer.

We have some error rate where it

doesn't exactly work according to

our model all the time but pretty cool,

these are entangled and they're

measured and we have that.

That's the experimental data right

there that entanglement is a real thing.

Yeah. Okay, that concludes the presentation.

Thank you very much. I hope you

all feel as though you followed the whole thing,

no real confusion and

feel that you could keep on learning.

This isn't like mad genius science.

This is very accessible science.

So, thank you very much.

For more infomation >> Quantum Computing for Computer Scientists - Duration: 1:28:23.

-------------------------------------------

Hearing continues for parents suspected of prostituting child - Duration: 0:56.

For more infomation >> Hearing continues for parents suspected of prostituting child - Duration: 0:56.

-------------------------------------------

Chance For Rain Lingers Through The Week - Duration: 2:48.

For more infomation >> Chance For Rain Lingers Through The Week - Duration: 2:48.

-------------------------------------------

Police searching for suspect after chase - Duration: 1:58.

For more infomation >> Police searching for suspect after chase - Duration: 1:58.

-------------------------------------------

DIY FURNITURE FOR CAMPER VAN CONVERSION - Duration: 11:06.

good morning today we are moving on to the kitchen but let me actually give you

a quick update on what we've done and we now have a beautiful couch it's really

simple we basically just did like a bunch of supports and then flats on top

and this is just gonna have cushions here and on the back we are going to be

putting drawers you see those little slots in there we're going to be putting

drugs beneath that right so today is the kitchen this is the allotted area for

the kitchen it looks so cool in that almost friends I almost feel like I

could like just throw a couple of things down and chilling it friend I know right

well and it's kind of interesting because originally we were thinking

we're gonna make all of it pretty much whites with like our couch will be tan

and our comforter cover will be tan and stuff like that but now we're really

liking the color of the wood and so we actually want to bring out a lot more

wood colors so our cabinets are gonna be just natural wood we found like a good

seal that isn't gonna take the color away or anything like that

so it's gonna go show them the the seal and everything and then we can yeah so

I'll show you our door covers basically but this is gonna be the color that our

cabinets are so it's basically just going to be this natural wood which I'm

super stoked about and then we're just kind of standing down the edges to make

them a lot smoother I found this stuff called spar urethane one of the problems

that we were finding was like any just clear stain with making all the wood

yellow and I hate the yellow color this far urethane is doing the trick okay

change of plans we realized we do not have long enough

long enough screws so Christian is on his way to I think like the local

hardware store Christian's leaving me again the good news is I have a friend

there is so cute Christian's grandparents are babysitting

Davie while her parents are away so she's just hanging out with us while we

build our van or aren't you and also she loves me the best so the other good news

is let me show you we got a packet this is the rest of our reclaim

barber would you guys might remember in one of our I think like two videos ago

we were not able to finish the ceiling because I completely underestimated the

amount that we'd need for the ceiling so they were amazing and sent us some more

so we're gonna finish that while Christians gone work on this bye bye

I've been sent on a mission it's so causing Annie and Paul Paul any poeple

are some of the worthiest people I know Danny's gonna make us some vegan coconut

something I know she's like yeah give me three cans of coconut the canned coconut

milk at Brookes hers is a local grocery store

I say Papa you need anything Franco he's like yeah you know what why'd you go get

me some a gallon of milk up at Dollar Store I might pop all Marty going to

Brookshire's can I just grab it there he's like no it's about a dollar mark

senses there Oh make it an extra stop a

lot of you guys have mentioned and rightfully so that the adhesive is not

probably wanting to work very well in a moving vehicle

um and what gravity so we actually have been planning this was the plan all

along to eventually just take a nail gun and kind of zip everything in if you

guys missed it um we are working with reclaimed Arbor they sent us all this

way and we have a discount code so I will put that discount code again in the

description box so you can see it in the last video we talked about it I'm loving

it so far so I would highly recommend it if you're looking for a unique element

to your home what's the saddest update my baby I think there's one little

hardware place sighs all I get stuff so we got almost everything we need that's

exciting Aubrey has now gone in to make lunch I'm

gonna finish a couple of quick things then I'm gonna go in for lunch too

the bed the garage is almost done something put some tracks on that guy

every night made it one of our rules during the bill that we're gonna take

serious lunch breaks because it is so easy to just go go go non-stop and then

you never rest you never get hydrated you never eat up so I'm gonna we're

gonna go take a serious lunch break because the afternoon but in the kitchen

is going to be a serious business the face that I just walked into I've been

waiting for you and I did all the dishes and I had spare time are you kidding me

I just put up the entire rest of the bed you said five minutes let's go eat this

is lunch maybe what do you think quinoa has been staple I just throw that in the

rice cooker in the morning anyways i crumbled up some fielder's sausage mix

that with onion and bell pepper topped off with some salsa delicious it really

is so good you need one of these super filling hearty meals to get your energy

going all that really well he's full you judge for yourselves belly looks Daisy

wants to be outside with us don't you you just follow us everywhere don't you

want to be a van dog you just kidding you already have family what is that

whoa fancy all that more this kitchen dude no we're just making a box right so

I'll make the main beam all on the stud there there anything that just seems a

little low maybe we should make it 36 because our counter is gonna go on top

of that just thinking about the actual construction of it is that where there

is there another cross being playing this way there's one right here right

yeah are you still thinking will basically do a 2x4 out all the way

basically we're obviously gonna have support here here

gotta clean all right it's pretty easy too so let's start with the basic

supports okay it's gotta be like 90 percent unity to I let me show y'all

before we went on with our kitchen build we wanted to figure out how much room we

needed for the fridge we did this two kitchens in a row it's kind of an

awkward sighs but we designed around our fridge we're gonna have to figure how to

fit those young guys but last time we pulled the fridge out sideways and just

didn't work that was kind of awkward and it was too much weight for this sliders

so I really just didn't wanna mess with sliders again it's probably the law I'm

not gonna build a little slide things for everything this thing works so super

well it's like the smoothest slot smoothest ride ever I've got just L

brackets on either side to hold the thing to hold the fridge end one piece

of 1x3 of this it's right in I'm gonna put a

block on the back but it slides right there it's going to slide right in place

to the back these supports are super steady sturdy this is what we got so far

we are about to finish supporting these last two beams then we're gonna make

basically that same system here we're building the cabinets next week so we're

just trying to get this basic frame upright then how we're on let's go cut

these lost beams let's stay motivated in focus

we don't need towels there they go holy cow you see him do you see him it's

hot okay unfortunately we did not reach our goal

completely and we have to clean up and go inside because we're just done kind

of get to a point I feel like sometimes where you've been building and building

and building and nothing is making sense in your head and it's just time to be

done and that's kind of where we're at because we've been building since

today's Saturday we've been building like morning tonight every single day

since Monday I think you guys might be wondering why are we using so many

two-by-fours isn't about a lot of weight I feel like I'm just anticipating that

we're gonna get that question a lot in the comments here's our reasoning number

one and the most important most the biggest reason that we're doing this is

first stability we want everything to be really really really solid the second

thing is you guys might we've already gotten a couple of comments from people

who are like you should know woodworking you should do all this we don't and

we're still making you do so I think we're still going to come out with

really solid stuff even if it's not necessarily as efficient in the weight

department as maybe somebody who has done this before could make it we're

just kind of hoping to prove that even if it's not perfect even if it's not the

best best best if you can still make an awesome bearing conversion if you don't

know how to build just wanted to address that before we get a lot of comments

about that us opening multiple two by fours and just building structures out

of 2x4 a man you got anything to add my baby that's not true we've worked

equally hard all three weeks but this has just been so far with that I'm gonna

peace out guys I hope you enjoyed this video if you did give it a like if

you're new around here subscribe we make a lot of videos about three or four

times a week and we're deep in this build and will continue to document it

throughout the throughout the whole process also if you guys want daily

updates on the build we aren't making a daily video on this so if you do want

those daily updates make sure you follow us on Instagram I put our I'll put our

handle right here see you can see that go follow us there and put daily updates

on our stories every single day so can't wait to see you guys over there and I

will talk to you on Wednesday bye guys

For more infomation >> DIY FURNITURE FOR CAMPER VAN CONVERSION - Duration: 11:06.

-------------------------------------------

Montgomery County officials propose funding for projects - Duration: 2:12.

For more infomation >> Montgomery County officials propose funding for projects - Duration: 2:12.

-------------------------------------------

Trump Humiliates Past Presidents In Speech For US Embassy Opening In Jerusalem - Duration: 7:12.

Trump Humiliates Past Presidents In Speech For US Embassy Opening In Jerusalem.

Liberals are freaking out after President Donald Trump gave his opening speech as the

U.S. Embassy in Israel is finally moved to Jerusalem.

The truth bomb Trump just dropped is going to leave a few former Presidents humiliated.

According to Daily Caller, President Donald Trump delivered a blunt message to his predecessors

in his pre-recorded opening speech, shown at the official ceremony of the new U.S. Embassy

in Jerusalem.

Trump has managed to step on the toes of all three of the past Presidents who came before

him, and in my opinion, he has no reason to stop doing it now.

Trump's speech was truly historic.

Our President proudly proclaimed America's admiration for Israel, and their significance

as the homeland of our biblical heritage.

I cannot remember any of our other three past presidents taking such an unabashed stand

for Israel as our closest ally in the Middle East.

"Today we officially open the United States Embassy in Jerusalem, congratulations.

It's been a long time coming," Trump said in reference to past administrations who promised

to move the embassy but failed.

"Almost immediately after declaring statehood in 1948, Israel designated the city of Jerusalem

as its capital.

The capital the Jewish people established in ancient times so important," Trump said,

according to Fox News.

Former Presidents Bill Clinton, George W. Bush, and Barack Obama all failed to move

the embassy to Jerusalem.

Each I'm sure had their own motives for not following through on that colossal commitment,

but in a way, it's very appropriate for a man of Trump's character to finally be

the one to get it done.

U.S. law has dictated since 1995 that the U.S. Embassy must be moved to Jerusalem.

Every president dating back to Bill Clinton had pledged to follow through on the move.

"Today, Jerusalem is the seat of Israel's government.

It is the home of the Israeli legislature and the Israeli Supreme Court and Israel's

prime minister and president," Trump continued.

"Israel is a sovereign nation with the rights like every other sovereign nation to determine

its own capital, yet for many years, we failed to acknowledge the obvious, the plain reality

that Israel's capital is Jerusalem," he added.

"On December 6, 2017, at my direction, the United States finally and officially recognized

Jerusalem as the true capital of Israel.

Today, we follow through on this recognition and open our embassy in the historic and sacred

land of Jerusalem.

And we're opening it many, many years ahead of schedule.

As I said in December, our greatest hope is for peace.

The United States remains fully committed to facilitating a lasting peace agreement,

and we continue to support the status quo at Jerusalem's holy sites," Trump continued.

"Including at the Temple Mount, also known as Haram al-Sharif.

This city and this entire nation is a testament to the unbreakable spirit of the Jewish people.

The United States will always be a great friend of Israel and a partner in the cause of freedom,

and peace.

We wish Ambassador Freedman good luck as he takes up his office in this beautiful Jerusalem

embassy, and we extend a hand in friendship

bless the United States of America," President Donald Trump concluded.

Trump's speech for the ceremony of the Jerusalem Embassy is a great accomplishment for a man,

who has overcome tremendous adversaries and continues to battle the left on a daily basis

to do what is right.

Trump didn't seek the presidency to serve himself or to amass wealth like so many politicians

before him.

This tremendous accomplishment speaks directly to his purpose for solidarity with our allies,

and peace through strength with our enemies.

Those principles are in direct contrast to the liberal and globalist agendas.

It's crucial for Trump's supporters to gather strength, and help him build a new

team in Washington, D.C. which will put America first and continue to honor invaluable relationships

such as the one we have with Israel.

What do you think about this?

Please share this news and scroll down to Comment below and don't forget to subscribe

top stories today