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.  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.  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.   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.   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.  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, 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.


Hi If you're not asleep already You can join us in the next talk. I am parol and with me you have Krishna and We are going to talk about how you can empower the efficiency of your clusters by using Power aware Kubernetes scheduling. So we've had too many AI and LLM sessions This is a good refresher for you and stay with us So first who we are we are open source contributors that are working on cloud native sustainability stack and the major contribution comes from IBM Intel and Red Hat any Intel folks here No, we have few IBMers and Any Red Hatters Okay So at the cornerstone We have the project Kepler which gives you energy observability metrics of your cluster and Around Kepler. We have other projects that We are using to consume those observability metrics to do cluster optimization Kepler is a CNCF sandbox project already and feel free to drop at a kiosk on Friday 10 30 to 12 30 if you want to know more about Kepler But today we are talking about peaks which uses Kepler observability data to Do energy and power aware Kubernetes scheduling? So what problem are we trying to solve? Well, we all know that the I'm not sure if all like anybody familiar with Kubernetes scheduling framework Okay So like Kubernetes scheduling framework gives you the provision to have your in-built or like custom scheduler plugging that you just hook up with the Scheduling framework and you can optimize or you can try to Solve whatever problem you're solving in the scheduling or whatever objectives you are trying to Maximize or minimize but within the ecosystem. We found that there's a lack of scheduler plugins that focuses on power optimization or energy efficiency While also taking care of the other objectives that they are trying to solve so we thought of developing peaks that can address this gap and What peaks does it it essentially tries to maximize the energy efficiency of your cluster while also Focusing or letting you do other stuffs like how to optimize on topology and how to optimize on Network or CPU utilization So our goal was to come up with a Configural scheduling plug-in that minimize the aggregate power consumption of the entire cluster and We wanted to implement it as a score plug-in While making sure that we are not altering the default scoring plugging of the Kubernetes framework So the solution obviously peaks being just talked about peaks for so long. So Peaks is a Kubernetes scheduler plugging That aims to optimize the aggregate power consumption of your entire cluster and the important Thing to note over here is during scheduling. So it at the moment peaks only do this optimization at plot placement and It uses pre-trained machine learning model that correlates node utilization with power consumption to predict the most suitable node for your workloads and these predictions are based on the resource need of the incoming workloads and The real-time utilization of the nodes so let's go where peaks workflow and This is quite going to be very descriptive. So stay with me We'll start with what happens or the pre-processing. We need per scheduling cycle so we start with taking a node in your cluster and You have all the nodes that you have in your cluster You extract some metrics right now We are using energy consumption metrics that comes from Kepler and we use usage node usage metrics that comes from Node exporter or load watcher But the thing to note over here is you can bring your own metric provider It doesn't really matter what metric provider you're using as long as that metric provider push the metrics into Prometheus and you can read from Prometheus The energy consumption and the node utilization metrics so for each of the node you will have these metrics and then you will create a Node power model which is a function of node utilization Node energy consumption and the workload request that your pod has So you train a machine learning model for each of the node within the cluster the next step is you have an incoming workload and The pod has its resource requirement that can be read from the manifest so Not this processing is done per node So what you do is you consider a cluster node and its power model So you have a node you have the power model you try to predict what is going to be the change in the nodes instantaneous power if you schedule this part on this node and you whatever is the change in the nodes instantaneous power is What is returned as the plug-in score? So you do this for all the nodes in your cluster if you have more nodes You just repeat this process if no then you just go towards normalizing the plug-in score So over here we have given a basic normalization function but essentially what it does that it gives higher score for nodes with has less change in power and once you have The normalized plug-in scoring done then you can put a suitable weight for the peaks plug-in and weight is essentially Kubernetes led to you assign a weight to the plug-in and depending on the weight of the The priority or the importance is given to that particular plug-in so Once you have the weights you have the score you just This whole cycle will give you a node that is best fitted for the pod If it and you decide that by the highest normalized score So if you have more parts to place you just repeat this process if no then your cluster That that's really happens. You will always have more workload so Let's talk about the power model training and inferencing so each node will have run some benchmarks and This is like a screenshot of all we were using stress ng for this particular experiment So we ran a lot of benchmark we Overutilized hundred percent utilization of all the node we collected the metrics the particular metrics we were focused on worst CPU utilization and power consumption and using those metrics you generate your node power profile and Inside the plea plug-in you you import the model power parameters and Once you have the pod you get the resource requirement of the part you get the node model parameters from the model and then you predict the best node for that particular part and The prerequisite for this was Metric provider as I said you can bring your own metric provider as long as they push the metrics into Prometheus We used Kepler and node exporter You can also bring your own model like it doesn't really matter How you have trained your model as long as peak can use that model so The training is outside the scope of peaks but when we were creating this we have a training pipeline But it doesn't matter how you train your model peaks just uses those model to the inferencing so the important thing to note is You you can train your model depending on your cluster behavior. So if you have like AI specific Workloads, then you can create the model according to the AI if you have edge specific So you will consider those parameters in your model training and you'll have edge specific node model So next we have experiments and Krishna will give you an overview Yeah, thanks, but So we have gone through the what peaks is till now I would like to take you through the value of peaks how you can realize actually the value of peaks so that We all can appreciate the work right so before I jump into the different use cases Let me also first explain you briefly about the experimental setup that we have so it's a two-note cluster that we have considered for the evaluation of a peaks performance and We considered it in particular a bare metal cluster Kubernetes cluster with two nodes These nodes being heterogeneous in nature. What heterogeneous here refers to is the resources allocated to these Nodes are Not exactly the same right so one is a high power machine one is a low power machine you can see the CPU cores varies from 8 to 40 and also the memory allocated is very high in this node and And then we run the benchmark workloads and fit the try to capture the nodes power behavior and these curves represent the nodes power behavior the One in blue is for the node one and the one in orange here is for node two you can see that the the power curves actually depict two things one is they consume some power even when the node is Almost not utilized right even in the ideal state They consume some power and the power consumed the ideal power is very high for the high power node and Low for the low power node and also during the active phase as well The amount of power consumed by the high power node is very high. So this we can look at this from this graph and with this you can actually Relatively rank these nodes one being the more efficient node the low power No, is more efficient the high power node is the less efficient right another important aspect is that as I said some of the use cases we Go through to realize the value of peaks plug-in This is the scheme of evaluation right we first Run some workloads using the Kubernetes default scheduler then we repeat the same experiment Replacing the default to Kubernetes scheduler with the peaks scheduler During these two scenarios we calculate the we collect the matrix like node utilization energy efficiency matrix and then compare how much is the energy consumption during this experiment and See if there is any Saving in the energy consumption using peaks if that is the case then that is attributed to the value of Peaks plug-in. So this this this scheme of evaluation is Common across all the use cases that I will take you through and this is the particular cluster set up on which we Demonstrated these use cases, but these use cases are generic enough to be able to carry out on any cluster node with any number of Nodes and with any types of homogeneous or heterogeneous only that the amount of savings will differ Okay, so let me jump into the list of use cases that I would like to take you through So this one is the most regular configuration when a party is being deployed With the help of a Kubernetes scheduler second one is the scaling of your part using horizontal part order scalar and using a cube cut all scale that is another very popular Cli interface To operate on the different API objects and fourth one is migration of a part via part explicit eviction And the fifth one is a much more generic case That is a cluster auto scalar. We'll see more details and of these use cases But this is the gist of the use cases that I would like to spend the next 10 to 15 minutes The first use case is a deployment of your part using Kubernetes scheduler Under this we considered the cluster with the two nodes and we assume there is no other application or part running on this cluster and Only one part is to be scheduled that belongs to our application and That is a part when it is a schedule using the default scheduler because the default scheduler is not cognizant of the nodes Efficiencies it can place this object this part on any of these nodes Assume that it places this part on the node enough on the node, which is energy inefficient So and if it runs for a while about 10 minutes, you can see that the node utilization of that energy inefficient node is At some level it is around 12 percentage You could actually turn a bigger workload and the utilization can be much more higher Then repeat the same experiment with replacing the default scheduler with Peaks scheduler, but this time because Peaks scheduler is aware of the energy efficiencies of these nodes So it will choose the node n1 which is most energy efficient in this case. So you can see the part Executing on this node again. He transfer about the same period 10 minutes, right and the right side a graph actually depicts the energy consumption of The cluster across these two nodes over the time progresses now you can see that using the default scheduler the Energy is consumed some some amount and with using Peaks the amount of energy consumption is lesser So there is a saving the gap between these two graphs represents the saving in the Amount of energy consumed by the cluster across its all nodes So in this experiment what we observed is the saving amounts to roughly about 12 percentage And points to note before I jump into the other use case is that the energy savings can be more if you run this same experiment for longer duration because the accumulation accumulated energy over time Over time we have some Portions of energy which gets accumulated over time and hence over time if you run the workload for longer duration You will see more savings. So that's one thing and second thing is because the active energy for the The high power machine here is very high. So the as the utilization of that node goes up So here we are running these nodes at lower utilization if you increase the utilization of these nodes You would also see a higher savings. So there are two ways for realizing higher savings and I would also like to extrapolate the fact that if These parts are running on these clusters along with other applications as well We can realize such a saving just for the sake of understanding the concept more easily We had we assumed the fact that there is no other application running at this time But this can be co-located or co-executing with other applications parts The next use case is a scaling of a part using a horizontal part autoscaler. So in this use case actually we have a particular Deployment and the deployment is configured with the horizontal part autoscaler the particular CPU percentage here represents the fact that when the Resource utilization allocated for this part goes beyond the 50 percentage limit Then a new part is created by the HPA And we want to have minimum of one part at any time and a maximum of 30 parts to be configured by the HPA controller and When we do this experiment using the default peaks scheduler. So you can see that as the load increases then The HPA controller starts creating more parts and When the HPA controller wants to create a new part The placement of that part the decision is made by the scheduler default scheduler and Because it's not Default scheduler does something called spreading of the parts on the nodes, right? So it equally tries to Place these parts over the time. So during this experiment We created about 15 parts and those parts were alternatively being placed Between the nodes of this cluster. So you can see that the at any point in time almost the utilization across these These two nodes is at the same level, right? So and now Come come back to the the peak scenario when peaks is used for scheduling When the load increases the HPA controller horizontal part autoscaler controller Does the same kind of scaling that that it decides a new part to be created as the load increases but this time the part placement is the decision is made by the peaks scheduler plugin and Because peaks is aware of the no energy efficiency of nodes It wants to first adjust all the resources available on the most energy efficient node So it tries to keep the parts as much as possible on node one first Okay, so you can see that the utilization of for node one goes all the way up to hundred percentage before a pod is Placed on the node two, right? So initially the pod The node one is packed with the parts and then once the node ones all the resources are exhausted Then no two starts getting packed, right? So this is the place where no two starts getting packed and you can see that at this level Node one is at hundred percent utilization, okay? now you compare the energy consumption of the cluster across these two nodes under these two scenarios the RNG line represents the energy consumption using the default Scheduler plugin across these two nodes Whereas the blue one represents the energy consumption across the cluster nodes both the nodes using the peaks Scheduler plugin so you can see there is a gap between the energy consumption Over the period right so as the time progresses the gap increases so this is because While time progresses actually in this deep default scenario. We are using the more resources of Node 2 which is energy inefficient. Hence the gap is increasing now There is another observation that you can make is that after a point here the Gap starts decreasing why the blue car who starts growing up here is because This represents the time scale timeline where? Using peaks we started using the resources of node 2 which is energy inefficient, right? So as long as this was not used the gap was increasing because we are using under the default scenario resources of node 2 in this so hence that there is an increase in the gap and here We started Using the resources of node 2 hence the gap starts decreasing So this demonstrates the fact that using HPA horizontal part auto scalar with a peaks plugin you can still realize energy savings and horizontal part auto scalar using a hard horizontal part auto scalar along with the The deployment is a very common use case because HPA enables us do scale up and scale down automatically Right, so let me go to the third use case in the third use case we see the advantage of peaks with a very famous CLI that is cube cuttle scale the cube cuttle scale actually interface Is helpful to scale up and scale down the parts of an application where the API resources are not just being the deployment resources, but they can be The stateful sets or replication controller or replica set and so on so there are a variety of application API objects that Kubernetes actually allows users to work with and under This variety of API objects To configure right to scale up scale down. This is the API now. What happens? So let's see with the default controller plugin assume that We have a deployment Which has two parts initially assume that these two parts are Deployed on node one and because this is the most energy efficient assume that due to some scenario The nodes the parts are initially placed on these nodes now Think that the application one or wants to scale up the number of parts from two to five now the new three parts They are scheduled by the default scheduler default Kubernetes scheduler on the node two because default scheduler behaves the thumb rule is to spread the nodes across the nodes, right, so it Places these newly created parts on node two even though there is a space for Deploying these parts on node one which is more energy efficient because it cannot simply do that I just not aware of the energy efficiency of these nodes now on the other hand if you Consider the scenario of a peaks plugin consider that we have initially two nodes and Sorry two parts which are deployed on the most energy efficient node And now we are doing the same experiment We are scaling up nodes number of parts from two to five, but this time the new parts are deployed on the node one because this deployment is Handled by peaks scheduler plug-in and it is aware of the energy efficiency, right? So Please note the fact that Okay, so maybe I will Go to the another use case migration of part. So This is the fourth use case where consider the scenario where at any random time instance certain parts may be running on the cluster nodes and Assume that at a given point in time We we have an application running and its two parts are running on two different nodes, but you know that The node one time by one is more energy efficient. So ideally you have two options here. You can let the Application run as is and complete or you can actually try to move this part from node to to node one because not running on node One is more energy efficient. So if you try to delete that part manually and this time Because the API object the replica set knows that a part of this number of replicas is Deleted it needs to create a new part. So it will try to create that part to meet the desired state of two Replicas so but this time The part is again created on the same node because this The underlying scheduler plug-in is default on the other hand You repeat the same experiment with the peaks plug-in assume that there is another application running which is already consuming most of the resources of energy efficient node and our particular application PHP Apache is Running with the two parts one on node one and another one on node two So assume that after a while the other application CPU stress test exists so when it terminates it Releases the resources allocated to this application. So now we have the same scenario where The either we can let this application run as is or try to see if we can move this part to the energy efficient node So this time try again the same command try to delete the part that is running on the energy inefficient node and this time again replicas it knows that one one part is Exiting so it needs to create a new part it tries to create that new part And now this time the scheduler plug-in will try to allocate that on the energy efficient node So this mimics the auto migration of parts from energy inefficient nodes to energy efficient nodes At random time periods, right? So this we have done it using a script, but it is always possible to Exercise the same behavior using some automated scripts like Jobs and cron jobs and so on right which can actually be monitoring the energy the resource usage of energy efficient nodes and if they find that Energy efficient nodes are anytime underutilized then they try to move workloads from energy inefficient nodes to energy efficient nodes automatically right so all this is possible to automate so the Last use case that I want to touch upon is Using cluster autoscaler in the previous use case. We have seen the scenario where the parts corresponding to a given Deployment we are trying to migrate. What if we want to do it across all the deployments of a Cluster, right? Why can't we do it? So if we try to do that across the cluster By trying to migrate all the parts running on the most energy inefficient node of the cluster to Any other node of that cluster then ensure that the most energy inefficient node of that cluster is Dried up of the parts then the cluster autoscaler will identify that this is underutilized and automatically will Delete that part then by doing that you are not only saving the active power so by the way when we do the Migration of a pod we are actually saving on the active power, but by shutting down the nodes We are also saving on the idle power and if you see these two graphs The idle when the node is any node you consider any cluster node when it is in idle state It accounts for some energy and which is also known as ideal energy and this is increasing in nature even if you just to keep the Node idle right you you think that okay my node is not doing any work and Still it is consuming a lot of power and it is a significant portion of nodes total power So shutting down the node is one of the best ways to handle energy savings So this is the use case that that demonstrates shutting down node so before I move on the other aspects let me because of the Time constraints. We are not actually doing a live demo, but this is a slip of the logs from the live cluster where this demonstrates the fact that an incoming pod Is placed on a node which has less jump in energy consumption over a node which has More jump in the energy consumption So that means that we are making the decision where the incoming pod is placed on a node such that the Change in the clusters energy consumption is lesser by making this decision, which is the wager decision in our context Okay, there are some FAQs I will come to this slide later before that let me spend couple of minutes on future work For example the pod migration scenario that I explained we have demonstrated energy savings possibility with Pod migration, but one can actually automate the same workflow that I explained using automated scripts very easily So that is one feature work item for us Immediate on milestone for us and shutting down the nodes to minimize the power consumption again This one the use case file that I have referred to is done using manually Running scripts, but one can write automated the scripts to exercise the pod migration across the cluster and across the nodes in an automated fashion The next enhancement possible is vertical pod autoscaler We have seen that with the use of HPA horizontal pod autoscaler. There is a benefit in terms of energy savings When it comes to VPA when VPA tries to scale up the resources allocated onion node for a particular pod you could actually Make VPA more Aware by enhancing the By performing the scale up on those nodes which are energy efficient when you want to Scale up the resources allocated for a pod using VPA Today it does on any of these nodes without being aware of the energy efficiency right you could actually make the VPA aware of the energy efficiency and ensure that it scales up those parts running on Most energy efficient nodes. So the another one is a cube cutter scale Okay, I will not spend that much time and they here we have listed some of the related work and Yeah, here are some of the reports the first report is where the plug-in score is implemented So this repo peaks repo is more for the project management and the last repo is the Kepler repository, which is one of the Dependencies of our project. I'll hand it over to Parul. Yeah before we get into the questions Just wanted to know that we are working on a cap that will be creating with the Kubernetes scheduling SIG and So keep on monitoring our peaks repository and we also have a community meeting that happens once in a month So we are trying to build a community and we want more contributors So if you have any suggestions, you want to participate in any discussions or you want to have Present to us like a use case, please open a discussion or issue on our repository and Now we are open to yeah few acknowledgments like Felix was not able to make it To our session, but he has actively contributed and we also have a sale So thank you to both of them and now we are open for questions Any questions? Yeah Yeah Hello, thank you for the presentation I saw the future slide at the end and I'm just asking could Where the power Is created, you know because it's it's important to know where the electricity come from Especially for the carbon Will pick picks Take in contemporary Consideration sorry for my French English. Oh, so if I can replace you are yeah asking the fact that during the energy efficiency power Conjunction minimization process. Do we also consider the carbon efficiency? Do you consider where the node are running? Children can be speaking So if I got your question, right, you are talking about do we also Assign a value or like a priority if depending on the source of energy, right? Yeah, exactly So we did dive into like we two years in 2022 We were working on the use case where we are trying to consider carbon as well as the source of electricity But we like a process to be very transparent and open source based and it was very hard to get those data In Europe, they're still possible if you use electricity maps, but in US It's just very hard to get by so just because we want our policies to be super transparent That's why we right now. We are not working on that we explode, but we are not And just to add to what Parul said optimizing for energy efficiency and Carbon minimization are not exactly the same, right? And there is a different talk called a Caspian that is going to come tomorrow from the same group that we belong to Please step to that Session if you want to really know about carbon optimization. Yeah, so we have one more question. Yeah, sure Hello, thank you for the talk I noticed all the pods got scheduled to a single node What happens if I have anti affinity policy does the scheduler respect that sure so because the scheduler plug-in Follows the scheduler framework. So it does respect the part affinity anti affinity node labels all these aspects And if there are any such nodes filtered after these Phases only those nodes are considered. So this plug-in respects the framework of scheduling At the beginning of your talk you referred to like creating a profile for servers Would that be would that profile be the same for the same configuration of server? Like if you create a rack where all the servers are the same not necessarily not necessarily because why would that be? Yeah, because even though the hardware configuration may be same But the applications running may be different and different workloads may use different amounts of resources of the Servers hence your power modeling needs to be cognizant to the workload type that is going to run And there's also two components to it So either you can have like an offline model that you train once and then you don't revisit again But you can also do like keep an online model where depending on the instantaneous or what is happening in the cluster at that Moment you keep on retraining your model. So it's very unlikely that two nodes will have identical node model profile Next person, yeah So this is the last question, sorry Okay, it's over two question. You told about creating model per node or node When does this occur? What's the overhead correctly? So, yeah, that's what we said that that's a pre-processing Step, let me just quickly go back to the slide. Yeah, so at the start when you are just starting and you When you have you haven't enabled the scheduling So what you do is you just pre-process the node model for each of the nodes in the cluster So that is pre-scheduling. But again, as I mentioned, they are two approach You can have online on an offline. So for an offline, you just do it once but for online this process keeps on going on and that's when you get the model parameters using for example of webhook Okay, thanks. And second question The processor have poor efficiency modes and they can switch basically between poor modes and why Do not did you try to Leverage this features during your Sorry say that again. I don't the poor modes CPU can downclock and Yeah, that is called the DVS functionality Dynamic DVS functionality. Yeah, this can work with the DVFS though in the use cases. We didn't Include any particular use case with the DVFS, but definitely it should work with the DVFS to It's cognizant to the frequency of the node So, yeah, that's about it. And I'll just bring to the QR code So yeah, drop by in a community meeting and we have a kiosk on Friday as well 10 30 to 12 30 So feel free to talk if you're interested in exploring the use case or Start a discussion or whatever. Thank you so much and also try to provide your feedback by scanning this QR code. Thank you


To help a child learn about the sense of sight, you can have them try to draw a picture without looking. You can either ask the child to close their eyes or give them a blindfold. Then they can try to draw a picture of themselves. Next the child can take off the blindfold or open their eyes and draw themselves again. When they are done, you can talk about what it was like when they couldn't see compared to when they could. This activity helps them learn the value of the sense of sight.


Hello everyone, this is Shila Ratnabanswade from Walchand Institute of Technology, Solapur. Today we are going to see the topic transition fit, learning outcomes. At the end of this session, students will be able to describe transition fit. Now moving further, look at the images on the screen, the first, second and the third. At this moment, I suggest you to pause the video and see the relation between the hole and the shaft for all the three images. Now coming back, in the first image, the hole and the shaft have a gap or a considerable gap in between them. In the second image, the gap between the hole and the shaft is bit reduced. And in the third gap, in the third case, the gap between the hole and the shaft is zero. The size of the hole and the size of the shaft are nearly equal. So these are the various types of conditions which defines fits. Here the gap is more, here the gap is reduced and here there is no gap at all. So moving further, fits can be defined as the relation between two mating paths. As said earlier in this image, the relation between the hole and the shaft. In the first case, the second case and the third case, here it is loosely fitted, here a bit loose and here it is exactly equal to the size. Moving further, the degree of tightness or looseness as shown in the previous figures, fits can be defined as the degree of tightness or looseness. Fits are classified on the basis of the actual limit of the hole or shaft. The actual limit here represents or mentions the actual sizes of the hole or the shaft. Depending upon the actual size of the hole or shaft, we can have clearance fit, the first image, interference fit, the second and third and transition fit, the first and the second. Moving further, let us have a look on transition fit. Transition fit may result into either a clearance or interference fit. It comprises, it is a compromise between clearance and interference fit. Depending upon the dimension of the hole and the shaft, we get either a clearance or an interference fit in the case of transition fit. It is used when accurate location is important between the shaft and the hole. So transition fit may either result into a clearance fit or interference fit depending upon the sizes of the hole and the shaft that is including the tolerance level. Now let us see the transition fit on hole base system and shaft base system. First on the left hand side of the screen you can see the hole base system and on the right hand side you can see the shaft base system. As far as hole base system is concerned, this is the zero line or the base line and the yellow color box shows the tolerance zone of the hole. So minimum of the hole coincides with the zero line. Thus the size of the hole is fixed whereas the small red color boxes on the screen represents the tolerance zone of the shaft. So as you can see the tolerance zone of the shaft over here, over here and over here.  So you can see the sizes of the shaft are changing whereas the size of the hole is fixed. Thus this system is known as hole base system. Now coming to shaft base system, again we have the zero line or the zero line or the base line. Now the red color box towards the right hand side shows the tolerance zone of the shaft. So here the upper limit of the shaft coincides with the zero line. Thus the size of the shaft is fixed or the tolerance zone of the shaft is already fixed. Now the small yellow color boxes represents or shows the tolerance zone of the hole. So here you can see this is one size, this is another size and this is the third size. So dimension of the shaft and dimensions of the hole. So clearance fit, two interference fit, we have these represented on a shaft base system. So here you can see the difference between the hole base system and the shaft base system for the case of transition fit, moving on further. Now look at this diagram, this is the hole and this is the shaft. The sizes of the hole are maximum size is 30.05 and minimum size is 29.95 whereas the maximum size and the minimum size for the shaft is maximum is 30 and minimum is 29.05. Now in this case we may have either a clearance fit or an interference fit depending upon the sizes of the hole and the sizes of the shaft. For example if we consider the size of the hole as 30.05 and the size of the shaft as 29.95, we will get a clearance fit as maximum size of the hole is used with the minimum size of the shaft. So maximum of hole and minimum of shaft will give you clearance fit. Apart from this if we consider the hole size as 29.95 and the shaft size as 30, in this case we get the interference fit. So maximum of shaft and minimum of hole will give you interference fit. So this is an example of transition fit. So here you can see how the tolerance or the sizes of the shaft and the hole decides whether the resulting fit will be a clearance fit or a interference fit. Now transition fit where we have these types of fits or the types of transition fits. First the push fit it refers to zero allowance and a light pressure. The moving parts show least vibration with this type of fit. It is also known as snug fit. In this case the shaft easily gets inserted into the hole without much effort and the moving parts if available will give least vibrations. So moving further we have force fit or shrink fit. The force fit is used when the two mating parts are to be rigidly fixed so that one cannot move without the other. So if you want to have zero relative motion between the two mating parts we go for this type of fit that is force fit or shrink fit. It either requires high pressure to force the shaft into the hole or the hole to be expanded by heating. So in this case either we use high pressure to force the shaft into the hole or we heat the hole so that it gets expanded and the shaft can be accommodated in it easily. It is used in railway wheels and etc. The heating hole example can be of PVC pipes where we heat one side of the pipe and we insert the other side of the pipe or the other pipe into it or we can simply say that PVC fittings. Moving further the wringing fit a slight negative allowance exists between the two mating parts in wringing fit. It requires pressure to force the shaft into the hole and gives a light assembly. As compared to force fit the wringing fit requires a bit low pressure to insert the shaft and the two holes and the shaft do not get in contact with each other rigidly as the case is in force fit or shrink fit. It is used in fixing keys, pins etc. Thus the clearance or the gap between the hole and the shaft in case of wringing fit is bit considerable as compared to the same in the force fit. So here the shaft can be easily removed from the hole or by using a light pressure but the case in the case of force fit or shrink fit you require pressure to insert the shaft into the hole and the same to remove the shaft from the hole. So we have seen force fit or shrink fit and wringing fit. These are the references thank you.


You know, and it's also interesting too that like, you know, I mean the The two of the most famous strains out there The Kush and the sour diesel neither one of them reverse very easily. Yeah There's a lot of failure with those Right.   So a lot of times a lot of times things get reversed on to them Yeah You know, that's that's usually how it goes. The only the only real OGs I'm seeing people like regularly reverse or OG hybrids and they They have to get lucky and find something that'll reverse well But most of these old OG cuts be it, you know, bad seeds the bad seeds and we're finding that like s2s s3s Shit like that doesn't reverse well for whatever reason. It's really hard to reverse like a Multiple self or multiple bags each generations and that makes sense for OG it makes sense


Today's lunch morning basket is Halloween. Creatures of the night. We have Bunny Fillins. My haunted house adventure. Trivia and Fun Facts. We have Word But True. Halloween 300 spooky facts to scare you silly. Spooky jokes for kids. What do you call a ghost up your nose? Poetry. We have A for young people. Egger Allen Poe. After Dark. Poems about nocturnal animals. Spooky Map. We have A set of spooky multiplication stories. Worst Vampire. This is a series. Road Doll. The Witches. Next we have Who Was Egger Allen Poe. Next we have Be A Night Detective. Out of Sight Fill Tonight. Owls. Creepers. Nocturnal Animals. 100 Facts. At Night. Full of spooky stories. 50 Tales to Make Your Spine Tingle. These we have this box. Fill a little Legos. Daddy put on the Lego plate. Halloween Brick Pit Cards. We have Paint by Stickers. Kids. Halloween. Here's a Mummy. And a Spider. Next we have Us Born Sticker Dolly Dressing Halloween. We have Spotted Tails. These are Pocus Pocus which we all know the movie. They also have a game. Addos of the Forest. Think Fun. Not Least. Ghost Fighting Treasure Hunt.