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.
