So I’d like to take an opportunity to

have a really honest look at the field right. Why does

the field even exist? Where we going? Where are we at? So there are valid

questions to ask at all levels of those statements. So, to begin with we’re going to look at five generic approaches to quantum computing,

because there isn’t one, right? People look at lots of different

things and are trying lots a different ways to do something interesting in the field of quantum stuff so we’ll have a look at each different way,

its strengths and weaknesses and you know when they’ll choose my favorite way

and argue why it’s the best and then we’ll go through what

that means. So once you choose that way what algorithms could you run on such

computer how could you go about building such a device. How could you make sure that

it actually works and then the overhead of actually doing

something that you can’t already do with existing machines and how believable that overhead is. So here’s one generic approach to building

a quantum computer so you create an exotic state of matter, you excite some exotic particles

and you braid them around. Now there are many beautiful features of this,

it attracts a lot of high grade, highly intelligent physicists.

The biggest question mark is still well we haven’t observed this state of matter conclusively people are still debating the various

experiments that claim to have demonstrated as to whether it’s true or

not or some effect. It hasn’t been reproduced and we certainly

haven’t got to the stage being able to store and manipulate data. Also, people have already identified some

sources of noise and manufacturing defect in some of these cases these guys in

here superconductors and they have quasi particles and that poisons the qubit and it kills it. So some aspects appeared to

kill the robustness that the theory is intended to

predict So right now I would say it’s still an open theoretical problem not just

experimental but an open theoretical problem as to whether these guys really will be

robust and in particular exponentially more

robust as you make all the size scales of these

devices bigger so it’s unknown, open problem. Here’s

another one, so we have a commercial quantum computer

you can buy one of these if you have a spare 15 million burning a hole in your

back pocket. So it’s a kneeler and what really that

means is if you have some function of a binary nature in this case anything up to 509 binary variables that was supposed to be

512 but 3 of the qubits don’t work, you can have a minimization of that function executed worked out by

this chip and you know, it does actually work so you’ve got to give

credit where credit’s due, D-wave has built a chip that does what it says it will do and then

all the things that they get in trouble for you know which

is exactly how powerful that is right. So it should be stressed

that there’s nothing at the way machine can do that cannot be done classically there are algorithms that will

give you the answer for any D-wave style machine and

indeed larger versions of the D-Wave machine. However, in some cases you can

squint and argue that the D-Wave machine might be sparse or specific instances

if you mess the dial in the wrong way but nevertheless it is a fifteen million

dollar machine if you throw fifteen million dollars of classical hardware the

same problem, you solve it quicker. Okay? They compare with single core or a

small number of cores machines which really the big question is this: can you achieve commercially relevant

performance right? You can’t sell someone a fifteen

million dollar machine and say yes it really does solve these problems but I can solve the same problem with a

fifteen thousand dollar work station right? It is unknown if you can build a version

of this big enough before temperature effects

which are known to be a limitation decoherence effects, known to be a

limitation. Kick it in and just stop you solving with any degree of acceptable

reliability this problem so again there’s still

theoretical questions in addition to hard way. Yes? Emphasizing its not a

universal makes no claim It’s dysfunction

that they minimize is actually a very useful thing classically. Okay? They don’t need to claim its

universal because this is already useful enough. Yeah, but minimizing a function of this

form is incredibly generic in the classical world. It applies to a huge range

optimization problems this is good enough right? The only question

is can you make it work cheap enough and we don’t know. it also doesn’t actually matter so

people will undoubtedly argue until the end of time about whether

it deserves to be called Quantum or not but fundamentally the machine makes

sense even if you view it as a classical

machine right? I mean if you were going to say I have a

function that has some constraints well if you represent your qubits as loops of wire and the constraints as some

particular interaction strength here, then if you just imagine the current in

each direction is zero and one you can imagine that by settling to a

solution of your problem. So really it becomes a very gray

question, to what extent is quantum mechanics helping to get there and the fair answer that

d-wave will say is they don’t care. They care that the device

works. If you push them a bit harder they will

say things like well we believe and again people debate. We’ve demonstrated a qubit entanglement

true or false I don’t know but they will say that and

we believe therefore that we have 500 out of these qubits and every group of 8 qubits that is

coupled can see tunnel barriers and therefore

there might be some advantage from quantum mechanics because groups of 8, of which there are

many of these can all see these tunnel barriers

and hopefully get to the solution quicker. Now that may or may not be true, but ultimately it only matters that the

device works and to be built cheaply enough. I have a lot of time for this approach

the theoretical questions are hard open but to me do not decrease the

credibility of the device which should just be only by its

ability to get answers. Now the D-wave press that’s a completely

other issue but let’s avoid that. So, here’s yet another one boasts on sampling. Now here we’re really really not focused on really doing anything useful it’s about proving that you can play

in the quantum world and get a speedup. However again we have this recurring issue, errors. It’s unknown if errors will prevent this

from being meaningful. See it’s a scaling argument

the claim is that as we scale this object it’s exponentially better but as we scale

this object you have more and more errors and sooner or later it doesn’t work so

is that a fair claim? People are still debating

whether that’s a fair claim or whether you can modify the

claim to not have to rely on this hardware being perfect. Can you find some regime where even if these devices are imperfect the level you observe in experiments

that some aspect of the probability distribution

you see here remains classically hard to simulate

this is known alright, valid question but it’s unknown

it’s still theoretically not 100 percent sound, quite irrespective of the experimental challenges to

implement it. Yet another one quantum simulation so you

have some piece a physics you like, you build in hardware, why not sounds like

fun but again you really need to compare

with classical techniques to see if there’s any chance of a speed up.

Now to be fair to the people that do this kind of thing they’re usually not even looking for a speed up but long-term, if you want to be doing

this in twenty fifty years and selling a device, it matters, right? You have to show that

you can do something we can’t already do and it’s completely unknown if you can

build a sufficiently large scale system again with no error correction that

actually does something anyone cares about and would pay for better than an existing computer system. So

there’s still plenty of time to do that in some

ways it’s early days for quantum simulation but we need a lot more people

looking at what can be done classically to see if

the engineering of the systems can be pushed far enough to do better. Or finally you can do this universal

fault-tolerant quantum computation and here I would argue well theory is

done and has been done for over a decade. We know that if we can make a lot of qubits and get them

working together to crack their own errors then we can do arbitrary quantum

computation and so for this reason because it’s

theoretically sound because we know we can do it if we try

hard enough this is what I’m going to claim is the way to go and that’s what we’re going

to focus on in this talk. No, not on the D-wave, not quantum-simulation, not photon sampling. The way not D-wave, no, the way. Alright we can do anything with a quantum

computer. What does that really mean? So if you are in the military

secretly spying on this talk that means you care about code-breaking so we have factoring this was the first

application for a quantum computer. We have ways of breaking

the BlackBerry encryption and even more exotic codes

the people initially thought would be quantum-secure people are finding ways to break

them and no one knows the limits alright so there are plenty of proposals

out there for more codes that are still hopefully quantum secure. They have some issues that classical pricing is high the key lengths are longer but we really don’t know how far you can

push a quantum device as a code breaking machine, and again if you’re in the government

you’re already sold you don’t even keep reading, you say right I want one, build me one but it should be stressed

that this is not a commercial application. If you are IBM you cannot pay for

a code breaking machine, it’s a legal. You’re not going to sit there and break banking

transactions and Chinese communications this is not a commercial thing its

military. If you care about commercial applications well, people say that 30 percent of worldwide superconducted time is spent

doing quantum chemistry. Now, that number is a good start but we

really need to look at that number a lot more closely because if quantum

chemistry means molecular dynamics with 10 to 100 million

atoms if it means proton folding

with tens of millions of atoms, this is not

likely to be something that a quantum computer can help with because the sheer representation of

data already means so many qubits before you add in error correction that you’re not gonna build a machine that

big. We really need to check whether any

significant fraction of that 30% is doing things like high-energy

quantum dynamics with small molecules where you care about exactly how you

catalyze a reaction or something like that where the quantum effects might matter you

know how do you build your porous platinum catalysts such that this product and that product

go through it maximum rate mentioned, all that kind of thing right these are

the kind of quantum calculations you could imagine

having an impact on I don’t know how much of worldwide

supercomputer time is spent doing that alright vs. protein folding

which is probably a lot vs. drug design which might be a very

large thing which is probably a lot and probably not amenable to on a computer helping at all there are some other famous ones an

exotic mats so not theory calculating loop invariants and knots again exponentially fast. All the things I’ve listed on this page are exponentially faster than the best

classical equivalence. That picture on your slide, what is it? It is a random picture I got from Google

image search it represents the idea of doing quantum

chemistry. Can you expand a little on why you think quantum computers would not be useful for protein foldings? It’s a data problem yeah I know they

claim. Well, people claim a lot of things without actually thinking about it. So let’s think about it. How many

atoms do you need to do a protein folding problem? You’re typically looking at least hundreds of thousands to

millions sometimes a lot more. Some proteins are really big so that means

at the very least you need a bit per atom and of course that’s not enough, you probably gonna need three coordinates per

atom at least. So now we’re talking about representing

three coordinates, let’s keep it modest, say 16 bits per coordinates it’s probably again

not enough. You’ll probably need at least 32. So if we take 32 you’re looking

about a hundred bits per atom probably as a minimum and even if it’s a

really small protein say a hundred thousand atoms, you’re talking at least 10 million bits of information now we still have no error correction

thrown in and as we’ll see error correction can block this enormously so even if I’m incredibly optimistic that’s going to be at least a factor

of 10,000. Alright, so we’re now up to one hundred billion qubits that sounds really unfavorable okay and

that’s a small protein with low precision coordinates and assuming I

don’t need any extra information per atom. so seems unlikely. So your argument isn’t based on that this is the

kind of simulation problem a quantum computer wouldn’t offer an advantage but rather just the practical concern. Yeah. It’s pretty fundamental. Yep? How large problems are being dealt with fast So protein folding you can do hundreds of thousands, molecular dynamics say we can do up to a hundred million atoms. But obviously the obstacle, They’re not very quantum that’s the

point its done as a very classical thing. but that’s the whole point people sit there and say “oh we’ll fold proteins” protein folding is not that quantum a problem. It’s a very classical problem alright

we’ve got to design drugs most of that’s all classical. How much quantum-ness is in your

drugs? Not that much. So you know people make a lot of off-the-

cuff statements but when they do they really should be

picked up on them and said give me a reference what’s your source, what are you talking about?

A quantum computer is not a high darter device you can’t represent

a lot of darter in the so if your problem natively requires a

lattice of a billion atoms, probably even if it’s a quantum problem it’s

completely intractable on a quantum computer. You’ll never build a computer big enough just to represent

the data before you even start talking about the computation. So anyway a lot of care is required to

find problems of this nature that are actually useful and

particularly commercially interesting. So then you have all these exotic

things which require a lot less overhead but again

you’re to ask yourself who’s going to pay for that and then wear down to just

speculations. There’s some things on machine learning where you

take one object and say you know is it which one out of this class of objects,

very common problem but again it’s pretty well solved classically a lot of people work on its not clear that

we can give an advantage and ultra speculative if I put on a wizards

hat is you know maybe just maybe because artificial intelligence hasn’t been solved despite lots of effort

for a long time a quantum computer’s going to help us. Okay, and the that’s about the level of

which you should assign credibility to that statement. So the short answer is there is no one

application we have that is worth money. So, right now

if I go to an industrial giant and say I’d like to build a quite a computer I’m

saying I want five to ten million a year growing

exponentially as the computer gets bigger for twenty to thirty years to build the

device that will cost perhaps a hundred million dollars and has no known commercial applications. That’s where we’re at so we badly badly

need a lot more work on algorithms to

identify something that would justify the cost of building the machine. Other than that we’re just hoping and

that’s okay i’m hopeful but we should be very honest when we make that request for money

that that’s where we’re at. So keeping in mind that you know the dream of large-scale quantum computing even if we realize

that is just something we hope will be helpful let’s nevertheless get on with trying to

build one anyway because it’s fun. At UCSB, we are looking at x 1 qubits and we have

this little architecture picture which basically is this plus shape can be viewed as a

capacitor and the fact that its neighboring this plush means its capacitably coupled

directly These guys can be viewed as allowing us to tune the frequency of

this guy so there’s also completely invisible some Josephson

junctions that act as inductors so this is a resonator tunable frequency and then you can tune

these guys in and out of frequency without in resonance with each other to

execute gates and it’s quite a simple approach in

terms of the number of objects on the chip and it works quite well so at the current point in time we can

demonstrate initialization measurement two qubit gates all with better

than 99 percent fidelity and at the same time I think single

qubit gates were better than three nines. So this is clearly not a large scale quantum computer yet, we need to had a 2-D array of qubits at least. You can’t just have a chain of qubits that’s useless if one of your qubits

doesn’t work you have two computers not one. So you need for fault-tolerant reasons if

nothing else you need a 2-D array of qubits where optimistic win collaboration with

some people here at IQC that the wiring can be moved to the third dimension.

We’re optimistic that we can use microwave photons to

communicate chip. It hasn’t been demonstrated also hasn’t

been demonstrated the wiring in 3-D, and optimistic that we can build a large

2-D array of nearest neighbour qubits, all with operations that includes the

two-qubit gate better than 99.9 percent fidelity so if

you press me hard and say exactly how are you going to take this resonator

which is larger than this qubit and put it in the third dimension I’ll

give you the honest answer, we don’t know. We’re just optimistic that we can find a

way to do it. You know, it’s a large architecture but when your resonator is

bigger than your qubit that, that doesn’t help you it’s likely

that we’ll probably need to put a bus of some kind between these qubits and then spread it out so instead of

being a simple 2-d array with some questionable 3-D wiring you actually need a larger, soI have a bus to create more space and again architecture of this nature are

one of the reasons why I am physically here at this point in time because Matteo Mariantoni is working on

not exactly this but something of this form, where there’s some more space and we can

realistically hope to get the wires in here. You can imagine

now well sure this guy’s bigger than the qubit but there’s pace for the resonator

to go there is space for contact pads there is space to put a connector in so

again you gotta do all that and keep the fidelity high but we’re optimistic that we can do it. However note that what I’ve drawn on the

page is a bunch of qubits that interact only with the nearest neighbors so we want to be able to control errors in a

manner that is consistent with what we can build physically and

it’s very fortunate that we have a wonderful code called the

surface code that is completely compatible with that 2-D array. So you only need nearest neighbour interactions

and you can get away with errors provided they’re below about 1

percent per gate. So at the moment the UCSB device if

we just allow ourselves to imagine we can build it

in this manner, no buses in between while preserving the

current threshold aerates the fidelity’s and we try hard so they are

different frequencies for each qubit and we have a look at a schedule that would

actually work and and so on and so forth so, with just the assumption that we can

magically control it, the physics stays the same make it 2-D the numbers we currently have are at threshold

which means that if you improve anything you start being able to correct

the errors the device has natively. That’s hard, don’t get me wrong, going to

2-D, moving the wine away and still maintaining performance and then

making it even better is hard we just believe we can so we

believe we can build a surface code quantum computer that will work alright of course the

question is then well how big does it need to be to do

anything interesting. So, to answer that you need to know how well

the surface code works and the answer is very well so if we have a

look at this bubble what’s it saying? It’s saying well all these white dots are data qubits and we are going to constrain those 4 data

qubits to be in an igon state of the operator Z Z Z Z we don’t care which one just we have to know

which one. To work out which Igon sate we have we use the circuit we

initialize one qubit this is one physical qubit interacted with its four nearest neighbours and

measure it and that’s a wonderful thing so 6 gates,

8 gates if you don’t allow yourself to initialize in the plus state and then have to do a

0 and then a hadamard and same at at the end of the hadamard then a measure in the Z basis six to eight gates gives you

a classical bit of information so not many things need to work to give

you something you can use to stabilize your

computation same deal for these guys so the only

difference between measuring a Z stabilizer and X stabilizer is instead of controlled Z’s these are

controlled X’s gates so you can implement all of these ticks in

parallel and so you are very very rapidly

generating information that says look at where are my errors, where are

my errors and then you can process it and keep bad errors as logical errors, chains

of errors out of your computer because you need at least this is the edge length if you’d like in data qubits (d+1)/2

errors to occur on some line before this thing can fail. For

example, if I had an error here and an error here I would see a

stabilized value change here and believe that it is most likely that

only one error occurred and my error must have been here and that will be

wrong when I put that correction in it will complete a line, I’ll have a

physical error, physical error, software error logical error and I’ve lost my data my

computations over. Yes? So, everywhere you see an M is a qubit,

so it’s a uniform 2-D array of qubits. Physically they’re

all identical now when I say that practically you

might, you might choose because you cannot make them all

identical to optimize some things differently for example

you don’t really have to have a measurement device attached to all your

data qubits physically might choose to only

associate a measurement device with a measurement qubit but nominally at least at the theory level it’s

just a uniform 2-D array of qubits with nearest neighbour

interactions. So how well does it work? So when you do

these simulations alright so you go and code up a device

like this run it, you have single qubit, 2 qubit gates depolarizing noise so executed 2-qubit gate, you have a uniform chance of all the different

tense products of every different polly error and then you go and identify where

the errors are and process them, get rid of them you

can work out a probability that you have a logical error per round of error detection. You know this is distance 3 which is this guy here and that every

time I increase the distance I’m saying that instead of 3 data qubits on

the edge, I have five or seven or 9. So just bigger and bigger squares. You can look at this crossing point to work out the threshold error right where it

works if you look at this point you’ll find a threshold error slightly

below 0.6 percent however if you come far enough down you

notice that these lines are bendy and the actual behavior well below

threshold can be fit by this formula one on this is 2 percent so the code behaves well below

threshold as if the threshold were 2 percent and we

believe this is about as far as you can squeeze things we don’t think it’s going to get any better you know we’ve

put a lot of years working to the decoding algorithm we’ve made it as sufficient as

it can humanly be working on a proof that this is indeed

optimal and you know we think we’re done when

it comes to classical processing with the exception that needs to become a bunch of cold electronics one day which

will take years as well but the algorithm itself we feel is

done so it works very well. If you have a look here at our target

error rate of three nines right every time you

increase the code distance, increase its ability to correct one more error, you get a suppression by over an order of magnitude, a factor of 20 indeed. Even at just three 9’s, very modest target increased the code

distance factor of 20 suppression and logical errors.

Very, very efficient code should be just as the getting 7

operations which no but we’ll talk about that very

shortly To work out the number operations you

can get you need to look a little deeper into the surface code and while I’m not going to go through

the details of this let’s imagine this is time and not drawn in this picture is a great

big 2-D array of qubits. Then you’ll say well what on Earth are

all these 3-D structures? These structures correspond to regions of space, time where I turn off my qubits

I stopped doing my checks there and for the purposes of this talk that’s

all we need to know and so you can initialize the logical

qubit using this kind of U shaped region a space-time. You can measure a

qubit by putting a cross bar on the top and we have two different types of qubits essentially corresponding to “have I turned off Z stabilizers or have I turned off

X stabilizers” and you can build up CNOT gates I haven’t drawn all these stuff that

goes in the middle here you can build a Hadamard gate in low space time volume and you can use

this hadamard gate to build S gate. So this gives us the

full set of Clifford gates in low overhead now unfortunately that doesn’t give you

universal computation you also need T-Gate. To get a T-gate you need to distill an a state. This is zero plus either the i pi

over 4-1 and that’s expensive it’s not too

ridiculously bad if you compare this to this the volume of this is approximately forty

six times the bottom of this so 1 t-gate is like 50 times more

expensive than 1 CNOT gate and if you’ve ever had a look at the

details of just how much more powerful non-clifford gates are to clifford, that’s

not too bad and we are of course still working on

making this smaller. So working on compressing all of this

structure further and further. We don’t know what the

limits are I’m optimistic that we can bring it down a

lot but that will take time. Yes? What do the colours represent? So up here these coloured bits represent essentially decoding my logical qubit to

a single physical qubit and measuring it. So, state distillation is an interesting process that can be viewed in the following

manner: we want to prepare this state now we can’t do that directly what we can do is there’s a nice code is that a 15 qubit read-muller code. This code has a transversal T-gate. So if we had a logical qubit encoded like this

we’d actually be able to apply transversal T and T is this and get our desired stage – A which enables us to perform a logical t-gate

on an arbitrary piece of logical data. What you do is you start off with a plus state I’m going to point to this region and say

there’s a plus state, you make it into a bell pair so you do a C-NOT so essentially this

bottom cross bar does that state gives us a bell pair and that is basically this W shape is my bell pair right here then what you do is you take

one half of that bell pair and you make it a reed-muller thing and that’s what all this does. so that makes a surface code read more logical qubit so it’s a logical reed-muller

build-up Service Code all of this stuff once you’ve done that you can apply error-prone T-gates so you decode these bits that’s here that’s all these tapering

double pyramids. We’re taking what used to be a nice big

fat defect which is well protected from errors and shrinking it down to a single qubit, then you just apply transversal T. Now this might seem

a little odd but while these are error-prone we have ever protection from our Reed-Muller code So a reed-muller code is distance three that means it can correct a single error

and detect any combination of two errors and when

you go through the math, so we’re only vulnerable to groups of three

errors, because if we detected an error we discard the output so you’re only vulnerable to

groups of three errors that are undetectable and corrupt the

output and surprisingly enough despite the large value of shifting choose three there are only 35 combinations of three

errors that both are undetectable and corrupt the

output so if we detect any errors here, we throw away this output

if we take no errors we keep the output and our error rate P on these gates goes to 35p cubed. So we can produce very good T gates and hence 8 state’s by doing

this procedure twice in a row because now this is order P to the ninth whatever error I started with down here

I’m going to have the ninth power of it plus some constant on

the output so you can achieve really really robust gates. Just so that I understand, the T-Gate can’t be applied in the logical qubit but it can applied to the physical qubit? That’s correct, and a physical qubit is very easy

to do anything. There was another question, yeah? Oh same question good, good. So those are the things we have to

play with, Clifford and T-gates that’s what we can do. It’s enough to do

anything but what’re we gonna do? Let’s focus on

something where there is, in my opinion the strongest hope for

a commercial application namely quantum chemistry. We’re gonna

start with something that is simple calculating the ground state energy of

a molecule alright this is surprisingly difficult

to do if you want to do it with high accuracy and indeed is currently on scales

exponentially essentially in the number of degrees of freedom of the system spin

orbitals that you care about in your system. To do it on a quantum

computer what we’re going to do is simulate the

Hamiltonian of the melt molecule and look for the lowest Igon value of that Hamiltonian so

that’s the ground state energy and this can be imagined as well if I start with an atom that

shattered across the entire universe, nuclei and electrons and then bring it

together to form some kind of meaningful molecule, how much energy do I liberate in that process? This is the

number we’re calculating. Now, this number in isolation is

completely useless because absolute energies have no meaning but if you have a collection of

molecules where you’ve done this you can then work at how much energy you

would liberate converting some into other products okay now of

course you could just burn the stuff and work out how much things heat up so

we’re not really talking about something that is enormously useful but this is still

classically hard to do. To really get to the point where

someone would pay you a great deal of money to build a computer I believe we need to go to dynamics or

as I said I gave the example of looking at some slightly more

complicated products as they go through a catalyst of some description I think that might have some chance of being worth money but this is still classically

intractable arguably not useful but classically

intractable and it’s physically interesting so we’ll look at this. We’ve gotta start somewhere so the quantum

circuit that corresponds to this calculation, the Hamiltonian so this is

one of the terms in the Hamiltonian on the previous page

I’ll just flash it up again for reminder we have a bunch of 2 spin orbital

terms and a bunch of four spin orbital terms and this is just one of those terms. There’s a big sum over many

of these each one of which looks like this so the key thing that you can barely see

because of the blur is this is a controlled outer triangle rotation. This angle depends on how many steps I

divide my simulation into and the exact spin orbitals that I have but just imagine it is an arbitrary angle we

know what they are when we begin our simulation but they’re nothing specific right,

continuous angles. If you work out all of these circuits for all of

the terms in the Hamiltonian as has been done by the group at

Microsoft so you can thank Dave Wicker for these

numbers you get about 10 million of these controlled

rotations per trotter step so we divide our

Hamiltonian evolution into many individual steps per step we have to do

that many control rotations another area of very open research is

really how many steps do we need to get to

sufficient accuracy because sufficient’s a complicated thing

ultimately it’s a commercial question what accuracy do I need, right? People are still

not sure so the best I’ve been able to get out of people is that we need about 10,000 if you have

any better numbers than that I’d be very

interested in it, but this is what we’re going to work with its a

reasonable number it’s supposed to get us to what’s called

chemical accuracy and you know what we really want to know

is what is commercial accuracy and I don’t know the answer to that so this is the number 7.4 by 10 to the tenth

control rotations now as we mentioned before T gates are really

expensive C-NOT gates are really cheap we need to

look at how expensive a controlled rotation is to see what can be neglected and a

controlled rotation can big decomposed as two controlled swap gates and then a single qubit rotation and you can

decompose these into all of this circuit then you take your

controlled rotation and you use some of the latest greatest

techniques on expressing these guys as sequences of HT and you find that if we assume that errors in our rotations scale favorably that is if we have a

small rotation angle that is in our system that

corresponds for probability of getting the wrong state that goes as

the square of this and intuitively that should be the case here is the state I

really wanted to rotate two here’s the site I actually rotated to if

you imagine the overlap between psi prime inside that’s

going to go as epsilon squared so this is the assumption we’re gonna make

on our target accuracy using the latest techniques that

decomposes into 51 of these T-gates so you know given a

T-gate is itself 50 times more expensive than a C-NOT

gate and for each controlled rotation we need an order of 50 in fact an order of sixty

when you include these guys so it’s three thousand of these C-NOT’s basically so a single controlled rotation is a good

three thousand times more expensive than a single controlled not that means that despite going back they’re being an order of a hundred times

more clifford the gates than these controlled rotations these guys are still negligible, there’s

still a border a couple percent of the total algorithm. So all we’re going to consider, all we need

to consider is the overhead of implementing these controlled rotations. Yep? The time overhead? We will get to that. Because you were saying that they take up a lot of space and that’s why they’re important. When I say overhead I always mean

space-time overhead. But in your circuit, your controlled rotations are all the same than the previous circuit. Yup. The controlled rotations are the ones at the bottom? That’s right. So could you use the same gate again and again? Like, that space would be confined? Only if you want to do it

very very slowly we’ll talk about that. So, temple over-head, so one big question is you know how long

are these algorithms actually going to take to execute and if

you’re not careful the answer is an awfully long time so this slide is about

being careful if you take an arbitrary algorithm you can always decompose it as a layer

Clifford followed by a layer of T-gates, Clifford T Clifford T. If you have such a

decomposition then you can always do this: you can take

your first layer of Clifford and then you set first layer of T and then do

this teleportation circuit which selectively patches in an S-gate

correction from a T-gate or not cause although a T-Gates a

probabilistically 50/50 T or T dagger so I have to fix them as I go and that’s

what this does based on this measurement which tells me

did you get T or T-Dagger I either patch in my S-gate correction or not and I can then just teleport back, sort of, to the beginning

of time and perform the next layer of my Clifford circuitry, right here T-Gate patch an S-gate correction so the only

thing that limits how fast any algorithm can run is this cascade of

measurements so I have to be able to perform a physical

measurement perform the classical processing to work out which physic,

which logical measurement I got and then choose

to perform one of these two banks of measurements

which basically means either not doing a hadamard gate or

doing a hadamard gate. This is this hundred nano-seconds

feedforward single-qubit gatetime. We believe we can get to that we can’t do feedfoward at all at the moment but

we believe that’s a reasonable number to achieve

sometime in the next few years. So that means our execution time is a

multiple of the sum of these two guys, measurement

plus feedforward and that total number is the number of

controlled rotations then we have the number of T-gates per

rotation plus two to make it controlled times this and straight away before we

even work at how many qubits we need we know that our algorithm must

take at least 14 days now this is an OK number you can imagine someone

waiting for some interesting problem for 14 days this

is not an uncommon duration to sit around, staring at the wall. What we now need though is the space overhead, so going back to Joesph’s question the question is you know can you take the logical error rate per round of

error detection of a square surface and equate that to

the probability of error of the logical gate? And the answer is no

because there are lots and lots of these square surfaces if you like per logical gate so we have to convert the data we have

into something meaningful for this guy so what we’re going to do is

take a worst case arrangement of these objects which we call plumbing pieces. So we have a

bunch of defects you got you know a light and a dark, we’ve

got primal and jewel they have lots of different names in

the literature it doesn’t really matter they’re just two types of defects. We’re going to

assume you have a force of one type and into lead with that same force,

which is not drawn a force of the opposite type. So two forces

here and then we want to upper bound the

probability of error of every class of error so we could have a

a chain of errors from here to here or from here to here and we can upper

bound each one of those probabilities that by the probability of error, of a chain of errors from this boundary, to this boundary cause this boundary and

this boundary are longer then the face presented by this defect to this defect Which is a good upper bound, another good upper

bound. Also we have a ring encircling each defect again there are very few

rings that encircle a defect and match up with themselves so again we can

upper bound with a probability error from one boundary to the other/ That’s the three here, the two is for the

two different types of defect the 5-D on 4 represents the fact that

we separate this length by D so the D rounds of error detection from here to here, that means this little cube is

D on 4 and from here to here the generic size scale of this whole

picture is 5-D on 4. That’s here and then we multiply it by

the logical error rate per round that we’ve got in the previous slide. When you put that together you get

this nice little formula and that gives you the probability

of logical error per plumbing piece and in this picture if I imagine tiling C-NOT gates there

would be well you can see 8 plumbing pieces I

would need another 4 so 12 plumbing pieces to be able to tile this in 3-D. So if I wanted

to know the logical error of this C-NOT gate, I would take this formula and multiply by 12. That’s how you go from square surfaces to the logical error of logical gates. Did that make sense or was that complete

nonsense? Can I clarify something? Yes please. In the previous slide, the plumbing pieces were associated with single qubits in some sense right? No, so plumbing pieces of great big

construct have lots of qubits. So remember this is the code distance alright and that’s the temple direction.

This is also the code distance and this is a spatial direction in any

spatial direction the number of qubits is twice the

current distance. So this is D=3 and you can see in each direction you

have data measurements so twice as many qubits per D. So this is like a cross-sectional picture of a single plumbing bit? No it’s not even that see if I take a plumbing piece let’s see, this is a bigger picture so this length from here to here is D and so you could imagine this being

just some patch of the computer potentially between a square-shaped

defect one plumbing piece is just a 3-D volume alright and it has a certain size scale and what we actually simulate are square patches So here is the 2 scale conversion

between what we simulate this is D and the actual space-time volume

of what we compute with. If I take a concrete example, let’s imagine I choose this thing to be

distance 3, I have to be precise there’s going to be

five qubits from here to here. It’s a bit blurry

but if I went on the inside here there would be 5 from here to here. This distance from here to here is also

3 so this would be 3 rounds of error detection. It’s a space-time volume. Lots more than just one physical qubit,

each one of these is D here, D on 4 here and so for a

large code distance this is a picture involving a large array

of qubits for a large number of rounds of error detection. So I didn’t follow all the details, we can talk about it offline, can you at least remind us what the definitions are of capital PL, lowercase PL? Capital P L is on this slide so this is the probability

of a logical error anywhere in one plumbing piece and let me perhaps draw a generic plumbing piece. So we want a 3-D volume and we want to be able to capture every possible object that we could have in that volume.

So a plumbing piece contains the option for one of these cubic things in

the corner potentially 1 of these prisms in that

direction in this direction and in this direction, they may not all be

present but there’s the possibility this one is say primal and the option four

also a jewel one in the center so again all or none of

these may actually be present but we want to find a way to say well

regardless of what’s actually in a given plumbing piece and of course

these guys if there’s another one out the back here, there might be another jewel plumbing piece here that

feeds into it. So it’s sort of an arbitrary 3-D Microsoft screensaver

style plumbing thing right? So what’s your definition of plumbing piece? It’s this volume. Is it the operation between error detection scans?

It’s a volume. A definition of a plumbing piece is

a volume that is big enough to hold a generic piece of the structure that does computation. In space time though. Yeah, it’s a space-time volume. So we

want to know the probability of logical error per space-time volume and what we have is the probability of

logical error per round of error detection on a square of side length D. So we don’t have, we are working on

software to get this directly we don’t have it yet. All we have is this

but we can use those squares, use that data in this manner to upper bound that because the worst case scenario is

you have 2 inter-lead forests 1 primal one jewel of defects. That’s where you have the most

options for logical error. Yeah, we’re doing okay we got 10 minutes we’re nearly there. Alright so space overhead, so we know

how many T-Gates we need that’s the number of controlled rotations,

number of T-gates per rotation plus 8 to make it controlled it’s 4 trillion love them. That’s a lot! This is the gate error were going to assume we’re going to assume 10 to the -4 by the time you want to implement four

trillion T-gates I’d really hope that we’re at 10 to the -4 so this

means you need two level for the distillation, this structure which corresponds to

about 550 plumbing pieces. So we have two quadrillion plumbing pieces

to implement but fortunately because the surface code

works really well particularly at this error rate, it only translates into

distance 15. If we assume we have a 500 nanosecond

surface code cycle so this is this initialize, four lots of interaction measure alright so

this is again can measure it with what we can do in the

lab today then each plumbing piece with this code distance takes about 10

microseconds and that means we can do about 10 to the 11 pieces in time in 14 days which is the execution time

we choose because it’s the shortest possible execution time that means that we need a factory producing these state’s involving at least

20,000 pieces in order to complete the necessary 2

quadrillion plumbing pieces in our available time measured in plumbing

pieces. That’s the footprint size of the factor required to produce enough of these A-state’s to

satisfy the demand of our time optimal version of the algorithm. So

what does that mean? We have D=15. 20,000 plumbing pieces this is how we calculate the footprint

of each plumbing piece, so you know a data and a measure qubit

times the edge length of your plumbing piece squared. It’s about 1400 qubits

per piece which is arguably a good number I know it’s way beyond what we can do

now but it’s not 10 to the 20 it’s

1,400 and that translates to 27 million cubits total so again you know you can take this one of two

ways you can be depressed and say that’s an awful lot and we only have

5 to 10 inside the eye experiments and then you can turn around say we’ll

hang on wall we only have five ten qubits in say they eye of experiments

because there is no point scaling up yet the

qubits don’t work well enough yet we’re only just now getting to the point after

to 20 of hard work where the qubits have sufficient

fidelity to even bother scaling up and we shouldn’t even bother scale up until

we get the qubits better so it’s reasonable that we still have a

small number secondly I mean what do you expect? This is a classical computer, state of the art

fastest in the world it has 3 million cores and a petabyte

of RAM right if you want to outperform something

that has three million cores each of which has several hundred

million transistors, it is not unreasonable that you might

need twenty seven million quantum bits. 27 million quantum bits right it’s not

really a lot to outperform it, do something that it could

never do. Now while I’m arguing this is already a

good number we know that there are ways to bring it

down people believe we can chop another order of magnitude off that So we have all of these controlled rotations,

if I have a rotation of angle theta 1 and somewhere in the circuit separated by

some number of gates there’s some other rotation by angle theta 2. If I can work out a way to move these

gates somewhere else so that I can put the two

together and get a single rotation theta one plus theta 2 I just win, it’s all win I’ve got fewer gates few rotations I

only need the same accuracy in fact less accuracy that’s why I have fewer

total rotations each one therefore needs to be

implemented with less accuracy therefore fewer T-gates so I can reduce strictly the volume of

my algorithm without sacrificing anything and people believe that you might be

able to do this to say a factor of 10 then we’re talking less than 3 million qubits to

out perform something with three million cores. That’s a good number and who

knows how much further we can go but we shouldn’t expect too much less. Anyway you know to me this is an

optimistic picture but obviously challenging you know we’re not

gonna have a quantum computer in 3 years or 5 years, we’re not going to

have several million qubits anytime soon. At UCSB we’re hoping to double the number of

qubits every year from now because we feel the fidelity is high

enough that that’s worth trying to do. Even if you do that

you still looking at twenty years thirty years to get the kinds of numbers of qubits where we gonna start doing

something classically interesting so to me this is a very important

statement you know we can’t go to the public and say oh yes give me

5 qubits give me 10 I’ll out perform a classical computer it’s nonsense. People know it’s nonsense. We can’t even

say okay so quamtum chemistry algorithm, it has a 112 spin orbitals therefore its an algorithm that requires

113 qubits and when we have 113 qubit’s it’s

gonna outperform a classical computer. That’s also nonsense. 113 qubits became $27 million when you

add error correction so you know we need to

tell people that we need millions of qubits this is the right thing

to do because people need to be prepared to accept that it’ll be twenty or thirty

years before we have a quantum computer that will do anything useful it’s just reality but it’s an okay reality. It’s one I’m

certainly okay with, what I think is reasonable, one I’m hopeful about and we just need to accept the

challenge knuckle down and get on with it. Thanks. Any questions? Yeah? I see you find this 27 million given the fact that 10 x 10 (inaudible) chip can hold let’s say 5, 10 qubits and (inaudible) How big is this machine? I think that’s your answer. 1 x 1 x 1 meter

would be an awesome outcome from my point of view yeah that’s small enough I mean if the computer fills this room

come on, seriously that’s fine. it’s still much smaller than this machine. It’s cheap that’s what we need. We need

cheap qubits we need to gun for a dollar a qubit, right? So when you sit there and go and buy a

10,000 on pulse generator drive-one qubit we need to question whether that’s

viable because one day we want it to be one dollar per qubit. Ultimately we need things like a

superconducting qubit that requires only DC lines for example get rid of microwave control. It doesn’t exist maybe can’t exist, maybe it can

exist but we need people thinking about these problems right we need cold

on-chip electronics that sit between our wires

like D-wave does except D-wave has much simple problems because they only have static control. They load a program and then everything runs

whereas we need dynamic control we need a chip that fits in maybe one by one centimeter

that can actually drive a qubit. People need to be thinking about

this that’s the only way you get to a device that has any hope of being one dollar a qubit. Yeah. Robert? So Rainer Blatt often states as his research goes to keep a qubit alive using quantum error correction to keep the qubit alive. In Santa Barbara, John Martinis group, do you have it on your road map? Sure. Can you give me of years, say first how you’re planning to store a qubit through a hundred or a thousand error correction cycles. Do you have plans for such things? So of course it comes down to two things:

how many qubits you have, what’s your fidelity. So initially

what we’re gunning for is repetition codes we’re not going to try to go for full quantum preservation it’s too hard. So we’re

looking at nine qubits which are in the fridge now and these again

they all operate around the 99 percent level and fortunately this number is below

threshold significantly below threshold for the repetition code so if you do

a sort of surface code analog, this should work and we should be able

to suppress environmental bit flip errors only bit flip. No face coherence but we

should be able to show an extension of the T-1 lifetime of a qubit and then maybe the year after that we’ll add another X qubits, keep it linear

for the moment and show that you get exponential

suppression of error, which of course is a big open question as you have more qubits, does it really work? Is something else going to come into

play and stop you having independent errors and therefore

exponential suppression? That would be our starting point because this is much cheaper to do. It’s all classical but it’s out of quantum components and yes I completely concede it’s all

classical but I hope people don’t criticize us for being all classical. I

think this is a very valid thing to do to see whether the 2-D version could ever work and once we’ve done that, you

have to start tackling the hard problems for going to 2-D and there are many: wiring, crosstalk, temperature. As you start having a lot of control coming in here you put a

lot of heat load on your actual chip and you’ve gotta keep the

temperature cold as you do this and of course all of that impacts

ultimately on the only thing I care about which is fidelity and whether to work. So we

need to maintain a high fidelity’s while making our lives harder. There are a lot of challenges but if we can double the number of qubits

every year then we’re working on 9 qubits now in

three years that hopefully is a hundred and is a 2-D array and we’ll be stabilizing a logical qubit. That’s ambitious, yeah, but we hope in 3 years that that’s realistic. Have you ever thought about auto tuning They aren’t even here repetition

code auto tunes is useful for this so, yes. Yes is the answer. So you know, it gives you better performance. So the threshold for repetition is about code is about 3 percent when you use autotune. So you think John wants to reach (inaudible) in 3 years so how’s it going to be? In 1-D? No, in 2-D is the hope. But as I said right at the beginning the

slide completely openly there are no obvious solutions on how to

do it we’re just optimistic we can. There are

vague ideas many many problems that need to be solved

to see how it should be done. You were saying that it’s not known how to run in 3-D architechture. Not even in 2-D, so you a little over 3-d with wiring

in the top. (Question inaudible) Yeah, not at UCSB, no. You know D-Wave, are they pursuing their annealing thing? They’re still building bigger and bigger chips. They’re not branching out? No, definitely not, that’s fair

enough I mean the device does actually work so they’re just gonna push it, see how

far they can push it and see if it becomes commercially interesting. D-wave technology is not in any way a stepping stone to a fault tolerant architecture but you know that’s not their

focus its okay. When you mention the feedforward, is that a physical level? That means taking the measurement result, processing

it slightly and then using that result to control whether

you do or do not do a single qubit gate. That’s the feedforward we want at the

physical level. I was under the impression that someone might have done it. Oh I think they have done it but we have not done it. I believe feedforward’s been done in

a number of systems even optics where it’s really hard to do

they’ve done it I believe Even in something that may have been done,

it’s not been done at UCSB. We need to be able to do it that’s the time scale we

believe we can do it on. Do you think they’re going to tell us what Hamiltonian we need to implement the service code? You don’t need a Hamiltonian at all. So, see this is one of the big things about when you go fault torrent

quantum computing if you’re not doing anything the assumption is that these guys are

non-interacting so you bring these guys into resinence to affect controlled Z-Gates in our current hardware and the Hamiltonian required to do this frankly is beyond me to write down and

give a coherent talk on because that’s not really what I do. The guys at UCSB every one of the other

twenty members the group know that much better than I do but you

only have a meaningful Hamiltonian when you’re doing something if your computer’s working well. Now of course that’s not true you have

crosstalk, you have environmental noise and yes you could write down the Hamiltonian that

corresponds to an actual device but our goal is to minimize all of that to

make the evolution of a qubit when you’re not doing something with

that trivial and clean so I couldn’t give you an answer that I

know would satisfy you which is write down the actual Hamiltonian for the qubits we have but I should stress

that the surface code, the error correction does not require a Hamiltonian it requires gates and that’s something

slightly different, it requires evolution, unitary operators and I wouldn’t personally say that this

unitary operator this two qubit operator corresponds to a Hamiltonian I would say it

corresponds to a unitary and I think that’s a different thing, my

opinion. We want to engineer our physical Hamiltonian to give us clean

and controlled unitary evolution and the surface code only calls for

clean and controlled unitary evolution not a Hamiltonian. Now why that might

seem not correct you is many people do

study the surface code as a Hamiltonian but that’s not what we do. If you stick the Hamiltonian picture on the surface

code, it’s not robust. So if you require 4 qubits and your Hamiltonian is

this tensor product of X turns and the neighbouring one is this

tensor product of Z-terms this picture has been studied as a

Hamiltonian picture but it’s no longer robust because soon

as you have an excitation so say let’s imagine this

becomes an excitation it can wander around without energy

penalty, there’s nothing forcing these things to go

away. This is being looked at and essentially it was concluded that it

wouldn’t work. You have to do active repeated

measurements of these guys, and then you want good

clean controlled unitary evolution followed by measurement and then in my

opinion the fairest way to think about it is you no

longer have a Hamiltonian. You can say that the surface code is a state of the time code. That’s right and you want to be able to evolve. So when you move because you measure, basically it’s measured qubits and projecting one state of the time code and in fact as you said, if you want to do quantum memory, that’s what they call this with the Hamiltonian like with a physical device, it’s still unstable in 2-D so you actually can’t do it. If I’m understand what you’re saying is that the Hamiltonian is not gapped, that is correct. It is gapped but doesn’t grow with size, there’s a lot of people that looked at this, correct me if I’m wrong. The gap just doesn’t grow

with the system size, there’s no suppression of these excitations. and even in 3-D it works very poorly and in

4-D it works a bit better. So direct Hamiltonian stabilization

of quantum information in my opinion it does not look very promising, we really

need to have nice clean gates and measurements and classical processing of that

information to rapidly and efficiently remove entropy from our computer. Nature itself seems too lazy to do it. I will stay here if you want to ask

more questions.

So how would a Quantum computer stack up against a DNA based computer? What would be the pros and cons of putting the time and money into research for either/or?? And given the astronomical costs of going down either road (Like you could easily buy a Boeing 747 for your own personal use any time you desired it for the next 20 years) just to compare to the research costs of either computer, and why should we not just stick with a more normal Intel Xeon based processor type computer for example?

Professor Tao gave a good lecture on the mathematical techniques of proof by attempted disproof, and if Quantum Computing device is going to do anything useful, it's going to have to do similar operations? And, (rhetorically), that is why a digital machine is the only successful device so far, and why parallel processing is the "middle ground "?

The efficient "solution" is to have more people who are better trained and informed with more transparent access to better data through improving search engines coupled directly to human brain power. (Would that be a voluntary Matrix?)

I have an idea to make a quantum computer and to account for errors and corrections, It looks pretty crazy. I can imagine the power of it, may be used for evil and not good so am sitting on it.

Ok your technology is 1,000 years behind is what your stating. You are showing the world it's not a good process because of uncertainty.

What your building is a Turing machine. A slide rule with a large energy foot print.

Quantum mechanics describes a physical place. To understand the Quantum physical nature of it you can't do it without understanding photonic resolution. Photons have infinite Shell's which Carry Quantum Fields by Fielding Relativity with Gravity.

You could never build enough Quantum circuits for anything useful this way. Quantum errors are a matter of focus alignments and true position. In other words there are no errors in nature God doesn't play dice.

not just protein folding, imagine an exponential particle system forming eroded mountains with 2^2^1024 photons blasting around every scattering.

finally a dude i can understand.