- So, hi everyone.
I'm Christophe Vuillot.
I'm a PhD student at TU Delft in the Netherlands
where I study error correction with Barbara Terhal.
And I'm very happy to be here today
to present to you this work.
Where I sort of set out to try
to test fault-tolerant on an actual machine provided by IBM.
So what's the general context here.
This is the context of trying to get
to this fault-tolerant quantum computing regime.
So what do I mean by that?
I mean, a regime where you can
run your quantum computation with arbitrary precision
for an arbitrary long time.
So basically you have to do the full BQP machine.
And how would we do this
because those systems are like very noisy.
It's extremely challenging to control them.
And so we would use error correction.
So error correction is a way of correcting errors
and there's a sort of another term that people use,
which is fault-tolerance
and which basically means implementation
of error correction protocols,
but with systems that are,
like where everything is noisy.
So it's like robust implementation
of error correction protocols.
And so that's what I want to test on actual machine
to see if scanning up towards
this like very nice regime is possible.
So at around the same time,
when IBM released that in the cloud,
it's IBM quantum experience,
there was also a paper on the archive by Daniel Gottesman
explaining sort of making a proposition
of what would one do if they wanted to sort
of demonstrate fault-tolerance in a actual setting.
And this proposition is pretty sensible.
And so, I saw both these thing come out,
I was pretty excited about both
and so I decided, okay, let's actually try to do this.
So what would you do?
So the first thing, you want to protect against error.
So you have to choose some error correcting codes
that can fit in your machine.
And then once you have this,
what you need to do is to devise
some fault-tolerant circuits to prepare logical states
and some fault-tolerant circuits
to do gates on your logical encoded information.
And then once you have these building blocks,
then you can think of stringing them together
to make like more complicated circuits,
more complicated logical states.
And then once you have this,
you sort of want to compare this encoded version
to a bare version.
And so there's different metrics
you could think of looking at,
but like very precise one like full state tomography,
full process tomography
but they are pretty costly to compute.
And so one simple one,
which is also in the idea that's in the end,
when you compute,
you just want to get your answer directly
is just sampling from the outcome distribution
of your circuits and looking at this as a metric
of how good you're doing.
And then of course you would choose the best
of your physical qubits to compare all this
like encoding implementation to be the most fair
to the encoded version
and try to see if you can
beat the bare version with the encoded one.
Okay, so as I said,
this was like the very early days of the quantum experience.
This was when the chips had some cute names
like Raven or Sparrow, I like these names
I don't think they're anymore.
It was also very early days of Qiskit.
There was this API.
So I mean, all my code is broken now,
but it should be back rewritten soon.
And then with these five qubits, what you can do,
you can test what's called a 4,2,2 codes, okay.
So that's what this paper is about.
So what is the 4,2,2 code?
So as its name indicates,
there's four physical qubits in which you encode
two logical qubits and then the distance of the code is two.
So that means this is sort of the first program distance two
mean you cannot correct errors.
You can only detect.
But that's okay,
because if you can detect error you're half way there
to error correction,
because you can pass that act and just keep the good runs.
All right, so we have these five qubits
we want to do this four qubit coordinates.
So we have to first map,
which qubits...
Physical qubits correspond
to which of our code qubits.
And then this 4,2,2 code is pretty simple just
to stabilize out the old X, and old Z.
So X and Z are polymatrices,
and then you've got two logical qubits given by vertical
or horizontal strings of these.
And when I think about this code is that,
you can think of this as the smartest quarter code.
And so it has nice from just our gates.
So applying a code if you apply transversally
on your four qubit Hadamard gate,
then on the logical level,
you get a Hadamard SWAP.
If you apply phase gate transversally,
then on a logical level, you get a control Z.
So that's pretty nice because transversal gates
are sort of almost the definition of four Hadamard gates.
So because you're doing only single qubit gates,
and so you cannot propagate errors.
Okay, so we have sort of...
We can do propagate these gates,
and now we think what logical state can we prepare?
So if you work out the details, for example,
the logical zero zero States is actually
on this four qubits is a cat state.
So zero zero, zero, zero plus one, one, one, one.
And how do you do this in a full transversion?
So the sort of the quick and short way
to do this is on the right.
You just Hadamard one of the qubits
and then propagate with (indistinct)
But this is not fault-tolerant,
meaning that if one of the C-NOTs fails in dissipates,
then you can make an error on your system
that you won't be able to detect.
But there's some other nice,
like fault-tolerant circuits like this one,
which is not that much longer.
And which is like in the family of these flag circuits,
where you actually using an ancilla
it's a good thing we have five cubits here
to solve flag if something goes wrong during the circuits.
Okay, so we have basically these two version
of preparing zero, zero.
One is fault-tolerant the other is not,
and we are going to be able to compare those two
and see, okay,
is it worthwhile doing this two extra C-NOTs
and having one more qubits where we can do like super,
very shorter circuits.
And like, keep in mind that this C-NOTs have like 10
to minus two errors.
So, okay, should we do this or not?
That's sort of the question.
Now you can also prepare some other logical states.
So the zero plus and cat states on the logical level
actually two pairs of bell states and bell state
are super easy to prepare for turnaround keys.
So you do Hadamard or C-NOTs,
this is fault-tolerant because this is stabilized
by any error you could think of.
And so that's pretty nice.
And so the architecture of this,
you can do one of them without doing a SWAP.
And then for the other one, you have to do a SWAP.
So this is potentially problematic because this SWAP
can introduce errors that you won't be able to detect.
But in our setting, those errors won't matter.
So that was sort of, we got lucky at this point.
All right, so that's our building blocks.
We know how to prepare zero, zero.
We have these like fault-tolerance away and this very short,
but not fault-tolerant one.
Then we can prepare Zero Plus with some logical error
that won't matter in the end
and the zero zero plus one one.
And then we have these nice encoded gate,
Pauli operators, Hadamard Swap and control Z.
And so the idea is to try
to test all of possible combinations
and compare with it an encoded version.
So, this is such a small example that you can actually work
out all the different States that you can prepare with this.
There's only 20 of them.
And then you can optimize sort of the number of gates
to obtain these 20 different states,
so that you get sort of the best
bare version possible of this.
And you have the most fair to the not encoded version.
And then the idea is to run.
So for the encoded version,
you run the encoded circuits,
and then you measure everything at the end,
and then you have two steps.
First you check if you detect an error,
if you detect,
you throw away the results,
if you don't detect error,
then you sort of decode the information
and look at the outcome distribution.
And you compare this with the encoded one
So I'm going to show you two plots.
So on the bottom here,
that's the 20 different circuits.
And then here,
I just show all the possible bare implementation
on every pair of neighboring qubits in the five qubit chip.
And first thing you can see is that,
so there's no clear best two cubits, right
It's a bit all over the place.
Another thing that you can see is that there's
no real correlation between the size of these circuits
and how good the outcome distribution you sample from is.
But if you take, for example,
the average and look a little bit closely.
You see that the two zero pair is sort of the best one
out of the older bares.
And so, which was this one to compare
to the encoded version,
and that's what we get.
So in this plot,
you want to be below this stick line,
for the encoded version
to be better than the bare versions.
And so we see different things here.
We see, there's a bunch of circuits
for which encoded actually helps you.
So you get outputs distribution,
which is closer to what you would expect.
But there's also still a bunch of circuit rates
where it doesn't help.
And another thing that you can see,
so this blue and red points doing the same circuits,
but one with these fault-tolerant,
preparation of zero, zero,
and the other with the SWAP and non fault-tolerant one.
And what you can see is that in most cases,
the fault-tolerant one is actually doing better.
So, which is sort of reassuring thing, okay,
we didn't do these two extra C-NOTs for nothing.
We actually get better result from this.
All right, but this is a little bit
of a like mixed product, right.
So there's no clear conclusion saying, oh yeah,
we do everything better with the encoded version.
So when you, at least you can take the average.
If you average, you see that's you're actually winning.
So that's sort of a,
I would say, mild win for
the chip saying that on average,
over all the circuits,
which is all you can do with this four two code,
then you'll do...
You're doing better.
And also the on average,
if you choose the non fault-tolerant version,
then you're doing worse.
So like designing fault-tolerant circuit is important.
Okay, so that brings me to my conclusion.
So I'm afraid my, yeah,
my conclusion at this point is pretty boring.
So, I put this shiny books to sort of make up for it.
(crowd laughs)
But I would say
that it's still pretty hopeful situation when,
because these already devices sort of already interred
the fact that they'll be able
to perform our correction and scale up.
And I would like to sort of make the point,
that in my opinion,
we shouldn't lose track of this far goal
that we want to do like a full turnaround computation.
Because as far as a NEASC experiments are very interesting
in themself, and there's a lot of physics,
a lot of science to explore.
I think it's very unclear at this point,
what they can be good for.
I mean, it's even unclear what like perfect
small quantum computer would be good for.
So I think we should still grind our way up
to this like, fault-tolerant computer
and not lose this from our site.
So with this, I would like to thank you and thank you,
of course, the IBM team for putting the chip online.
That's a really nice thing that allows tourists like me
to play around with this.
(crowd clapping)