 I'm going to finish off what I was speaking about this morning. So we have, I was speaking about chemical phase estimation in the last certain lectures. That was a very, very expensive method. Okay, so that was kind of the recipe that was devised by some of the original people who worked in quantum computing. But there's been a lot of work in phase estimation since and there's been a few modern kind of advancements in the past year actually, and I'm going to speak about that today. So, particularly the one by Linlin in this, in his not like a phase estimation, which allows you to work in the Heisenberg limit for scaling error, but it's significant and cheaper, and it might be much more intuitive than the kind of kind of phase estimation. So, going back to phase estimation. Remember, when it acts on an eigenstate to a time machine operator, you get this perfect spiral in the real imaginary space of time. As you can see with this plot, the, and you can see that like the, the propagation defined by the phase. Well, obviously, when you have these competing eigenstates, if you have a linear combination, if you have a linear combination of eigenstates, you have this kind of different competing weightings of phases in the unit with a spiral. So this is quite difficult. And like, how do you extract information out of this. So it's quite difficult for them. But it turns out that you have this quantum, this quantum exponential least squares, which is this really simple idea, by Linlin, which essentially said, that says, what if we take the ZN, which is your transition state, transition matrix element, which is either the IH and Tau, where Tau has a time slice of propagation in the plan to look at. Then, then you can, then they say what, and then then that gives you the sample that for different powers and you get these blue dots on this graph and that gives you your data points. You say, what if we can fit that with some kind of quite simple exponential function here. So you've got this one set like two parameter exponential function where you have the R, which is the kind of the magnitude of the exponential the I theta N2. So N and Tau are fixed, it's only R and theta, which you need to worry about. Okay. It's a pretty simple idea, it makes sense. So basically you have all these data points at N, and you're trying to fit that with one. And you can see by theta and Tau, and you can see that if by doing this over all that points N, and try and make this as close to zero as possible. You can say that your, your, your function N, R, E to the I theta and Tau is equivalent to the time addition to transition matrix. And then you can then estimate the phase because you can replicate this perfect spiral basically. So the aim is to replicate this perfect spiral. And there's some quite nice revelations coming this thinking about this and, as we said before, calculating this transition matrix and ease the IH and Tau. This is quite simple thing, simple in terms of competitive cloud. And then there's an estimation object to evaluate. So you have, you basically have this Hadamard test for these different time periods, T to N. Yeah. And then you can calculate the real part. So the normal Hadamard test and you get the imaginary part by adding the phase gate where it's going to be. So this was slightly different length times with your chosen method of time evolution, you can use trotter, you can use terminated Taylor series, you can use quarter signal processing, whatever. But essentially, that you have a simple single answer. Which gives you the expectation value. So getting the ZM is done by the circuit quite simple. Now, it turns out that you can actually do some quite simple differentiation to make the problem even simpler. So, if you keep the fixed value feature and then vary R for minimization of L, you end up with this function, essentially. And then there's, you have to work through this paper in reference on the second book. You basically get you can substitute this back into the original equation yet you end up with this function which is, which is this minimum. There's new, there's new form of the loss function, which is substituted this. And you basically removed often the problem. Now you get your problem defined completely in terms of detail. And basically, because this function is so simple, you can see that minimizing this is just maximizing this function here on the right hand side. So now you just need to build Zm, e to the i, e to the m, tau. And Zm is calculated from what you see your quantum computing measurements and e to the e to m, tau is just now this parameter, this one parameter function. So you can see here, like, taking in your data input, data input Zm, which is a quantum computing measurements. And then, and then just scanning over the theta parameter so you can see you get maximums exactly where the eigenvalues, the phase up. So you've got this, so you can see here in this equation. So you can see the longer time you propagate for the more resolution you get in the peaks, but you can see the peaks are relatively in the same place. So this is completely, this completely avoids doing like the quantum period transform and having to do phase kickback. You're just getting the phase from the transition measurement. So this is really clever post-processing with the data. So this is one of the use cases that the students would do over the hackathon. That's pretty cool. So you just, it just requires measurements and it's all just the post-processing method to calculate the eigenvalues. So, so it's satisfied this method satisfied the Heisenberg limit. And then so you obviously need quite a good eigenstate initial eigenstate so you have, you need to have the paper says that you're 0.71 greater than 0.71 over that to get to be able to use repeating still success. And if it's below that you can still use some filtering and single processing methods to extract that eigenvalue. So everything's formally proved in this paper rather than them. But I would say this is really the cutting edge of phase estimation at the moment. So, so this is where you should really start. Okay. So we've spoken a lot about time evolution in the previous, in previous lectures. And now I'm going to dive a bit deeper into time evolution now, and this is kind of fault tolerance approach. I'm not going to talk about variation time evolution, just going to talk about the algorithms which come under the umbrella of Hamiltonian simulation. So, typically in this field you see by people like making maybe then Ryan Babich says guys there, and, and Donbury like they really heavily working complexity theory so they work from a top down approach where they're trying to think about asymptotic complexity, etc. But it does help to think about this is also different from the bottom up so how do we do the search strategy runs, rather than investigating complexity. And that's basically what I'm going to show you today is like how you how you actually implement these fault tolerance algorithms on a quantum computer. If we have a good enough quantity for. So, so rather than using an arachnid picture. I mean, it's like, here's a box at the time. It's like, here is a time vision box, I can run this with a private kid. If I wanted to. So there's a number of different ways to do this. You have the famous three are properization, which uses the same number of qubits for your state. And then the entire vision by LCU, which is essentially trunk, you do tables to take the series about to then truncate is truncated Taylor series LCU stands for linear combination of unit trees. We'll find out that. And then there's also the quantum signal value transform which allows you to do, which apparently is the most possible in the asymptotic limit, but it's still not downside. So the game is still out as they're like in the whatever regime you have, but they should try to have LCU or QSP, QSP T I should say. And it's very system dependent to like, hey on sparse to your Hamiltonian trotterization my better sparse to, yeah, etc. Okay, so what is trotterization. So I apologize this quite dense slide. Okay, but we trotterization you have this time evolution in the entry. Why is this, you think of as integral. Over time. That's it. Every time. But we know that time which can be implemented as a unit tree. You should be sure you've seen that. So you can think about this as kind of an infinite number of this integral into infinite problems of slices with infinitely small. So you can think about discretizing this, because you can think about discretizing this into a finite number of steps. And then this is kind of, and then obviously with your better resolution you want smaller steps so you can think about this. It's kind of I call trotterization sledgehammer, because it's just the, it's simple that you slice at your Hamiltonian times this. And it's really nice to test algorithms because it's so straightforward. But the basic thing is this you end up, so you go from this theoretical unit tree foundation into some, some of the unit tree you know, because you can implement the trotter steps directly. But obviously, because of because we're now doing products of trotter steps products of these a me entries, these slices. And this is not the same as the summation of it. So there is a trotter as lots of theory, lots of work into the air trotter, like studying trotter, but I'm trying to, for example, going to go deep into the algorithm literature. Okay, so we've already seen that we can take our phone on a Hamiltonian, and then we can turn it into a wasted linear combination of linear, wasted linear combination of unit tree policies. Okay, that's what, so we take, we don't draw a big contrast when I've got this set of power these with the weightings. So here's an example. Now, if we take, if you're, we can then take this linear combination of powers. And then we can trotterize that for a given time slice. So we're now exponentially each time and we propagated it by this time tab. So it's very important to add this extra, but it's been treated really much I didn't got the town. Okay. Now this, as we saw in the previous lecture. We know we're not do this with the sex is the powder gadget. Okay, so our friend is back. So here we have, so, and you can do this in my ticket by just panic Xbox. So it's abstracted away very nice. Well, the coding exercise actually to do this. So, you can see here, again, we have this internal, either the eye. And then we have a basis changes cubic depending on what the power. So we have, we have either the eye. Peter. Over to Z naught X one X two Y three so we've got changed into the X basis and had a Mars and change the Y with the RX. And we change it back. So it's thinking about these terms of these same similarity transforms, the base changing inside the neutral middle that you get, you can get a lot of ground. This idea and this, you'll see this again later on in the lecture, but extrapolates the much largest abstractions to. Okay, so. We can, we can just say I should say this, this example is not good because these these circuits do not correspond to this Hamiltonian. But you can get the idea so to say, so this is. So you've got two exponentiators power gadgets. So this kind of mathematical structure. Ends up being this, this circus. So, and then this, the feature here is that it's a two H a pizza, because there are five or two factor. There's a factor of parking here. So you just basically chain together all these kind of gadgets and then slice them up. And then you can just hang on the time slice and concatenate them all together and get your time position. So that's where trotter is so nice and you don't need any extra on sellers in and you don't need to do in blocking coatings or anything like that is the brute force ledge have a. So it's really easy to implement and sci-fi. So you can just exponentially the matrices and directly play within that, which is also an exercise for you to do this afternoon. Okay. So moving on to linear combination of the entry so as we've seen in quantum chemistry applications. You'll have to always will be given to you a linear combination of entries after you do the thing of transport. So you can see, as again, we have this structure where now summation over a and then PA can be quadratic or classic terms, whatever you want. Typically, though, so in the VQE lecture, normally you have to work, you can only measure the power is directly on the console computer by operator averaging or at best in commuting sets, but linear combination of entries. So it's a little kind of mutuals allows you to be able to manipulate the whole operator as a, as a matrix. It's a way of getting an operator into a sec and I'm manipulating it. That's how I actually think about it. So you don't need to like loop over the terms. You just get this big operator as you wouldn't in the linear algebra setting. It's directly direct manipulation of the circuit H at the operator H and would say the Hamiltonian at the second level. And it also gives you the access to do what you can actually do these brackets as one on one circuit, rather than having to loop over or power it. And it allows you, it's a stepping stone for many other algorithms such as quantum processing, which allow you can be function of these matrices, etc. So summary of this, like moral story, LC you get an operator into the circuit. Now you get the whole thing to play with. It's often called a blocking cone strategy because you'll see in a second. Let's take a simple list. Let's take a simple example. Say you got a two term linear commensurations one we have alpha X minus beta Y and for simplicity. Alpha square equals one. Okay. So we've actually accessed we can apply this whole operator to the circuit with this help to the to the state side with this circuit and I'll break it down for you. Okay, so, so what we have is we have this register at the top. It's called the prepare register. Okay, and the prepare register contains the weightings of each Hamiltonian term as a vector. Okay, so you can think about it as the first row of this are why contains the coefficients out and be there. And it just so happens that because alpha squared the speed squared equal one, they can be encoded directly as an I matrix. So you can see here and now we've got square real alpha minus square beta is at this stage, we haven't touched the side register yet. But the carriage to your nice to position. And then we can selectively apply our operators X and Y to their corresponding bit strings. Okay, so this is really the core of the new method it's like you can see that we've got the coefficient and now we're doing a control zero to apply the X to the X. So apply the X to the right to the right coefficient, same with the RY. So same with the control Y. We have my square of beta on the one is going to imply the Y. Just cross one bit string, but when coefficient with the controls. One. Okay. So you can start to see how the methods working. It's very simple but like you can deal not with this. Now, we have now in order to get this information out of the circuit we have to rotate back onto zero register so that's why it's a square root because you are rotating into it and then rotating out of it back on to zero. You times it by square of alpha and square beta twice to get alpha. So now you can see we've got on the zero register zero X sign. Yeah, so you can see we select when I replied. The coefficients to our side, and then we can extract it by measuring on the zero state so you can see these probably should be magnitude square. So you can see by orthogonality then this gets to one and then we just get this nice application of the original off rare tip to side. So you can do this for like very, very large matrices. So this is this is the LSD method. It's, it's very simple. People, it's often used in complexity of papers. But it's actually quite simple methods and I don't think many people think about it from the bottom up really. Okay, so the generalized form is a bit more complicated but not not much. It's the same idea. You have a pair step, select step and prepare step. So we again, we have this weighted some of power is. But now we have to do a bit to a bit more technical which is essentially we have to rescale. All this terms and all the terms in the Hamiltonian. We have them up to get this. This, this is the Euclidean norm. And then we just rescale all of our credit by this. And that's because obviously reason why we do this is the Euclidean norm has a bound that says it doesn't mean that this ULCU it always means this H can fit inside a large unit unit area. I can show you the proof for this. But the main idea is that we've got this larger ULCU which is this big circuit new truth and we're embedding our Hamiltonian as a block into the top left corner of it. Okay, and the top left corner is like in the previous example where we had zero. Now we have one key bit on zero state now we have registered zero. Okay, and the zero zero zero state corresponds to block that our Hamilton has been coded into says, and then you don't really care about the rest of the block. You, you allow for this to be a non-unitories thing by letting the rest of the block account for that because the total circuit unit tree is obviously the entry. It's pretty cool. It's open this open the door to like proper quantum linear algebra basically. So here's that here's what we call this Oracle framework you might see in this in some papers. So what we call the, we have a prepare step, which, which prepares all the bit string, so the Hamilton coefficients, weightings. And then we select to be applied the power is to the coefficient with a select Oracle and unprepared. And then we, then we post select into the zero on and filter on zero shots, which projects us back into the block of the larger matrix. And then that applies. This should be rescale so it's a sigh. So I'll talk you through this again so I meant yes and that's what this is kind of representing. This notation is just projecting into the block of that with that injury. Yeah. And we often see like I said prepare select prepare. So, in the general case, so we've got a long linear combination of weighted values. Remember we have to rescale everything. So rescale the coefficients by the Euclidean norm, just so that we're, we're sure that the blocking code may still fit inside the large of the entry. So you can see we basically we take, say we say the same as how the combination of how these has h and all had long history, etc. We encode each one of those into a unique bit stream on the prepare register. So we got zero zero zero zero for H naught zero zero one H one, etc. So we're storing the coefficients of the weightings and how the. The weight as, as a vector, basically, and it's the first, it's the first column of this. We start in zero and just encode it into this state. And you can think about if this prepares a new tree is the first column of the repair register. So it's a state preparation algorithm where the state repair contains the coefficients of the Hamilton terms. And then so typically the kind of the brute force way to do this is a serial kind of multi control way, which has a lot of work into improving the prepare states. So you can see here by doing these successive alpha rotations are why we can prepare this real vector by doing these kind of selectively multi control rotation. So basically what I'm trying to say here is that there's a guaranteed way to get this vector, if you use the circuit, but then there may be better more efficient ways to do this. And there's even very important approaches to state preparation, such as Q, Q wrong, etc. things like that, if you want to get into that. But you got that you couldn't do in particular position you can actually do it. And then one thing I should say the, if we have negative or complex way to do that, but Hamiltonian, that can be absorbed into the select part don't need to worry about that in this in the prepare. Okay, so now we've got. We've got our prepare state and got coefficients of the Hamiltonian stores a vector and Pete and P state coming in, which and the vector is zero zero zero zero one, etc. We then selectively apply the corresponding power is to that coefficient why they control how the operation multi control operation, but a multi control is indexed on the vector of the parent which coefficient that belongs to. As you can see here, we're like this, this is zero zero zero P naught is applying this P naught to this bit stream which contains this coefficient. This is a bit scary, but I think multi controls are lots of work being done to reduce the cost of multi controls. I first think it's evil that we can't really get away from so. They're necessary, but I think. I mean, you could obviously always decompile this down to sing on cubic gates, etc. but algorithmic development. It's much more simple to think about things in terms of multi controls. Okay, now we've got this. You can see where this gets. We've got our coefficients applied to our house. But now we need to get get this information out of the circuit. So, so we need to come. We need to unprepared the states. Actually, I should say. Yeah, so this is what if we if we look at this. I mean, how we select this, this is Oracle box. How one would actually do this. This is a serial instruction, which is kind of naive way we just apply the multi control to say if we have a Z two, why one X naught. We can just apply the serial like this. That's fine. But then, but you got you've got three sets of multi control to see that's not good. I think it can do this. So if you basically made a circuit with it with a third. Why an X and the three cubist thing that they made a box of that. If you then went to do a two control box. It will generate this circuit view and I'll probably optimize it a bit more as well. But there's a slightly more efficient way of doing that, which is using the power gadgets, which is our friend is back for the third time today. Let's take this simple three few example. We can implement this control multi control nutrient very efficient way using power gadgets. So we have this in again we have this in the center. But now there's no rotation like this is just the multi multi cubist power to operation. And then we can ask before just do the basis rotation on each side to get the power to. Now this looks more, looks more expensive than doing a simple. Z Z to Y one X and all, but you can do that. The reason for doing this is they allow us to compile really efficient way of doing the multi control. So you have this. So, so we have this similar if you ask you can if you can spot these white all these similarity transform structures in your circuit. You can often make a big savings between multi control control operations. So here you've got this GG structures similar to transfer. Essentially because you have this self this property where if there was no you, this would be identity. You can just control what's in the you. And then that will control the whole thing. So this is the big savings so you can apply that logic. And yet, so you can now we can just multi control and said, okay, so this is the same way that even with trust with trotterization has a structure as well. You can even control trotterization very efficiently this way to behave using it for control select operations. So produce the multi control back to the by like by third, which is pretty good. We've got paper coming out this soon. Yeah, so anyway now needs unprepared so we've got the final. We've got the controls. So we have this. We have the prepare register, which has had the power is applied to the state register with an unprepared and unprepared takes everything back on to zero six. So you can see you got H naught, and it was a time device coefficient again so you will move the square root. You can see we've got H naught zero zero P naught psi H one renom nice zero zero P one. And then what you do by you by measuring here. You should probably take it out. This is not right. So it's just a curfusion. But if you can see that this through your phone out soon. These just get one times the curfusion so you now you apply every single time I did this post-election, you apply your all the power links to their corresponding. And then you also apply it to the states as well. So now you can implement this H side. And this should be renormalised. I apologize. There should be a page. Now, you may notice that we're doing post-election here. So the big downfall allows you is that you have this success probability. And success probability is really important for doing the complexity answers that are considered. But also the practicality. If you have something, if basically this. This function tells you how many times you get zero zero when you do your post-election on the register. And it's basically a function of how you know, you know, Tony pictures. And also the normalization factor here. So you want H to be quite large, if you can. You can normally be close to one. Okay. So most of the work doing else to you at the moment, by people like our tourism is my life. I mean, it's like playing with the operator. Try and get it to be more to have to reduce this to improve the success probability. But still give you the properties that you want. That's the game with us years in improving the test probability. Yeah, so now, now we just to show some sort of how you can play with us to you. So now we can do these bracket had them on tests, but rather than just take the single power is we can take operate. We can take the whole operator like you would do in the night. Which is, so you can see here, we can just simultaneously measure the whole operator with what's called the generalized Hadamard test. So this is the Hadamard test. So we have this extra prepare register here, and it's prepared register and codes that allows to block encoding and basically gives us this whole operator rather than so you can basically allows to do this identity. This is very cool. Now you can do this with you can combine this with VQE if you wanted to. And because remember I said in the last lecture that this excess probability of the number of measurements with the power turns in your drawing the tracks form for operator averaging in the institutional VQE can be a killer because you get enter for measurements. This does enter the four measurements in one name. The problem is that you again have a successful ability here so there is a trade off it's not it's not magic. So you may have heard of Grover's algorithm, amplification, you can apply this with successive reflections on the repair register, and I'll boost the probability. That's that. If anyone's up for a challenge, try that. Okay. So, finally. Well, how long are we going to check the time. Okay. This is this magical new algorithm that's coming around. Originally provides 2016 was when the archer paper came out. But I think 2019 was when people came out by the time I can call it. The second processing is a really cool and it's part of this. Why is the foundation of this framework for grand unification quantum algorithms paper that came out by the time I think that's in there. But it allows you to allow you to show these these ideas you can unify all the algorithms on the one framework, which is very cool to try and explain that now. So if you think about just a signal rotation. You can treat the, the zero input with a zero measurement. As this operation right so you just do this, they got the cosine square this time in here. Now if you were to plot this, we'll just measure in zero. You can see it's just this. It's just a square function right pretty pretty standard. But it turns out when they were. Looking into this. They were thinking how much information can be stored on a single qubit. Okay. And it actually turns out from composite pulse sequence theory. I just trying to have an insight on this because he was originally NMR electrical engineer, which is like all built around composite pulse theory. So when they apply that to qubits, she's genius, because still actually to some groups that you do. Basically what they showed is that if you interleave these, these are z with the original signal rotation, which is cosine function, you can manipulate the cosine function, however you want. Okay. So here's an example where I just, you just give a random set of these into the use fire hazard fire rotations. And you can see that. Now what was on my cosine has become this crazy function. Okay. And what I'm trying to show you is not that this is useful, but it's like, you can really do a lot with a single qubit. And it turns out that these files can actually be encoded to make any functions. Right. It's kind of up to some caveats such as it has to be between minus one and one, the X, so on the Y. And that has definite character. So you can see here we've applied the same idea with this with this original cosine rx and then we've manipulated it with a known we've got now. You can generate the files as algorithms do that. It's classical problem. From the processing. It's quite the romance exchange. Basically, now you can implement this is a single single qubit. So we're still measuring the zero, zero, zero, zero. But you can see now, we've, we've, you can optimize, you can basically treat this as the best fit line and optimize the parameters. However you want for a given function. So we hit here. This is cosine five X or something. And this function on a single qubit. So it turns out there's this, this, this theorem that shows we can implement any chair we share polynomial of cosine theta, using this, this framework. And obviously the chair we share polynomial is a very versatile they can be used a basis for most functions I think. Yeah. Okay, so PA is this product of signs and co science. So it's products of phases and co science etc. So you can basically generate any function PA, given the some caveats such as definite parity and the emissivity one minus one of the original input. Okay, so this is, it's just a, it's just a single qubit constant processing is just generating function, but the by and by measuring on the zero zero element. You can implement whatever function you want on the original input data. Now, this can be used for. We can apply this to the, we can combine the blocking coding technique that we used in just I just arrived. Now every matrix has its own SPD, right. One matrix can always decompose as an SPD where you have a huge matrix scaling and then another huge rotation matrix. And then, but think about it when blocking coded matrix. We also have this in this SPD, but now this is living in the circuit. Okay. Right, so this is pretty cool. And the scaling factors, the s the diagonal s matrix. They can be manipulated just in the same way as how matrix function is done classically, where we apply the matrix function to the singular values. And then we apply the matrix which is immunized directly at the circuit level, using the codsign pressing mentality because the codsign pressing mentality value to implement functions on the circuit. Okay, so that's the really powerful revelation with this. And the circuits quite complicated but it's, it's kind of, it's like it does kind of make sense. So, rather than have before you had this RZ, RX, RZ, RX, whereas now, because we're playing with matrices, not just function. We, we want to, what we do is, we have to get the singular values onto this signal processing unit. So we do the block, the typical blocking coding, which gets our H, the matrix of interest into the circuit. We know that this is in the zero zero block of this. So this, this, these two qubits implement the ULCU circuit. Okay, as you can see here, we can then pick out that block by doing a multi control. And then zero zero basic now this, we can then pick out the block using the zero zero. So this, this mean this equals a zero zero zero multi control. And then that controls this matrix and projects it onto the signal processing qubit. Now because it projectives the matrix onto signal processing qubit, and then we're doing this diagonal. So this RZ diagonal phase thing, this implicitly manipulates the signal values of the matrix, it's quite, it's quite hard to come. It's not really intuitive, but this RZ diagonal, right, and then the signal values diagonal. So that's the kind of thing about it. So yeah, so this is the methodology to implement arbitrary matrix functions on a quantum view, because we do implicit SVD and then we signal process that the signal values using the quantum signal processing mentality, using the combination of block encoding and signal qubit rotations. And then this is, it's basically that's it like for the grand unification, you can show that Grover's algorithm, Hamiltonian simulation factoring, they can all be represented as matrix function problems. So that's that's what leads you to this grand unification is that you can add it or the matrix functions. So if you think of any cool matrix functions, you can probably come up with a new quantum algorithm. Yeah. Yeah, and then I just, yeah, we can do this now in part of it. So you get given, we have an operator we can do this. Okay, and then so this is now if you want to do Hamiltonian simulation with constant processing you have to, I believe this is out of date now because I think there is a way to get around this but. But for the purpose of completeness, I just says, so, because you have to have definite priority, which basically means you have other even functions, the exponential function is not a lot of even. So you have to take a process a cosine part signal process, the sine part, and then do it else in you on the hat with this handle martyr dad them together. Yeah, and so that that's basically the end of my side and my slides. So I hope you kind of have a grasp on the different flavors of time evolution and how constant processing can lead to the grand unification techniques. I hope it's not as complicated as it seems in the papers. Thank you. How do you like answering the answer. How do you advance it out. You just, yeah, good question. You just basically, you run all this you just take the, you run maybe 10,000 shots, and then you just pick the results which are zero zero on those cubers. You, that would just the successful prep. It is a bit confusing. So this only to visit circuit only works when you get the current zero zero. So it's like a successful application that else and you only happens when you have a current through this series of history. So if you give up, if you give it a set of shots through the whole circuit, you're going to get only a few of them are going to have zero zero. Yeah, so that's only the one three zero zero on this bit string, have the information playing H side. Yeah, that's your question. Yeah, you can keep going. You can't copy the way function. So it's, it's not copying the way function, the way functions just, you're applying operates the way functions it's like, you can always apply operators successfully to the way function. This is this is just a big way of applying an operator. Yeah, exactly just mentioned that the, the, the state, but the states register stays alive. So that's your point is that you're not measuring that this is not measuring the L.C. This is applying the L.C. to the state that is the state is still present in the circuit. Yeah. So that not really to be a side dash, rather than a side. Like using your application without measuring. You can do application and then measure the answer and then you'd have a higher, higher success probability. Yeah, yeah. I just don't know. You still have to measure the answer that, but it will be a higher success probability. Okay, this might be very low success probability. Okay, grow versus a series of successive reflections and like you do that, you reflect around the sphere, then it quadratically improves success probability. The amount of times you get zero zero would be quadratically better than if you did it, but you still need to post select at the end. Okay. Thank you.