 Well thank you for coming. This talk is going to be the first time we do it. So hopefully you cut us some slack, but you know feel free to ask questions. I mean you know so don't make it easy. So I'll introduce us quickly. So this is my colleague Paul. He's a senior engineer at IBM and does all kinds of things. If you go to the Knative booth, you will see him because he's a committer and has contributed tons to Knative. But now he's working with me on OpenQuantum at IBM. So Max, some people call me Dr. Max, but Max is fine. Yes, I do have a PhD, but it's not in quantum physics. So this is new territory for me. And I'm a distinguished engineer at IBM and I also used to do Open Serverless. So I did contribute to Knative as well, pioneering the CLI. So you know we can talk about that. And the quantum effort came because as you'll see, there's a little bit overlap, but not too much. So that's that. Okay, so the talk is divided into three parts. I'm gonna do the first part and Paul is actually gonna go over how. So I'm gonna try to give you my best intuition of quantum computing or quantum computers. And more importantly, why are they important? Why should you care? And Paul is gonna get into a little bit more details by going over how you actually program a quantum computer, at least using some of the tools that we have at IBM, and then how Kubernetes can actually play into this emerging field. And there was gonna be some live demos as well, so hopefully it works. Okay, so what is quantum computing? I mean, obviously everybody here probably has some notion of regular computers. And sometimes I don't speak too much. And of course, we all have supercomputers in our pockets. And quantum computers are actually very different. But fundamentally, there's some similarities as well. So we're gonna try to at least give you the intuition behind them. So first is thinking of problems, right? So if you've taken a complexity theory class, you know that computers are great at solving problems. But believe it or not, there's a lot of problem that you cannot solve. Or at least it would take you so much time to solve them that the best computers we have right now, even supercomputers much bigger than the ones you have in your pocket, would not be able to solve them. And part of the reason is because the best algorithms that we know tend to require a lot of operations. And computers are pretty straightforward, they just compute operations. And you could resolve, you could take any operation, all of the computers that you have in your pocket to reduce them to essentially doing additions. So at the end of the day, that's pretty much what you're doing. But if those numbers to actually solve a problem are very big, then you can't use the classical class of computers to solve them. And this is not theoretical. It's actually very practical. And we're gonna get into an example that we all use and you use every day. Okay. For people that have taken complexity theory classes, you understand this. But for some people, it might be a surprise, but it's very true. And the class that we cannot solve is actually significantly big. And we're gonna get into some example of this. Quantum computers will try, you know, help you solve not all of them. So we're not gonna be doing TikTok on quantum computers. Okay. So don't be, don't worry about that. But there are some problems where you can actually solve it significantly faster. And this is, and because some of those problems are critical, this is why you should care. One of the problems, and it's not just one, but it's one example, is trying to do a lot of research around, you know, solid state or any molecule that are kind of complex, even biological, you know, research in that space, because you have to compute the state or the energy state of some of those ions or the molecules. And if you're trying, like if you're, you know, creating an EV and you want to create better batteries, then you're essentially, you know, computing quite a bit of these, you know, imaginary molecules. And you have to understand the state of it. And it, the physics is actually well understood. But the number of computation that you need to do tends to be so large that classical computers would take forever. And quantum computers can do it like this. Another example of this that's more, that's closer to us is, you know, classic traveling salesman, you know, that's a very classic problem in complexity theory that you can actually do with quantum computers very fast. So it's logistics. And there are real companies right now using quantum computers to solve some of those problems. Now, another problem that I want to get into a little bit more after is essentially cryptography. So the basic primer in cryptography is that they're all, especially the recent ones, the ones that we all use, like say, for instance, RSA is based on a symmetric keys, okay, cryptography. So basically, you have two numbers, you multiply them, typically primes, and you have now a, another number. And that other number, you can make it public. And that's your public key. And the reason this works, that you can use that multiplied number to encrypt data is because it's very hard to find the primes from an existing number. Okay, so given any number, if I ask you, give me the two primes when you multiply them, it gives you that initial number, it's extremely hard. And it's, you think, no, it is freaking hard. I mean, it's basically more time than, than we have to live, you know, in the current computers. So if you get big, large enough primes, and you create these public keys, I'm simplifying a lot, but you can essentially encrypt everything. So the whole world, you know, you could say all of, you know, commerce right now on the web is essentially using these kind of cryptography. The sad part, and this is where computer computers come in, is that with, I guess there's another example of this. Right. So it's part of the reason it takes so long to find the primes is because the best known algorithm right now tends to be exponential. So you essentially would need a really large number of time because of the nature of exponential, it goes very fast. So the larger your number that you're using for your keys, the more time it would take you for the best known algorithm right now to solve it. So how do quantum computers come in and solve these problems? So this is the part where I'm going to ask you to, I guess I'm going to try to give you the intuition behind it. So if you think of, I mentioned at the beginning that all of your, you know, the phone that we have, all of it is based on these classical computers, where basically you have gates and you can build, let's say for instance, an adder, because pretty much everything else will build on that. And you can put two bits, let's say you're adding two numbers, you know, one or zero and one or zero. And you can go to the adder and then you'll get a result. So one, one will give you three would give you two, one, zero, zero, one will give you one, right. And so on. And that's because the bits are either one or zero in a quantum computer. You don't have that you have these notion of qubits. Now what's a qubit? It builds on quantum physics where matter, a lot of matter or at least the initial representation is in this sort of, you know, in this state where all of the possible spins, you know, zeroes or one can be at the same time. So what ends up happening is if you have, like, say full qubits, like this is represented here, the qubits can be in any of the different states. So that's interesting, but that's not really not enough. What's important is that in addition to being in those states is you can also have them be, so this is called superposition of the state, you can also have them be entangled. And that's what's important. So the qubits, if you can entangle them, then it means that when you run them to a gate, so this is a circuit, a quantum circuit, you can actually specify the ones that you want to entangle and get one result because otherwise what would end up happening is, let's say this was an adder and you had four, you know, bits, then you would get a result that you would not know. But with the quantum circuits that we can build today, assuming those qubits are perfect, so they don't have errors, you could actually solve them, you could, with the circuit, get a result that you want. What ends up happening, typically, though, is that the qubits are not perfect, so even though they can be in 0 and 1, they tend to get out of coherence. So basically, instead of being in superposition and entangled, some of them will get out of entanglement. So what you end up having to do, let's say this was an adder, it's a simple circuit, you would have additional numbers, so you're adding more to use that to error correct. And in many ways, it's not too hard to get few numbers of qubits, but for real problems, like for instance, what we talked about, you need large numbers. So let's kind of look into this. So in, I think, 1994, Peter Schor, I think he was doing his post-doctorate at Berkeley, he came up with an algorithm that goes by his name, Schor's algorithm, that actually can factor numbers and almost pretty much constant time. So this is the blue part. And the best known algorithm right now for factoring numbers is Number Field, and you can see it's exponential. So what does that mean? That means that for what you would do, like say on your WhatsApp, which is about 256 bits, you would need 2 to the 25, or more than that. So 225 is for about 220, and if you go to 256, you can see it goes to about 10 to 25, 10 to maybe about 30. And those numbers don't mean too much to you maybe, but if you think how many stars in the universe, it's 10 to the 50. So the problem with the existing algorithms is that it would take pretty much this number of operations to be able to factor from the public key. With a quantum computer and using Schor's algorithm, you're basically at constant time. So you can keep increasing it. So it doesn't matter how big the key is, you can factor in almost constant time. Now, you shouldn't be too worried because in order for you to solve this algorithm, you need, I think it's in the order of about 8,000 qubits that are perfect. But that's where we are today. When Schor's created his algorithm, I think it was in the order of 2 million qubits. So that's what people expected that you needed to do. So what the point is that the technology is improving much faster and the qubits are better and better, meaning that they are more perfect, meaning that you don't have to do error correction. So the number of operations is getting close to what you would expect in Schor's algorithm. So for some problems, and that's the key thing, quantum computers will make solving those problems extremely, extremely fast. Just as a last thing, and I will go to Paul, around November of last year, there was a group of Chinese researchers that claimed that they were able to decrypt WhatsApp messages over a couple hours. It turned out that there were some problems in their experiment, but there are lots of people doing this right now. And why is that a problem? Not for WhatsApp messages, but if you're a bank or if you're a government and you're trying to keep secrets, what do you do? You encrypt and you use 256, 300 RSA, it won't matter very soon. So a lot of bad actors, what they're doing is they're keeping this encrypted beta to decrypt later. So that's one of the reasons why quantum computers matter. So hopefully you're convinced, but if you're not convinced, Paul will try to do a better job of showing you how you can program them and real problems and then how Kubernetes plays into this space. Just to be clear, I don't have a quantum computer in my pocket or anything like that. That's the picture. I think that's the one that we had at the Cleveland Clinic right now. I mean, they're big machines. They have electrons that have been had spin put on them that are kept at like basically almost as cold as you can possibly make a thing like down here, like absolute zero. That's what we use to run these quantum calculations. So how do we do that? We don't expect people to have PhDs in quantum mechanics or physics to be able to write quantum programs. Similar to what we've done with classical computers where we started off, we wrote things in assembly and then we developed higher level languages like C and things that let us abstract away and write for different architectures. We've done similar things with quantum computing. So how we do quantum computing is we use SDKs. The most popular one that we have is something called QuizKit. QuizKit is an open source quantum computing SDK. It's been around since 2017. We've got over 100 contributors, 3,000 stars on GitHub, really a lot of stuff going on there, the links on there, quizkit.org. We'll have links and things at the end as well that people can access if they want those things. What QuizKit does is it provides you tools to write and run quantum code kind of at the most basic. It gives you tools for building these quantum programs out of the circuits that we had showed earlier. There's also a collection of quantum algorithms. You don't have to re-implement every quantum algorithm. A lot of them are there for you that you could just call it as functions and methods. There's a number of applications for different industry use cases. There's a lot of quantum machine learning. We have algorithms for that that people can use. In chemistry and things like that, as Max was saying, some of these chemical reactions, there are applications out there that you can use that you can pull in. We're going to demo one of those a little later. Finance is big in quantum optimization. The traveling sales person that Max mentioned, there's algorithms out there for that that you can use in the QuizKit toolkit. Lastly, running quantum programs. There's both simulators. If you don't have access to a quantum computer, you can simulate these and still run them kind of on your laptop with a little less power. Or you can call out to different quantum computers from different quantum providers. There's a provider tool you put. You pick the provider. You attach to your quantum computer and run it. That's what QuizKit is. How do we do it? Again, it's like regular software development. There's a four-step process for doing this. The first thing you do is you build your quantum circuit. QuizKit's Python tool, so you can write some Python to build out your circuit. We'll look at that here in a minute. Like any other, well, not like every, but any compiled language, the next thing you do is you're going to compile your circuit for the particular architecture you're going to run it on. Different computers have different architectures, so in quantum, it's a similar thing. Then you run it, and then lastly, you analyze your results. That's how you run a quantum workload. We're going to do a demo here. This is live, so this may or may not. We're going to run kind of by the seat of our pants here a little bit. Okay. Now, of course, I can't see it on this screen, but again, for people in the back of the room, can you read anything on this? How about now? I feel like an eye doctor. All right, cool. All right, so I'm not going to, whoops, bear with me once I've got to find which screen I'm on. There we go. Okay. Now, where's the mouse? Okay. All right, so given, what time are we at? We got like 15 minutes. I'm going to go a little quick here. So the build step, first thing we're going to do is we're going to just declare a circuit. Again, this is, because the thing is, is regular Python, it should look fairly simple. We're going to declare a circuit with two qubits that we're going to have two regular bits at the end. So we're going to have our two kind of quantum atoms here that we're going to do some stuff to, and we're going to measurement at the end. So we're going to do that here. And then we're going to build a little circuit. And rather than go over, so we're putting gates on the gates are just simple, like circuit dot gate name. So at H gate is an H, C not gate is a C X. And then we're going to measure it. And this, if you want to see what that looks like, we can make that look pretty, well, we can make it look pretty when it's on the screen entirely. And there you go. So you've got two qubits, q zero, q one, we've got two measurements, we're going to get a zero or one at the end. So we're going to have a zero, zero or a one, one when we run this thing. And the way this quantum gate works, not to get two of the weeds, but it's basically going to give us, you know, we've, the H gates going to put our qubit in our superposition so we don't know what it is, we're going to entangle it with a C not gate, which means basically our output when we measure is going to be 50 50, give or take a little bit if it's a zero or one. So that's we, this is our circuit, we built it. Now let's compile it. Given that networks are always fun. I'm going to do a simulator today, but we're going to simulate this. And then compile it, our compiler is just a call to transpile with the circuit in the back end we want to build it for. We're going to run it is just again, simulator dot run, nice and easy. It runs, and then it's done. And then we can do, you know, some counts. We can see we ran zero zero one one. That's our, you know, zero and one, roughly split evenly 49 to 5 11. And then if we want to, you know, we're in a notebook so we could do notebook driven development and build some histograms at the end there. That's a trivial example or a fairly simple example, but you can obviously how you could build this up to much more depth. If you wanted to giving a nice little visual toolkit to work your way through that. So that's kind of quiz kit as a demo. Now I'm going to try to get back to the slides if I can find them. There we go. And then just come back to the, pull the presenters notes back up. If I can click on the right thing and then bring this back to my other screen. Don't blame Linux. We're the Linux foundation event. Don't don't blame Linux. All right. So that's our demo. Just come back over here. All right. So we're 20 minutes in. We're at cloud native con cube con. We haven't talked about Kubernetes yet. Let's rectify that. How do we make quantum computing cloud native? Or also known as why are we here talking about quantum at cube con cloud native con? You know, so what's the role? What role does Kubernetes play? And if we think about kind of what Kubernetes is, you know, it's an orchestrator, you know, if we want to go back to, you know, Kubernetes comes from the Greek that means pilot or helmsman or navigator or a couple other things. And we can use Kubernetes to run a whole bunch of different workloads. So we're all familiar with running Kubernetes on cloud. You can use Kubernetes to run on prem workloads. You can call out to high performance computers. Kind of the takeaway here is you can use Kubernetes to run a whole bunch of different heterogeneous computes. And quantum is just another kind of heterogeneous compute that we can add into these particular workflows. And we can use the one that makes the most sense for the problem or the part of the problem that we're attempting to build. So if it makes sense to build part of our program or our algorithm as a quantum algorithm, let's do that. If it makes more sense to run it on HPC, let's run it on HPC, so on and so forth. And so to kind of think about this, let's use something that's a bit more complex than the last example I showed. Let's take an application at the outset. It's a big problem, but we can break that problem down into smaller pieces. And each of those pieces can be broken down into smaller pieces. Some of those pieces may be best served by building a quantum algorithm, building a quantum circuit to build our calculation if we have a quantum algorithm and enough qubits to do so. But we can break this down into a bunch of smaller problems, compute those results, and then combine those results back up to get the final result. This should be familiar to anybody who's grinded leak code recently. This is divide and conquer, right? You take a big problem, break it down into pieces, combine those pieces back together. But you need something to kind of orchestrate that. That's where Kubernetes comes in. And that's where kind of what we've called quantum serverless, quantum middleware plays a role. So this is an open source software that we built that's out there people are contributing to that's used to make tools to build and orchestrate these quantum and classical workloads for people to run it in the optimal place. So again, if you've got a quantum workload, and again, it's not quantum or classical, it's quantum and classical. So if you take, you know, a particular workload, you send it to Kubernetes, you send your program, quantum service will figure out, you know, do we need to run it in quantum? Does it need to be run classically, in HBC, whatever, so on and so forth? It'll kind of go out and do that. So that's a lot of abstract stuff. We've got 10 minutes. Let's see if we can get through a couple of examples. So simply, so what does this look like in practice? Let's take, you know, the first example. Let's say we want to calculate the ground state energy for lithium hydride. This is a kind of a basic chemistry example where we're going to, and this can be done as a quantum algorithm. There's a quantum equation you can solve. And you can also, and you can do it for different parameters. So maybe you want to solve it where your atoms are this far apart, maybe this far apart, this far apart. So you can kind of run this as, you know, a parameterized equation where you're the bond length would be your variable. So what might this look like in quantum serverless? We could take that program and that set of parameters, ship it off to Kubernetes. We can let quantum serverless kind of parallelize it, run each quantum algorithm individually on separate quantum hardware as individual processes, take those results, pull them back and return them to the user. So it's, we're going to attempt to demo now. Let's see if we can jump back and forth again. All right, let's try this again. Okay. So now we got notebook two. All right. We can still read this. Perfect. So let me do this. We build a writer program in Python that's going to do the things we want to do, which for, you know, to summarize this kind of quickly, we're going to build our atom using some of the quantum nature tooling we're going to do here. That's this, you know, driver equals, etc. Then we're going to do our quantum transformations. We're going to take our quantum algorithm, which is down here where we're going to build a VQE, which is what we use to calculate the ground state energy of this molecule at this particular bond length. And then we'll return the results, package it up in a Python script, and we can then ship that off to Kubernetes and run it. So let's see how are we going to do this? Oh, we're going to do it from a notebook. So we're going to import our stuff. We're going to make so we're going to, we have a, there's a gateway that's just in front of the Kubernetes that we use to send the things to, for resource management and that kind of thing. But we're going to declare an instance of quantum serverless that uses that gateway provider, which we shall do here. Then we are going to define our program. Our program, it takes, again, the Python input, some dependencies. These are, you know, Python dependencies that we're going to add in, Kiskit nature, our arguments, you know, which we're going to use as basically just a, we're going to run a for loop with different bond lengths, and then we will pull those results back into a list of jobs. So let's do that. We've got three jobs. And this is where it gets fun. We're going to see if this thing is actually going to run. Awesome. We're actually running. And now we wait. And that was quick. Again, these are small examples, you know, real workloads can take longer, hence why the parallelization and the running things independently matters. And then we can pull our results back. So we can see that, you know, for bond length 2.55, we got a ground state energy of negative 7.58, where three go threes down here, we got a negative 7.59 3.55 is going to be negative 7.6. So again, as you're getting a little bit further apart, a little bit different thresholds of energy. So that's kind of the parallelization bit. All right, let's, all right. So that's that example. Last example, I think we're going to have time to get through circuit knitting. So again, kind of Max mentioned, we've only got like so many qubits in quantum hardware. I think we're like 433 right now. And that means we can build, you know, circuits that have less than 433 qubits in them. But maybe we want to solve problems that are bigger than that. We can use some kind of, in certain instances, we can actually split a circuit in half into two smaller circuits that are mathematically equivalent to the larger circuit. So we can basically decompose this into smaller workloads, run those smaller workloads, recombine the results, and get the final result. And what's nice about this is when we split our circuit, we're able to split it into a smaller number of qubits, so it can fit on the hardware that we have. So that's what we call circuit cutting. It's part of this circuit knitting toolkit that we have, which is also open source. And again, Kubernetes is our orchestrator. We're going to ship the job out to Kubernetes. It's going to run the circuit cutting. It will then farm those subcircuits out to a quantum machine, pull those results back, recombine them in Kubernetes, and ship them back to us as the user. So we're going to demo this even quicker than we did the last one, since we're running low on time, if I can find my mouse. There it is. All right. So circuit cutting. So what we're going to do is we're going to, and again, this is a small example. We can build bigger ones, but we're going to build an eight qubit circuit. And obviously that could, in real life, could fit on a quantum computer, but for our purposes, we're going to pretend it can't. So we've got an eight qubit thing. We're going to build our quantum serverless instance. And what we're going to do in this case is we're going to run this locally. So we're going to run our quantum in our notebook. And then we're going to make, we're going to send remote calls out to Kubernetes. We're going to run our individual functions. So instead of building it as like one Python script that we run in Kubernetes, here we're going to make individual calls that will run out to Kubernetes. This is kind of more of like a, you know, data scientist type worker might be doing more stuff in a notebook as opposed to building out kind of a full program. Just what we use here, we use this at quiz, get remote function to basically declare this as a remote function. That's going to do its thing. Then we're going to cut it. So we'll run this cut circuit wires remote. That's going to take a little bit of time. We'll watch that kind of run its thing here. It'll give us some outputs. So right now what happens is we've shipped this off to Kubernetes. It's running its thing. It's done some cutting. And now we've got, it's done a lot of cutting. And eventually we're going to get there. There we go. So now we've got two circuits. And we can, if we take a look at this, we'll see that we've got one circuit that's five qubits, another circuit that's five qubits. So we've taken that eight qubit circuit and made it into five. Now we'll run it. And I know I'm running through this stuff really quickly. This stuff's all available online. And we've got links at the end. So you can see it, but we're going to, you know, evaluate it. We'll build a back end. Now we'll call again, we'll call another serverless thing. And this is going to be our evaluate subcircuits. And we're done. Yep. Now we're going to reconstruct it. So again, split it in half, run each individual half, pull them back. And then let's run this again. Now, so this is going to verify the results. So the nice thing about this being a small example is we can actually run the full thing and we can compare the results of our split to the results of the full piece. And so that's what we're going to do here with this verify method. And what we can happen is, again, it's quantized, there's probability distributions and we can pair the distributions of solutions from the full example to the two, to the circuit cut example. And as you'll see down here at the bottom, they're exactly the same. So each use case has exactly the same probabilities or the same probability distribution for that. That's a way that's, again, how we can kind of parallelize big workloads, dividing, conquer them using Kubernetes to orchestrate them. So run low on time. So take away points here. Three kind of big things I think to take away from this. One, we can use quantum to solve those hard problems that we kind of mentioned. Some of those hard problems, not everyone, but some of those hard problems we can solve with quantum. And if we combine quantum and classical, we're able to solve some of those bigger problems much faster. It kind of gives us, that's kind of the optimal way to this. It's not just quantum, it's not just classical. It's quantum and classical together. And, you know, Kubernetes really is kind of the natural orchestrator for these types of workloads. So, yeah, that's kind of takeaways. We've got some links. I'm going to put these, I think these things are online. There's QR codes. The links are at the bottom. And then we've got the feedback slide at the end. So I'll leave this up here for a minute to give people a chance to take pictures and maybe, do we have time for questions or you got a, we got a, yeah. Got it. So what, thank you Paul. Oh yeah. Thank you for the great talk. My question would be the Kubernetes. There's actually running your serverless workloads on which infrastructure on which provider is this using? Where are you running this? We're IBMs, we run ours on IBM cloud, but they can run any cloud. Anything that can run containers. I think they want an open shift. Yeah. Open shift. Yes. Yes. So those are in different locations and then they're connected. The example that you just run, did it run also or it took the decision to run in a quantum computer or it was completely simulated? Because Yeah. So today I simulated them because networks, what could go wrong? But just to make sure that it was, so I've got a local cluster. So what I showed today was a local Kubernetes cluster running on my laptop. But to make it run on, you know, AWS or IKS or any Kubernetes, you just would, it's the same deploy, use Helm deploy it, and then you would just change the backend from simulator to quantum computer. You need an account and so on. But for experimentation, I think IBM gives you time when there's a series of quantum computers that we have all over. So you can just apply for it and get access to it. Okay. Last question. Thank you. If I remember back to the times where I was writing five bit programs at IBM, that was kind of a batch process. So I send them in and I got the results in the next morning. So that's probably not what fits in that classic concept that you have just provided. So if I download that, then I'm running the simulation, right? We showed very simple circuits. As I mentioned, like if you were to try to run shores or any kind of, you know, real problems, you'd need a lot more circuit, a much bigger circuit. And then you'd have to cut it multiple times and then use a real computer to combine. But this is what we're doing right now. So I think in the slides, we showed where you can actually go in. And if you wanted to contribute and try this, a lot of those Jupiter notebooks are there. So you can actually run them yourself. And then more importantly, all of the Qiskit, the circuit, sorry, the quantum server less, all of that is open source. And you can start using it right now. And if we had tried to run bigger things, we would have very quickly run out of time, as I think we are being noticed that we are out of time. So thanks everybody for coming. Really appreciate it. We have a question afterwards.