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.

Austin Fowler: Why and how should we build a quantum computer?

6 thoughts on “Austin Fowler: Why and how should we build a quantum computer?

  • September 16, 2014 at 2:33 pm
    Permalink

    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?

    Reply
  • December 6, 2017 at 11:17 pm
    Permalink

    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?)

    Reply
  • April 3, 2018 at 10:14 pm
    Permalink

    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.

    Reply
  • October 28, 2018 at 4:56 am
    Permalink

    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.

    Reply
  • January 7, 2019 at 4:34 am
    Permalink

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

    Reply
  • January 7, 2019 at 5:27 am
    Permalink

    finally a dude i can understand.

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *