Deep Prasad - Introduction to Quantum Computing

That's about to fall, David. Yeah, see, watch out, David.

What?

The tripod's falling.

Oh.

How are you? Good, good.

Yes.

Would you be interested? Oh yeah, absolutely. Okay, another signature. Great.

You too.

Did I? Yeah, emailed you, right?

Yeah.

Okay.

All right.

All right.

You have the clock tower.

There it is. Three o'clock.

Yeah.

And everybody's here. Wow! Brilliant. All right. So thank you all for coming. I'm very pleased to introduce Deep Prasad. He's here visiting from Toronto.

He has—

he's the CEO and founder of ReactiveQ, which is a quantum computing company, and he's here to talk to us about quantum computing. So thank you.

Thanks, Kevin. So yeah, good afternoon everybody. As Kevin said, my name is Deept Prasad and I run a startup company called ReactiveQ. ReactiveQ was incubated in the world's first quantum computing incubator. And this incubator, they call it Creative Destruction Labs, 5 years before starting this program, this incubator that I was accepted into, they spent these 5 years developing partnerships with the right people who would help them execute launching these quantum computing-based companies. So what they did was they partnered with the world's first quantum hardware providers. Some of you might have heard of D-Wave. They're technically the world's first real quantum computer hardware builder. Then they went on to partner with Rigetti Systems as well as IBM and some other people. So, and again, these are all quantum hardware providers. On top of that, what they did was they found some of the world's best researchers who were at the cutting edge of either the hardware computing side, the theory side, or the quantum machine learning side, which is another yet burgeoning field, kind of a subset of AI, but it's coming out of quantum computing. And yeah, finally, the last thing that they put in the piece were these investors, or a group of venture capitalists, who were looking to invest in deep technology companies such as mine. And so some of these investors include Bloomberg Beta, which is the investing arm of Bloomberg. And what was fascinating about this experience, and I'm out one year after it, what was interesting was the amount of people who were passionate about quantum computing, knew nothing of it, but they knew that there was some sort of application for it. And so as a founder, you kind of have to do this legwork where you're looking at what— how they look at their business, you're looking at their technology, and you're trying to think, can we even use quantum computing for this, or is this just kind of, yeah, using a hammer? My company specifically— this talk is about quantum computing, so I won't talk about it too much— we work on AI-driven engineering simulations. As many of you, I'm sure, have experienced firsthand with numerical methods and solutions that are generally iterative, for example solving a PDE, all these methods, when they become sufficiently computationally intractable, you're kind of just stuck waiting and you're hoping Or you have some trade-off that you take with the accuracy. What my company looks at is, can we leverage quantum computing, quantum algorithms, and hybrid algorithms, so quantum plus classical, to speed up these simulations? Can we calculate a better— a bigger family of PDEs or get to the answer faster? So yeah, that's what we do. Now, the agenda for today is this. I'm going to first look at the complexity analysis of classical computations, Versus quantum computations. Complexity analysis, it's a— it's used in computer science. It's a way of determining, given how, let's say, mathematically complex your problem is that you're trying to compute, how would a classical computer fare and how would different classical algorithms fare against that math problem you're trying to solve. So what I want to do first is we'll look at the classical version and then compare it with the quantum. After that, we'll move on to the motivation for quantum computing. Why even use it? What might it be good for? Then we'll go into the quantum model of computation. So what some people might not remember, because including myself I wasn't born yet, but there was a classical model of computation. And so a model of computation, it's a very well-defined concept. So we'll go over that and we'll go over quantum version. Then I'm going to go into 3 different leading quantum hardware. These guys are at the very cutting edge. They have figured out engineering problems that were thought to be impossible to solve even 2 decades ago. So this includes Rigetti, D-Wave, and Xanadu. And I'll go over different examples for each hardware system. Then finally, we'll look at future applications and some closing remarks. So first of all, the model of classical computation. A lot of people might be familiar with the Turing machine. The definition of a model of computation is a model describes how units of computations— emphasis on the units— memories and communication are organized. So here we have 1 bit, and the bit can take on the state 0 or it can take on 1. And then you have the—

yeah.

You have the classical unit in this case, and then there's something interesting here. So this diagram really well captures the Turing machine and the sort of ontological relationship it has with the underlying logic of the system. So in our case, this combinational logic, we're working with Boolean logic, right? All classical computers are based off of this kind of combinational logic. And interestingly enough, it follows the classical world. Then you have the quantum Turing machine. Now, this quantum Turing machine, it was initially proposed by Paul Benioff in 1980. A couple years later, it was followed up by David Deutsch, who— so David Deutsch, he's an interesting character. He saw the quantum Turing machine and he immediately realized that we can theoretically create these quantum analogs to the classical compute paradigm that we have currently. And so he said, where, like, if you take a Boolean gate, can we create a quantum gate? And that's exactly what he did. He is the guy who's created these quantum gates, and we'll see in a more pragmatic example what a quantum gate even is.

I'm curious, where does the— have you heard of the Soviet— the Soviets at one point, I know, had a system that was trinary, -1, 0, 1, right?

Yeah, yeah.

So where does that fall in things, and why did that kind of Not take off?

So I think, to my understanding, the reason why it didn't take off is because while you can— sure, you can make qubits, you can make qubit quartets, you can make a bunch of different states— what's hard is applying gate operations in it and maintaining your coherence. Every time you're— right, every time you're messing with your system, you're risking decoherence. So yeah, they weren't able to master the engineering control problem. So yeah, the— going back to the whole unit of computation in quantum computing, the basic, as I'm sure we've all heard, is the qubit. So I tried to represent it here. Notice how the classical bit I represented as 1 and 1 separately. This is trying to show that a quantum bit can be in a superposition of states of 0 and 1, so rather than just 0 or 1.

Hmm.

And then you have the quantum Turing machine, as I mentioned. The fascinating thing about this, from— and it's a statement about reality as well— the fascinating thing is that we can construct these universal machines where the combinational logic is quantum and quantum mechanical in nature. So this is what— how we describe a qubit state. Let's say that these are These are called computational basis states, and if you've taken quantum mechanics, you're probably familiar with the Dirac notation. So these are ket vectors. Ket vectors are just column vectors. We use it for convenience. This is the typical quantum state that you'd be representing the qubit in. In this case, the qubit can take on the computational state basis 0 or it can take on 1. Or like I said, it can be in a superposition of both 0 and 1 based on these constants. The interesting thing to remember is that when you're trying to describe a coherent quantum state like this, you need a normalization condition where the alpha and the beta squared equals 1. So with that said, what you can do is you can look at the quantum state of your system or quantum state of just one qubit, and you can look at it as a two-dimensional complex vector in the Hilbert space. Then these are some abstract examples of gates. I'll go into the math.

But so yeah, the state is simply characterized by a pair of complex numbers whose sum of the norms equals 1.

You're right, exactly. It's literally just a unit vector in a 2-dimensional Hilbert space. And every time you entangle the qubit— I didn't include it, but every time you entangle a qubit, what you would add is— let's say I entangle another one, you would have 0, 0 inside this ket vector. And one one or one zero, depending on how you entangle it. But yeah, the idea of it being a normalized unit vector still stays the same. So yes, these are some examples. You have a qubit, which is represented as a wire for historical reasons. Then you have the classical bit. This is a gate operation. So this is you're trying to keep your quantum state right. It's super, super easy to disturb. So you want to maintain the coherence, and you want to do computation on top of it. So these gate operations are very difficult. That's why I said the Soviets weren't able to, you know, crack quantum computing. It's because of this, partially this idea. Then you have this different measurement. So this is just you get a classical readout from your quantum system, and then time moves forward. So this is the complexity analysis that I was talking about. If you're familiar with writing algorithms in computer science, the one on the left is So this assumes, and it's an open problem in computer science, we don't know if P equals NP. So I decided to keep both possibilities in there. But so this is generally how we break up the complexity based on different problems for classical computers. So without going too much into the computer science side of things, all you really need to know is that these problems are essentially classically intractable. They're incomputable and we can create approximations. We cannot get exact solutions to an NP-hard problem. Then you have this quantum space. And so notice how you have the P problems and they reside in the same quantum space, P space. We have NP in both, but then you have this BQP. So BQP is the quantum version of the computational complexity analysis. There's a whole field of study that analyzes how we can even measure how hard it would be for a quantum computer to solve a problem. That in itself is a very non-trivial task. So yeah, this is— keep in mind this is theoretical in the sense that we are constantly pushing the bounds of BQP problems and quantum problems to figure out what exactly does this complexity map look like. Now, a few motivations for quantum computing just before we get into some more details. The first one is accelerated materials discovery. I might be a bit biased. My company is focused on materials discovery. It's actually how I got really into this space because what I found was that when it comes to algorithmically discovering new superconductors, I wonder why that was so hard, and I found out that the reason why it's because of this complexity class problem. The amount of simulations that you need to model become intractable very quickly. So one thing that quantum computers are going to be really good for are these materials discovery, where you can reduce the search space of the molecule that you might be interested in if you're able to algorithmically encode the desired properties that you want. And it allows us to explore the boundary between classical and quantum complexity Besides the obvious of why we might care about that, like the mathematical, the abstract, the science, I also think that this is important because it tells us again about the nature of reality. Like, does this complexity analysis reflect what reality actually is like? Then we have quantum computers for just discovering these intractable problems that would normally be inaccessible to current computers. And then quantum sensors. Now quantum sensors have been around for a long time, but anytime you have quantum data, naturally you can imagine intuitively to process that quantum data, you would ideally use a quantum computer for it with quantum algorithms. Of course we don't have that, but we have something close, right? We have near-term algorithms, and we'll get into that. And then the other one, and this is what the incubator that I came out of focused on, which was quantum machine learning. How can you enhance machine learning methods currently by running them on a quantum computer or using those algorithms? So going back, you guys have already seen this before. This is— let's take for example the NOT gate. It's the most simple quantum gate. Same with the classical version. The classical NOT gate is equally, I guess, simple and The one that you kind of start with to build models of computation. So one thing that I want to note though before I go on is note the name universal gate model. As the years go by, you're going to hear this debate a lot, which is this. A lot of people will hear about D-Wave, a lot of physicists who are in the space, and they'll say D-Wave isn't a real quantum computing, you know, it's not a real quantum computer, it's not a real quantum computing company because they're not doing this universal gate model. They're following a different computational model. And we'll see why that's important in a second. But suppose that you took a quantum NOT operation denoted by this X gate right here. It's literally equivalent to taking the bit flip. So let's say you had a 0-1 computational basis, it would just flip them. So if you started out with 0-1, you'll end up with 0-1 just with the Coefficients changed around. That's it. Now, another gate that's really, really helpful is the Hadamard gate. Now, Hadamard gate has no classical analog because it's specifically used to take, let's say, a single-state qubit and put it into superposition or take that superposition and take it out of it and back into just one computational basis. So in this case, let's say we start out with this initial qubit state again and we apply the Hadamard gate. What this is doing essentially, notice the 1 over root 2, is it's putting the— this qubit into an equal superposition of states of alpha beta over root 2. So the other thing that's really interesting to notice about this is the nature of this matrix. This we know. This is our qubit. This is our gate acting on the qubit, and our gate, this by definition has to be unitary by necessity. And the reason why, if you want to look at it from a physics perspective, that we need to do unitary operations is because let's suppose I take another unitary. Let's suppose I do a Hadamard gate on this one more time. What would I get? I would get back to this original state here, which means that I kept my— A, it's reversibly computable, and B, I kept my coherence.

Yeah? What does it mean mathematically to add a complex number to a ket?

So that's a great question.

If—

so earlier I mentioned that this wave function, this quantum state, it resides in the 2-dimensional complex Hilbert space. So technically, while we're seeing alpha and beta, these can actually be complex-valued numbers.

I think his question is why are the parentheses missing in alpha plus beta and alpha minus beta?

Uh, for this part? Yeah. So this is to— it's just for general, uh, generalization, because we could have started with, um, the Hadamard gate can give you either -2 or can give you a plus depending on whether you started with 0 or a 1. Yeah, so like let's say, uh, yeah, yeah, let's say I had a 0, then I would get, uh, I believe it's a -2. If I just had this guy, I would end up with a positive version.

I think the issue is you can't add alpha to beta 0, right? Because those are 2 different things. I think you want alpha plus beta parentheses and then 0.

Oh, I see what you're saying. Yeah, yeah, um, yeah, okay, all right. It's just for simplicity, like I tried to, you Yeah, but keep in mind these are all vectors though, regardless of like how this might show. It's all, yeah, complex vectors. Okay, that makes sense. Awesome. Yeah, it's not just a coefficient or scalar value. So let's start off with the D-Wave. As I mentioned, there's some controversy right now with whether D-Wave is an actual quantum computer or not. This is what their hardware looks It follows what's called a chimera architecture. The chimera comes from graph theory. It's a specific type of computational graph that you can represent nodes and edges with. In this case, the D-Wave has greater than 5,000 qubits, and that will mean something soon, I promise. And so yeah, this is what a glimpse of the hardware will look like, where you'll have these little superconducting wires.

Mm-hmm.

So each one is represented by a superconducting qubit, each node here, each circle, and they're connected by couplers. So when you're trying to represent your problem, what you'll do is you'll bias these coupling weights and you'll use that to represent the problem that you'd like to solve on the D-Wave. So the step 1 for D-Wave is obtain the qubit. Which is a quadratic unconstrained binary optimization problem. The D-Wave is really, really, really good at solving these optimization problems. If you're unfamiliar with like the idea of solving or like optimization problems in general, all it's saying is that given some objective function that I would like to maximize or minimize subject to a set of constraints, what would the most optimal solution be? Calculating this can be very trivial to extremely difficult. And so what you're doing here is, for example, like I like to use the example of maintaining your diet. So let's say you have some diet restrictions and you have a budget on top of that, but you also have taste. You like certain foods, you dislike other foods, and you need to pick 5 out of 10 foods that are presented to you, but you need to maximize the health value You need to minimize the dislike value, the taste, and you need to, let's say, minimize the overall cost. That can be represented as a QUBO once you convert it into this optimization value. Then what the D-Wave does is once you have this QUBO, it'll convert it into this Hamiltonian where you have the initial Hamiltonian and the final Hamiltonian. This Hamiltonian is— it's This essentially represents the Ising model, and what it's doing is it's taking your qubit and it's assigning those specific values that you asked for it to, to the couplers that I showed you earlier. So now when it solves that— solves for the ground state of the Hamiltonian that I just set up, that ground state and that lowest energy ends up being the answer to my problem. So D-Wave has figured out how to master this at a very, very big scale, relatively speaking. Like 5,000 qubits is a lot, and you'll see that compared to other hardware paradigms. So yeah, essentially I wouldn't worry too much if you're not seeing the connection as to why the initial and final Hamiltonian matter, but all you need to know is, and we'll go to the next slide. All you need to know is that this is what happens. We start off with the— with our problem and we've encoded it. So initially all of our qubits are in a superposition state and they're representing your problem. That's it. It hasn't tried to solve it or anything like that. Then once you have it, you start introducing, like I mentioned, you start introducing your final Hamiltonian. So this Hamiltonian represents your real weights. So the cool thing is that you're starting out with your ground state and then you're increasing and introducing these Hamiltonians while staying in your ground state. So what that does is that you've transformed your initial very simple problem to a hard one while staying in the ground state. And that means that once you're— once the D-Wave is finished annealing and it collapses to the classical version, it'll collapse to the lowest version of your new problem. Keep maintaining the— yeah, maintaining the initial equations. So here I kind of depicted it where you have these bias couplers and then you end up with your final state. So let's say this is your energy landscape depicted by your Hamiltonian. What these curves are telling you, these are created by your constraints of your problem. And so the constraints alongside with the actual objective function will tell you where your answer lies in. And in this case, we're always interested in the lowest energy state. So again, this would be our answer in this case.

One question, can something like that be done completely classically?

It can. That's a great question. There's something called simulated digital annealing. It's the exact same idea. Except obviously you can't leverage the quantum effects like quantum tunneling plays a big role. Like actually, I'll just talk about that right now. In the classical case, if we did this, we would be able to do the exact same thing, but what we wouldn't be able to do is we wouldn't— let's say we were in this 0 state here, we wouldn't be able to tunnel down to the 1 state. We would have to go over it, which increases the time for problem to be solved and whatnot. So yeah, go for it.

So to add to your question, there are some people who think that that's basically what the brain does. The brain is basically modeling information in terms of dynamics, like a dynamical state. And so by changing the landscape, you basically change the attractiveness of an oscillation to To a different type of oscillation, that's that's what some people think is happening there.

Possible, yeah.

There would be possible.

So this is my favorite example of somebody using a D wave for a any problem really. Some of you might be familiar, especially if you're in condensed matter physics, of the K T phase transitions. These guys they won the Nobel Prize. For it in 2016, I believe. And so the KT guys, what they found, I believe in 1975, was that for very low-dimensional thin film superconductors and thin film superfluids, there are certain quasi-long-range ordered states which shouldn't exist, which weren't predicted back then. So they figured out why that's the case. They realized that it's due to vortices and anti-vortices. Vortices among these spins that lead to this phenomenon called the K-T phase transition. So what these guys did, they actually— I met some of the chief scientists who worked on this. They're from D-Wave. This paper is actually, yeah, initially by them. It's a— it's, I believe, the first time anybody in the world proved that a quantum computing machine could actually be used to represent faithfully quantum information in a way that we wouldn't be able to regularly classically with the specific intention of the material design. So notice in this case, remember the chimera architecture that I showed you? What you're looking at here is that this is the physical problem we're trying to represent.

Yeah?

Your summary of KT was correct and on point, but there's a physical way of thinking of it that Yeah. So if you're trying to nucleate an isolated vortex, there's a very large free energy cost. But if you think of the vortex as having a particular orientation, it's much easier to nucleate a pair of vortices with opposing sense of rotation. And then the costal-asthalus transition is the temperature at which these— this vortex Right, that's the way we look at it. That's a physical picture that's helpful.

Perfect. So, so yeah, you can imagine the excitement for somebody to use a quantum computer, right, to simulate this kind of transition. Because I linked the paper, by the way. I think it is worth checking out. But yeah, just before I go on to the The thing that I was talking about was the chimera architecture. So what they would have done is they would have— in this case, these are a bunch of geometrically frustrated lattices, and they're represented by a bunch of different coupling weights. And you map that onto your D-Wave architecture, and suddenly your spins on your actual QPU reflect these spins. And these are the results. So what they were able to do was they were actually able to replicate the emergent KT phenomena from representing this state, which I think is incredible because the other cool thing that the authors did was that they actually presented this paper to one of the remaining Nobel Prize laureates. There was only one person, I believe, who was still alive, and so yeah, they showed him this paper. It's fascinating because this is obviously not trivial to obtain, this kind of graph where you're actually observing this simulated topological exotic phenomenon predicted by Nobel Prize winners, right? But you're actually seeing it on this quantum computer. So theoretically, if I hadn't even known about the KT guys and I just solved this problem, I would have also figured out the KT phase transition. Maybe you've gotten a Nobel Prize. But clearly that's not how it works. So then, okay, so yeah, this is the— I think this is a really important part for people who are just entering the field because again you'll keep hearing these nuanced views of D-Wave versus Rigetti and all these other model— like computational models. But the fact is they're all equivalent. They're all polynomially the same thing. So what I can do essentially with the D-Wave I can do with the Rigetti. Universal model and vice versa. So if somebody ever says that, let's say, a D-Wave isn't a real quantum computer, that's just not true. It totally is. It just might not look like one. And then, yeah, this is a—

yeah.

I think there's quite a few people who are arguing against the statement that they're equivalent. I mean, they're not programmable in the same way.

Right, exactly.

You have a quantum annealer. I think you Even the D-Wave people are not referring to D-Wave as a quantum computer. In certain circles anymore, they refer to it as a quantum annealer.

Right, right.

Which is very different from a quantum computer.

Right.

When you say computer, I understand something that you can program.

Right.

And annealer is something that you can use to look for the minimum of a landscape, which is what D-Wave does. And so in this respect, the 2 things are very different, I think.

Absolutely. I think it depends on how you use the hardware. Like, say somebody's crazy enough to create a general computational model on the D-Wave. It is possible, I just don't know why you would do it. But yeah, you're absolutely right that it's meant for annealing first and foremost.

I think at the moment there's a pretty well-established consensus in the community that D-Wave is a very powerful quantum annealer.

Yeah.

And that what the other people, including Ruggeri and Iheb and everybody else, is doing, they're looking for a quantum computer.

Right, and interesting enough, the Rigetti and the Xanadus of the world, the people who aren't D-Wave, they're trying to prove that they can use this circuit in the gate model to also do quantum annealing and do it more efficiently.

Most certainly, you have a quantum computer in the annealer too, but you cannot do the opposite thing.

Absolutely. But this is why— so this is why I mentioned the number of qubits, because in the end of the day, doing this universal gate model is very difficult. It's not trivial at all. Whereas with D-Wave, it's really just scaling the same kind of physics that they mastered with the Josephson junctions. So yeah, you have 5,000 qubits there. Obviously, it's annealing. It's not the same kind of qubit as what you have here, but you have less than 100 here. This, for the record, in quantum computing, any hardware you run right now, you have to do error correction even if it's D-Wave. So when you do error correction here, what you have to do is construct these error-correcting logic gates, and that takes up qubits as well. So once you're done your error correction, you might only have like 5 to 6 fault-tolerant qubits that you can use to do your computation. It's really nothing. It's not a lot at all. So yeah, we're really in its infancy.

Hmm.

But yeah, same idea though. You have these— Rigetti uses superconducting chips as well. So what Rigetti did, or what Rigetti was used for, was another materials discovery type application. And this is solving— this is using an algorithm called the variational quantum eigensolver. So notice this is— I'm sure everyone's familiar with this. It's just Schrödinger's equation. Notice that if you wanted to calculate the ground state, you State, would have to solve this. it can become another very computationally intractable problem. And now we have these quantum computers that can't handle that. We can't address very large complex problems. So we introduced variational methods. And by we, I mean the quantum computing community. But so what variational methods are essentially are a way of— so I'll move into the next step— is you do this. Let's say that I want to calculate the Ground state of some function, some Hamiltonian I'm given. And what you start off with is called the quantum ansatz. So this is your quantum state preparation, and your ansatz is essentially just a bunch of random initialization. So you have this one big superposition of states that represents your problem. You don't really care what the values of your initial coefficients are for this wave function. All we're really trying to do is. Finding the eigenvalue or the eigenvector that gives us the lowest energy state. And so in this case, we prepare each quantum module can be a series of different gate operations. And so once you're done that, what you do is you calculate the expected value. And after you've calculated the expected value of your of your energy, if it's not the lowest possible value that you could get. What you'll do is just repeat the algorithm. So that's where the variational part comes in. So once you're at this state and you're not satisfied that you don't think that this is the lowest possible solution, what you can do is classically optimize how you're going to change the coefficients of your weight function, and then you just start the whole algorithm over again.

Yeah.

So how do you know if you've found the global minimum as opposed to just a local? So this is a global as opposed to a local, right?

Yes.

So this is a common problem in optimization in general. It's not just physics-specific. And the way that they do it, like let's say gradient descent, is that your lowest is always your lowest until you find the next one. If your program, for example, let's say it's no longer ending, you've entered into some infinite loop, it means that you're no longer able to satisfy your constraints, you know that, okay, this is your lowest. It's not going to get any better than this. It's really just about iterations. Like, it's a really good question actually, because something like this we might run 1,000 times just to make sure that we didn't miss the global minimum. And also, you're not— just like with classical computational problems, you're not guaranteed a global minimum anyways. You're only really guaranteed a local. Uh, so then there's Xanadu. Now, uh, I had a really fascinating conversation about this Yes. So, as I mentioned earlier today, Xanadu is using q-modes rather than qubits. Recall that I defined the qubit as the 2-dimensional complex vector in the Hilbert space. In this case though, the q-mode is not that. It's not just represented by zeros, ones, and superpositions. A q-mode can take on an infinite number of values that technically it's— it can represent continuous variables. That's what it's used for, continuous variable computations. And there's less than 5. I believe Xanadu has like 4 of these qubits that they can use, but these are actual quantum computations they're doing though, so it's still very impressive. Yeah, this is a very common problem in quantum information science. It's doing quantum state teleportation. And so what I decided to do was use something like this quantum state teleportation and then just show you how we might do it on a quantum computer and simulate that process of teleporting your qubit. In this case, in the Xanadu case, you start off with your shared wave function. And let's say Alice and Bob, they want to transfer the quantum state— like, let's say Alice wants to tell teleport her quantum state to Bob.

Hmm.

Now, technically, the actual coefficients of your wave function are inaccessible directly, right? The second you probe it, collapses, you've now lost your quantum information.

Hmm.

So how are you going to physically move all this quantum information to the next person over and teleport it? And so that's where you use these— so this is a beam splitter, but really what you can look at it as is An entanglement operation where you're entangling the qubits that you want to protect. And so both parties have this pair, and so if one destroys it, that's no problem. All they need to do is tell the classical readouts, classical measurements, to the person that wants to recreate it. So in this case, it's Q2. Let's say Bob wants to create Alice's qubit, then all Alice will do is give them Give Bob the classical information. Then based on what classical information Bob was given, Bob will then apply the right unitary gates and then recover this quantum operation. Now recall that this is only possible because of this unitary constraint. It's like it's— it both matches the physics as we talked about earlier, but it's also a necessity for doing quantum computations.

What if Eve eavesdrops on between Alice and Bob?

That's fantastic. So yeah, that's a great question. So let's say Eve drops— she intercepts a message here. So there's a classical part, right? Alice is like sending a text message to Bob that I destroyed my quantum state, here's my values, and Eve eavesdrops. Well, so like, let's put ourselves in Eve's shoes. Eve will see the classical readouts and And that's it. She doesn't have this quantum bit, this qubit that Bob has, so she can't do anything with that classical information. She can't reconstruct her— the quantum gate, or sorry, quantum bit that Bob has.

Is that what— and that's why quantum communication, if it was made practical, would be more secure?

Much more robust. Exactly. It— because like right now, if this was all classical, this whole thing is vulnerable. But if it's quantum, Only in the classical part where we're transmitting information is vulnerable. Okay, now just quickly talking about some of my work, the specifics. We're hoping to publish in a couple months, so there's no link just yet. But essentially, one thing that I found when I was first starting out trying to figure out how we can So all these PDEs, faster was— I noticed how big of a difference meshing plays a role. When you're doing, let's say, the finite element method and you want to calculate the solution to a PDE, one of the first steps, right, is to calculate the mesh. And calculating the mesh can be extremely intractable as a computational exercise. Think of it this way. Let's say I'm meshing this physical space right here, this tall wall. And there's no grid lines just yet. There's literally an infinite number of ways I could slice this thing up to create my mesh, but there's only one optimal way of doing it based on the metric of minimizing your total angles, and that would be the Delaunay triangulation. The Delaunay triangulation, it's from a computer science perspective, it's the dual of the Voronoi diagram, and so what it's doing is it's Optimizing the area covered with the least amount of points you can save, and also minimizing the total sum of the angles for each triangle. This makes it really easy, or any tessellation, this makes it really easy for the PDE to do its job. How you do your meshing can make or break the accuracy, right, of your problem, and how long it takes, and also make or break maybe like, let's say, your patience. Uh, it could take from 6 hours to 6 weeks. So what we found was that, um, notice that like if you convert this, try to think back to the chimera architecture again.

Mm-hmm.

Imagine that rather than treating these points as mesh points, imagine treating them as qubits instead, where the angles are encoded by the coupling weights between the qubits. So now I can actually represent my problem of calculating the Delaunay triangulation as a Hamiltonian, as an Ising model. And I found that that's actually helpful. There are certain problems where D-Wave, once it gets better— it's not there yet in terms of number of qubits— once it does though, it will completely blow out of the water traditional classical ways of calculating the mesh grid. So yeah, that's what a lot of our work comes down to. Currently it's just meshing. But then there's also other results that we found. For example, by the way, like I didn't mention this, but if you're ever trying to solve a problem, the first step, if you want a naive method, is try and fit your problem to the architecture of the hardware that you're running this on, and you might see just natural advantages from the get-go. So in my case, let's say that I have a Chimera architecture for D-Wave, and there are certain problems where Chimera architectures are good for, like say the maximum clique problem. That's where I can actually apply this and it would make sense to get advantages. But you can anyways, it's just a heuristic. So, and I also— we also found out through our simulations that yeah, the more complex the topology, like let's say this, the better D-Wave actually ends up doing than when it's too simple, which I found was very non-intuitive.

Have you considered doing this with the ion traps?

No, because we don't have access to ion traps. I would love to, though.

Because the ion traps will not do— it's not a minimization problem. But with the ion traps right now, they have the ability to address the couplings. So they can prepare an all-to-all spin system. And they can individually address the couplings within however many spins they have in the lattice.

I see.

So it's not— So it's no longer a simple minimization problem, but it's something that you simply measure and it tells you what the outcome is.

Gotcha.

They can actually individually say, okay, I want, you know, spin number 1 to be coupled to spin number 10 by this much.

Right.

I want spin number 2 to be coupled to spin number— by this much. And I think this is uniquely suited for something like that.

That's smart. Yeah, fair enough. Um, yeah, I'll look into it. Thank you. So yeah, so then this is also super important to note too though. There's no real quantum advantage right now on quantum hardware. It doesn't mean that there's no theoretical advantages, doesn't mean we haven't hit quantum supremacy, but it does mean that we can't just replace all modern-day computing right now with quantum computers. It's just not going to happen. Even when they do get better, they'll be good for certain things, not everything. Then you have this part. We found this really interesting. We're not the only people trying this. What we're trying to do is generate these quantum circuits with machine learning instead, because if you looked at the computation models I've shown you, technically what you're doing is you're initializing the— all you need to figure out is what gate do I need to create and what coefficients does this gate need to have. For me to create the computation that I'm interested in? And can I outsource that problem to machine learning algorithm rather than a human? Then finally, I guess like I mentioned earlier about the complexity of the topology and all that stuff, quantum circuits could indeed provide faster and more accurate results than modern-day classical computers. Now, Here's some future applications of quantum computing. Assuming we have fault-tolerant quantum computer, remember I mentioned that you need to do error correcting for all your current quantum hardware? There's a definition that we have called a fault-tolerant quantum computer, which means that it's just like my current computer right now, right? I don't need to— you might not know this, but there's errors every time you do classical computation. However, we have so many bits in our current computers that it's not really a problem. We can do the error correction just fine. So yeah, let's say that we're there. Keep in mind though, this could take anywhere— what I'm describing, a fault-tolerant quantum computer with let's say even a billion qubits, we could be decades away from that still. It could— it might not even happen in principle. There's no reason to say it won't, but yeah, we're a while away. Anyways, the first one is maximizing the use of of quantum sensing. So, um, I mentioned that before, quantum sensing is used, uh, all over the place, and I do think that it's still a nascent technology because we don't have the processors to usefully use that data just yet. So I bet there's a ton of new quantum sensors that we haven't designed yet, uh, just waiting to be built. Then there's the obvious case of drug discovery, because in the end of the day, um, humans are just as serious chemical reactions if you buy that model, and chemistry is represented by quantum mechanics. And so therefore you can definitely simulate and predict what each, let's say, bimolecular interaction the body might go through. Let's say I designed a new drug, I can theoretically predict the exact effects it'll have given the biology that it'll be interacting with. So yeah, really personalized drugs is something that we can look forward to. And then designing better quantum computers. It might sound meta, but this is essentially where I started from, as I mentioned, which was figuring out can we use quantum computers to discover superconductors or exotic materials in general. And I think we can.

I—

as we saw through the KT transition and the variational quantum eigen solvers, that there's lots of room for building these better Quantum computers, and then it just becomes this infinite feedback loop. With that, I thank you for the attention. That's it.

Go for it.

I had a question related to the last slide with the periscope. Go for it. Also, is that for like the protein bundling problem? Protein folding, exactly, exactly. Yeah, so there's a company called— he's one of my friends, he came from the cohort right before mine. He runs Protein Cure. So Protein Cure is a company that specifically works on protein folding done on high-performance computers and quantum computers.

Yeah.

Good question. Yeah.

I'm not precisely sure how to word this properly, but you mentioned quantum computer with a billion qubits.

Billion.

Yeah, billion. Does it get really, really hard to tell what state that something's in and to make sure it doesn't decode here when you get a large number of qubits? I've always heard about quantum computers maybe getting a few dozen, maybe a few hundred qubits and Topping out there, do you really think a billion is feasible?

I do, and it's not because like I can say I'm like time travel or anything like that. I just figure it's the exact same. I'm sure somebody asked that same question to a classical computer guy, let's say 5, 6 decades ago, right? Do you really believe that we'll have millions of these bits rather than a couple thousand? So I do think it's inevitable because on top of that, there's no— there's not necessarily any Obvious physics or fundamental problems stopping us from doing it. It's just such a hard engineering and control problem. But then there's also this— I actually like how you framed it— of like what happens when you have so many quantum states or such a big quantum system, because we are large quantum systems. So I don't even think we fully understand the, the threshold, right, between when things start becoming more classical. And I don't really think we've poked that valley down. If we ignore about the difficulty of realization, currently we are using qubit. Assume if we use qubit or arbitrary qubit, will this be improving the efficiency of the algorithm? Absolutely. So what it's really good for right now is getting exact solutions, for example, to the Schrödinger equation because you're literally using the quantum physics system, right, to represent your problem. So right now, and there's this— we're in the era called NISQ. NISQ stands for noisy intermediate-scale quantum computers. So we have these metaphorically tiny quantum computers. They're super noisy, but they do work. They are performing quantum computations. And so what we've been trying to do is let the million-dollar problem The question is, what can we do with this right now? And the way that I look at it is that if your problem is a physics-based problem, you have a much higher chance because there's less layers of computational abstraction to represent your problem, right? Like, let's say the k-T transition is a perfect example. You're simulating a bunch of spins and the actual thing is a spin system. So, yeah.

So, So have you considered applying these techniques to what some folks call mesoscale problems? That is to say, there's 1 or 2 body problems, there's too many body problems, and then there's not too many body problems, like say 10 to 100.

Right.

These are often very important in addressing cell biological or cell biochemistry problems.

Gotcha. So we've— I haven't personally looked at, let's say, few-body problems. I know that that's a thing, like rather than many bodies, there's few, as you just explained. What I've found though, to some of my colleagues who have tried to probe few-body systems, they said that we can't actually calculate all the— or predict all the possible emergent phenomena because we ourselves don't know enough about it. I don't know like enough about it to incorporate it on a quantum computer. So I don't know if that problem is still a problem today, but yeah. But it is absolutely— that would be a great place to start. Again, small system, and it is a quantum system. So yeah. Yeah, no problem.

Go for it.

That would be a bit of an aversion of a question I have, which is If you're using quantum effects, there's the problem of quantum collapse, and that's what a lot of the error control is for. Do you have any sense of how managing that difficulty scales?

I do, and it scales differently for your architecture, right? It depends on what physics you're using. So let's take, for example, This chimera architecture for the D-Wave. So the D-Wave is using these superconducting qubits, which— and like, they're relying on a super cold environment to keep this coherent conducting state. But every time, every time they couple too many— for example, in this case, this architecture will let you couple to 5 other qubits, so you can have a total of 6 connected qubits. More than that, and suddenly your You're guaranteed your system will decohere and collapse and you'll disturb it and break it. The way that it scales for D-Wave— so first of all, I'll say this as a general example, forget D-Wave actually— is with photonic computing, if you can master the control, the actual interactions of these, and you can make these small little quantum gates for photonics, that will scale much better and safer. and stable than, let's say, this kind of architecture where we're always going to have this low temperature requirement and high energy and light? Yeah, so, so yeah, I mean, this environment in general is just weaker, whereas with photonic-based light computing, heat and room temperature won't destroy your quantum state if you can get it there in the first place. So you can actually have room temperature quantum computing. That's what Xanadu's Working on, yeah, these guys.

Any more questions?

Let's thank the speaker again.