Now we have lots of really good building blocks. We haven't yet put them together. Cause we don't fully know how they fit together, but we have lot's of cool things. We have controllability, that tells us whether or not it's possible to control the system, if we have access to the state. And the way we do that is using state feedback. We have this notion of observability, which tells us whether or not it is possible to, to figure out the state from the output, and the way we do that is. by building observers and we have this tool that seems remarkably strong which is pole-placement which basically allows us to place the closed loop eigen values where ever we want. So make them equal to the desired eigen values and the big question now is how do we put everything together. And the answer is known as the separation principle. And in a nut shell, the separation principle, which by the way, is quite wonderful tells us that we can actually decouple observer design and control design from each other meaning we can actually control the system as if we have X, even though we don't. And then we can get their estimate from x using an observer structure. So this is the topic of today's lecture and it really is the reason why we're able to effectively control linear systems. So, here's the game plan. Now, I have x dot is Ax + Bu. Y is Cx. So this is a standard linear time and variance system. Now I'm going to assume that this system is both completely controllable and completely observable. If it's not then, to be completely frank, we're toast. What that means, we need to go and buy new sensors, which is fancy speak for get a new C matrix. Or we need to buy more actuators which means get a better B matrix. So let's assume that we have complete controllability and complete observability. Well, the 1st step in our game plan is let's ignore the fact that we don't have X. So I'm going to design the state feedback controller as if I had X, meaning I'm going to pick U=-Kx, which means that I get my closed loop, my closed loop dynamics to be this. Now, this is what I designed for and I have my favorite pole placement tool to do this. Now, in reality, I don't have that. reality is I have u is -Kx hat, where the hat is my estimated state. So that's what I actually have even though that's not what I designed for. Now step two, of course, is I'm going to estimate x using, using an In order to get this x hat and to make it be as pleasant as it can. The big thing that we should note now is that previously we didn't have a U term in the observer dynamics. Now we do have a U term that we need to take into account but it turns out that it's very simple to do that. I built my predicter and the predicter part now. Contains both Ax hat and a BU term, because a predictor is just a copy of the dynamics. And then I have my corrector part which is this error between the actual output and what the ouput would have been if I had x hat instead of x. Well, this structure again gives me the same aerodynamics here. So what we do is I pick L so that my error, my estimation error is stabilized. And that's before the error is the actual state minus my estimated state. So this is my game plan. Now, let's see if this game plan is any good. A fact. It should be good right? because otherwise I'm wasting everyones time with these slides, but let's make sure that it indeed is worth while. What do we want, this system to do? We want to drive x to zero, because we're stabilizing it, and we want to drive e to zero, because we want the estimate to be good. So, what I need to do, is analyze the joint dynamics together. So x dot, is ax+bu, but u is, if you remember, u = -k, not x, but x-hat, which is why I get my x dynamics to look like this. While me e dynamics, that's the matrenary dynamics, is what it has always been. Okay, let's simplify this a little bit. So, I know that the error is X minus X hat. So I can replace this X hat with X minus the error. So then I get my dynamics after some pushups to be A minus BKX. Plus BK. E. So now I have something that involves X and E and here it only invovles E. So now I can actually write everything in a joint way. X dot E dot is this large matrix now that's not an NxN but it's a 2Nx2N*X E. And mow, our strategy, our joint strategy works if and only if this new joint system is an asymptotically stable system. Which means that we need to check the eigenvalues of this new system matrix. Now, here is where the separation principle comes into play. This is my dynamics. Now, this matrix here is a rather special matrix. Because it's triangular. It has a block there, it has a block there and it has a block there. And triangular matrices, or block triangular matrices. May they be upper or lower triangular. They have a particularly nice structure. So this is an upper triangle block-matrix and the eigenvalues are given by the diagonal blocks. Which means that the eiganvalues to this whole matrix are the eiganvalues to this matrix and the eiganvalues to this matrix. Or another way of writing it is that the characteristic equation is the characteristic equation to the first block here. Times the characteristic equation to the second block here. All that this means is that the eigenvalues are given by the values of the diagonal blocks. And here is the wonderful part. If we haven't been stupid in how we did the design, then this thing has been stabalized, because we did cold placement to make sure that the real part of our diagonals is strictly negative. This part we have made sure is also well behaved because we have designed our observer in such a way that real part of the eigenvalue is completely negative. Which means that we haven't messed anything up. Everything works. What that means is. Control design people, we can design our controllers as if we had the state and than we rely on our clever sensing people to estimate the state for us. And thanks to the separation principal everything works. Now the ones that we keep in mind is that we still have this term here, and this term that basically tells you something about what happens to transients. But after awhile. This term doesn't really matter and everything works, so now we are ready to state the separation principle. The separation principle tells us that we can in fact design controllers as if we have x. And then, we can design the observers independent of the control actions, because all we're doing is, we're adding a + Bu in the observer dynamic, so the control actions are actually just canceled out. In other words, control and observer designs can be completely separated. So, if you put everything together, in a final Glorious block diagram. This is what the world looks like. We have our system. This is physics. This is what a system does. Now, we have modeled it using A B and C matrices, but what comes out of this thing is Y, meaning our measurements and what we push into this system is U, our control action. Now, we're taking u, sorry, we're taking y and feeding it into the observer. So the observer now is, ax-hat + bu + l(y-Cx-hat) and, the one thing to note, is that we need both, y and u to Feed into the observer. Now, out of the observer comes x-hat, meaning, our estimate of what the system is actually doing. And now, we use x-hat to feed back, to get are, are u. And the beautiful thing here is that, these two blocks together, they constitute the controller. So these two blocks are what's being done in software and this, is the physics of the world. So this the plant, there's nothing we can do about that and the controller consists now of two pieces. One piece that, estimates the state and another piece that computes the control action/g. So now we have everything we need to do effective control design and what we'll do in the next lecture, which is the final lecture, lecture of this module is that we'll actually deploy it. And in fact, we're going to see it in action on a humanoid robot where we're doing simultaneous control and state estimation.