WEBVTT

00:03:08.000 --> 00:03:14.000
is Chief Scientist for quantum algorithms and Innovation at Continu

00:03:14.000 --> 00:03:20.000
And Professor algorithms, complexity theory and quantum computing at the University of Amsterdam

00:03:20.000 --> 00:03:31.000
He is also the founding director of Qsoft, the Dutch Research Center for Quantum Software, which he co-founded in 2015.

00:03:31.000 --> 00:03:36.000
For those less familiar with Continuum, it is one of the leading companies

00:03:36.000 --> 00:03:44.000
working on Krabdion quantum computer computing and quantum software, bringing together quantum hardware, algorithms and applications

00:03:44.000 --> 00:03:56.000
Harry has been one of the pioneers of quantum computing research in Netherlands and internationally. He established one of the earliest quantum computing research groups in the Netherlands in the late 1990s.

00:03:56.000 --> 00:04:05.000
And his work has made foundational contributions to the quantum algorithms, communication, complexity, and computational complexity theory.

00:04:05.000 --> 00:04:11.000
His research has helped establish both the power of quantum computation and importantly, its limitations.

00:04:11.000 --> 00:04:20.000
He was elected to the Royal Netherland Academy of Arts and Sciences in 2020 and has received a Wiki grant, among numerous other distinctions

00:04:20.000 --> 00:04:24.000
And cells on several international scientific advisory boards

00:04:24.000 --> 00:04:42.000
And I have to admit, I have a little bit of personal interest in today's seminar. I'm using a continuum quantum computing for some of our research with NQC colleagues, and also I happen to own 3 shares of continuum.

00:04:42.000 --> 00:04:52.000
So, Harry, there is at least one shareholder in this Seminar who is particularly interested in. Jokes aside, it is a real pleasure to have you here

00:04:52.000 --> 00:05:05.000
And I'm very interested to hear your perspective on quantum advantages to actual scientific discovery. So with that, please join me in welcoming Harry Perman

00:05:05.000 --> 00:05:10.000
Thank you very much. Is there a chair for you? Yeah

00:05:10.000 --> 00:05:22.000
You're almost majority shareholder. Thank you very much for inviting me and for the very nice introduction.

00:05:22.000 --> 00:05:27.000
Today I want to talk a bit about

00:05:27.000 --> 00:05:41.000
My vision of what you can do with a quantum computer and how to approach that. And I chose this title, what should quantum supercomputers compute

00:05:41.000 --> 00:05:46.000
Because I think there is a great

00:05:46.000 --> 00:05:57.000
promise in using quantum computers, AI and HPC. But of course my focus will be mostly on quantum computing and quantum algorithms.

00:05:57.000 --> 00:06:15.000
But before I continue with this, I want to tell you a little bit a story about technology scientific discovery and commercialization. And I want to go back to 1674 to be pre

00:06:15.000 --> 00:06:33.000
Couple of centuries back to the Netherlands in Delft, where there was a gentleman called Antoni van Leymanoek, and you see him sitting here, and he was a merchant in class. He was not at all a scientist. But for his own amusement, he made a microscope

00:06:33.000 --> 00:06:45.000
And you can see here a picture of that microscope where the sort of the lens is really where I'm pointing at here. There's a tiny little lens which he he made himself

00:06:45.000 --> 00:06:58.000
And this was really a big feat of craft ship because this microscope was magnifying 300 times better than any microscope around it at the time.

00:06:58.000 --> 00:07:15.000
And so what this I'm telling you do with this microscope? Well, he started to play with it. He started to put all kinds of things under it, under the lens and looked at it. I won't tell you exactly what kinds he tried, but one of the things he tried was

00:07:15.000 --> 00:07:20.000
drop water, a clear drop of water from the pond behind his house

00:07:20.000 --> 00:07:31.000
And he wasn't expecting to see anything. But to his bewilderment, he could really see what nobody had seen before. And he saw something that looked like this

00:07:31.000 --> 00:07:35.000
We saw little animals crawling around in this

00:07:35.000 --> 00:07:40.000
clear drop of water, and you actually make pictures of it

00:07:40.000 --> 00:07:50.000
And this is what it looked like according to him. And nobody believed him at the time that these things were actually in the water.

00:07:50.000 --> 00:08:05.000
But they were. And he called them little animals in Latin. He called them Animalculus but now we know they are microorganisms, they are bacteria, protozoa, algae

00:08:05.000 --> 00:08:11.000
And this was really very important discovery because this was the birth of microbiology

00:08:11.000 --> 00:08:23.000
And then, of course, this opened up a whole lot of possibilities, mainly it led into industrial advantage and unlocked advances in medicine, agriculture

00:08:23.000 --> 00:08:26.000
food production, biotechnology, etc.

00:08:26.000 --> 00:08:30.000
And so why am I telling this story? Because there are

00:08:30.000 --> 00:08:38.000
kind of three phases that you have to go through. And the first phase was that you had to get better equipment, better hardware

00:08:38.000 --> 00:08:40.000
And then

00:08:40.000 --> 00:08:51.000
Antonio went through this scientific discovery phase, this plane with the machine, with the microscope in this case. And then a bit later came industrial dynamics

00:08:51.000 --> 00:09:08.000
And with quantum computers, it's exactly the same thing. So we at Continium, and not only we, but certainly we also are working on better hardware. And here you can see the roadmap that we have laid out for the coming years. We are now

00:09:08.000 --> 00:09:16.000
In 2025, where we have available online Helios, which is about 98 qubits

00:09:16.000 --> 00:09:29.000
And what is important is that the physical two-qubit error is small, is less than 5 times 10 to the minus 4. So that means that you can

00:09:29.000 --> 00:09:31.000
roughly

00:09:31.000 --> 00:09:37.000
10 thousands to 5,000 gates with and still get a meaningful answer out.

00:09:37.000 --> 00:09:44.000
And then, of course, you can add error correction and fault tolerance to it, so in this case, error correction to

00:09:44.000 --> 00:09:55.000
Even more stable qubits, then you get fewer of them. It's called logical qubits. Then in 2027, so next year, and this is already up and running in our labs

00:09:55.000 --> 00:10:00.000
We doubled the number of qubits, we even make the error smaller

00:10:00.000 --> 00:10:19.000
And then in 2029, we will unveil Apollo, which will have thousands of qubits. And then in 2023, we will have Lumos, which has about a million qubits. And so this is sort of the roadmap that we have laid out. And by the way, we have H1 and H2

00:10:19.000 --> 00:10:21.000
I will say a little bit about it

00:10:21.000 --> 00:10:24.000
But

00:10:24.000 --> 00:10:38.000
Going back to the story of Van Leenhoek, we are making better hardware. So now we are in the phase where we have to play with it, where we are in the scientific discovery phase and then much later, industrial advantage comes

00:10:38.000 --> 00:10:50.000
And my bosses wants to have this industrial advantage to be as forward as possible. And I'm a scientist and I want to

00:10:50.000 --> 00:10:58.000
As much fun as possible in this space. I guess we are all neuroscientists, so we probably agree with me on that.

00:10:58.000 --> 00:11:13.000
So we are in this space, in the scientific discovery phase, and I hope, and I expect also that with this new device, we can see things that we couldn't see before, or rather compute things that we could not compute before. And we really

00:11:13.000 --> 00:11:28.000
Here in the realm with 98 qubits, where you cannot simulate this anymore on a classical computer. It's just simply too big of a state vector if you want it to simulate that. And so the goal is to find algorithms and applications

00:11:28.000 --> 00:11:33.000
that can do something meaningful and something interesting

00:11:33.000 --> 00:11:46.000
Okay, so I have to say a little bit about continuum, because that's where I work. We are a company that makes qubits, quantum computer that's based on trapped ions

00:11:46.000 --> 00:12:01.000
And each ion in itself is perfect and identical. And these ions, they carry the qubits, a suitable photon ground state and an excited state form the 0 and the one

00:12:01.000 --> 00:12:03.000
Of these ions

00:12:03.000 --> 00:12:18.000
And here you can see our device, H2. It's based on a quantum charge coupled device. And so we're pushing around these ions which have charge. And you can see here a

00:12:18.000 --> 00:12:34.000
A real life movie of the ions moving around in our trap. So our ions are not fixed at a certain location, but they can move around, and they can also overtake each other, but they can switch places. And then the goal is that if you want to do an operation on two qubits

00:12:34.000 --> 00:12:50.000
You first bring them together or letting one overtake the other so that they're next to each other, and then you move them into these gate zones, these gray areas that you see here. These are gate zones. And once you move these ions in there, you can hit them with a laser poles, and then

00:12:50.000 --> 00:12:53.000
That effectively does an operational

00:12:53.000 --> 00:13:05.000
a CNOT gate, or actually in our case, it's a ZZ gate. Or you can have one ion in there and do a single rotation under heat. So this is… this is how it operates

00:13:05.000 --> 00:13:13.000
I'm computer scientist, so for me, this looks like complete nonsense, but it actually does work

00:13:13.000 --> 00:13:14.000
Come forward

00:13:14.000 --> 00:13:31.000
Yeah, so it has very low error. That's the lowest error in the industry. Another thing that we can do is we can, in the middle of the computation, we can do a measurement. By the way, you also do a measurement by qubits in this zone and hitting it with another laser and see what light comes back.

00:13:31.000 --> 00:13:46.000
That then measures these qubits, and we can do mid-circuit measurements. So while the algorithm is still running, we can measure a few of these qubits, see what the answers are, and depending on the answer, change what the next gates are going to be

00:13:46.000 --> 00:13:58.000
operated on the remaining qubits. And even the qubits that are measured can be put back into the computation and have to be initialized to zero

00:13:58.000 --> 00:14:13.000
So then, about a year ago, we unveiled Helios, which is the current best model, which has 98 qubits and still has even higher fidelity, so it has lower error than the previous one

00:14:13.000 --> 00:14:29.000
You saw, and the layout of this one is slightly different than this racetrack that we had. It is kind of it has one big ring where the ions can move around as before and then we have these two legs

00:14:29.000 --> 00:14:46.000
that you see here, and then the ions can sort of be shuttled out, and the ions that need to be together can be shuttled out in the right amount in the right time, so that they exit one after the other. And then here are these gate zones again. We have eight now

00:14:46.000 --> 00:14:48.000
And then they enter these gate zones

00:14:48.000 --> 00:14:58.000
Again, the same principle lets us hit them, and then they fed back into this ring and they circle around again, and they exit again in the right order.

00:14:58.000 --> 00:15:04.000
So this is how we operate, by the way, our ions are

00:15:04.000 --> 00:15:22.000
Barium at the moment, and we have another iron that sits always next to it, so there's really a little crystal, and the other one, the ytterium ion is there to cool down system. These ions, they heat up when you do these operations on them

00:15:22.000 --> 00:15:38.000
And when they heat up too much, they lose their quantum information. So you don't want that. So you want to cool them down. But if you cool them down, you might also change the state of the iron and thereby lose the information. And so what happens is that you cool

00:15:38.000 --> 00:15:55.000
It's… it's neighboring and now we have no neighboring ion and then that by sympathetic pulling force to the one next to it

00:15:55.000 --> 00:16:01.000
Without this survey, it's quantum information. It's internal state.

00:16:01.000 --> 00:16:04.000
And here you see an actual picture from the trap

00:16:04.000 --> 00:16:12.000
That we have. Unfortunately, I cannot show the moving irons anymore, but these are the ions in our trap

00:16:12.000 --> 00:16:16.000
at some snapshot.

00:16:16.000 --> 00:16:32.000
So these are the three models that you've seen actually and then talk about H1, which was just the line. Then we have this racetrack, and then we have this funny-shaped thing. The next one over, which is sol is now a square lattice. So you can sort of see that

00:16:32.000 --> 00:16:47.000
Needless is somehow in between the racetrack and the square lattice. We sort of practiced a little bit with this crossover point, where ions can cross over from one track to the other. The next one is really a grid track, where

00:16:47.000 --> 00:17:03.000
We have gate zones at the end of the trap, and these ions can actually move around and make these sharp images that you can see the sharp turns that you can see here. And this, again, is a footage of a real experiment.

00:17:03.000 --> 00:17:18.000
Let me show you a little bit how a circuit runs on our machine. Imagine that this is the circuit that you want to run. So you have three qubits at play. I color coded them red, green and blue, and that you want to do Hadamar and a Hadamar

00:17:18.000 --> 00:17:31.000
On the green and the red, and then you want to do a CNOT from the red to the green, a CNOT from the red to the blue, and then you do a measurement

00:17:31.000 --> 00:17:42.000
So it starts out with the three ions over here, and by the way, these gray areas are the gate zones. And as you can see, we want to do a Hadamar

00:17:42.000 --> 00:17:48.000
On the green one and on the red one, so that means that you hit them with that laser and the instantiate the

00:17:48.000 --> 00:17:51.000
The blue one to zero

00:17:51.000 --> 00:17:54.000
So now the next thing

00:17:54.000 --> 00:18:10.000
These are the Harder marks. So the first one was initialization. The second time step is now doing the Harder on the red one and the green one. And now we want to do a CNOT right from the red one to the green one

00:18:10.000 --> 00:18:27.000
Over here, which means that we have to bring the green one and the red one next to each other, so we can actually move it over into this so that they're now together in the same gate zone. And then we apply another laser pulse to it, which actually does this CNOT

00:18:27.000 --> 00:18:43.000
And now we want to do a CNOT between the red one and the blue one. So we move over the red one over the green one and we move to the blue one and we hit it with a laser again. So now we have done the whole circuit and then we do a laser pulse

00:18:43.000 --> 00:18:54.000
To measure this particular qubits. And this is how it acts in our machine, of course, much faster than I just did and also with all these gate zones in parallel

00:18:54.000 --> 00:19:07.000
But I find it really amazing that this actually works, that this does something. And I will show you some results that we have

00:19:07.000 --> 00:19:15.000
So, of course, the question is, what on earth can you compute with this machine that you couldn't already compute on a classical computer? And this has been

00:19:15.000 --> 00:19:30.000
haunting me since the mid 90s, and I still don't… I mean, have a little bit of an answer, but I don't have the full answer here. But first, I want to tell you the story of complexity theory a little bit, and how

00:19:30.000 --> 00:19:47.000
Weak complexity theorists looked at the world, and the way we looked at the world was we looked at the worst case analysis for a particular problem. So if you have a computational problem that you want to solve, then one measure that you can attach to that, sort of the time it takes to solve this problem

00:19:47.000 --> 00:20:02.000
It's by looking at the hardest instance among all the instances, and say, I have an algorithm that minimizes the time it takes to solve the hardest instance among all the instances. And that gives you a guarantee on the running time

00:20:02.000 --> 00:20:07.000
Always, right? No matter what instance you put into the algorithm, it will never run more than

00:20:07.000 --> 00:20:10.000
the time it took to run on the hardest, just by definition.

00:20:10.000 --> 00:20:14.000
And that way we have developed algorithms for a long time

00:20:14.000 --> 00:20:26.000
But that may be not a good measure because it might be that the hardest incidence is not the instance that you're interested in at all, but that there is an instance that can be solved much faster

00:20:26.000 --> 00:20:44.000
But isn't the hardest one, and you only care about solving this particular instance and not about this exotic instance that's sort of out there, that you never encounter. So, what we need to do is to look at what people call heuristics, and we need to have a quantum version

00:20:44.000 --> 00:20:53.000
Of this heuristics, we need to argue about special typical instances, and what are the best algorithms for these instances.

00:20:53.000 --> 00:21:10.000
Now, this is, of course, difficult, and in practice, what we have been doing, and by the way, AI is an example of this. Like, if you look at what AI can do, if you model that as a problem, and you look at the worst case instance for that problem

00:21:10.000 --> 00:21:19.000
AI should never be able to do what it is doing now. And it's able to do what it's doing now, because it only works for specific instances. It doesn't work for the worst case.

00:21:19.000 --> 00:21:25.000
And so how does AI work? Well, we had a bit of computer and we could run it and we could play with it.

00:21:25.000 --> 00:21:39.000
So this is what we need to do with the quantum computer as well. And the machines that are coming out are almost and are suitable to do that and we need to have a look at better ones. But we also developed a theory

00:21:39.000 --> 00:21:46.000
The reason about this quantum heuristics and there is a definition here that I want to throw out

00:21:46.000 --> 00:22:00.000
Maybe because I think it's we have a very, we have a paper that makes this all precise, but I think it's very important to have a name for these instances, and these instances, I call them queasy, or we call them queasy

00:22:00.000 --> 00:22:15.000
Where QEEZI stands for on one hand, quantum easy, and on the other hand, classical algorithms feel queasy. They cannot solve this problem very well. And so the queasy instances are the instances for a particular problem where we have

00:22:15.000 --> 00:22:34.000
Fast called an algorithm for which there does not exist a fast classical algorithm. And we made this all precise using ideas from Kohmo-Gorge complexity and insert complexity. I won't go into details, but at least this gives you a little bit of a handle to reason about these

00:22:34.000 --> 00:22:37.000
And so the intuition is the following

00:22:37.000 --> 00:22:46.000
Here I have a problem called satisfiability. Who of you have heard of satisfiability as a computational problem?

00:22:46.000 --> 00:22:48.000
No worries

00:22:48.000 --> 00:23:02.000
Only one, two, two people. Oh, very good. Well, not very good. Because I wanted to skip over this. The satisfiability is an optimization problem

00:23:02.000 --> 00:23:14.000
It's a famous optimization problem in computer science, and the question is, I give you a formula with variables and end and or clauses and not

00:23:14.000 --> 00:23:25.000
And so a big formula, and then the question is, can you find an assignment to the variables which are Boolean, which can be 0 or 1, such that this formula evaluates to true

00:23:25.000 --> 00:23:36.000
And this is sort of a very famous problem which is called NP complete. And what does that mean? It means that we

00:23:36.000 --> 00:23:54.000
Don't have that fast algorithm for this, but we would love to have a fast algorithm for this. And there are many, many other problems that are NP-complete that have the same property as satisfiability. We would love to have a fast algorithm for them, but we don't. We only have exponentially slow algorithms for this

00:23:54.000 --> 00:24:03.000
And they're NP complete because if you can solve one of these problems efficiently, then all the others are also solvable efficiently.

00:24:03.000 --> 00:24:17.000
Maybe you've heard of the troubling salesman problem or hacking problems. And there's hundreds of thousands of problems out there that like, for example, computing the train schedule for the train, an optimal train schedule is also an example of this

00:24:17.000 --> 00:24:28.000
So to think of satisfiability as whatever your favorite hard problem is, by the way, solving ground states for classical Hamiltonians is also one that you can

00:24:28.000 --> 00:24:38.000
refuse equivalent of satisfiability. And so satisfiability has instances in them that are hard, and instances in them that are easy.

00:24:38.000 --> 00:24:58.000
That you can solve classically easily. And these are what we solve every day on our computers. And then there is this new region now the queasy instances which I have shown here. And typically the analysis of satisfiability would go to the worst case

00:24:58.000 --> 00:25:06.000
to the hardest instances, so that we'll be focusing on this red area, whereas I think we shouldn't focus at the red area, we should focus at this purple area.

00:25:06.000 --> 00:25:18.000
And so here's another example factoring, which I guess you know given the number factored in its prime vectors, for which we do have

00:25:18.000 --> 00:25:32.000
a fast quantum algorithm due to Peter Shor, but we don't have a classical algorithm. So all the all the instances that are not easily solvable on a classical computer are crazy instances.

00:25:32.000 --> 00:25:36.000
Okay, so this is a little bit

00:25:36.000 --> 00:25:47.000
Computational complexity theory. But of course, I want to tell you what can you do with this new hardware? What are the problems that we are trying to solve?

00:25:47.000 --> 00:25:48.000
And

00:25:48.000 --> 00:25:55.000
There are two routes really to this quantum advantage and useful scientific applications

00:25:55.000 --> 00:26:03.000
And one route is bottom up. Start with a funky quantum algorithm or a quantum trick

00:26:03.000 --> 00:26:20.000
And then and then see where that leads you to. And the other is top-down. Start with a problem that you already wanted to solve, or maybe are already solving classically, and then see if there's somehow a subroutine in there, or maybe the whole problem itself that could

00:26:20.000 --> 00:26:35.000
It could be replaced by quantum algorithm and then try to massage this content algorithm so that overall the whole complexity of this algorithm is better than what you had before.

00:26:35.000 --> 00:26:40.000
So the bottom up, and actually I want to argue that

00:26:40.000 --> 00:26:55.000
We focus a lot on the top down and we should maintain doing that, but we should also focus on the bottom up, which we are not doing so much. And so the bottom up really starts with discover quantum native, primitive

00:26:55.000 --> 00:27:12.000
Try to do some resource estimate and validate it on hardware. And then see if you can find the use case that it sort of can help or that it can solve. Or maybe it gives you a completely new use case that nobody ever thought of that you can solve

00:27:12.000 --> 00:27:20.000
And I want to give you three examples of this. The first one is complement sampling, which I've been working on myself

00:27:20.000 --> 00:27:35.000
And I'm quite excited about it. And then the other two are quantum topological data analysis and interacting electron dynamics. I want to show each of these how we work with them on continuum

00:27:35.000 --> 00:27:40.000
And then the top down really you start with an existing use case

00:27:40.000 --> 00:27:55.000
You do resource estimates and look at an end-to-end workflow that is classical and see what part of it you can make quantum, and then you validate small examples on hardware and try to, as the hardware grows, you try to make this

00:27:55.000 --> 00:28:03.000
These algorithms bigger and bigger until hopefully at some point they will actually outperform the best classical algorithms.

00:28:03.000 --> 00:28:20.000
And examples here are many, for example, material design, quantum chemistry, optimization, product design, and there's really a big list of potential use cases that people look at. But I want to focus on this part here, on the

00:28:20.000 --> 00:28:31.000
The bottom up. And by the way, the whole field started with this bottom-up approach because the field started with an algorithm of David Deutsch, actually not far away here from here in Oxford

00:28:31.000 --> 00:28:36.000
Which just did the very silly thing, could compute the parity of

00:28:36.000 --> 00:28:53.000
through Boolean variables with just one query, whereas classically you need two, and then that the Deutsch and Richard Josa to come up with a problem that is called the Deutsch-Jose problem, and then that led eventually to Peter Shor's

00:28:53.000 --> 00:29:05.000
But Peter Shore didn't start with factoring and worked his way back to the Deutsch Jose and Deutsche's problem. It went the other way. It started with some

00:29:05.000 --> 00:29:11.000
freaking funny content algorithm that was better than classical. And then that led to an application

00:29:11.000 --> 00:29:16.000
And I want to sort of focus more on that.

00:29:16.000 --> 00:29:31.000
And of course there's going to be interplay between these two. And all of this is sort of within the back of my mind. I want to hunt for these squeezy instances because those are the ones that are actually interesting for a quantum computer

00:29:31.000 --> 00:29:45.000
And then, because the talk is also a little bit about how AI works, we really use AI whenever and wherever we can. And I guess you guys are doing that probably too, because it's getting so, so good and so smart.

00:29:45.000 --> 00:29:48.000
You can use it for almost anything

00:29:48.000 --> 00:29:56.000
Maybe next time I won't be standing here anymore. but hopefully for for a little while I can still enjoy it

00:29:56.000 --> 00:30:14.000
And here you see that in a picture. So the top down is you start with no use cases and you sort of map it onto existing quantum algorithms. The bottom up is to start with sort of funny quantum algorithms and see

00:30:14.000 --> 00:30:34.000
Where they lead to. And for these 2 Hamiltonian simulation and qtva, we already found some use cases, and for complement sampling, we are still looking, and I sort of see it as sort of a sort of an approach where you can now, when you do the top down, you can reach other use cases that that you would actually miss if you were starting

00:30:34.000 --> 00:30:37.000
From the top down

00:30:37.000 --> 00:30:38.000
Fair enough.

00:30:38.000 --> 00:30:44.000
By the way, if you have any questions, then please stop me

00:30:44.000 --> 00:30:52.000
So I want to talk a little bit about complement sampling, which appeared earlier this year in PRL

00:30:52.000 --> 00:31:00.000
We got done with these people and Benedetti and Beckermans

00:31:00.000 --> 00:31:02.000
And here's the idea. So this

00:31:02.000 --> 00:31:11.000
So I'm just telling you something that I found study and we can hopefully find some good applications of this. So the idea is the following

00:31:11.000 --> 00:31:16.000
I start with the probability distribution d. One

00:31:16.000 --> 00:31:20.000
And I want to produce a distribution d2.

00:31:20.000 --> 00:31:30.000
And the rules of the game are the get one sample from distribution b1.

00:31:30.000 --> 00:31:36.000
And then I can compute, and then from that, I have to produce a sample from distribution D2.

00:31:36.000 --> 00:31:45.000
For example, and this is very, very well studied in computer science, are start out with the uniform distribution

00:31:45.000 --> 00:32:00.000
And then I feed that into a circuit, classical polynomial time circuit, efficient circuit. And then what comes out is a sample from distribution D2. And this is all these distributions that you can make this way are called

00:32:00.000 --> 00:32:19.000
efficiently computable distributions. So it's very easy to get a uniform distribution, and with a little bit of effort, you can get all these other distributions out of it. So this is a paradigm that's very well, very well studied

00:32:19.000 --> 00:32:21.000
That's where it stops.

00:32:21.000 --> 00:32:27.000
Let's see

00:32:27.000 --> 00:32:50.000
Seems to be frozen.

00:32:50.000 --> 00:33:20.000
Podcast.

00:33:36.000 --> 00:33:43.000
Yeah, sorry about that. Don't know why that happened. Okay, so

00:33:43.000 --> 00:33:56.000
And I want to compare this classical setting where you have to sample from this solution V1 produces sample from this solution. But the quantum one where quantum sample is a coherent superposition

00:33:56.000 --> 00:34:08.000
The strings in d1. Quantum sample looks like this state where you have superposition over all the strings in S

00:34:08.000 --> 00:34:24.000
And the dx squared is the probability of observing X. So it's a simple way of representing the distribution in a coherent way. And by the way, if you give this to a classical person, the only thing it can do is measure it

00:34:24.000 --> 00:34:30.000
And it will get the sample with according to distribution d

00:34:30.000 --> 00:34:35.000
By the way, are you familiar with this notation?

00:34:35.000 --> 00:34:39.000
sort of these tricks

00:34:39.000 --> 00:34:40.000
Okay, so

00:34:40.000 --> 00:34:45.000
The goal is the following. So suppose that I give you a distribution

00:34:45.000 --> 00:35:00.000
I have a set that contains half of the elements of all the elements of all the 2 to the end elements that I have of length length N. So I have a universe universe, and I have a set that sort of splits the universe perfectly in half

00:35:00.000 --> 00:35:05.000
But I don't know how I only know that explicitly enough

00:35:05.000 --> 00:35:14.000
And I have a unit in my distribution d1 is uniform over all the strings in this first half

00:35:14.000 --> 00:35:23.000
And the goal is, given a sample from the first half, produce a sample from the complement, from the half that doesn't have any support.

00:35:23.000 --> 00:35:27.000
So, in a game that looks like this, we have a referee

00:35:27.000 --> 00:35:33.000
That chooses a random set from all the sets that have had the universe

00:35:33.000 --> 00:35:38.000
And then it gives a classical player a sample Y from S

00:35:38.000 --> 00:35:45.000
And then the classical player, having seen y, has to produce a string y that's not an S

00:35:45.000 --> 00:36:00.000
Now, this is extremely difficult. For example, if the strings 0, sorry, 1, 2, 3, 4, 5, 6, 7, 8, so I have eight strings in total, and my set s is the first half. So it's one, two, three, and 4.

00:36:00.000 --> 00:36:03.000
5, 6, 7, 8 are the complement

00:36:03.000 --> 00:36:12.000
But you don't know that it is 1, 2, 3, 4. And now what you get is you get a string from S, say 3. And now the goal for you is to produce

00:36:12.000 --> 00:36:16.000
Either 5, 6, 7, or 8

00:36:16.000 --> 00:36:33.000
Now, since you don't know what the set is, the best thing you can do is produce a random string that's not the one that you saw. The one that you saw for sure is not correct. And all the other ones are equally likely, as far as you know, to be an S or outside of S. So you just pick one at random

00:36:33.000 --> 00:36:38.000
And then that, with probability slightly better than a half, gives you the right answer.

00:36:38.000 --> 00:36:54.000
It's hard classically, and you can prove very easily that the best thing you can do is really pick a string y prime that is not the one you got and give that back. And that is correct with probability half plus 1 over 2 to the end

00:36:54.000 --> 00:36:56.000
Basically, you have slightly better than

00:36:56.000 --> 00:37:09.000
Now, quantumly, and by the way, it's very efficiently verifiable for the referee whether the string he receives back is correctly not in S order.

00:37:09.000 --> 00:37:11.000
Because he knows what S and what SR is

00:37:11.000 --> 00:37:19.000
Now, quantumly, to my surprise, actually, it turned out that there is a very efficient algorithm, and I'll show you in a minute

00:37:19.000 --> 00:37:36.000
That's the algorithm that actually can do this perfectly. So if you get coherent superposition over the strings in S, so if I give you superposition over what was it, 1, 2, 3, 4, so the sum of one half

00:37:36.000 --> 00:37:48.000
1 plus 2 plus 3 plus 4, then this algorithm that is on the next slide will produce a superposition over the other strings. And it will do this for any set S without knowing what S is

00:37:48.000 --> 00:37:54.000
So here's a circuit. It's a very simple circuit. It contains of Harder gates

00:37:54.000 --> 00:38:00.000
And Z gate, and it has in the middle here, a very big

00:38:00.000 --> 00:38:07.000
Control, control, control, not gate. And this is really a big end gate or also called the totally gate

00:38:07.000 --> 00:38:16.000
This sort of toggles this bit if and only if all these bits are 0.

00:38:16.000 --> 00:38:31.000
And now it turns out that if you put S in there, then S bar comes out on the other side. So if I put in the superposition over, for example, 1, 2, 3, 4, then what comes out here is a superposition 5, 6, 7, 8

00:38:31.000 --> 00:38:40.000
And again, no matter what the set is, the superposition of the complement will come out. It's kind of a little bit strange that it does that so well.

00:38:40.000 --> 00:38:58.000
Until my colleague observed that it's actually something that Ross started before by Grover, and maybe you… have you heard of Groffer's algorithm? So this is, like, one of the famous algorithms that came after Peter Shor that shows that you can search quadratically faster

00:38:58.000 --> 00:39:15.000
In the database, and if you look at one building block of that algorithm, that's a prover diffusion, then that what it does, it sort of reflects the amplitudes around the mean of the amplitudes, and

00:39:15.000 --> 00:39:29.000
Flops them around. So here we have a superposition over all the strings in S and all the strings not in S don't have any amplitudes. And then one rover iterate or one Grover diffusion actually

00:39:29.000 --> 00:39:42.000
makes these guys all diffused to zero, whereas the zero ones get diffused to what the amplitude of the original ones were. And so one step really

00:39:42.000 --> 00:39:48.000
If all the amplitudes now to the to the other strings.

00:39:48.000 --> 00:39:59.000
And this is basically why it works. But that's not how I discovered it. I just did the calculations and to my surprise, it did what it did

00:39:59.000 --> 00:40:02.000
So here we have this very good

00:40:02.000 --> 00:40:10.000
experiment for quantum supremacy where we have a game where we can actually find a good S,

00:40:10.000 --> 00:40:23.000
show that classically giving you a string in the complement is very hard, but quantumly, we have this easy circuit that should, in principle do it perfectly. Now there is one remaining problem, and that is

00:40:23.000 --> 00:40:33.000
This works and this hardness result really is only hard because we argued about the random set S.

00:40:33.000 --> 00:40:42.000
But it may be very difficult to produce superposition over a random set. Actually, provably, this requires an exponentially large quantum computer to do

00:40:42.000 --> 00:40:57.000
So we cannot do that. We have to only consider random or sets S that are easily generable. And we found a way to do that. But first I have to tell you that we can compute how well an experiment works by

00:40:57.000 --> 00:41:01.000
Computing how much how well

00:41:01.000 --> 00:41:11.000
The quantum computer works divided by how well the classical computer works, and how well it works means how well it can do better than a half.

00:41:11.000 --> 00:41:23.000
And quantumly, we saw that classically, we saw that it can only do 1 over 2 to the n better than a half. And quantumly, we saw that it can do perfect in theory. So that's one half better than a half.

00:41:23.000 --> 00:41:35.000
And so this ratio becomes in the perfect case, 2 to the n minus 1. It's an exponential violation of sort of classicality

00:41:35.000 --> 00:41:49.000
And we also came with a good idea. And by the way, we used the help of AI here. We came with the family of easily computable sets S that can be implemented physically

00:41:49.000 --> 00:41:59.000
And then still have this classically hard property. So you don't need to compute a very difficult S

00:41:59.000 --> 00:42:06.000
And then, of course, now that the proof is in the coding, we implemented this whole thing on our

00:42:06.000 --> 00:42:07.000
Quantum computer

00:42:07.000 --> 00:42:22.000
And this is what I find really amazing. So now imagine that we implement this on these ions that are moving around and that go into these gate zones. And we implemented this algorithm. And here's what happens. And so focus on this appeared a couple of weeks ago in Nature Communications. And this is

00:42:22.000 --> 00:42:26.000
This line here is the optimal

00:42:26.000 --> 00:42:29.000
sort of ratio that you can have

00:42:29.000 --> 00:42:39.000
when there's no errors in the machine, and we sort of were able to go up to strings of length 35, or even a little bit bigger, and we get almost perfect

00:42:39.000 --> 00:42:46.000
fit with this optimal exponential violation

00:42:46.000 --> 00:42:51.000
And you see that it's starting to filter off here a little bit because of the errors in the machine

00:42:51.000 --> 00:43:06.000
So we need… as the inputs become bigger, you need more and more gates, and as the arrows start to accumulate, but still up to 35, we could get a violation which is of order 2 to the 35. It is exponential in this number

00:43:06.000 --> 00:43:09.000
You get an exponential advantage here

00:43:09.000 --> 00:43:12.000
And it's verified

00:43:12.000 --> 00:43:29.000
What we're doing now is trying to find the applications of this. So this is like a funky, nice quantum algorithm. What it can do, we don't know yet. We found some applications in cryptography, and we're searching at the moment for other applications

00:43:29.000 --> 00:43:34.000
This is what I wanted to tell you about complement center. How much time do I

00:43:34.000 --> 00:43:39.000
still have I can talk a little bit more, right?

00:43:39.000 --> 00:43:42.000
The other is

00:43:42.000 --> 00:43:46.000
About quantum topological data analysis

00:43:46.000 --> 00:43:51.000
And this is a team of Adam Connolly at Continium who's doing that

00:43:51.000 --> 00:43:58.000
And the goal here is the following. If you have data that can be represented as a graph

00:43:58.000 --> 00:44:14.000
For example, interaction of people in interaction graph, or in biology, which molecules interact with another molecule in the cell, then you can represent that as a graph, and a graph as nodes

00:44:14.000 --> 00:44:20.000
objects, and which ones are connected, or which ones interact with each other, and they have an edge between them

00:44:20.000 --> 00:44:36.000
Now, this is very useful object to study and to analyze, but there's actually more information in this data than just this interaction between individuals, individual nodes. And this is what topological data analysis

00:44:36.000 --> 00:44:52.000
tries to extract from the data. The idea here is that instead of looking at this point and just this node and edge relationships, look at subsets of nodes and how they are connected to other subsets of nodes

00:44:52.000 --> 00:45:01.000
And note now that this object becomes much bigger, like a ground has only n nodes and at most n squared edges, so you can

00:45:01.000 --> 00:45:05.000
Right? Any graph has a big matrix where you put the notes

00:45:05.000 --> 00:45:12.000
on one side and on the other side, and at position IJ, you put the 1 if i interacts with J

00:45:12.000 --> 00:45:27.000
Now, if I want to know something about this higher dimensional structures, what happens if K nodes, and how do we interact with K other nodes? My object becomes much larger, it becomes of size n to the k by n to the k.

00:45:27.000 --> 00:45:34.000
And if K grows like order n over 2, then this is an exponential by an exponential large matrix.

00:45:34.000 --> 00:45:50.000
But it does have this information in there. And by the way, if you have these matrices, then often all the information is in the eigenvalues of this matrix, and that's also the case in topological data analysis

00:45:50.000 --> 00:46:01.000
As you can imagine that either you miss this higher dimensional structure because you don't look at these subsets of k and other subsets of k

00:46:01.000 --> 00:46:08.000
Or it takes a tremendous amount of time to compute this, because then you have to analyze this huge matrix

00:46:08.000 --> 00:46:22.000
So here is what I already described. So this Laplacian matrix is this n to the k by n to the k size matrix. So this huge object that whose eigenvalues you actually want to know, and they tell you

00:46:22.000 --> 00:46:31.000
What the topological structure is of this data that you have at hand. And

00:46:31.000 --> 00:46:34.000
So it grows exponential, but

00:46:34.000 --> 00:46:48.000
We have developed a quantum algorithm that doesn't have to compute this whole big structure. It can somehow in superposition with some very nice tricks, access this data, and efficiently get some version of this

00:46:48.000 --> 00:46:52.000
higher dimensional features out of the data

00:46:52.000 --> 00:46:58.000
And this is what we call quantum topological data analysis. And here you see

00:46:58.000 --> 00:47:10.000
sort of a schematic of on the top, you see the classical algorithm that sort of it doesn't really matter how it works, but this is important here if you want to figure out

00:47:10.000 --> 00:47:21.000
What's this eigenvalue is? So this is lambda. That's the thing that you're trying to assess. Then the shot count grows exponential in one over lambda.

00:47:21.000 --> 00:47:24.000
So the classical algorithms

00:47:24.000 --> 00:47:40.000
exponential in 1 over lambda, whereas the quantum circuit that we developed runs linear in one over lambda. So there is an exponential difference in runtime in order to figure out what this lambda is. That is the thing that tells you

00:47:40.000 --> 00:47:42.000
This higher dimensional structure.

00:47:42.000 --> 00:47:58.000
And actually, it's kind of not as nice as I say here, because we don't get this lambda output, we get a normalized version. And we also don't get a normalized version. We get an approximation to that because there's errors. This algorithm isn't perfect. But it

00:47:58.000 --> 00:48:06.000
And sort of a piece of this lambda piece of the cake that you couldn't get before

00:48:06.000 --> 00:48:17.000
And actually, it turned out also that we're not really computing this lambdas or these Betty numbers themselves, but

00:48:17.000 --> 00:48:32.000
calculate moments of this Laplacian. doesn't really matter. But there is sort of properties that you can get out that resemble topological data analysis that that we can actually get from our machine

00:48:32.000 --> 00:48:39.000
And so we applied this to a use case together with SoftBank in Japan

00:48:39.000 --> 00:48:49.000
And the idea was that maybe we can get from their telephone call representation data, we can maybe use this higher dimensional

00:48:49.000 --> 00:48:53.000
features to see if there's fraud or not fraud.

00:48:53.000 --> 00:49:10.000
So here, and actually it kind of worked because you see that the blue line is what you sort of get with sort of are the normal data points, whereas these orange ones are the fraudulent ones. And you can see that the topological

00:49:10.000 --> 00:49:16.000
Information is different in these two. So this higher dimensional features

00:49:16.000 --> 00:49:29.000
are able… enable you to tell fraudulent data points from non-fraudulent parts. There may be other methods, by the way, that do the same thing. The point here is that this particular

00:49:29.000 --> 00:49:32.000
method also works

00:49:32.000 --> 00:49:46.000
And so then you can imagine that these features, these topological features, you feed them into some other machine learning or AI technique, which then has extra information about the data, which then can then hopefully better classify

00:49:46.000 --> 00:50:01.000
What it can do. Again, this is an example of bottom-up because we started with this funny quantum algorithm that didn't really compute exactly what we wanted, but some approximation of an approximation of something that resembled it. But it's cool

00:50:01.000 --> 00:50:07.000
We don't know how to calculate the classical, and it turns out that it actually is useful for something.

00:50:07.000 --> 00:50:14.000
And we're also trying this on other sets of data, for example, biological data sets to see whether it can help us.

00:50:14.000 --> 00:50:30.000
Of course, it will become only very interesting when we can compute it on our… when we can use this on our bigger machines, where you cannot simulate anymore. Currently, these data points can still be simulated on a classical computer, but as the quantum computer grows

00:50:30.000 --> 00:50:35.000
We will be able to see or compute things that we couldn't compute before.

00:50:35.000 --> 00:50:47.000
And so this is kind of our pipeline where we have the classical algorithm, which is called coal, which up till now, this is all the data that we got was computed with coal, can compute

00:50:47.000 --> 00:51:04.000
classically, up to a certain point how well it works and what the data does. And then, whenever Cole finds something interesting, then we can sort of run it on bigger instances and hopefully reap the benefits that they're

00:51:04.000 --> 00:51:10.000
Then finally, I want to tell you a little bit of simulation of physics, which I guess is actually closest

00:51:10.000 --> 00:51:15.000
to what what you guys are doing, so maybe I should have focused more on that.

00:51:15.000 --> 00:51:22.000
And the example here is high temperature superconductors

00:51:22.000 --> 00:51:39.000
And these are really of interest to many, many people, maybe even to guys use some would be beneficial to have these. I don't know if you're a particle physicist. But I mean, there's many companies who want that, for example, nuclear fusion, nuclear

00:51:39.000 --> 00:51:41.000
magnetic resonance, etc.

00:51:41.000 --> 00:51:54.000
And sort of the way it works is that you have this objects which are atrium barium copper oxide, and you sort of sprinkle them in certain

00:51:54.000 --> 00:52:07.000
way, and then if you do that in the right amounts, it's kind of almost like magic, then they become superconducting. But nobody understands exactly how and why, and with this one, it was recently found

00:52:07.000 --> 00:52:23.000
that if you shine some light on this object, then for a very short amount of time you get superconductivity. But it's not stable. It's only for very short amount of time. And actually, nobody really understands why

00:52:23.000 --> 00:52:31.000
So that… but there are some competing hypotheses why this is the case. I just want to show you an example.

00:52:31.000 --> 00:52:45.000
Of how we can use a quantum computer to distinguish these hypotheses. So if we can figure out which one is correct, that can maybe help us understand why the superconductivity happened, and maybe we can make it stable for longer periods of time.

00:52:45.000 --> 00:53:04.000
And amongst its hypothesis postulates that the superconductor is described by an extended Fermi-Hubber model. That's actually the normal way of describing these systems. But it's extended in this case, the Fermi-Hubbert model, and that the laser destroys stripe ordering that competes with superconductivity. And

00:53:04.000 --> 00:53:12.000
This is a hypothesis that we can test on a quantum computer that's difficult to test on a classical computer.

00:53:12.000 --> 00:53:27.000
And here is how the algorithm works. So here you have this extended Fermi-Hubbert Hamiltonian where this t prime term here, t prime s indicates

00:53:27.000 --> 00:53:39.000
the light that was turned on and off for a certain amount of time. And you want to now test whether you want to do the following

00:53:39.000 --> 00:53:53.000
So you prepare a room temperature state of the extended Hubwork model. So on our digital computer, we produce a state that is this. This we can do. And then we simulate this Hamiltonian

00:53:53.000 --> 00:54:08.000
And we change this parameter t over time and sort of see what the difference is when turning on T or not turning on T prime. And then we measure both superconductivity and stripe order, which is something you can also do

00:54:08.000 --> 00:54:25.000
By the way, this is how you measure that. How do we measure superconductivity? We do this by the Meissner effect. You can somehow put a current through this object all of course in digital

00:54:25.000 --> 00:54:41.000
form and measure whether this thing becomes conducting or superconducting. Oh, and the current will develop in response to the magnetic field, and then a current should come through. And if this is there, then it's a conductor, and if it's… sorry, if it's not there

00:54:41.000 --> 00:54:48.000
It's a conductor and otherwise it's a superconductor. And this you can then do on our own computer.

00:54:48.000 --> 00:55:06.000
I also want to say that about a year ago on our Helios, somehow the first steps towards such algorithms were made by this team where they were able to do this on a reasonably large grid using all our 100 qubits

00:55:06.000 --> 00:55:24.000
And I did some of these Hamiltonian simulations. And I guess for all you guys, maybe this Hamiltonian simulation is something that's very interesting. And Avery and I were talking a little bit. This is something very difficult to compute classically, and also this dynamics is very hard to compute

00:55:24.000 --> 00:55:31.000
But on the quantum computer, in some sense, this is almost what they're made to do.

00:55:31.000 --> 00:55:33.000
Okay, I'm

00:55:33.000 --> 00:55:48.000
Summarizing, so I really want to estrogate that we are in scientific discovery phase at the moment, and that this industrial applications will come a little bit later, although, of course, we're trying to bring them forward as much as we can

00:55:48.000 --> 00:56:03.000
And by the way, there is merit in working with customers to see if we can find these applications, because this way you can already find out which algorithms you have and which algorithms you can still develop and still

00:56:03.000 --> 00:56:09.000
tweak so that it actually works for these applications

00:56:09.000 --> 00:56:24.000
I also told you a little bit about quantum heuristics, how we should focus on actual instances and not on worst case instances. And I told you about queasy instances. Don't forget them. Queasy instances, cool name

00:56:24.000 --> 00:56:30.000
And then I discussed two principles, top-down and bottom-up

00:56:30.000 --> 00:56:33.000
approach to getting new quantum algorithms and applications

00:56:33.000 --> 00:56:44.000
And of course, use AI whenever you can, and I described these three examples complement sampling, quantum topological data masks. And they're acting electron dynamics

00:56:44.000 --> 00:56:47.000
simulation of Hamiltonians.

00:56:47.000 --> 00:57:00.000
And that's what I wanted to tell you.

00:57:00.000 --> 00:57:16.000
So one thing, and I missed the first couple of moments of your talk, so you may have answered it then, but I wanted to understand better how you're using sometimes hardware, sometimes simulation, what your engagement is

00:57:16.000 --> 00:57:23.000
the company that… I understand you're an academic, right, but you're working with Continuum, so how

00:57:23.000 --> 00:57:40.000
how vital is it to have that link rather than you simulating this? Classically unique? Yes, so how far… you mentioned at some point that the classical simulation could prove that some of this works, and then at some point you have to go for the hardware. What triggers you to do that at some point

00:57:40.000 --> 00:57:44.000
So that's an excellent question. So

00:57:44.000 --> 00:57:49.000
All of these problems that I discussed, they have quantum advantage

00:57:49.000 --> 00:58:04.000
Which means that at some point, when it has become a little bit larger than what we studied, or already some of them have this property, you can no longer use a classical computer to compute these properties.

00:58:04.000 --> 00:58:13.000
But the consequential methods are still very useful, because it allows you to validate on smaller instance that your computer and your algorithms are actually doing what they're supposed to do.

00:58:13.000 --> 00:58:25.000
But at some point, you cannot use your classical algorithms anymore, because they would just simply take too long, and you have to use the quantum hardware to do so. And we're currently

00:58:25.000 --> 00:58:37.000
kind of at the at the sort of the borderline where the classical can still keep up with the quantum, but the quantum is sort of soon overtaking the classical for these problems

00:58:37.000 --> 00:58:42.000
And the interaction with the actual hardware point

00:58:42.000 --> 00:58:52.000
At what point do you need to use the very best and can you get insights on how the very best would work from the less good quantum computers?

00:58:52.000 --> 00:58:57.000
You see what I mean? Can you use them to simulate the next version of themselves?

00:58:57.000 --> 00:59:21.000
Well, I mean, if you want to have more qubits… Yeah, exactly, yeah. And so you need more qubits. I suppose what I mean is, in going from classical computing to a fewer qubit machine, that presumably does get you closer, though, to understanding the larger qubit machine. Can you use the fewer qubit machine to, in effect simulate a larger machine? In a better way than the classical code.

00:59:21.000 --> 00:59:31.000
Yeah, it's a good question. There are some results where you say… where they say, suppose that you want to have 100 qubits, but you only have 99

00:59:31.000 --> 00:59:44.000
Can you simulate with the 99 and the 100 one? And you can, but there's an exponential blow up in each qubit that you add.

00:59:44.000 --> 00:59:47.000
So the answer is we went from 100 to 200

00:59:47.000 --> 00:59:56.000
You cannot simulate 200 machine with 100 qubit machine. That will cost you two to three hundred law, which

00:59:56.000 --> 01:00:03.000
too much to handle. So you can maybe get by with one or two qubits if you're lucky

01:00:03.000 --> 01:00:24.000
But really, you want to have more qubits. That's awesome. We're selling more qubits. Makes sense, of course. It's good for us. I have a second one, if I may, which is about you said use AI whenever you can. Yes. So you talked about, you know, top down or bottom-up, and I suppose, are you using AI to identify what those use cases are as well? Is it good at spotting what a good use case is?

01:00:24.000 --> 01:00:29.000
So far, I don't think it was that good at doing that. So you see a lot of

01:00:29.000 --> 01:00:35.000
of lists out there which are, to my mind, a little bit fantasy use cases

01:00:35.000 --> 01:00:41.000
What I meant more was like, if you have a particular

01:00:41.000 --> 01:00:50.000
Use case in mind, or if you have a particular algorithm in mind, you have a particular specific price, and then we use AI a lot to figure out

01:00:50.000 --> 01:00:54.000
To help us identify how to go further

01:00:54.000 --> 01:01:10.000
But maybe eventually it will be also very good. But we have a whole team, maybe let me say a little bit about that. That's the AI team that does three things. One is it uses AI for quantum. So for example, these pulses that maybe I'm not sure if you

01:01:10.000 --> 01:01:27.000
They actually focuses that we need to tune to get our qubits to actually get the right gates applied to them, optimizing these processes, we can use AI to do that. Another one is using better air quality codes, quantum aircraft codes we use AI

01:01:27.000 --> 01:01:45.000
to help us optimize that. Then there. So this is the AI for quantum. Then it's also the other way around, which is topological data analysis is kind of an example of where you can use the quantum computer to compute some classical data that you can then feed into your AI so that that becomes better

01:01:45.000 --> 01:01:53.000
So we call that quantum data. It's really classical data that comes from a quantum computer that was hard to compute classically.

01:01:53.000 --> 01:02:10.000
And then there is a loop, which we call the GenQAI loop, where they sort of perpetually fits into each other. So you produce a circuit that produces some quantum state, and you compute the properties of that quantum state. And by the way, the quantum state. On your quantum computer

01:02:10.000 --> 01:02:27.000
And then there's maybe some approximation of the ground state to some Hamiltonian. Then that feeds back into your classical AI, which then starts to compute a bit more and then produces a new quantum circuit that is run on a computer in this whole loop

01:02:27.000 --> 01:02:32.000
It's how you can envision quantum and AI all work together.

01:02:32.000 --> 01:02:51.000
And I also want to stress that, in some sense, quantum is very good because it probably cannot be simulated completely by AI. AI can do a lot of things, but I don't think it can simulate a quantum computer. At least we don't believe so. So AI and quantum are in some way orthogonal

01:02:51.000 --> 01:02:57.000
And they kind of help each other rather than competing.

01:02:57.000 --> 01:02:58.000
Great.

01:02:58.000 --> 01:03:03.000
Maybe it's a little bit of a theoretical question at the moment, but

01:03:03.000 --> 01:03:09.000
It doesn't this quantum enhanced AI have problems with GDPR and scalability models

01:03:09.000 --> 01:03:24.000
Yeah, probably. Well, we are not so sure. It depends a little bit what you put, what kind of data you put in here. Yeah.

01:03:24.000 --> 01:03:30.000
I don't think the problems are. So for example, with biological data, I don't think the problems are

01:03:30.000 --> 01:03:43.000
And more complicated than they already are with classical computers, because data is there as well. So you just have to be sure that it doesn't leak or that it's protected well enough

01:03:43.000 --> 01:03:52.000
Yeah.

01:03:52.000 --> 01:04:02.000
I don't know. I mean, I think we have already struggled with classical AI to make it explainable, and maybe we won't even succeed in doing that

01:04:02.000 --> 01:04:10.000
In my mind, we may… maybe we don't want to be able to explain what it does, but we want to be able to trust what it does

01:04:10.000 --> 01:04:26.000
And so changing the law might be easier. So we need to have verification methods that allow us to be certain or almost certain that what we got from the quantum computer or from the AI or the combination thereof

01:04:26.000 --> 01:04:40.000
Actually, it's what we wanted, that it concluded. And there are techniques, we're working on that, and there are nice techniques that you can use. And for the TDPR, there is actually something that's called blind quantum computing

01:04:40.000 --> 01:04:43.000
That allows you to compute

01:04:43.000 --> 01:04:49.000
An algorithm or data on the computer

01:04:49.000 --> 01:04:52.000
Without a quantum computer knowing what it's computing

01:04:52.000 --> 01:05:06.000
And this issue can have classically only under assumptions, like cryptographic assumptions. But in the quantum case, you can actually show that you don't need these assumptions, so that it's in some sense, perfectly secure

01:05:06.000 --> 01:05:11.000
So in some sense, quantum can even be safer to use than classical

01:05:11.000 --> 01:05:14.000
But I'm a little bit out on

01:05:14.000 --> 01:05:26.000
About the error correction you were talking about, how do you actually implement it in your existing machines and what do you anticipate the evolution being in the

01:05:26.000 --> 01:05:28.000
qubits

01:05:28.000 --> 01:05:44.000
So, the way we implemented this, I talked about this mid-circuit measurement forward at the very beginning, so in the middle of this circuit, you can measure a few qubits, and depending on what the values are of these measurements, change the gates of

01:05:44.000 --> 01:05:49.000
future qubits. This is exactly what error correction and photon computing

01:05:49.000 --> 01:05:50.000
Thus

01:05:50.000 --> 01:05:58.000
And so we actually have already papers out where we show in real time how this can reduce the error

01:05:58.000 --> 01:06:09.000
And in the future, this is the way to go because you need to have the logical error so low that you can run long algorithm.

01:06:09.000 --> 01:06:19.000
So for those who don't know, there is a threshold theorem that says if your physical error is below a certain value, then you can make

01:06:19.000 --> 01:06:28.000
You can make the error arbitrarily small by using multiple qubits as one qubit, and then look at how the error is of this particular

01:06:28.000 --> 01:06:30.000
ensemble digits

01:06:30.000 --> 01:06:41.000
And yeah, we have several proposals and ways of doing it. And in practical hardware, do you do computation in FPGAs or

01:06:41.000 --> 01:06:43.000
You take it.

01:06:43.000 --> 01:06:49.000
I think we do, actually, yeah. But now, again, that's not really my

01:06:49.000 --> 01:07:00.000
I don't know exactly well enough how they do it, but then you need… in order to do this error correction, you need to have very fast compute close to the metal for it to work

01:07:00.000 --> 01:07:16.000
Because you need from the measurement outcome, which is called the Sindler measurement that tells you what kind of error happened, you actually need to do quite some compute to figure out what that error was. So you need some classic, some heavy duty classical compute

01:07:16.000 --> 01:07:22.000
As close and as fast as possible to your quantum argument

01:07:22.000 --> 01:07:24.000
Yes.

01:07:24.000 --> 01:07:35.000
Thank you for the wonderful talk. I actually want to ask more than one question. Okay. Thank you. So first, my field is neutrinos

01:07:35.000 --> 01:07:42.000
And one thing that's very important in our field is to evaluate what nuclear effects after interaction

01:07:42.000 --> 01:07:46.000
So I wanted to ask like

01:07:46.000 --> 01:07:53.000
If quantum computers can be fast and efficient at simulating

01:07:53.000 --> 01:07:56.000
Nuclear detached

01:07:56.000 --> 01:08:06.000
I think we kind of took slow. A bit of… it depends. If your interactions are quantum mechanical in nature, which I believe they are

01:08:06.000 --> 01:08:11.000
Then quantum computer is a good tool to use.

01:08:11.000 --> 01:08:21.000
However, if your interactions are just classical or described by classical mechanics, you shouldn't use a quantum computer because it's slow and noisy and whatnot

01:08:21.000 --> 01:08:33.000
It's really a quantum mechanical description, and if it has like, for example, in quantum chemistry, if it has this strongly correlated system, so there's a lot of entanglement

01:08:33.000 --> 01:08:44.000
That is also being formatted or at play when you analyze your system, then a quantum computer is a good one to use, because it can do that. And your classical methods

01:08:44.000 --> 01:08:53.000
Or, in my terms, if your neutrino question is a crazy question, you should use quantum computer. Otherwise not

01:08:53.000 --> 01:09:07.000
I mean, Jared and I, we've been using comparative analysis for IBM and we do realize that the error rates give it error rates that continuums are much lower comparatively

01:09:07.000 --> 01:09:13.000
It just sort of acknowledged it by multiple companies announcing that they're going to also have

01:09:13.000 --> 01:09:23.000
Do you think continuum would be able to give its advantage on that? How is the competition plan looking

01:09:23.000 --> 01:09:41.000
I certainly hope so. I work for Martini, but at the moment, it's hard to predict, right? But at the moment, our machines have the highest fidelities or the lower lowest error. And we have the highest number of qubit

01:09:41.000 --> 01:09:42.000
Counts

01:09:42.000 --> 01:09:53.000
With those fidelities. For example, IBM has more qubits, but the fidelities are lower. By the way, fidelity is not the only thing that is important. It also is important

01:09:53.000 --> 01:10:00.000
The time it takes to do your computation or the throughput. And actually, continue is not that good, because it's a slow

01:10:00.000 --> 01:10:03.000
So although the fidelities are

01:10:03.000 --> 01:10:08.000
All right, and we have this other thing, this old connectivity

01:10:08.000 --> 01:10:25.000
Our machine is slow. But this all to all connectivity and lower error rates allow for sort of more efficient error quickly codes. And so overall, that is an advantage we have, and the disadvantage is speed. And, for example, Ibn has a very fast machine

01:10:25.000 --> 01:10:37.000
But these fidelities are not very good. And so now the question is, which of these two is going to win because they need to do more error correction. They don't have all connectivity, so they have to do swaps. So

01:10:37.000 --> 01:10:39.000
Without the air

01:10:39.000 --> 01:10:46.000
It's unclear which one is better, but I think that predictions are that they're about the same speed

01:10:46.000 --> 01:10:50.000
If you take everything into account

01:10:50.000 --> 01:11:06.000
But in some sense, I mean, I don't know. I mean, I surely hope that continues to stay is the winner. And if I were CEO, I would say, yes, of course, maintain it's competitive advantage

01:11:06.000 --> 01:11:21.000
If there are any questions online, please raise your hands. Can I ask the other questions as well? Thank you. So it might be like in a completely different direction, but are there like any cases where classical computers are actually faster than computers

01:11:21.000 --> 01:11:38.000
quantum computers. Oh, yes. Oh yeah, they are yeah actually almost everything you can think of. For example, if you want to do if you use your text processor or your your work program

01:11:38.000 --> 01:11:50.000
Well, you don't want to do that on a quantum computer. First of all, you don't have a lot of qubits, bits available. Second of all, it would be full of errors and would be extremely slow. So we better use your password

01:11:50.000 --> 01:11:59.000
And this is true for almost all of the tasks that you use your computer for. Actually, if you are using your computer and it works well

01:11:59.000 --> 01:12:08.000
And you use it, right? It ain't broke. But for those problems where it doesn't work

01:12:08.000 --> 01:12:13.000
It might be the case that a common question

01:12:13.000 --> 01:12:15.000
Yeah

01:12:15.000 --> 01:12:26.000
Well, it's something I asked for, like, other, like, marketing seminars. So is there like any chance of a quantum memory system?

01:12:26.000 --> 01:12:36.000
Because, like, if you have a computer and you… it's not only the CPU that does everything. You need RAM registers, so is there any…

01:12:36.000 --> 01:12:42.000
Yes. Yes, I mean, in theory, we know exactly how to do it.

01:12:42.000 --> 01:12:53.000
rebuilding the quantum entry. Actually, there is this thing called quantum RAM where you want a classical, you want your classical data accessible

01:12:53.000 --> 01:12:58.000
in superposition and in a coherent way is called QRM, and also there are proposals

01:12:58.000 --> 01:13:06.000
for doing that. So it's still only proposals. It hasn't been demonstrated to work in real life

01:13:06.000 --> 01:13:16.000
One reason I was thinking about quantum memory is that I realized that if you look at these supercomputers

01:13:16.000 --> 01:13:29.000
IBM and Fukargo. They actually don't operate for too long. I mean, they work for a day maybe or even less. And then they break down some component fails

01:13:29.000 --> 01:13:38.000
And what they do is they do this checkpointing. So every now and then they just stored the whole contents of the memory

01:13:38.000 --> 01:13:53.000
And then they compute, and if they compute it again for a certain amount of time, they update the checkpoint. But if in between somehow the machine breaks, they can go back to the previously stored checkpoint and start from there. So not all is lost

01:13:53.000 --> 01:14:05.000
I was thinking quantum memory would be — oh, and by the way, quantum computers, I don't expect them to be better than the supercomputers. They're probably also going to sort of break it down if you run them for too long

01:14:05.000 --> 01:14:21.000
So we need a quantum version of this. And I haven't been able to figure out how to do that because it's complicated because you can't just store quantum information and continue on top still quantum maker allows you, doesn't allow you to copy information

01:14:21.000 --> 01:14:31.000
So you need to come up with the smart click here. But I certainly think that there will be in the future modalities that do quantum memory and other modalities that do fast compute.

01:14:31.000 --> 01:14:37.000
But we're very far aren't on that.

01:14:37.000 --> 01:14:39.000
Any questions

01:14:39.000 --> 01:14:53.000
So you're both a professor at university and an officer at Continium. Yes. Do you think there's a reason why quantum computing seems to be so dominated by companies and not universities or like places like, you know, Rawlers or whatever

01:14:53.000 --> 01:14:56.000
Why are private corporations so much better?

01:14:56.000 --> 01:15:12.000
Well, let me say they're not, I don't know the answer here. The thing is the whole thing started in the university

01:15:12.000 --> 01:15:28.000
30 years ago. And then the first systems, I mean, Derek was one of them were built in the labs and Ucubits worked and systems grew. And now we're at the stage that

01:15:28.000 --> 01:15:44.000
It's really a lot of engineering to build these bigger systems, and you can no longer expect academia to do that, first of all, because it's too expensive, because there's a shitload of money to build the system. Second, it also requires more than 4 years

01:15:44.000 --> 01:15:47.000
of work, so you cannot have a PhD

01:15:47.000 --> 01:16:03.000
Work on it, right? You want someone to work on it for an extensive period of time. So the reason why you see companies now take the forefront and building quantum computers is because of these two reasons, mostly because of these two reasons

01:16:03.000 --> 01:16:06.000
Thank you.

01:16:06.000 --> 01:16:11.000
But it doesn't mean, by the way, that there's no place for academia. I think there's a big place for academia.

01:16:11.000 --> 01:16:19.000
For example, in developing new algorithms, but also maybe developing new techniques or discussion about memory or applying quantum computers.

01:16:19.000 --> 01:16:23.000
We have one more last question, comments

01:16:23.000 --> 01:16:41.000
You mentioned earlier coming up with algorithms to solve. I think you said the complement something you can what is your process for actually I wish that I had a process. I mean, I don't know

01:16:41.000 --> 01:16:49.000
Now it's like doing science. Like what's the process for doing science and coming up with a good idea? You start out by reading

01:16:49.000 --> 01:16:51.000
papers

01:16:51.000 --> 01:17:06.000
Focusing on a particular problem, and then at some point, I don't know how it works, but maybe you guys help it. For me, sometimes something comes, you wake up at night or you just found something, or you're just playing around and you see, oh, this is for me. Let's explore a little further

01:17:06.000 --> 01:17:11.000
It's really a bit of luck, I would say.

01:17:11.000 --> 01:17:15.000
I don't know how that works.

01:17:15.000 --> 01:17:28.000
Let's maybe call it intuition. Let's end there and thank our speakers.

01:17:28.000 --> 01:17:38.000
Eddie will be joining us for lunch at the canteen, so please join us and continue the conversation there. Thank you. Thank you very much.

01:17:38.000 --> 01:17:46.000
to our online