 Today number two, I hope y'all had a good night rest and we're able to enjoy some of Trieste and Saw some things, but anyways today. We're gonna be all day. We're gonna be up here. We're gonna have lunch again outside The buffet like we did yesterday, so I think we now getting the role of things how things work, right? So that's good. So today we're gonna have Glenn and bang Opening so he's gonna continue his discussion on adiabatic quantum computing and then we're gonna have start with error Mitigation in the morning, so we're gonna have some zoom meetings Unfortunately speakers couldn't come and then the afternoon we're gonna have error correction, so It's gonna be very exciting program again today. You're gonna learn a lot Please ask questions if you have a question. We do have you're supposed to have a mic We have a microphone, so we're gonna try to use the microphone because people online can't hear you but without any photo do You look forward to Part number two. Okay. Thank you okay so thank you very much for the introduction and Today I'm gonna continue the discussion. I started yesterday and I'm gonna discuss about this Diabatic quantum computation so the main thing that I'm gonna maybe write here that we should Remember is This is will be the conclusion of our of the last lesson. So we started saying at the end that if we have a classical Optimization problem. Okay Okay, so this is gonna be the problem of given a certain function H Which goes from a set of classical bits to R It's gonna be finding the minimum. So Zeta star, which is gonna be is gonna be let's say R mean so it's gonna be the minimum of H of zeta over All the bit strings so here zeta As we said our binary variables The one is a collection of and binary variables Okay, so actually, let me just change notation Compared to yesterday and I'm gonna use small n to indicate this and this can assume This zeta here can assume value zero one. So as we say there are some interesting problems that can be written like that and what we discussed is that these can be translated in a ground state Okay, which is gonna be finding the ground state of the following Hamiltonian which we called final H final and it's gonna be The sum over the z over the strings of H okay, and Finding the ground state so that we are gonna say Yeah, the ground state is gonna be equal to our Z star that we are looking for so it's equivalent to solve the ground state problem of this Hamiltonian or to solve the optimization problem and to solve the ground state problem we used adiabatic quantum computation okay, and We said that we supplement the Hamiltonian which with another Hamiltonian H I and We start the initialize the system in Psi zero At time zero is gonna be equal to the ground state of H I so we are gonna call it C zero where C zero is the ground state of H I and Let me just Continue here. Okay, and if we Do that we can evolve the system with the following Hamiltonian Let's say we can define this H which is gonna be F times Hf plus one minus Yeah, one minus H I Okay, okay here. Maybe let's Use a different notation because this so this F here just represents the final that is final So I'm gonna maybe write it like this just to differentiate from this F, which is gonna be a function of S Okay, and we say that usually we will take it to be as S Equal to S so so the important thing is that f of zero Should be Equal to zero and f of one should be equal to one so under the condition there if I think start from the initial state and I evolve with the Hamiltonian H of D over thought all over the total time, so we are using as equal To T over the total time I'm gonna end up after a time T in a final state Which is gonna be approximately More or less proportional to the final ground state, okay Which here is Zeta start so The time so this for this to happen so for the algorithm to solve the the problem what I need is that the evolution has to be slow enough and Because in this case that the abatic theorem tells us gives us around time so tells us that if the time is The time let's say that I need is gonna be less or equal the constant By epsilon which is the error that I I expect I want to obtain So it would be related to the accuracy and here I'm gonna have the H of s we say Almost divided by the gap Squared and I'm gonna have a maximum s in Zero one, okay, so This is telling us that if we have A problem and we find these Hamiltonians we can compute then for the time that is gonna Required to solve this problem with this algorithm by using the adiabatic theorem Okay, so the adiabatic theorem. I repeat it or repeat it just quickly What it says it says that the system is gonna remain in the instantaneous ground set of the Hamiltonian as long as We have this let me just draw Here we have that this gap It's gonna be these are the energies these are gonna this is gonna be the time and we're gonna have the energies as a function of time for the let's say Is zero state and for the you one and this gap it's the Delta is this Delta of s it's gonna be the difference between these two energies. So you want minus minus is zero of s okay, so so this is what we discussed and I want to show I want to discuss today an application of this of this Algorithm and I'm gonna discuss with the simplest Application and that is going to be Applying it to the Grover problem. So so we are gonna look at the problem of search in an on on on structured search so We are given a database which contains in this case n which is gonna be two to the n elements which are bit strings of You can write them as bit strings of and beats Okay, and we are given a marked State in this case we're going to call it Zeta star again, we are given a mark state and we have a Function such that if we call it on Q of z is gonna give one If Z is the mark state and zero otherwise Okay, so so, okay so this is the function that tells us which is the The string we are looking for and we are in the Grover problem. It's an Oracle problem. So the so the Problem involves the number of queries of times I have to call this function in order to So in to find the item so we know that Classically so we have That the number of queries is going to be of the order of Or to the end Okay So to the small and in this case and we know that on the other hand You have seen that In the gate base, let's say gate based Quantum computing you can make instead you can use the Grover algorithm, which is gonna achieve The same results. So it's gonna solve the problem. However, it's gonna do it in a time which is scales at Square root of n and these are like actually this is this is the best you can do right? So the best you can do classically it's scales at n and so you get a quadratic speed up in the algorithm if you go to the gate base quantum computing and now I want to look at the same problem and tackle it with this adiabatic Quantum optimization algorithm that I've described So in so the first thing that we have to do to tackle the problem is to to transform the problem into a minimization problem Okay, so we have to we have to find an H of Z that we want to minimize in the Grover and the H of Z that we want to minimize is Quite easy to get So we see that we want that the mark item So we're gonna take Q of Z minus Q of Z and in this case We're gonna have a minus one if Z equal to Z star and is zero otherwise and And a noun this star is Exactly the minimum of H of Z because it's the only point where the Values minus one and we have zero for all of the other ones Okay, so now that we are Into this kind of problem into an optimization problem We can use the we can start the program to use the adiabatic algorithm and To do this we say the first thing is to write the final Hamiltonian so the target Hamiltonian Which we want to That's for which from which we need the ground state and this Hamiltonian is going to be in this case As we said, I will write the formula game Okay, okay, and in this case since we have a zero for all known marked item This is going to be simply minus okay, and The second thing, okay, so we want to find the ground state of this Hamiltonian which by the way it's a bit It's written as a projector, but you may want to see it as In terms of spin Pauli spin operators on each side so this can also be done and If you want to write it like that, you're gonna get that the Hamiltonian is gonna be a product For J that goes from one One plus this star of J Sigma Z J Okay, and this I'm not Gonna discuss it is just this is just simply the projector a projection operation on each individual for each individual Qbit is projecting on the right value of Of that the Qbit you have according to this star and by doing this for all Qbits We can obtain the Hamiltonian So it's like actually a quite a complicated Hamiltonian if you write this product explicitly and would contain products of This Sigma Z variable Which can be up to the the whole system can Contain the whole system the Second thing we need is an initial Hamiltonian, so we said that the initial Hamiltonian should be chosen Like should be should be chosen It's can be chosen by us So once we have the final Hamiltonian we have to make a choice and choose an appropriate initial Hamiltonian so in this case the final Hamiltonian is It's what is for us is gonna be the Oracle. So it's playing the role of this Qz here in the classical algorithm because this final Hamiltonian contains its information about the state we we want to that is marked and we Want to use it Within the evolution to find the mark state. So in this case calling the the Oracle becomes using this Hamiltonian and Consequently the initial Hamiltonian which is part of our algorithm instead Cannot use the mark state because we should find the mark state without Making use of the fact that we know what it is. So it cannot contain this star and The choice for the initial Hamiltonian is gonna be simply minus again a projector C0 where C0 in this case is Since the Hamiltonian is written like this C0 is it's the ground state of the by the is the ground set of the Hamiltonian and we choose C0 to be They normalized So they normalized sum over All states so this is the equal superposition. So we're starting from from the equal superposition of of computer of the computational basis and Sorry Get and the read and this of course does not assume that we know which what is the mark state because this state is totally independent because we are taking all state with the same weights and the state it's actually not so hard to prepare because it can be written as Let's ask the product so it's gonna be let's say the tensor product of Zero one divided by So on this on the J on the J spin so it's gonna be like So it's gonna be like a state which is defined on Single QB on it's a product state. So these product states are usually quite easy to prepare and they the initial Hamiltonian can also similarly be written as in terms of the Pauly operators and In this case Sigma X and you will get a similar similar expression to the previous one But with Sigma with the Sigma X I will not I'll not write it down because in the Following we are going to mainly use these expressions in terms of projects or projection operators So after this the evolution The Hamiltonian is gonna be of the system is gonna be controlled by The by the by the the evolution of a system is gonna be controlled by this disambult onion which is going to be given by Substituting in that formula these expressions and we are gonna have F times G star minus And we're gonna have one minus F times Okay, so if we evolve the system with this Hamiltonian again F is Should have those properties that we described before and one Easy choice as we say it is gonna be F of s equal s If we use the evolution that I described before we can solve the problem with the adiabatic Optimization algorithm, but and in this case the issue is what is the time that's required to solve the problem. Do I need a time that scales worse or Comparable to this classical time that is needed or can I do Something with this algorithm as good as I was getting in the gate-based quantum computing Model and to do so we have to use the formula of the time and you would see that the formula for The time which is Gonna is involving the derivative let's say H dot of s and It's involving the gap Delta s So the next step is going to be computing these objects in order to In order to evaluate what is the time needed and let me just Okay, so from here, we're just gonna keep until here and just keep the Results that we need on the blackboard first result is that Hf was minus this star Actually and that H I Was is zero, okay and Now as we said we have to evaluate And we had that sorry maybe let me write also the fire day in Terpolation, which is gonna be minus This star this star minus 1 minus f C0 So this is what we discussed previously and now we just have to evaluate the terms that appear in the In the in the time in the expression for the time So the if we compute the first term, which is gonna be the norm of of H We had mentioned yesterday that You can take various norms here, but here I would consider the two norm So which is gonna be equal to so the two norm square is gonna be equal to the trace of Of H of square h dot squared Okay, and We are gonna have that for this In this case we are gonna get The trace of f dot this is gonna be equal to the trace of SF dot this star Z let's say minus C0 C0 Okay So never the Moreover, we will assume that we will assume that f dot is positive. So we can take it out Okay, and we are gonna use just this simple relation which says that The trace of X Y equal to This is going to be equal to Y okay, so We are gonna use this and we can compute the trace and let me just give you directly the result So you're gonna have that The trace sorry the the square Let me write here just explicitly. I mean that's correct, but let's use the trace form directly here So we can go to the next step and in this case. We are gonna have one Minus one over n where we use that the overlap between C0 and Z star Is equal to one over square root of n Okay, fine, and this is the first term that we need. So similarly we can for this problem we can compute Also the second term that we need which is gonna be the gap So the gap the computation of the gap. It's a bit more involved. So I will just in this case describe Quickly maybe a method to get to get it, but I'm not gonna write it explicitly. So Why can we get in this? Problem which is a many-body problem. So How is it possible that we can compute this object? when to do it we need to diagonalize the problem and we have Usually a hard time diagonalizing Many-body Hamiltonian. So the reason is that the Hamiltonian Joe all involves the projection or projection over two states So it can be written in the basis with we can use the basis the basis a basis containing Z star and It's orthogonal which is going to be Which is simply going to be Z star minus the Minus one over square root of n times This is zero divided by divided by one over divided by the by the norm So, I mean, I will not normalize actually. That's not quite important big for for this one It's actually gonna be like this So the Z star is proportional to this and the reason is that this is the projection of C zero on this star and we can remove We want to remove the projection from Z star and we do this we have just a basis with two elements because all the other Elements in the basis we could we can leave them the same and they don't contribute to the problem and We get a two by two Hamiltonian a turn by two Hamiltonian and for this Hamiltonian, which is simply a two by two Hamiltonian we can find the Gap, so I'm gonna write the expression of the gap after this, so let me Copy it directly from the notes Okay, so the expression of the gap is gonna be L the mean square one close Okay, so this is the expression we get You'll get if you do this computation of diagonalizing the two by two the two times two Hamiltonian and computing the game values and taking the difference Yes, so actually this I've written It for the gap squared if you take the square root of that you're gonna get the gap But let's just keep it with the gap squared because that's actually what appears in the Hamiltonian, so I have to tell you what are these terms that I've introduced so we have that Delta mean let me just Go here a second. You're gonna have that Delta mean and V are Gonna be respectively equal to the square root of n and One over Where root of n Okay, and now we can use these expressions To evaluate the the time so as we said the time It's gonna be the ratio between the It's gonna be the ratio between proportional So to the ratio between H dot and we have to take the maximum Over s of the ratio between h dot and delta squared and if we take this in this case we we get an expression which is Let's Write it over n. So this is the one for The h dot there and we're gonna have divided by Divided by delta mean and we are gonna have a Delta of s divided by delta mean Okay, so Okay, so what is Let me put the squares because it's squared. Okay, so if I take this expression and I try to I I can rewrite the I can separate Delta mean square the Delta mean squared from it. So This is gonna be Square and we're gonna have Let's say sorry Over Squared and we're gonna have here a Delta mean over the s And we are gonna have here the f dot time square one of n Okay, so How do we see how this What's the scaling of this object when we take the maximum right because it was a maximum here Over s and we have a maximum Over s. So how do we see how what's the scaling of this object? So I called this Delta mean because actually as you can see from the function of the gap This is the minimum. So if I plot the gap as a function of s We are gonna have like that Okay here we're gonna have that the gap is like this And s goes One and at s one-half We are gonna have a minimal gap here Okay, and the value of the minimal gap is You substitute s one one-half here you get exactly that is Delta mean and They They Okay, so so that's the first thing then the second thing. It's what is this F dot Okay, and this f dot we say that Usually we can choose equal f of s equal s and in this case we are gonna have F dot equal one so this Will directly imply that when taking The maximum we can have that we can replace We said we can replace we are gonna this with okay times n and We are gonna have a maximum over s of the ratio of Delta mean over Delta of s squared, okay, and this expression. It's Always smaller than one because Delta mean is the minimum gap Okay here. I substituted the expression of Delta mean and what I get is that the time that I need it's going to be Under the assumption that I'm taking this linear schedule is gonna be proportional to n and then we have a term which is square root of One one minus one over n which it's more or less proportional to n in In the limit of large n so we get that this unsatisfying result that the that the That using this linear schedule in the Grover problem. We would have a Result similar to the classical one. We have that the time needed so the time for which I need to use my Oracle hf it's Scales as as n as the number of items in the in the in the problem So how do we correct? can we correct this and The issue is that this is closely related to our choice of the schedule and The the idea is that we can find a better schedule which does Which does A better job so we have to choose an f of s we want to look for an f of s which when substituted here I can take the maximum and the maximum it's gonna be The maximum that I obtain is gonna be bad. It's gonna be It's gonna be better. So I'm gonna have like some total time which scales So better than n and in this case one The way to do it was proposed in 2002 by Roland serve and they suggested that We should try to keep this object. We want to maximize a Constant during the whole evolution. So what is this object saying as we already described yesterday this? object that we're trying to maximize is telling us that when When the gap is small The way this object is growing and so if I want the total time to be Somehow reasonable and not too big. I have to slow down. So each dot has to be Or has to be smaller so each dot has to so I have to slow down the evolution when I see a Closing gap. However in the linear schedule, this is not done. So since in this case I know the gap I can look for an f of s in such a way that this This object is constant. So the error that I'm making So let's say this error that I'm making depending on s. It's s independent and then when I will take the maximum So if I have a function which I can keep constant equal to c to const It's gonna be equal to To this so f dot we say it and one minus over n per root Delta mean square over delta s okay, so this it's a differential equation for my function f okay, and Let me Just mention that this differential equation for this particular problem can be solved exactly and I'll just write the solution of the differential equation directly. So So if you solve The differential equation that is below you are gonna get such a solution So, excuse me. Yeah, you are gonna get F of s it's gonna be One half Two s Okay, so this is the solution and where the the objects that I've introduced are function of Square root of n minus one. Okay, and Okay, what once you have this you can insert F dot in the expression for the for the For the time and you would get that the total time Has to it would be more or less less or equal and you're gonna get a square root of n and Okay, so you're gonna also get some Arquita and Jen so And this is proportional. Of course, you also have still this one minus epsilon which is related to the error the Okay, so if you if you fire and if you after this substitution you get that instead of having a Scaling with n you get a scaling with Square root of n for the total time. So let me just To give you an idea. I'm gonna Draw the kind of schedule that you get. Let me try to make it as accurate as possible Okay, okay And Okay, okay, sorry. This is f And this is s. Okay. So this is the kind of scale that you get and indeed is slowing down at One half where it's which is where we know that the gap is closing. So by taking a schedule which does this and Computing it Properly get a total time which scales which in the end is scaling Is let's say Has the scape order of magnitude of square root of n so in this case by doing this By doing this we can recover the The speed up that was obtained with the gaze based quantum computing and we can do this in this With the instead with the adiabatic quantum computing algorithm. So So what is maybe the lesson from this problem? So first of all It's we can recover the speed up Obtain with the usual quantum computing model using these other adiabatic quantum computation we and this is actually a Result which is quite general. So in general we know that There is a theorem That states that the two models of computation are equivalent I didn't write them down. Okay, but the two models of computation are equivalent. So I can equivalently use Gate-based Computation and I can equivalently use adiabatic quantum computation and I'm going to obtain at the end The same scaling if I do it properly if I use both of them at the best At their best performance. So I don't have to do for example choose wrong amiltonians or choose not the schedule not in a smart way because this is going to make the the problem Algorithm on their perform so so intrinsically Since they are the same Why should I prefer one or the other one? So first first thing is that let's say let me add here Adiabatic Okay, so little so let me describe the differences So the difference is that while this one is obtained with using gates on a digital device This one is obtained using an analog evolution on a on an analog analog device but from how I've introduced it and So this can run quite easily on analog devices. So this would be the first Advantage the the second advantage is that Since this computation as we described from the adiabatic theorem occurs Only within the ground state. So the system is somehow by the adiabatic theorem forced to stay in the ground state We would expect that this is somehow As long as the temperature is low enough somehow it's Would have some intrinsic noise really resilience to to to let's say to thermal to thermal noise and the so this may have this kind of advantage and the Set the other thing that I want to mention are maybe some difficulties that you would encounter when using this kind of This kind of problem. So we saw before that this HF was Actually that is written here. It's actually Quite a complicated object in the Grover problem. So in the and Implementing this you must have a device where the amiltonian so the interaction in the device are such a way that the amiltonian H of s is this one and in this case I would just remind you briefly that H of s was minus the product Okay, okay, and No, so this if you expand it would contain All kind of terms that you can imagine and there is there's Basically no device that can implement such an amiltonian. So you would also find have to Redefine the problem in such a way that you can change the H of s such that this H of f can fit into your Into onto your device. So this is actually also One of the problems that arise in this kind of approach is that you can you it's hard to expect that you can Do all computation with a single device without Let's say large overhead due to trying to make this Implement this Complicated amiltonians on your quantum device So I'll not discuss how this is done But there are techniques to to do this which are Go under the name of embedding and you can implement this kind of complicated amiltonians But this the price that you have to pay is that you have to increase the number of qubit So it actually requires a lot of qubits to solve the problem So for the grover will not require just n qubits But many more if we want to implement this complicated amiltonian on a quantum device So this is the the issue that you would encounter and the What last thing that I want to mention is that this time that we get here as we said is Related to the gap and the fact that the gap was becoming smaller And smaller it's not written here So but the gap the minimum gap at least was scaling minimum gap square was going as 1 over n and So it's closing Exponentially it's becoming exponentially small In the size of the system because the size of the system is 2 to the small n It did they know the n is 2 to the size of the system and this feature Which is what makes the computation slow? So what makes this to appear? It's quite a natural feature of many Of many quantum systems. So in many quantum systems that are I that Describe problem of Eltonians. You're gonna have these closing gaps and you're gonna have to use Similar techniques to try to slow down at the closing gap if you want to obtain some let's say if you want to obtain some Speed up using the best possible schedule and this is also something which is not usually so easy to do because it's Computing this difference it's hard for the many body case as we said We had an advantage because the Grover problem is very easy and we were able to compute this and do everything exactly So usually you will not know what is the runtime of the algorithm because to know this you need to compute the gap and You don't know the gap. So in most problems, you'll not know what the runtime of the algorithm is And what you do? It's usually goes under the name of quantum annealing in these cases you have no you know that Eventually you get the convergence if you go to a very long time, but you stop somewhere you cannot stop when Using the adiabatic theorem that tells you when to stop because the gap is unknown. So you just stop somewhere and you get Some values and you read those as an approximate solution of your problem and this is an heuristic algorithm, which is actually used and it's implemented in Current device in current devices and there are Company which commercialize this quantum annealers usually that are mainly based on Superconducting qubits, but there are now also some version on Rigberg annealing with Rigberg atoms and this are this is another way to try to solve these optimization problems and It's at the moment. There is quite some research going on in trying to see whether We can find a problem where this performs well because since we don't know the runtime we because we don't know the gap We simply have to in this case try it on a certain problem and see how it's performing and various Companies are research groups are trying to find problems where this algorithm Can perform well Okay, so that will be all thank you very much So if there are any questions Yes, I have a questions Okay, so what kind of devices would you implement it today because you said it's not gate-based what you were talking about So which devices are you using To implement this algorithm. Yeah, so it's not get based. I said like you can use Superconducting qubits or Atoms I mean in many cases actually in the gate-based device what they do is that to realize the gates they use some pulses or some Analog control that they used to realize the gate So what we do is what you can do in this kind of devices is to go one step back and use try to use directly the Analog knobs and controls you have in your device So it would work for most of the devices that are around The the the main problem is that you're not going to have control over all of the terms that I that you're required To control to implement the the driving Hamiltonian written there So you need some device which is sufficiently flexible Such that you can implement this driving Hamiltonian complicated driving Hamiltonians and is sufficiently has sufficiently long coherence time so that you can Get to the run you can the runtime is gonna be of the algorithm is gonna be smaller than the coherence time and at the moment Main mostly the experiments of annealing on large systems are done mainly with Rigberg and with Superconducting qubits Hey, thank you very much In case don't know more questions. It's thank our speaker again. Thank you And then we gonna