 We'll talk on, I think, really quantum middleware. It's the term that we're using at IBM. Hopefully you're in the right place. If not, welcome, anyways. Stay. I think we'll have plenty of time for questions at the end. So let's try to get to it. And then we'll answer it. Obviously, if you can't hear me or something like this. OK, let's get started. So Paul is my colleague. He's a senior engineer at IBM. And we're part of the same team where we do open quantum and open serverless. And why those two terms? It seems kind of weird. It's because before this new mission that we have, we used to be part of the team doing Knative, so serverless. And then the quantum team started looking into how to do quantum middleware. And then they started doing quantum serverless. And then, plus, it's always interesting to get new, interesting topics at IBM. So we built this team. And Paul and I are part of that team. And I think you played poker. Hold on. Yeah. And then for me, long-term contributor to open source for us different projects, particularly Cloud Foundry in the past. Even all the way back to Linux kernel and USB. So long history. And you'll often see me with a camera. So if you want a picture, I can promise a really good picture if you want, at least better than average, better than iPhone. Let's say that. So don't feel shy at all. So this is us. So the talk is really three parts. And Paul actually is going to do the heavy lifting, two parts of it. So I'm going to do the first part and try to explain to you quantum computing. And I say try because things are weird when you get to the quantum level. People put Einstein all the time. So let me do it. And even him, if you go back and you look at, he was very skeptical of a lot of things about quantum computing. And it turns out that's how it works. So sorry, Einstein, you were wrong very few times, but he was wrong. Anyhow, we're going to try to explain to you that. Then Paul is going to give you concrete examples, actually, of how, at least at IBM, you right now, obviously not during the talk. But after the talk, you can go and register and start using quantum computer and how to program it. I'll vary the lead that it's using Python. So probably everybody here can program in Python. If not, you can learn it probably during this talk. Super easy language. And you can actually program quantum computers. And we'll show you that. And then the last part is how we are connecting programming these computers with the cloud needs of space, particularly Kubernetes. And you'll see there's a series of use cases that actually it makes a lot of sense to do that, which shouldn't be too surprising to you, but at least we're doing that. And of course, we'll have plenty of time for questions, and hopefully we'll get to that. So OK, so what is it to have a quantum computer? Because this is how it actually looks like, although it's usually encircled because it has to be kept at very, very low temperatures, I think something like a little bit above zero degrees Kelvin. Some of the temperatures, milli-kelvins are colder than, I think, all anywhere in this galaxy, certainly, that we know of. So we're able to keep things at very, very low temperatures. And that's how a lot of what we're going to talk about in the next 10 minutes actually work. So let me try to explain this. So first, before we go is most of you, I'm assuming, obviously, probably are programming computers and understand how classical computers work, or certainly use them. We all have a phone, and it's pretty much a supercomputer. But did you ever think about how it actually works in terms of the hardware, like the details? It's surprising that not a lot of people notice because we sort of assume computers pretty much everywhere, so it's kind of assumed. But the hardware is very interesting, right? So it works in a very bastardized simplification is that you hear all the time, and it's exactly that true. It's zeroes and ones. Why? Because we can easily represent those two signals in terms of the electronics. And of course, zero, you can think of ground, and then one, some kind of voltage. And of course, you start thinking, well, how does it actually work? The computer is really just making simple computation, but it does a lot of them. So then you start thinking, OK, so how does it actually work? Somebody asked me, I remember way back when I used to use Facebook, you connect with a bunch of people, and they say, oh, you're a computer engineer. How does it actually work? And then they say, no, no, really in the details. And you can actually explain this. And the way I try to explain this to people is to think of, how would you do a simple addition, like two numbers? And first, how do you represent two numbers? Like a simple digit. And you can start thinking. And you start looking at the fact that we're using numbers. You could use binary numbers. You explain that. And I think everybody here would understand. Then binary numbers is zeroes and ones. OK, cool. So we can represent them with zeroes and voltage. So one. And then you start thinking, OK, how do you add? Well, it's not too hard to build a Boolean circuit. And you explain that to people how to actually do additions with Boolean circuits. And it turns out that NAND gates pretty much is all you need. You can reduce everything to NAND gates. And the first class of computer hardware, they basically show you how to build adders and all kinds of simple circuits. And it turns out that from these very, very simple circuits, you can build pretty much anything. Why? Because you can come up with what you say in instruction sets and then very simple operations that are all taking zeroes and ones. And then you build essentially a processor. And you're living a lot on the table. But the basic idea is that you start with circuits. And you have basic inputs that are zeroes and ones. And from that, we can build what we have today. There is one important thing also to mention, besides the fact that it evolved to a fact that I think the latest processor that you have on your Apple phone has billions of circuits, billions of transistors, is that all of that works perfectly, meaning that you put zeroes and ones, things don't change. They stay exactly that. And maybe there could be errors in the circuit, but it gets corrected. You add additional redundancy. But there's not any errors. Like, can you get a new Intel chip? That chip, if it has errors, it's a problem. You just return it and they give you a new one. So the things work very, very precisely. So it's very deterministic. And that's also another important thing, because quantum computers are not like that. So what is a quantum that moved to the next slide? So in many ways, and I'm going to explain the quantum computing piece later, but once we were able to build those classical computing, if you may, as you know, we solve the world runs on computing. That's why we're here. I think Jim had a talk, I think it was in November in Lake Tahoe, where he said Linux was responsible for some ungodly number. I think the world economy is like $100 trillion, and Linux impacted a third of that. And so it's all computing, and it's on, right? So there's a huge number of problems that you can solve. But it's interesting to also mention that there are problems you cannot solve. And it's usually around optimization, at least the problems that we care about. But there is a huge class of problems. And of course, if you take computer science class and complexity, then you start learning that not only are there problems, we cannot solve the current model. It's essentially they haven't proven it yet, but it's almost impossible to solve those problems. And increasingly, those problems are very, very important, or at least interesting for us to solve. And people have spent countless PhD thesis trying to prove this. But usually what you end up doing is you come up with heuristics to solve them. So you still solve them, but use heuristics. And part of the problem is that because the way classical computers work is the same, right? So whether it's your iPhone or it's a mainframe, it's very much based on a Turing model. So they work very much the same way. And the thing about quantum computing that makes them exciting, although I haven't even explained to you or attempted to explain to you how they work, is that they can actually solve problems that are outside of this space. Because they really work in a very different fashion. And we're going to try to explore that. And because of that, it makes them not only interesting for research, but also for practical applications. And there's actually one specific practical application of quantum computing that is sort of in the horizon that's going to impact all of us. And we're going to talk about that specifically as well. So some examples, if you're Elon, and you're trying to build the next better EV with more range, you're learning, you probably have tons of people figuring out the chemistry of batteries or longer lasting batteries. And I know that people at IBM, for instance, it spent a lot of time looking at lithium iron and then lithium air. So instead of using iron, use essentially what's in the air. So there's tons of different sort of chemical problems for material science that you need to, people are exploring because it has practical applications. And the problem is that even though we understand the chemistry and the physics, the equations end up being very difficult to solve, or at least difficult to simulate, because there are so many interactions between the different particles and your molecules. So these kind of problems where the number of input is very, very large tend to be overwhelming for even supercomputers. And Paul at some point is going to give you a specific example of chemistry problems that we're solving with quantum computing. And tons of companies that we work with are actually doing this in universities as well. So that's one problem. Another problem that people know very well, because it's sort of well studied, is the traveling salesman. Essentially, how to optimize your path to, let's say, Vancouver, maybe hitting all the different coffee shops. How to optimize that. It turns out to be very hard. It's like, for instance, if we said, I don't know how many people we have in the womb, I'm assuming about 15. And there is maybe 50 chairs. And if we said, OK, let's rearrange those chairs. Even if we had just 15 chairs, and I sat one place, and I said, let's rearrange. With 15, it's 15 factorial different ways. And 15 factorial is a very large number. You can check it. Try to compute it. You'll see. So these kind of problems are sort of optimization problem. They are very hard to solve in classical computers. Why? Because the number of operations is large. So even though, with very basic circuits, we can build computers. And with 5 billion transistors, we can build computers that do a lot of computation. The numbers get so big that it's even hard to comprehend how big a processor would need to be for a certain input. So in other words, as the input goes, if the number of operation is exponential, then you reach the limits of classical computing very fast. So what you have to do is you have to use heuristics. But some problems you can't. Or we don't know any heuristics. So that's the intuition I want you to remember. Because we're not going to tell you that quantum computers are going to be in your pocket and you're going to be running your TikTok or your Instagram on them. No, but for some class of problems that normal computers cannot solve, they are actually surprisingly fast at solving those. So that's the key. So how does it work? So go back for a second. So one of those problems is this problem. What? What do we look at like that? It's essentially the way encryption works today. And we mentioned this problem. We spent a lot of time on it. Not because it's mainly because it impacts everybody. And there is actual solution, an algorithm right now that exists and it existed since 1995, to solve this issue on a quantum computer. So what is that? So again, bastardizing cryptology. Right now, everybody here, every day, whenever you use your iPhone or any computer you have, you're encrypting data. If you're not, you should. You heard the talk by Eric this morning. You should be. And hopefully you are already. OK, so how does that work? That actually works very simply by the problem of factorization. So of course, there's tons of different kinds of encryption. But the basic encryption that most people use right now is based on sort of RSA. So it's like a symmetric encryption. So the gist of it is this. Numbers turn out to be easy to multiply. You could multiply any number, how large they are. Most of your iPhone can do this. You can just use it on your calculator on your iPhone. Just put two large numbers, multiply them. But now if I give you the multiplied, the result, and I told you, without telling you what those two initial numbers were, and I asked you, could you come up with two numbers that, when multiplied, give you the original, the result? Turns out to be a very hard problem. And it's a problem we've known for a long time in mathematics. Why that is, is maybe outside of the realm. It's probably in number theories. But just understand that it's hard to, if I give you a number large enough, and I told you, come up with the initial two, let's say, prime factors. You could spend the whole week using the current computers you have, the best algorithms, and you would not have a solution. And that's how encryption work is, because you can use these kind of two values. That's why you hear people say, you have a public key, a private key, and you can share the public key, because once you have one of them, then if I encrypt with the result, then I can decrypt because I have the private key. But if somebody has to guess the number, the resulted number, or two of those values, you can't. So because of that, you can assume that as the more you use large numbers to do these kind of encryption, the harder it is, because it's exponential. So there's a chart later on that shows you the actual number of computation that you need to do for some digits of encryption. But why is this particular problem important? Well, it's because there is a solution to this problem with quantum computing that can be done in hours versus years or thousands of years with the largest computer we know right now. We're going to talk about it a little bit more. Let's move to the next slide. So now finally, quantum computing. So before giving you a little bit more detail about the impact of these computers, let's think about why quantum computing is different and what's so special about it. So the best way I found, and I'm still trying to find the best way, and I stole this one from, I think, somebody online I saw explain this. So I have here a coin. It's a Canadian coin. The US, we practically don't use coins anymore. But it's a nice coin. It has the face of the queen. So we could assume this has to be one, and then heads. And then the other side is tail. So you could assume it as being zero. Quantum computers work on what we call qubit. So to understand what qubit is, that's why I'm using this coin. Whereas a bit, I mentioned, is either zero or one. Cannot be both. It's very precise. The whole computer architecture is designed to essentially assume that those bits don't just flip. Quantum computing are more like this, where you have zero and one, and then you flip it, it's going to catch it. And it's tail. So zero. And you keep doing this, and you essentially have an idea of what qubits are. So they are actually in both zeros and one at the same time. And of course, you resolve them by observing it, and then it can be zero or one. So anybody here has a coin? Well, if you did, you could do the same thing as me. So if we did it at the same time, then we would explore it. Chances are we're not sure. Yours could be zero, mine could be one. But quantum computing uses something else in addition to what we call superposition, the fact that qubits can be in both zeros and one at the same time. It uses something entanglement, called entanglement. And it's another one of those weird realities of the quantum world of nature. That if you had a coin like me, so hopefully any coin, I guess, it doesn't have to be just a Canadian coin, and we were entangled, and we flipped it, and we observed it. My observation is head. If those two coins were entangled, I would guarantee you that your observation will be head as well. And that's what's interesting. So first, that the coins are at both, or the qubits are in both states, so superposition. And then when you entangle those qubits, that you can observe the same result or the same value. And it's hard to put your head around it, but people have done multiple experiments to show how entanglement works, and it works. I think the Chinese did, and I mentioned the Chinese because there's another reason there. There's a huge group of Chinese researchers doing quantum computing and, of course, quantum physics and so on. And I remember maybe a few years back where they sent one of their walkets. And as part of usually we send walkets, you do experiments. One of the experiments was to show entangled qubits and show that they actually, even long distances, they will read the same. So they still entangled. So distance doesn't matter. It's a problem, right? That's what Einstein actually had problems with, because if you had one, and I had one, and we flip it, and it's entangled, how could it be the same? Is there communication between the two? And if there's communication, is it faster than light? All kinds of crazy stuff. So anyway, those two aspects, superposition and entanglement, means that when you build, all of a sudden, a circuit, a quantum circuit, you can actually have solutions for all of the different inputs. Now it's hard to think, well, how do you actually measure it? And this is where the entanglement part comes in, when you can start entangling things. Then you can actually get results that you want. Now of course, not all problems fit this model very well, but there is actually one problem. So let's go to the next slide. And it's Peter Schor's algorithm. And just an example, there are tons now of problems that are interesting to us that you can solve with quantum computing. But this one impacts all of us. And this graph is just showing you the number of the complexity. So currently, when you use your phone and you're using WhatsApp, you are encrypting, I think it's like 256, so somewhere here. So some digit that is very large. And for the best known algorithm to do factorization, number sieve, the number of operations that you need to do to compute, it's very simple operation. Divisions, multiplication, remainder, that's it. But you have a lot of them to do for large numbers. And right now, the estimation is about 10 to 25, 10 to 30. And you think, OK, well, 10 to 30, what number is that? It's easy to write. But it turns out to be more stars than the known universe. That's what 10 to 30 is, which is like, OK, yeah, serious. And then if you keep increasing to a point where it becomes 10 to 80, so let's say 1,000, it's more not stars, more atoms in the whole universe. That's what bigger number. So in other words, the number of operations that you need to do is impossible. So that means that unless we come up with better algorithm, your encryption will always be perfect. And remember, it's hard to figure out the prime numbers. But if you had two numbers that were 1,000 long, computers these days do this in milliseconds. So one way is easy, the other way is hard. So that's the key. Sure, figured out an algorithm in 1995, as part of his postdoc at Berkeley, that actually solved the same problem, assuming you have a large enough quantum computer at constant time. So you can see for 300, it's 10 to the 5 operation, which is pretty easy. Most of you might have more than that in your bank account, I hope. So that's the key, OK? So how did that happen? And it's complicated, but the gist of it is he came up with a way to do Fourier transforms with quantum computing. And Fourier transforms are great for all kinds of different signals. But it turns out, and this is the intuition, it turns out that when you are doing very basic factorization trying to figure out the factors of numbers, you will see repeating stuff. So every time you see repeating values, then you should think of sine waves or cosine wave. And you should think of Fourier transforms, because that allows you to extract signal from noise. And then that's how actually Schor is able to do it. So last year in November, back to our friends in China, there is a paper they would saying that they were able to crack WhatsApp messages in less than a couple hours. And it turned out that they made some mistakes, but the point is it's getting very quick. And they were running it on their quantum computing. So at IBM, our best quantum computer right now was, I think, announced yesterday, Jay mentioned something on LinkedIn, where it was 433 qubits. But very soon, when you start getting into the 1,000, to maybe like a few 1,000 qubits, then practically every encryption will be decrypted. And things move very fast also. And right now, the projection is probably around 2030, at least for us. That's what we think. Other people might get faster or longer. But this is one of those problems that once we reach that, there is no secret anymore. So we have to approach different ways. So there are different solutions for this. And we could talk about this in the Q&A. But let's move now to the second part and third part of the talk, which is going to show you concrete ways of solving or using quantum computing. So hopefully, I wet your appetite. If not, Paul is going to go into very concrete examples. Thanks. All right. So how do we do quantum computing? So to kind of lean back on the history piece, if you remember back, classical computers, initially, we built. There were electrical circuits that we wired. How do we do similar things with quantum computers? It still involves kind of building circuits, which isn't easy. So we've built, basically, an SDK called Kiskit that enables one to use Python to build these kinds of circuits. If I just jump back to this slide here, like the circuit here that we have up here, one would have to specify out kind of all the different pieces of that. We've got the Kiskit SDK, which allows one to build that, which is a couple of kinds of Python code. So just to kind of talk through Kiskit really quickly, it's going to skip this pretty quickly. But it's an SDK for building quantum circuits and quantum tools. So there's algorithms that are implemented in Kiskit. There's simulator. So if you don't actually have access to a quantum computer, you can still run quantum computer or quantum computations. It's helpful for things like CI, where you don't necessarily need to call out to a production system. And the basic way this works is, again, it's similar to kind of when we had classical computers, we started with assembly. We wrote higher level languages like CI and things like that that enabled us to write programs that run on those that made it easier. How does any type of thing like that work? Four steps. First thing you do is you build your program, you build your circuit, you build what you want to write. That's step one. Then you compile it. You translate it into a set of instructions that will run on the machine that you have. In this case, it would be a classical computer. Then the fun part, you run it. And then you look at the results of your program, analyze it, and go forward from there. So that's basically kind of how Qiskit works, how the quantum workflow works. So to demo this, let's take Max's example of flipping a coin. Let's say, for some reason, we want to build a quantum coin flipper. It's going to cost you a little bit more than $0.25 Canadian. But let's see what that might look like. So this is a Jupyter notebook that's going to run the Qiskit tooling to kind of show us how to work through this. So let's start step one. The first thing you want to do, again, this is all Python, so it should hopefully be pretty self-explanatory. But the first thing we're going to do is we're going to do this in kind of a quantum way. The first thing we want is we want to build a circuit. And we just declare a quantum circuit. We're going to use two qubits, so two quantum bits, and then we're going to have an output of two classical bits at the end. So we shall run this. The next piece we want is we actually build the gate. So basically what we're going to do is enable us to get a coin you flip it as long as it's not a two-headed coin or a fake coin or a cheating coin. You get a 50-50 distribution of heads and tails in the long run. So we want to basically do something like that with quantum. So we can basically set up a quantum gate that will give us a probability distribution of 50-50 in our outputs. We do that by adding an H gate and a C not gate, and then measuring it. And again, it's fairly simple. Circuit.h adds an H gate on the zero qubit. We put a C not gate or a CX gate by CX. And then we can look at what that looks like. The nice thing about these things is we can build our gate. And there's our little random gate. Those are things we want to do. So then we've built our gate. Now we've got to compile it. So I'm going to use a simulator because I don't trust conference network, no matter how much assurance we get in keynotes, that it's going to be great. So we're going to use a simulator here to build this thing. We just declare a simulator. And then we'll use a transpiled method to compile it. So that's basically just going to compile it down to this simulator set of instructions on the back end. And then what we're going to do is now we've got it. So now we're going to run it. And again, as I said, quantum computations, they're probability distributions. It's going to be basically hoping we're going to get a 50-50 distribution of outputs. We're going to run it 1,000 times. And then take a look at the outputs. So let's do that. And let's just take a count. So what do we get? 5, 10 versus 490. So our 0, 0s versus our 1, 1s, that's 50-50. And then, of course, we can do a nice thing and plot some histograms that may or may not actually fit on the screen, but that's 50-50 distribution. So that is a quantum coin flip with a couple lines of Python. Kind of some neat tooling that we can do with Kiskit to do that. All right. So that's Kiskit. It's open source. It's on github, github.com, slash Kiskit. We've got links at the end where you can get access to that as well. So that's how we do it. How do we do it in a cloud-native way, particularly how do we use Kubernetes to kind of interact with quantum computers? And one way to kind of think about this is that Kubernetes is essentially an orchestrator. It allows us to run different tasks. And we can call it a different workload. So we can use Kubernetes to run workloads on cloud. I think everybody's familiar with that. We can use Kubernetes to run workloads on prem. And our data centers and that type of thing. We can use Kubernetes to run workloads on high-performance computers. And kind of the takeaway from kind of all these examples is that Kubernetes essentially allows us to run different types of heterogeneous compute. Quantum's a type of heterogeneous compute. We can kind of add that into the mix. And so it just becomes another type of compute resource that we can use in the type of jobs that we're building and running via Kubernetes. So to something a little bit more complex and flipping a coin, a typical workload that we're running, a computation or something along those lines, we can start off with a big problem. But we can break that problem into a series of different tasks. And each of those tasks may have components and things like that. And each piece of that puzzle, there's going to be a particular way that we can optimize it to run it in the quickest amount of time. Some of those tasks might run best on HPC. Some of them might be quantum tasks, or if we want to factor algorithms, like that's a quantum task. If we want to do some Monte Carlo simulation, there's quantum algorithms that are much quicker than some classical ones. So depending on what the type of task is, we want to break this big problem down into smaller problems so we can solve them, recombine the results, and get our output. It's classic dividing conquer, like you might have done a merge or something like that, break big problems into smaller problems so you can solve them faster. So that's the tooling that we've developed, something called quantum middleware. How do we do this? It's taking that problem and using Kubernetes to orchestrate these different pieces. So in a quantum case, we've identified a workload that should be run as a quantum workload. We can ship that job out to Kubernetes. We can let Kubernetes handle the scheduling to the quantum back ends, bring the results back, and continue forward. That's abstract. Let's go through a couple of examples. I think we've got about five or 10 minutes left. So I'm going to do a chemistry example, and then another one if we have time. The chemistry example, so let's, assuming we're a chemist, we're modeling batteries, something along those lines, we want to optimize a chemical equation. We want to optimize a molecule, which we're going to simulate here by calculating the ground state of a lithium hydride molecule. So the way we do that is we have an equation that we can use to solve that. We have parameters that we want to tweak to figure out what the best version of that is. With quantum, that involves you build a circuit. You set the parameters to it. You send it off to quantum to run, and you get your results back. Lithium hydride is kind of trivial if you're building something bigger. That can take time. So how do you kind of parallelize that so you can speed it up? Kind of bury the lead there, but you parallelize it. So we can use kind of, Kubernetes is kind of that parallelizer. We can take these different quantum tasks, and we can ship them out, divide and conquer, get the results, pull them back, recombine them, and return them using Kubernetes to schedule that. So let's take a look at what that might look like kind of very quickly. So there's, I guess to back up a second, there's kind of two ways we can run these quantum workloads in Kubernetes. One is we can build a self-contained program that we can send off to Kubernetes and allow that to kind of do the scheduling there. We can also run some of these things locally and then schedule specific tasks that we can farm out. So the first example I'm gonna show you here is kind of the, you know, off-put everything, or we define what we call a quantum program, which we've got, what, two minutes, so this is gonna be quick. So basically what we're gonna do is we're gonna define a program here. Basically what happens here is we've written a Python script that has the quantum calculation we wanna do. We're using a VQE, which is a quantum algorithm to solve the ground state energy problem. And we wanna run it with a couple of different bond lengths. Basically what we're doing is we're seeing how close the molecules should be to get a specific energy result, which I'm not a chemist, but matters a lot. So basically what we're doing is we're gonna run which I'm not a chemist, but matters in chemistry. So we're just gonna run this in a loop, we're gonna fire each of those off as independent tasks, and what's gonna happen is we're gonna take that Python script, farm it out to Kubernetes, it's gonna do the run, it's gonna make the quantum call, get the results, pull them back, and ship them off to us, and then we're gonna run that for a couple of different bond lengths. So what happens is we're using kind of an actor model here, but we've defined basically four jobs, each of those jobs get run, we can watch the results, and this is where things get fun. They all succeeded again, this is a trivial calculation so it doesn't take super long, but we can go through and take a look and see that for each of those different reactions, so for example, for bond length 2.55, we get a total ground state energy of negative 7.5 for 3.0, we get negative 5.8, and so on and so forth. So depending on kind of which, what matters for our output, we've run this multiple times, speeding up the calculations, assuming these things took longer than we had for the demo here. All right, demo three, are we at, how much time do we have left? Okay, do it anyways, all right, cool, circumnaiting. So Max said that our quantum computers, again there's a number of qubits, so we're like 433. Sometimes you might need more than that, which would basically mean if you needed like 5,000 qubits, you're kind of out of luck for the time being until the technology gets there. But what if we could take that big circuit and divide it into pieces that were equivalent to the larger problems? That's one of the things called circumnaiting where we can basically decompose a big problem into a set of smaller problems that are functionally equivalent to the big problem, solve those smaller problems easily and then return a result. And we can, so again this is, again we can do this in Kubernetes where we can decompose, ship the results out to quantum, pull the results back, recompose, and return a result back to a user. Which, we're gonna use a bit of a trivial example here. This is an eight qubit gate that we're gonna build that lets us assume that we could not, we don't have an eight, for some reason we can't, we don't have eight qubits, we can't solve that. So what we can do is we can use circumnaiting. So here where we're gonna use the second example, I'm just gonna run everything in my notebook but I'm gonna ship out the computationally expensive parts to Kubernetes to handle for me. So I'm going to define a cut function. I've given it a run kiskit remote wrapper which is gonna farm it out, that's gonna be the Kubernetes piece of it for me. And then what's gonna happen, so then I'm gonna call with serverless context which is gonna run it via Kubernetes and this is gonna take its time but it's gonna basically go through and look and figure out where can I cut this big circuit to get a functionally or two functionally equivalent smaller ones. And so it's done all this stuff to get that and then if we take a look, we can see that now we've got one circuit that's got five qubits and a second circuit that's got five qubits as well. So we've went from eight qubits to five qubits. Again, a trivial example but it's indicative of kind of the larger pattern. And then what we can do is basically run, we can run these smaller things get a result and then we will have a solution to the bigger problem using smaller problems, divide and conquer. So given that we're running low on time, so what can we kind of take in terms of conclusion out of this? I think there's three kind of main take away points to mention here. One, some of those hard problems that we aren't able to solve with classical computers, quantum gives us solutions to them which can be good or bad in terms of encryption may not be the best thing in the world but they're optimization problems, they're hard problems we can now solve with quantum computers. And not just quantum, if we combine quantum and classical together, we're able to solve these bigger problems in a more efficient way. It's kind of the marrying of the two technologies that make things better for us. And last but not least it, Kubernetes really kind of serves as the natural orchestrator in terms of how we run these workloads and orchestrate them. So there's links here. I think these slides will be online too if you don't want to copy QR codes because you never know. I mean, they're good QR cards as far as I know but I heard there are vulnerabilities in QR codes as well so caveat up there, you know. But the links will be online. Yeah, thanks everybody. I guess if we have questions, I guess. I have one question, I have a burning question. Hi, you had mentioned IBM gave 2030 as a, around that time. And was that without factoring in circuit knitting as an approach to breaking down shores algorithm? So what would you say a modified timeline would be if somebody had a lot of circuit knitting experience? So one of the things that circuit knitting is it requires actually being able to decompose the larger problem into a smaller problem. It's not a magical, like you can't just, you know, you can't necessarily subdivide everything and make smaller problems out of it. So there's, I mean, if I had a, I mean, there's a lot of ifs in there and the best estimate that we have, I think is 2030. I don't, I mean, you know, there's any, you know, whole number of things could happen in there but I don't think we want to get into speculating in terms of what could happen or what could not happen. The other thing I'd mention is that I personally wouldn't even wait for even 2026, 2027 is to start exploring better cryptographic algorithm. So to solve, to get us into that, you know, sort of post-quantum world that we call, US government actually in January 9th, Biden signed a law that requires all US entities and I'm sure in Canada they probably have some similar law, I'm not 100% sure but they probably will follow to move us to post-quantum and the reason we can do this is because as we discussed the problem of cryptography, at least, you know, I say type of cryptography is based on factorization. So then they ran for the past 10 years, people have been studying what could you do beyond that, right? And there's ways to essentially encrypt data using completely new math. So it's not based on, you know, the basic number theory issues of factorization but it's based on lattice and lattice math is complicated but the basic thing you can think of is, you know, if you think of a lattice as a space, multi-dimensional space, and you have vectors on a space, it's finding how to combine those vectors to reach two points. And it turns out to be extremely hard because there are so many different possibilities whereas if I give you those two vectors, it's easy to find a combination to get from one point to another. If you're interested, we can talk about this after but the basic point is try to start learning about what we call post-quantum cryptography. And I'll do a free plug. Paul and I are part also of IBM's post-quantum efforts and you know, there is a open quantum safe. It's called open quantum safe. If you look into that.org, you'll find for instance, modified version of OpenSSL, Curl, HAPoxy, we have team members contributing to all of that that are essentially moved to using these new cryptography that use lattice. They're called kyber, similar to like, you know, doing your lightsaber. So easy to remember. So if you're interested, you should look into that or come talk to us or go to the ibm.com slash quantum and you'll find a quantum safe page that has tons of information. So let me stop there because the order talk is gonna start but we'll be outside. And also I think you're here until Friday as well as me. If you find us, we are always happy to talk to you. Thank you.