WEBVTT

00:00.000 --> 00:29.960
Well, so what is a verification, so a verification, it's kind of, it's basically

00:29.960 --> 00:35.960
comes from cryptographic protocol, but we use this to verify, like,

00:35.960 --> 00:41.440
result from quantum computer. So imagine, like, in the future, we have, like,

00:41.440 --> 00:45.920
fully functioning quantum computer, and then we want to run some simulation that is

00:45.920 --> 00:51.440
important, like, as Alexander said, you want to run fertiliser simulation, for example.

00:51.440 --> 00:56.840
And to simulate this fertilizer efficient simulation, basically it's nitrogen

00:56.840 --> 01:03.200
and fixations. The amount of atom you need is equivalent with the amount of atoms on the

01:03.200 --> 01:09.320
ocean. So there is no way we can cross check if quantum computer actually gives you

01:09.320 --> 01:15.560
a correct result or it just gives you some rubbish, right? So in this verification,

01:15.560 --> 01:22.760
it's actually gives you a way to give you some certificates. So you, you suddenly

01:22.760 --> 01:26.840
say some quantum algorithm, and then we, we say, we don't trust the quantum

01:26.840 --> 01:32.840
computer, and then it will give you the results that is, like, certified. So it

01:32.840 --> 01:37.480
kind of gives you some. So after you run computation in this protocol, you will have

01:37.480 --> 01:42.040
some confidence in your results. So should I trust the results, should I, we run this,

01:42.040 --> 01:48.480
or maybe the quantum computer is just too, too much of errors. So this is verification.

01:48.480 --> 01:56.520
Yeah, so in more detail, so does it look like. So it's run on something so called measurement

01:56.520 --> 02:00.600
based quantum computation. You saw already in the beginning, there is this analog in the

02:00.600 --> 02:04.680
morning, and then there is a gate base, and this is another thing, so called measurement

02:04.680 --> 02:13.320
base. So this measurement base, your quantum algorithm is described as graph, basically.

02:13.400 --> 02:20.440
So this is my quantum algorithm, and you only need to specify some angles. So the graph

02:20.440 --> 02:27.520
and the angles is your quantum algorithm. And then in this verification protocol, so you

02:27.520 --> 02:33.880
run the same algorithm, basically the same graph, and then some of them are just some

02:33.880 --> 02:41.520
traps, basically some tests. So imagine, this is just like a single measurement, so you

02:41.600 --> 02:46.240
run something, and then you measure. And then it's this single measurement. You will see

02:46.240 --> 02:53.880
like later, like how significant is this, like how hard this is actually, because if you,

02:53.880 --> 02:58.480
if you have quantum system, you can't tell what's going on in this quantum world, right?

02:58.480 --> 03:04.480
So what you do is you measure, so it means you collapse them into classical information,

03:04.480 --> 03:10.480
but if you only do it once, it tells you nothing. So you have to let over and over, then

03:10.560 --> 03:17.440
you give you a statistical output. So you need the statistics. So now in this protocol,

03:17.440 --> 03:24.800
for each single measurement, you need to do some randomness. So here you have sometimes

03:24.800 --> 03:29.680
you throw tests, sometimes you do your computation, sometimes so you keep doing this,

03:29.680 --> 03:34.560
throw this random dice, decide, should I test, should I compute, test, compute, you know,

03:34.560 --> 03:41.280
like over and over, and then statistically you will know, okay, it was like, it was rubbish,

03:41.280 --> 03:50.480
or it was like, it's good, I think, and you confidence with your result. So in more details,

03:51.600 --> 03:57.600
so for example, this is how it looks like to run MVC on graph with two nodes. So it's just

03:57.600 --> 04:03.200
like two nodes connected with one H, and you run with this angle, I don't know, five zero, five

04:03.200 --> 04:11.360
one, and in the language of the gates, it looks like this, basically. So this is if you do the

04:11.360 --> 04:18.000
computation on the top, and then this is if you did test, okay. So the crucial part here is like,

04:18.000 --> 04:22.080
you see like there is the red colors, they are like the randomness that you have to insert,

04:22.640 --> 04:27.680
and every time you do before you do single measurement, you have to prepare like again fresh

04:27.680 --> 04:33.200
on the numbers, and then you have to correct this, and then so you basically have to run randomly

04:33.200 --> 04:42.000
different circuits because it has different angles, okay. Now for the test, for example, in this case,

04:42.000 --> 04:49.200
then you should know what is the correct on term. So here, if the outcome is zero, it means you pass

04:49.200 --> 04:55.440
the test and otherwise it fail. So there is a theoretical bounce, and then you calculate if this

04:55.440 --> 05:01.200
percentage test pass, it means like it's good result. So this is basically how it works.

05:03.760 --> 05:10.000
Now the problem is the common setups in the quantum software stacks, they don't have this

05:10.560 --> 05:17.120
single shot randomness. So it's very common, as far as I know, all of the software

05:17.200 --> 05:23.040
quantum software stack, it works like you submit your quantum algorithm which is quantum circuit,

05:23.600 --> 05:28.000
and then you run it over and over the same thing and then you calculate this, you get the statistic.

05:28.880 --> 05:35.920
So there is no random numbers in writers that is provided, you know, on top of the quantum

05:35.920 --> 05:44.240
computer. So for example, here in this algorithm, the randomness that I did, like there is like

05:44.240 --> 05:49.840
at least four random number generators. So I have to decide if I want to compute or if I want to test,

05:50.720 --> 05:55.600
and then after that there is this some colorings that you have to do. So this is another random

05:55.600 --> 06:01.360
dice, and then after that for each node you saw, I also have to draw another random number which is the

06:01.360 --> 06:07.680
angle, and then also I have to draw another random number which is the bit. So there's so many

06:07.760 --> 06:14.720
random numbers. So this package is basically to accommodate all these randomness into this

06:14.720 --> 06:28.000
common framework. So how does it look like? It's a little bit tricky. So this is like for example,

06:28.000 --> 06:35.040
if I just want to run these two nodes, and what you do is you need to have a lot of classical

06:35.040 --> 06:41.840
registers. So in the quantum algorithm which is used to describe as quantum gates, if it's one line,

06:41.840 --> 06:46.720
it's usually like quantum information, if it's double lines, it means classical. So you already

06:46.720 --> 06:54.720
measure it with something like that. So here you need to here we generate the randomness on the fly,

06:54.720 --> 07:00.960
which is like basically one of the ways is you see in the circle, you basically bring the

07:00.960 --> 07:06.400
kibbits in superposition, and then you measure. So you have this 50-50 chance to throw random bits.

07:07.360 --> 07:13.600
And then from that you store all the necessary random number when you run this framework.

07:14.320 --> 07:19.680
So there is some more details like you need this circuit measurement. It means like

07:20.720 --> 07:26.640
you should be able to measure in the middle of the computation, and then you prepare again, and yeah.

07:26.800 --> 07:32.400
And then another thing you need is you need to be able to perform classically controlled

07:32.400 --> 07:40.480
rotation. So you see like it is basically our say, our way of saying if in the classical

07:41.760 --> 07:48.320
algorithm. Like for example, if this is zero, then you don't run this, if this is one,

07:48.320 --> 07:55.360
then you run this edge, something like that. So you have this sub-rural ifs there. So if all of them

07:55.440 --> 08:03.520
are one, then you run this, our x-tipper. So it is kind of something to keep in track of this.

08:03.520 --> 08:11.840
That's why this is all cfqc, like that's why we developed that. So how does it look like?

08:13.600 --> 08:17.840
This is for example, I just want to run these three nodes, just run z,

08:18.880 --> 08:24.560
apply z gate, basically this single gate. So what you do, you just, it's used something called

08:24.640 --> 08:32.720
geofcircuit, and this geofcircuit object has similar language as this mdqc. So yeah.

08:33.440 --> 08:39.680
And then this is actually a pithicat circuit. So a pithicat is developed by quantum you now,

08:40.320 --> 08:49.680
and it's also had a very agnostic compiler, and it can interact with many packages. So it can

08:49.760 --> 08:54.960
interact with many compilers to quantum parameters. For example, with IBM, iNK,

08:54.960 --> 09:05.440
Hanua, etc. And you just add the node and then add the edge and the measure, just like this.

09:05.440 --> 09:12.640
And then the program will tell you the versions that you should run in the common framework.

09:12.640 --> 09:17.840
So it's like it's hard to track, right? So it's just to run these three measurements,

09:17.920 --> 09:24.720
this is what you need. And then this pithicat helps you to manage all these registers.

09:29.440 --> 09:36.800
Yes, so we also demonstrate this on a real quantum computer. So we work with the continuum.

09:37.440 --> 09:42.880
So it was demonstrated on iNK. So this is the iNK, it looks like, it's from the new

09:42.880 --> 09:52.720
university, but it's kind of like floating ions physically. And yeah, we've done some algorithms.

09:52.720 --> 09:58.480
So for example, we tried this Grover quantum search algorithm. So this is like search algorithm that

09:58.480 --> 10:06.320
we have on the quantum algorithms people. And then we tried to search all this data and then

10:06.320 --> 10:13.280
all the results pass. So it works. So it means we know the answer. And then whenever it gives you

10:13.280 --> 10:20.880
or when it gives you pass, the results are correct. So this is the certified result, basically.

10:22.240 --> 10:31.200
And we also run it on the larger graph. So we run to 52 nodes. So this is the largest

10:31.360 --> 10:38.800
NDQC ever performed on a quantum computer, basically. And then we know the answer should be,

10:38.800 --> 10:46.320
this is basically just a bunch of node gates. And it's all give you like a correct result whenever

10:46.400 --> 10:54.560
it passed. So I hope you'll learn something that's, thank you for listening.

10:54.960 --> 11:05.760
So you have a question? Yes. Is there a feedback in the reading?

11:05.760 --> 11:14.160
Yeah, it was in the first page. Yes. Yeah, the care quality is the paper.

11:14.960 --> 11:24.880
I didn't tell. Yes. So my understanding of one of the reasons we want to do verification is

11:24.880 --> 11:29.680
so that we gain some confidence. Yes. And our machines instead of that, when we take it to places

11:29.680 --> 11:33.600
when we cannot simulate. But it already looked like we're doing a relatively small thing. You're

11:33.600 --> 11:42.240
already getting put a large circuit. Yes, large graph. Yes. So when you ran on something like

11:42.240 --> 11:55.280
20 qubits, what is the computational cost and how does that scale? No, it's quite destructive.

11:55.280 --> 12:01.280
How does the computational cost of doing verification scale in the number of qubits?

12:01.280 --> 12:07.920
In the number of qubits how it scales. So this is still also an often questions. So how many

12:08.000 --> 12:12.160
repetitions we need randomness we need. We still need to explore this as well.

12:16.000 --> 12:25.440
Like for this 52 nodes, we run like thousand shots only. It's actually not much, it's quite little.

12:38.080 --> 12:46.800
That's the difference. It's different algorithm. So one. Yes. The Grover.

12:48.480 --> 12:54.800
This one. So this algorithm is the eight nodes. And then it's actually only used three qubits.

12:56.320 --> 12:58.080
This is the algorithm.

12:58.400 --> 13:06.400
This one. No, but I meant the blue line. Ah, yes, sorry. This is just one of them is run the

13:06.400 --> 13:10.400
orange one is run on the quantum computer. And then the blue one is only simulator.

13:13.360 --> 13:18.880
Yeah, yeah. Just to see like, it's a noisy simulator, but to see how it performs.

13:19.520 --> 13:24.720
Okay. And special reason why you see a total to the quantum computer for quantum error.

13:25.600 --> 13:31.760
I don't know. So yeah, sometimes it's very important. Yes.

13:36.080 --> 13:43.200
Oh, no, actually this is the test failure, right? So it's more failure. It's not better.

13:43.280 --> 13:52.000
Yeah, but yeah, this one. I think it's, I don't know. But majority is more failure.

13:59.600 --> 14:05.280
Yes. I'm a broader question. Like has a researcher having to write one himself where

14:05.840 --> 14:12.880
what are some of the things that you struggle with in writing this package? And what tools

14:12.880 --> 14:22.000
do you need to wish for there to learn? So there are so many choices of the packages.

14:22.000 --> 14:26.960
I think the hardest part is like, again, like different language again and again, you know.

14:26.960 --> 14:34.320
Like, and I can understand like each vendor write their own language,

14:34.320 --> 14:40.800
basically the own package. So that was, yeah, it's just like learning new ones.

14:41.680 --> 14:51.120
And then what was a difficult part? Yeah, like, or like, for example, if I'm working with the company,

14:51.760 --> 14:58.320
they also have some confidentiality, like for example, okay, we try to make a research protocol

14:58.320 --> 15:03.760
and then can you tell us, please, can you tell us that? You know, and some information is not

15:04.800 --> 15:08.720
open, right? Especially if it's real hardware. Yeah.

15:10.720 --> 15:14.800
I'm not necessarily like they're restricting you from publishing their data, just like,

15:14.800 --> 15:19.360
you don't know what information I was happening on this case. Yeah, so we have to ask permission

15:19.440 --> 15:25.440
first before we publish the data. Yes. But I think it's everywhere.

15:36.400 --> 15:44.800
And yeah. Yeah, they're developing, are maintaining packages also a lot of time. And if you do research

15:44.880 --> 15:50.400
which is full time at the same time, it's quite a lot of work. And especially people asking

15:50.400 --> 15:56.720
for the commendations, you know, like, I don't have time to do that, you know. I think that's

15:58.720 --> 16:02.400
mostly done. There's their other people, basically.

16:03.040 --> 16:20.960
Sorry? Oh, yeah, how did we test the packages? Well, we test on the real

16:21.520 --> 16:27.520
content computer and then emulator and then it shows the correctly thoughts, basically. And

16:27.520 --> 16:38.320
anyway, you know, like if you saw, it's not much of, it's like you build this circuit which is

16:38.320 --> 16:44.560
already the object of my ticket. And a lot of developers. So we are quite sure that

16:46.160 --> 16:50.160
it should be correct. You kind of know like do some tests and you know already the output,

16:50.160 --> 16:56.640
how it's supposed to be. And then if they pass, then you kind of like, I think it's here.

16:57.520 --> 17:04.880
And especially this one, there's only not so many commands. Because the basic gates are only

17:04.880 --> 17:12.320
the preparing the notes. And then do this edge and then measure. So they only like few,

17:14.080 --> 17:20.000
you know, few commands. And then the rest, we give it to the particle. We like the

17:20.000 --> 17:35.920
secret is running correctly. And now, good. Thank you.

