Let's go for
super 820.
Thank you for the introduction.
And, it's a talk such I want to, show
how to work on quantum computers and more concrete.
First, I want to show what you need.
What ingredients, how it's,
mentally realized.
And one example.
And then, finally, how you can run programs and algorithms
on the quantum computer.
And there's an especially the last step is very exciting to me
because as a theorist, I, most of the time I'm sitting in the office.
And so I have at least sometimes elevation that I can work on an experiment
and see what comes up.
Before
I want to dive into, these topics, I want to show,
possible implications for quantum computers.
I mean, the most fleshy one, most of you know, is,
I have at least heard of is, concerning prime factorization.
Using Shor's algorithm, the idea is that this is an algorithm which,
factorize prime numbers
exponentially, faster than any known classical algorithm.
And it's, it's the reason why, for example, the military is interested
in quantum computers, and the funding is quite high in this field.
But, because the quantum
principle break, public key encryptions.
But, to be honest, this application is quite, is quite fine if you take a guess,
it would take at least 20, one year
or even longer until you can,
and make real use cases.
But this is more exciting from a physical perspective.
And this is also like something mentioned in this talks is,
this simulation of strongly interacting quantum systems.
So in this cases you have of, many,
competitive terms like
the kinetic terms and, and, interactions.
And so you, you will have not the dominant term
where you can apply perturbation theory on and in this cases it's hard to,
to, to apply classical algorithms.
And this is, quantum computers come into play.
One example are the strongly correlated systems.
Took me to mention before the, the, interesting
because one of the most, open problems
in, in physics, like high temperature superconductivity,
buried in this models another model,
as I mentioned, a little bit before, is,
concerning, quantum chemistry,
but are also strongly, interacting.
Let me Tyson in the hot to simulate classically but but also,
when you consider high energy physics,
I mean, you will have in order to understand
this, you'll have to build, large colliders, or,
or you can do to some very limited
as stand some classical simulations,
which goes then it's, let us quickly but,
but this classical simulations,
a very hard to realize you can only consider limited systems
and so and have to put much effort into this.
And it
turns out that there are also algorithms, to,
to simulate the standard models
and is active work on it to realize that on quantum computers.
And it's probably, at the long term and, and cheaper way
than building the next largest collider.
With this in hand, I, I want to show,
what you need.
And this was nicely summarized in there and consensus criteria
roughly 25 years ago, the first thing is that you need,
qubits or
which are scalable.
So it's just basically the, the building block of a quantum computer
and it's nothing. OS then you need classical bits.
Fine. Classical, classical computer.
The second thing,
is that you need long enough coherence times
this, you need that you, that you actually can use the loss of,
quantum mechanics to, to run algorithms which,
which are hard to simulate in classical computers.
And then it turns out that this is actually the the most challenging issue
for, for, for, current realizations.
And you probably need, quantum error correction,
a long term statistical this challenge that, this, was also mentioned at,
talked last year, but, by Benedict.
So I only briefly touched this at the end of of the talk.
Then you'll need, universal, set of quantum gates
and for quantum computers, basically the idea is that you will,
the algorithms, consists of unitary operations,
and then you'll need some ingredients to realize them.
And then it turns out that, the, the,
that you basically need one single cubit gates, which are there other methods and,
and, for example, a phase gate at gates here and, in the bottom,
which I will, trade later.
And then you need a, two qubit gates which can entangle,
qubits, which is in this case a control,
not operations.
This universal set, you can, can build arbitrary unitary operations.
And finally, to get
also something out of your, quantum computer, you will have,
measurements, to
get some results and compare what the, Giving,
Yeah.
So in the last 20 years, there were lots of proposals
and approaches to, to satisfy this criteria.
I just mentioned a few, the few, probably most promising right now,
but one, superconducting qubits, which are,
which is a strategy, pursued by, companies like Google, IBM.
And so here in Oxford.
And the idea is that, basically use,
electric,
particularly as circuit elements involving Josephson
junctions and encode the qubits, in this circuit elements.
I will show this, explain this later.
Then you can, another possibility possibilities using trapped ions,
values, values like,
the qubits into energy levels of
of this ions and then apply,
policies to manipulate this,
this, levels
now, there was, recently there was some announcement
that you can use topological quantum computing by, by Microsoft,
to not
want to state now, that this claims are correct or not.
But if, this are the case, this would be also quite a promising,
realization, which is,
is it was, to scale up,
another possibilities.
It's using ultracold atoms with neutral atoms in,
contrast to the ions, which we have before.
But, but it emerged, especially in the,
last five years is, another competitive, player in the field.
Now, there are lots of other approaches,
for example, photonic quantum computers,
attempts to use silicon, quantum computing and so on,
that I cannot, explain all of them,
because of lack of time and because I
if you have the lunch served later and I was hungry.
So I will focus, now
on superconducting circuits, qubits.
So here in this picture, you,
essentially can see, for transparent qubits.
What specifically? This cost state for.
And when you zoom in a
little bit, you see the order of micro,
meter, the hundreds of micrometers, you see this cross,
a few zoom in even more, and then you see what you actually see,
which has the size of a few hundred nanometers,
to, it's basically a Josephson junctions
and across, the cross shape, this is basically a large,
capacitor, c tens.
And the idea is that, the Josephson functions,
is a nonlinear,
conductivity of your circuit, which will become later.
And when you, when you do,
some elementary physics and,
for the circuits, you can quantize, say,
Hamiltonian, corresponding to the system.
And this has a, has basically this form.
So the first part, corresponds to the,
energy.
And and
and there's a number of, Cooper pairs, on the islands.
And the second term is, is, is basically a term,
coming from,
from the Josephson current, of, of this junctions.
But, what is very important is, when you look at this, point
that it's not, it's not quadratic, but it's a cosine, it's a cosine,
which is basically almost a harmonic oscillator,
which is also important is that, the number
of Cooper pairs and the Josephson face, the, the conjugate, the barrier.
But it's but it's,
you, so you get almost something as,
the harmonic oscillator.
Now, when you look at this model,
and compared with a harmonic oscillator, there you have a quadratic potential.
And as you know, from your,
first course, as in quantum mechanics, for a quadratic potential,
you get equidistant, level spacing.
Now, the cosine potential looks almost,
like this,
harmonic potential, but, but not quite.
So what what you see is that you have
a slight distortions of this energy levels.
And, the, the qubit itself, corresponds to the lowest
two eigenstates, of, of of the, of your transition qubit.
So with this in mind, we can, try to understand
how you apply quantum operations on, on this level
for this.
I consider a single qubit operations,
two qubit operations.
Similar.
Basically, what you have here is
a is a, is is a cavity,
and you, you copied your transplant,
qubit to, to the, to a resonator.
But, what happens is basically, that you get the hybridization
between the photon and, qubit states,
which means they are no longer independent of each other.
So but you get this light dressing similar to this quasi particle picture.
I don't mean to show it before at all.
Low order approximation.
The, you can still separate them,
but what happens is that,
the, the, basically by applying a photon pulse,
you can, you can change this state as a state of the transition qubit.
So you basically applying here microwave pulse, and then,
introduce,
transitions in the qubits
you have between the first and the second state.
Yeah.
This is a point where this, this
it becomes very important in the sense that,
transitions between the lowest trying states,
allowed, but,
transitions to higher states, the, the slightly off
resonance, which means that they are strongly suppressed.
So you're, you're aware that, that you excite higher levels and,
leak information of your qubits?
And then you want to apply to qubit operations.
This is it can unfortunately, is not visible here
in this picture, but, but basically you have, you have cavities.
Between different, different qubits.
And then you can, also,
you can, you can drive one qubit and
if you,
if you microwave pies and,
and the effect depends then on the, on the state of the other qubit.
Finally, we have to consider measurements for this.
You have,
here, this, this other resonator
and also coupled via, via cavity to this transition qubits.
And the other concept, this also provides, similar.
So, because of this coupling,
the, the states of the transmission qubits,
no longer, completely separate of the microwave pulse.
And on the other hand, is also,
the eight modes of, of this resonator depend on the qubit states,
but it explicitly means this when you look at the transmission frequency,
of your resonator, which you can just a measure
by applying a microwave pulse, then you see that,
it has a different resonance, states,
if the qubit is in state zero,
but it's, but it's getting shifted when the qubit is in state one.
And, basically
by reading out the transmission frequency, you can measure the qubit and, infer in
what state it is.
So with this in mind, we can
we, we have basically everything to, to,
you have to run algorithms and,
perform a quantum operations on your quantum computer,
the basic operations of which you have,
in this case, are often illustrated in circuit diagrams.
I want to, briefly sketch how they look like,
I mean, the.
Yeah.
Easiest case of in your head when you consider qubits,
they are basically denoted by a black line.
As you can see here above.
When your, when you consider,
quantum operations, they, illustrated
by, by boxes and there you, get again the protagonist,
which I have showed you already before at the beginning.
All of them are unitary gates.
But as you would expect from the laws of,
quantum mechanics, and then this is basically
the only restrictions you have, for this operations.
The most illustrative one is,
I think is the, is the not gate or the X gate.
This is, very similar to, to what your,
expect on, classical circuits and, basically,
I mean, you're right, it is a matrix element, but, but this,
operation is, doing a when, when your qubit is in state zero,
it's, it's, it flips it to a state one and otherwise it
flips, and vice versa.
Then then you have Hadamard gates.
The idea of this Hadamard gate, this, it
looks, slightly more complicated, but, basically what it is doing when you start
in the ground state of a qubit, after applying a gate, your,
your will be in a, superposition between, state zero and,
state one.
And, what I mentioned before,
you need some additional gates, which, which can induce
additional phases, between the states of the qubits.
And this is done by phase gates, specifically when you have a phase
shift of pi four is done here and it's, it's called, T gates.
And it turns out when you're basically,
when you
only apply Hadamard, gates, you can, you can create
arbitrary one qubit rotations by sticking together,
of, of has it has been shown roughly 30 years ago
now, one qubit gates,
so one qubit operations.
I mean, the, might be interesting, but,
you cannot do so much useful things with one qubit.
I do not have to build a quantum computer for that.
So you need interactions between qubits
and it turns out that when you,
when you have at one another gate, which is,
a c not gate, which is shown here, which, basically,
this cNOT gate shifts,
induces a transition of the of the second qubit only
if when, when the first qubit is in an excited, state
and it turns out of, in your, at the
si not gate to your, to your second, then this is already sufficient to, to,
create arbitrary unitary, transformation,
transformations with, with, an arbitrary
number of qubits.
And finally, as mentioned,
you have some of which are basically,
indicate the,
but by this box
now, I do not only want to implement them classically, but, but I'm also interested
to run them on a real devices and it turns out that, and the, solution.
So what you can do, is it it's a illustrates,
in a, a second
is that you can program your quantum circuits,
with Python library, which is called Qiskit.
And the idea is basically you construct your circuit, then,
then you, then you,
submitted to a compiler, which,
translates as your circuit
to a native gate operations of your quantum computer,
which is very similar as you are doing for, for classical coding. And,
yeah.
Then, basically you can analyze this circuit or so with Qiskit,
then you have small scale simulations with all the ten qubits.
You can simulate it classically, which is good for debugging to see
whether you are doing the right thing.
But, many of the,
of, companies, they,
they allow access to real hardware via cloud
services and notably, there's, a, a, s bracket,
which allows access, for example, to Google.
It works for,
quantum computers, but there's less, access, to IBM quantum.
And that's, interesting is that, you do not have to be a professional.
In fact, everybody can can register for this service.
And you have also,
limited a number of,
time to, to run operations on this quantum computers.
So, in fact, I think I know in the case of IBM quantum, it's,
you'll have ten minutes time of computation.
Time per month, but,
but this is sufficient to, to run small operations and also everything.
What I will show later is done within a few minutes.
When you look at the,
quantum computers,
well, and this is cloud services, they illustrate,
how the qubits are connected.
This is a this is,
snapshot of IBM. Yes.
Which has,
126 or 27 qubits.
And in principle, you can use all of them.
And it turns out that this is already hard
to simulate on classical devices.
Finally, and
I also want to advocate, you can,
do it on your own.
And it turns out that programing quantum computers is not that much different
to programing classical computers
too. So this I want to
illustrate of, first, a very simple example,
which is
creating a base state, but which is basically,
either both qubits are in state zero
and above states, in, in state one.
So, I mean, so, so it's not very, complex, but but but in principle,
this, this, like, creation of such, states,
was very important
also to, to, to, to test
causality of, quantum mechanics and also respected in
and Nobel Prize a few years ago, just a few years ago,
it turns out, when you want to run it on a quantum computer, you first,
import, quantum circuit object.
You, you basically import your, library
and then you apply your gates, quite straightforward.
So it, in order to create your by state,
first you have to apply a Hadamard gates to a qubit zero.
So you put it in a, the first qubit on a superposition of zero and one.
Then you apply a control not operation,
which basically means that the, the first qubit is then in state zero.
Then when the finished,
zero of qubit is in state
zero and and vice versa.
And then you perform
a few, two measurements to, read out the qubits.
That's basically it. And then your,
you can test how, how it looks on the quantum computer.
So it's, five lines of code.
Now, if you want to execute this,
I mean, you can do it in a classically simulated,
for this, they provide classical simulators.
If you're,
directly go to a quantum computer, you do not have to change much.
It's basically it's basically changing two lines of code.
And then, the next step is what I mentioned before.
You have to test by, like, compile your circuit for the, for this, your,
transpile.
Basically that, this, transpile has,
information of, the quantum computer.
You, you want to run your code, and it's, it translates,
it, it translates your circuit to the native,
gates of your quantum computer
and then your, afterwards.
And in this case, I have prepared this, in advance.
This circuit looks like this.
But what you have basically is that,
this is not this,
this is translated to, such a, two qubit operation,
which is almost a C, not, apart from some additional, phase shift.
And then this the single qubit operation is,
is translated in a lot of, of,
rotations and additional face gates.
But it's also interesting is when you look at the circuit,
there are two numbers, 49 and 50.
And, when you look at,
the quantum computers, I have, shown before,
it means basically that, the circuit is run on these two qubits.
You can see here.
And then,
I mean, apart from it, you basically submit your job.
And in our case, we want to run this circuit, multiple
times, to, get some statistics and see what, what comes out.
And then if, retrieve the result,
which encodes some information, what,
what gates you used, but, but,
of properties of the quantum device.
But nice.
Right?
It's it has and also, of course, the result itself.
And then you can show it in a histogram
in this case, I,
I have prepared it as I mentioned,
when you do the classical simulations,
you get basically this count.
I repeated the, the simulation a thousand, 24 times.
This,
this is a
basically a matter of seconds for the circuits.
And, what what,
what you can see is that you have, basically
of a 520 times here at your a measured the qubit,
both qubits and state zero and otherwise you measured in state one.
I mean, it's not not,
perfectly 50%, but this is basically to statistical fluctuations.
Now, you can, do the same on, on every other device.
And in this case, you see,
make this observation, it looks almost the same.
You you get almost 50% on state zero.
Both qubits and state seal of above qubits on state one.
But what you also see is that there's, slight deviation.
Basically that only one qubit is in state one and one qubit,
while the other one and this is this is basically due
to noise and hardware errors, which is quite remarkable.
Seen before is,
was a very small circuit, and we have already 2% error
rates, which gives you an impression how, how good current
hardware is.
So, I mean, this is basically the reason
why we have to deal with errors, in a, in the long run.
I mean, as I mentioned, this was very, simplistic example.
Now, if I want to, show you something which is,
more connected to real world,
at least from a theorist perspective.
This is namely, this is basically dealing with quantum dynamics,
which is one of the most,
promising applications,
basically use a quantum computer
to simulate other quantum systems.
And the idea is that you use the trusted, decomposition.
So you, have, usually you have a very,
complex operator or a complex system, your molecule or you,
your,
strongly interacting system to has some before
and what you can, what you can do
is that you decompose this big block or this from a,
in a bunch of two qubit operations, and then you have this cubit operations.
It's in state, straightforward.
To practice and compile.
And then you can run this
and this, this looks,
quite simple.
But, the issue is, from a classical perspective,
the dimension of the Hilbert space scales exponentially with the number of qubits.
And, when you want to simulate such systems, classically,
it turns out that, you're basically
at the limits of,
of, state of the art classical computers.
When you go to, to roughly set the qubits,
or a bit more, which is, I would say,
quite far from
complex molecules or, interacting systems.
So that's the reason why, this,
this approach is
actually used also to benchmark the performance of quantum computers.
And then you do a few, tweaks and tricks.
You can show already that occurring quantum computers,
can give competitive
results, to, to classical devices.
How is how is this done?
Again, using Qiskit.
I use a very simple toy model.
But it's straightforward to use, some,
something more complex.
And in fact, this case is so simple that you can solve it.
Exactly.
By hand.
So you have basically you have basically an interaction between two qubits,
by some interaction and you have some additional magnetic field,
and then then you want to,
to code that, Trotta evolution,
of what you have to do is you basically create
a trotter, a trotter gate.
So you, create your Hamiltonian with online what they took here, but
Hamiltonian and then this, automatically creates
you an evolution, this, qubit evolution gate.
And. Yeah, if you want to multiply it with the times,
you will
have a basically at a few lines of code which,
apply to, gates, either to the even bonds,
which are the first two lines,
to, to the odd and that's basically it. So,
I can show again when your,
want to consider one of these trotter steps for six qubits,
it looks like this.
I mean, it's a it's a bit more complex than before, but,
but when you look closely at this, then,
this red box corresponds
to one trotter step which I have implemented.
And and the rest is done, is done by inference by the.
Now you can again compare
the time evolution, as I have done by before.
In this case, I'm,
I saw, to not sample
exact strings, but, but measured in magnetization.
So, so the, the expectation value of a set on each side.
And you do it classically,
on, the exact simulation on a classical computer.
I start, with, with,
a staggered initial state, the,
which you, which is indicated by this pattern.
And then you evolve in time, you see that, the,
the system equilibria.
But you see also this, this long term oscillations.
Now, you can compared again with a quantum computer.
It looks not that bad, in fact, for, especially when a,
when you have in mind that before we have a 2% error rate per, packet.
So you, you see, especially at the beginning,
you, you see this oscillations there, there's spun qubits.
This, oscillation do not,
decay really, which indicates that probably this,
Q qubit does not work properly.
And, but additionally, you see that,
that the long time values,
it's, it seems to equilibrate, but,
but you are not able to, to, to, to capture the oscillations,
at least when we do it as naively as I did right now.
But, but still, in comparison to the Bose state
I have shown before, it seems that, especially when you look at,
look at observables.
So it's, performs relatively good in comparison
of what you would naively expect from,
from 2% errors per step.
And this is also basically an indication that when you consider physical systems
also, that they are basically more robust to errors than you would naively expect.
Now, I showed you
how how valuable the quantum computers are.
And as you have seen, you have lots of errors.
So I want to briefly sketch at the end of my talk how to deal with them.
One thing, and this is
is is basically the path to goal.
And in the long term, then you want to run more complex algorithms.
That's for example,
Shor's algorithm is that you have to do phantom error correction.
The idea is basically your, instead of using,
qubits, your, your encode redundant, information and basically,
repeat the information of the qubits in multiple qubits
such, that you can detect when you have an error incorrect for it.
And this, has, has been done.
Has been, Pope Benedict last time,
but this in order to do this, you basically,
require quite small error rates and large number of qubits.
Basically the reason is, when you increase
the number of qubits, you also increase an error rate.
And so you basically have to balance this.
And, I mean, this this is an active area of research.
This is for example, a picture of
encoding one qubits and in terms of roughly,
I think it's for the 50 physical qubits.
And then detecting the errors.
But, the point is, I think in order to get this work,
you need at least a few more years,
another, promising thing, which is probably more applicable.
The in this, short term is, so-called quantum error mitigation.
It's,
as you will have seen before, for observables,
it seems that we do not need the, the perfect, quantum computer.
And the idea is that you run experiments
to learn the noise and then do some interpolation.
This idea is basically quite simple.
And it's also what basically what you have,
you start with a noise rate one which,
corresponds to the noise you have from the actual, quantum computer.
And then even, then you know how,
how the errors speed up, you can basically artificially enhance
your noise rate is done by this, red dots, red crosses.
And then you can interpolate to zero noise
rate and,
it it's,
looks a bit fishy, but it seems that
it works pretty badly for observables.
And when you want to be competitive with classical simulations,
and this is the method which is done to get good results.
Quantum computers already today.
To, to sum up,
well, what I wanted to highlight is that basically programing
a quantum computer is quite simple, so everybody can do it.
I mean, this is a kind of trotter step which is only a few lines of code,
and then you are basically already at the forefront of research.
The remaining main challenge you have to do is,
is understanding the error and is where most efforts are right now.
Thank you for your attention.
And do it yourself.
Okay,
so basically the question as far as I understand
is a possibility is, better it's
better to think about improving quantum gates and, how fast you can run.
Yeah. Actually, that's, that's a good point.
And, I mean, I think that's, that's the main difference between,
different approaches of quantum computers.
But when you look at the, the execution times of gates in,
in the case of superconducting qubits,
it's of order one hundreds of nanoseconds.
And when you use trapped ions, it's,
it's basically three orders of magnitude larger.
And I think one of the,
one of the most important properties, especially when you have
ions, has so is finding a, finding approaches
that you can reduce,
the, the execution time of gates.
And this is, this is also a basically cutting edge of research,
not for the superconducting qubits, but for other devices.
Okay. The,
basically everyday you have different like,
language constructs to, to different,
types of quantum computing.
So far as I think
the issue is a little bit the I mean, the quantum computers are still in
such native stages that, I think there is so far.
No, no need to think about my infants cases.
I think it might be the case. I mean, your,
regard to what
complex algorithms and how to implement that, for example,
proposals that instead of,
gate operations, you only,
perform measurements.
And and this might be sufficient
to, to, generate the universal quantum computers.
So in this sense, it is thought about it.
But in principle, it's mostly that we are only at the single qubit
and two qubit stage.
And so it's a bit early in many cases.
Yeah.
So basically the question is how does quantum error correction work.
Yeah.
You need physical qubits to to get the logical qubits.
And then you run in, increasing
required coherence times.
How does it work.
That's a good point.
And that's,
I said the issue of why
we do not have quantum error correction right now to one point.
The point is that,
the, the way how it works is, when your
have as a sufficient number of qubits, then,
basically you can correct a small number of errors.
So, so this helps you, but at the same time still,
as you mentioned, you'll have increasing sources of errors.
So you have basically two factors.
What turns out is,
when when your error rate of physical qubits is, is large, then
you have no chance.
And then trying to do, quantum error correction,
the Q
however, right now
we are at the stage where basically quantum error correction of means.
So basically by, by adding security, by adding qubits,
you, gain as much advantage
that, it basically,
that it basically overtakes the disadvantage from,
more additional physical cubits and the as a, as a, concerning
the question how, how many physical qubits you need to protect, one logical qubit.
So it
basically, if
when you are below this threshold of, logically a quantum error correction bits,
what you can see is that, the more physical qubits
you use, the exponentially better, becomes
your, advantage.
And and then it's then it's, then it's, basically
trying to be as good as possible with the physical qubits.
And then you it might be that you need only
a few more,
physical qubits, but it's, but it's still a work in progress.
In fact, I think the, state of the art for superconducting qubits
is that you can generate one logical qubit.
Yeah.
So so the question is,
can you gain the advantage when instead of,
using qubits with two states, whether you, can gain advantage with,
three states rights or if more states,
yeah, this
is, is has been explored and there are some possibilities.
I mean, I think, for,
for most,
long time approaches when you are sufficiently efficient, it,
it will I mean, maybe make an difference of a factor.
So, so from a,
teaching and complexity point of view, it's not change,
but, a is, has been explored.
For example, when you simulate lattice gauge theory, a bit of it's is,
which is important to study high energy physics.
So the standard of physics of the standard models, then,
then especially in, in trapped ion systems,
it's easy instead of, controlling two qubits,
to, sorry, two levels,
controlling multiple levels up to 20 levels.
And it turns out that in this case,
you can gain an advantage in the length of the, of the circuits.
And and and.
Yeah, and get more efficient computations.
Yeah.
Observation.
So the question is,
but I just quickly pick.
Basically I saw, I saw, results here from.
And what about, time steps.
How does it work when I, when I, when I measure
the state, I actually destroy it.
And it's a good point.
And, the answer is that I have not run.
You have one experiment, but 30 experiments for each different system
size. So,
so basically, I, I,
in advance, I state, how many steps do I want,
for example, for, for,
ten steps, which corresponds to time peak for ten.
And then I run this, this experiment,
in this case, I run a thousand times to, to,
collect enough statistics and then to get the measurements.
Of course, I mean, you get the massive overhead,
but but it's doable.
So in principle, for one two steps,
sorry, for one time step to, generate a thousand measurements.
It took me,
10s on a quantum computer.
So I think the overall plot on the right is a matter of five minutes or something.
Yes, exactly.
So I think that this cube.
Yeah, that's, and this,
qubit does not work.
And, actually, even when you're look,
at, at, this IBM, quantum website, you,
you can have access, to, to the performance of this, qubits.
And the what you see is that, sometimes,
they are some calibrations and not all of this connections, perfect.
This is what, what happened here?
Yeah. Yeah.
So I think the the point is, I mean, yeah, it does not work for,
extra classical encryption.
Like, you could, you can break the as a encryption.
But the reason why they use it right now is,
it's because it's a relatively cheap to implement.
Yeah, but but this current research of quantum cryptography,
which you cannot break with quantum computers and would be,
secure because of the physical laws of quantum mechanics.
I mean, nevertheless, I mean, probably for most cases,
it's too expensive, and it's like quantum computers.
They might be useful in this field
long time, but, but then you have,
very sensitive information.
You will use a different encryption.
I'll do a certain.
No, I think not. Mine has one.
But I think it's it's, I think it's a reasonable concern.
And, it's also a when you look at the research
that it's for example, of classified and in the US.
So, when you,
when you travel to China and
you are quantum research, they are very interested in you.
Okay.
I think the question is basically what is more important
is that understanding,
errors and, and try to cure them is basically,
getting larger and better quantum computers, but it's just more important.
The point is, when you're,
when you consider, this error
mitigation techniques I mentioned before, I think they hope for.
For some cases as observables.
But I think they they ultimately break down at some point.
And you can it can also show that they, they will not given any cases.
So I think in the long term run you'll always need quantum error correction.
And but the quantum computers but
nevertheless when you look at,
amid near-future a
so what what would happen is that you basically you have an interplay of,
two approaches that error mitigation that I hope you to be a little bit better
and then you can ever get,
fast improvement with quantum error correction once is you.
Okay, that's a good question.
The question is basically,
but, I, as a program, responsible for quantum error correction.
It's done in the compiler or on a hardware level, I think.
I mean, that's already shown here
a little bit.
But what happens this time
instead of any of the of any of any
if any progress in quantum computer evolves, is that,
basically one was getting a black box, I mean, already here, I mean, you see that
a basically creates a poly evolution gate by calling it, another comment.
So 2 or 3 years ago, I took coded up a cipher
and it was a bit more complex.
But I think I saw with this, quantum
error correction is basically you, go down
either to the compiler or is lower to the hardware level.
And what, whatever. I did not know exactly.
All right.
It looks like it's one of those questions. So let's think of it again.