Well, so what is a verification, so a verification, it's kind of, it's basically
comes from cryptographic protocol, but we use this to verify, like,
result from quantum computer. So imagine, like, in the future, we have, like,
fully functioning quantum computer, and then we want to run some simulation that is
important, like, as Alexander said, you want to run fertiliser simulation, for example.
And to simulate this fertilizer efficient simulation, basically it's nitrogen
and fixations. The amount of atom you need is equivalent with the amount of atoms on the
ocean. So there is no way we can cross check if quantum computer actually gives you
a correct result or it just gives you some rubbish, right? So in this verification,
it's actually gives you a way to give you some certificates. So you, you suddenly
say some quantum algorithm, and then we, we say, we don't trust the quantum
computer, and then it will give you the results that is, like, certified. So it
kind of gives you some. So after you run computation in this protocol, you will have
some confidence in your results. So should I trust the results, should I, we run this,
or maybe the quantum computer is just too, too much of errors. So this is verification.
Yeah, so in more detail, so does it look like. So it's run on something so called measurement
based quantum computation. You saw already in the beginning, there is this analog in the
morning, and then there is a gate base, and this is another thing, so called measurement
base. So this measurement base, your quantum algorithm is described as graph, basically.
So this is my quantum algorithm, and you only need to specify some angles. So the graph
and the angles is your quantum algorithm. And then in this verification protocol, so you
run the same algorithm, basically the same graph, and then some of them are just some
traps, basically some tests. So imagine, this is just like a single measurement, so you
run something, and then you measure. And then it's this single measurement. You will see
like later, like how significant is this, like how hard this is actually, because if you,
if you have quantum system, you can't tell what's going on in this quantum world, right?
So what you do is you measure, so it means you collapse them into classical information,
but if you only do it once, it tells you nothing. So you have to let over and over, then
you give you a statistical output. So you need the statistics. So now in this protocol,
for each single measurement, you need to do some randomness. So here you have sometimes
you throw tests, sometimes you do your computation, sometimes so you keep doing this,
throw this random dice, decide, should I test, should I compute, test, compute, you know,
like over and over, and then statistically you will know, okay, it was like, it was rubbish,
or it was like, it's good, I think, and you confidence with your result. So in more details,
so for example, this is how it looks like to run MVC on graph with two nodes. So it's just
like two nodes connected with one H, and you run with this angle, I don't know, five zero, five
one, and in the language of the gates, it looks like this, basically. So this is if you do the
computation on the top, and then this is if you did test, okay. So the crucial part here is like,
you see like there is the red colors, they are like the randomness that you have to insert,
and every time you do before you do single measurement, you have to prepare like again fresh
on the numbers, and then you have to correct this, and then so you basically have to run randomly
different circuits because it has different angles, okay. Now for the test, for example, in this case,
then you should know what is the correct on term. So here, if the outcome is zero, it means you pass
the test and otherwise it fail. So there is a theoretical bounce, and then you calculate if this
percentage test pass, it means like it's good result. So this is basically how it works.
Now the problem is the common setups in the quantum software stacks, they don't have this
single shot randomness. So it's very common, as far as I know, all of the software
quantum software stack, it works like you submit your quantum algorithm which is quantum circuit,
and then you run it over and over the same thing and then you calculate this, you get the statistic.
So there is no random numbers in writers that is provided, you know, on top of the quantum
computer. So for example, here in this algorithm, the randomness that I did, like there is like
at least four random number generators. So I have to decide if I want to compute or if I want to test,
and then after that there is this some colorings that you have to do. So this is another random
dice, and then after that for each node you saw, I also have to draw another random number which is the
angle, and then also I have to draw another random number which is the bit. So there's so many
random numbers. So this package is basically to accommodate all these randomness into this
common framework. So how does it look like? It's a little bit tricky. So this is like for example,
if I just want to run these two nodes, and what you do is you need to have a lot of classical
registers. So in the quantum algorithm which is used to describe as quantum gates, if it's one line,
it's usually like quantum information, if it's double lines, it means classical. So you already
measure it with something like that. So here you need to here we generate the randomness on the fly,
which is like basically one of the ways is you see in the circle, you basically bring the
kibbits in superposition, and then you measure. So you have this 50-50 chance to throw random bits.
And then from that you store all the necessary random number when you run this framework.
So there is some more details like you need this circuit measurement. It means like
you should be able to measure in the middle of the computation, and then you prepare again, and yeah.
And then another thing you need is you need to be able to perform classically controlled
rotation. So you see like it is basically our say, our way of saying if in the classical
algorithm. Like for example, if this is zero, then you don't run this, if this is one,
then you run this edge, something like that. So you have this sub-rural ifs there. So if all of them
are one, then you run this, our x-tipper. So it is kind of something to keep in track of this.
That's why this is all cfqc, like that's why we developed that. So how does it look like?
This is for example, I just want to run these three nodes, just run z,
apply z gate, basically this single gate. So what you do, you just, it's used something called
geofcircuit, and this geofcircuit object has similar language as this mdqc. So yeah.
And then this is actually a pithicat circuit. So a pithicat is developed by quantum you now,
and it's also had a very agnostic compiler, and it can interact with many packages. So it can
interact with many compilers to quantum parameters. For example, with IBM, iNK,
Hanua, etc. And you just add the node and then add the edge and the measure, just like this.
And then the program will tell you the versions that you should run in the common framework.
So it's like it's hard to track, right? So it's just to run these three measurements,
this is what you need. And then this pithicat helps you to manage all these registers.
Yes, so we also demonstrate this on a real quantum computer. So we work with the continuum.
So it was demonstrated on iNK. So this is the iNK, it looks like, it's from the new
university, but it's kind of like floating ions physically. And yeah, we've done some algorithms.
So for example, we tried this Grover quantum search algorithm. So this is like search algorithm that
we have on the quantum algorithms people. And then we tried to search all this data and then
all the results pass. So it works. So it means we know the answer. And then whenever it gives you
or when it gives you pass, the results are correct. So this is the certified result, basically.
And we also run it on the larger graph. So we run to 52 nodes. So this is the largest
NDQC ever performed on a quantum computer, basically. And then we know the answer should be,
this is basically just a bunch of node gates. And it's all give you like a correct result whenever
it passed. So I hope you'll learn something that's, thank you for listening.
So you have a question? Yes. Is there a feedback in the reading?
Yeah, it was in the first page. Yes. Yeah, the care quality is the paper.
I didn't tell. Yes. So my understanding of one of the reasons we want to do verification is
so that we gain some confidence. Yes. And our machines instead of that, when we take it to places
when we cannot simulate. But it already looked like we're doing a relatively small thing. You're
already getting put a large circuit. Yes, large graph. Yes. So when you ran on something like
20 qubits, what is the computational cost and how does that scale? No, it's quite destructive.
How does the computational cost of doing verification scale in the number of qubits?
In the number of qubits how it scales. So this is still also an often questions. So how many
repetitions we need randomness we need. We still need to explore this as well.
Like for this 52 nodes, we run like thousand shots only. It's actually not much, it's quite little.
That's the difference. It's different algorithm. So one. Yes. The Grover.
This one. So this algorithm is the eight nodes. And then it's actually only used three qubits.
This is the algorithm.
This one. No, but I meant the blue line. Ah, yes, sorry. This is just one of them is run the
orange one is run on the quantum computer. And then the blue one is only simulator.
Yeah, yeah. Just to see like, it's a noisy simulator, but to see how it performs.
Okay. And special reason why you see a total to the quantum computer for quantum error.
I don't know. So yeah, sometimes it's very important. Yes.
Oh, no, actually this is the test failure, right? So it's more failure. It's not better.
Yeah, but yeah, this one. I think it's, I don't know. But majority is more failure.
Yes. I'm a broader question. Like has a researcher having to write one himself where
what are some of the things that you struggle with in writing this package? And what tools
do you need to wish for there to learn? So there are so many choices of the packages.
I think the hardest part is like, again, like different language again and again, you know.
Like, and I can understand like each vendor write their own language,
basically the own package. So that was, yeah, it's just like learning new ones.
And then what was a difficult part? Yeah, like, or like, for example, if I'm working with the company,
they also have some confidentiality, like for example, okay, we try to make a research protocol
and then can you tell us, please, can you tell us that? You know, and some information is not
open, right? Especially if it's real hardware. Yeah.
I'm not necessarily like they're restricting you from publishing their data, just like,
you don't know what information I was happening on this case. Yeah, so we have to ask permission
first before we publish the data. Yes. But I think it's everywhere.
And yeah. Yeah, they're developing, are maintaining packages also a lot of time. And if you do research
which is full time at the same time, it's quite a lot of work. And especially people asking
for the commendations, you know, like, I don't have time to do that, you know. I think that's
mostly done. There's their other people, basically.
Sorry? Oh, yeah, how did we test the packages? Well, we test on the real
content computer and then emulator and then it shows the correctly thoughts, basically. And
anyway, you know, like if you saw, it's not much of, it's like you build this circuit which is
already the object of my ticket. And a lot of developers. So we are quite sure that
it should be correct. You kind of know like do some tests and you know already the output,
how it's supposed to be. And then if they pass, then you kind of like, I think it's here.
And especially this one, there's only not so many commands. Because the basic gates are only
the preparing the notes. And then do this edge and then measure. So they only like few,
you know, few commands. And then the rest, we give it to the particle. We like the
secret is running correctly. And now, good. Thank you.