 Hello everyone. Welcome to yet another session of our NPTEL non-linear adaptive control. I am Srikanth Sukumar from Systems and Control IIT Bombay. So, we started with our excursion into this seventh week of this course on non-linear adaptive control and we are well underway to designing adaptive control algorithms. So, we've already seen adaptive control algorithm design for first and second order scalar systems and this week we have started the journey into a new method of adaptive control design which is the back stepping based adaptive control design. So, we are as always motivated by this very, very nice background images which depicts the application of non-linear adaptive control to space systems such as an autonomous satellite which is orbiting the Earth. So, what we were doing in this previous session was we had just started looking at back stepping in adaptive control. So, as a first step we had of course introduced the problem setup which is still an adaptive control type problem setup. However, the parameter was assumed to be known and therefore we were simply doing a standard non-linear control back stepping design. So, I hope that what we did in this previous session gave you a pretty good idea of how back stepping control design looks. So, I keep emphasizing this regularly and I will do so again that this back stepping design is in fact a way of constructing augmented Lyapunov functions. So, that's really what it is. It's a way of constructing augmented Lyapunov functions. So, you start with a Lyapunov candidate for the first subsystem, then you construct a Lyapunov candidate for the second error subsystem and then you sum the two and you get a Lyapunov candidate for the entire system. So, with this simple method you are actually able to get a handle on constructing Lyapunov functions because a lot of times many students ask me how to construct these Lyapunov functions because it looks like we are pulling it out of thin end and in a lot of cases this is in fact true. A lot of designing Lyapunov functions is in fact involving creativity and of course we are motivated by other Lyapunov function designs that are already existing in literature but fundamentally, yes, there is a lot of creativity involved and therefore this kind of method like back stepping which allows you to build Lyapunov functions piece by piece is something that's rather useful and might even be something that can be automated. So, we've already seen how back stepping control design works. What we want to do starting today is to look at the unknown that is the actual adaptive control scenario of using back stepping control. So, let me mark this lecture as lecture 7.2. So, this is the second lecture. So, now what happens when theta star is unknown. So, what we do is, so if you notice we were very careful and we actually defined the control law with the theta hat itself to begin with just like we do in certainty equivalence. So, the principle is still the same. We still use like the certainty equivalence principle. So, we designed it with the theta hat and we said that for the known case we just substitute theta star for theta hat and then we did the subsequent analysis. Now, when theta star is in fact unknown then nothing changes the theta hat remains as it is because it's an estimate and as always we need to come up with an update law for the estimate. We also noticed that the Lyapunov candidate that we had come up with in that the V2 piece was in fact exactly the Ortega construction and the V1 piece was additional. Yeah, this additional piece in fact helps us to make the Lyapunov, I mean helps us to make the Ortega function a Lyapunov candidate function. Okay, great. So, the controller remains with an identical structure. The only thing is now this and this don't cancel out. This cancellation does not happen. So, these and these forms an actual difference, right? This is theta star minus a theta hat. Everything else cancels out because they are known and then this good term is introduced as before also. Excellent. Excellent. Now, let's see what happens. So, now what we do is as we are always used to doing whenever there is an unknown parameter we simply add a term corresponding to the unknown parameter error and then this is theta tilde squared by 2 gamma and as always theta tilde is defined as theta star minus theta cap. Okay, so this is standard throughout the course. You always define the error as the true value minus the estimated value. Yeah, I mean you can always do the other way around and so on and so forth, but this is just a convention that we are following in this course. You're free to do it the other way as long as you're consistent and do not mess up theta tilde dot. Yeah, so for us whenever we compute theta tilde dot it is minus theta cap dot because theta star is a constant. Okay, so this is the only thing where we need to remember how we define the theta tilde. So great. So I took the same Lyapunov candidate, which is what we've been doing in adaptive control. You take the known case Lyapunov candidate and add a term corresponding to the quadratic term corresponding to the parameter n. That's exactly what we're doing here. All right. And then we take the derivative, right? What's the derivative? We've already done this. We get an even e2 and we get a psi 2, psi 2 dot earlier. There was only this term, but now like I said, because the parameter term doesn't cancel out, you also have this term coming. And then of course you have a minus one over gamma theta tilde theta cap dot just coming from here. All right. Now substituting for e2, again, this is something we did in the previous session also. We substitute for e2 because now the new variables are e1 and psi 2. So e2 is not really a variable. So we substitute for e2 in terms of psi 2 and e1. And we get e1 psi 2, which is the mixed term. And you get a minus k1 e1 squared and then minus k2 psi 2 squared and so on and so forth. Now, if you notice this term and this term contains theta tilde in it. All right. So this term together can actually be written as theta tilde psi 2 f x t minus one over gamma theta cap dot. Yeah. And so what do we do? We know that we cannot really make this negative definite or anything because that would require having a theta tilde in my update law, which is not allowed. Theta tilde is unknown to me. So I'm not going to do anything ridiculous like that. Right. So I pick theta cap dot just so I can cancel this. I do the best I can. I cannot really introduce a negative term, but I can at least cancel the bad stuff. And all of this is known because we, of course, again, we are assuming that we have full state feedback in this entire course. We know e1 e2. So we know x1 x2 and we know rr dot. Therefore, we know e1 e2 and so on and so forth. Okay. So we have full state feedback. So therefore, this entire thing is known. I can cancel it out by an update law which looks like this. All right. So once I cancel these out, right, I'm left with just, you know, I cancel these out. Right. So I'm left with just these three terms. Okay. And notice now that this looks exactly like this, exactly like this. Same. So what do we do? Sum of squares. Now, again, this should not be surprising that this v dot, right. I mean, I'm sorry, I should have written as v dot here. Right. This is v dot actually. All right, that's fine. It's from the last lecture, no problem. So it should not be surprising that v dot looks identical because this has been our experience in all adaptive control problems. Right. Our v dot always turns out to be the same as the known case. Yeah. Although we start with a different v for the unknown case, our v dot always turns out to be the same as that for the known case. This has always been the case with the adaptive controllers we have designed until now. So this should not come to you as a surprise. So as always, we do this, you know, sort of use this nice property. I mean, like I said, there is norms here and whatever. I mean, you can use absolute values and norms here. Yeah. But it's the same in this case. These are all scalar quantities. And so once you do that, you remember from last time that you get this. Yeah. Now, the only difference is in the previous lecture, this was negative definite, but now it's only negative semi-definite. Why? Simple. Right. Now our v is no longer the same, although the v dot turned out to be the same. v is not the same. v in fact has an additional state, which is the parameter error state. And so all states do not appear in v dot. And if all states do not appear in a function, what do we know? Well, that it cannot be definite. All right. So since only two out of the three states appear, it's only negative semi-definite. All right. Great. However, it's not difficult for us. I mean, we're not even doing these arguments. I'm not writing these arguments explicitly anymore. But we know that we can use signal-chasing arguments and Bablath's lemma. So I'm going to say signal-chasing arguments plus Bablath's lemma and corollary. Yeah. We can use signal-chasing arguments, Bablath's lemma and its corollary to show that e1 and psi2 are going to go to c. And we already know that psi2 is e2 plus k1 e1, which implies e1 and e2 are both going to go to c. All right. Great. So as before, even as in the case of the non-adaptive case, that is the case where the parameter was exactly known to us, I still achieve tracking. Yeah. Why? Because just the fact that v dot is negative semi-definite by standard Lyapunov theorems already gives me uniform stability in the sense of Lyapunov. Right. I already have uniform stability for the entire system, which means all the trajectories remain bounded, all nice things happen. If you start close to the origin, remain close to the origin. If you start close to zero error, you remain close to zero error and all that nice stuff. Yeah. On top of it, I can also prove that asymptotically e1 and psi2 go to c. Yeah. That is e1 and e2 go to zero equivalently. Yeah. Which means that my tracking objective is achieved. Yeah. That is, I track the desired signal while remaining bounded all the time while ensuring stability. Okay. Parameter convergence as always is not guaranteed. Okay. Parameter convergence is of course not guaranteed. Right. So, I mean, I mean, if you again look at the closed loop system, I mean, let's try to formulate it in again in terms of our persistence type results. Yeah. Let's see what it looks like. Right. So, you have your closed loop system is e1 dot is e2 and e2 dot is, let's see. Well, actually I'm going to write this in terms of psi2, if you don't mind, because those are the new states. Psi2 dot is minus theta tilde fxt. Is it a minus or is it a plus? No, it's just a plus. And then I have a minus k2 psi2. And then I have theta tilde dot as minus of theta hat dot and theta hat dot is this. So, this is minus of gamma fxt, yeah, gamma fxt times psi2. Okay. So, the sort of the thing that you would notice is if I write it again in this nice state space form, let's see, this will come out to be e1, e2, ddt. Why do I keep saying e2? My bad. e1 psi2 ddt is equal to 0, 1. No, this is not how I want to produce. I apologize. I want to write the whole thing. d of e1 psi2 and theta tilde as you have this nice block diagonal structure, which is 0, 1. And then you have a 0. And then here you will have a minus k2, 0 and theta tilde. This is fxt. And here I have similarly 0 minus gamma fxt, 0, e1, e2, theta tilde. Now, after all of this work, it should not be difficult for you to see. Unfortunately, close this. Let me look at, I think week five maybe we have this. Yeah. It starts to look again, like it has this structure. Like it has this structure. Because the error is e1 psi2, e is equal to e1, psi2. E is actually equal to e1 psi2 in this case. It's a vector. And then, so that is this system. So this, I will even mark this. This entire thing is the A matrix. Then you have this as 0, same. And then you have the connection to the theta tilde via this phi. The phi is of course your, this piece is phi. Oh, I'm sorry. I shouldn't do undo. Your phi is in fact this piece. Yeah. This is phi, right? And so, well, fine. I guess this is what you call phi transpose and not phi. So this is phi transpose. So in this case, your b is just the identity matrix. So b is just the identity matrix here. So b equal to identity. And this is c phi where c is equal to minus gamma identity matrix. I mean, you can just call it a scalar in this case. There's no identity matrix, but that's OK. Yeah, that's fine. b is a scalar. b is 1 and the c is 5 times and c is still minus gamma. So you see that it still has this similar structure. And we kept saying that this structure is rather used. And now remember that here, again, phi was only a function of time. And here it is a function of time and the state. So as always, we'll have to use the integral lemma type results, the more general integral lemma results. But we have a good hope that we can actually mimic this. Yeah, because a, b being controllable, a, c observable is pretty easy and a being stable. So a, you can see is already a stable matrix. This is a stable matrix. Very obvious. a, b being controllable is not difficult. a, c being observable is also not difficult to prove. Yeah. So if we use the general integral lemma, even if f is a function of the state and time, we will be able to claim that this system is exponentially converging as long as this is, you know, has this, in this case, it should have lambda uniform persistence of extension. OK. As long as this function has a lambda uniform P condition satisfied, you will have this entire system to go to zero exponentially. OK. And that's essentially what you will need. And that's essentially what you will need. We need that all these states go to zero. And when all these states go to zero, until now we've only proved that these two go to zero. Right. But when we prove all these three states go to zero, we also have the parameters to converge. Right. So in general, it's not difficult to say that if fxt is lambda uniform persistently exciting, then theta tilde also goes to zero. OK. So this is nice. Right. So we started with a nonlinear problem. Right. But we are able to use some result here, which looks like a linear result. Yeah. Again, we are not using exactly this result. Remember. Yeah. So this is a corresponding result via the, you know, lambda uniform PE and these results. Yeah. So we are not actually prove that result, but the equivalent of this result exists when this phi is both state and time dependent. Yeah. Because the state is just written as a solution with the parameter being the initial condition initial time. Right. And therefore you need notions of lambda uniform persistence where lambdas are some parameters. There is the lambda being t zero and x zero. OK. So great. So there is also conditions that one can talk about under which you will get convergence of the parameter also. Yeah. So remember that all of this, because this f, whenever you talk of persistence of the signal which contains a state, this is indirectly going to be connected to the persistence of the reference reject. Because the state is trying to track a reference trajectory. Right. So the state is trying to, because those are the errors, right, because the state is trying to track a reference trajectory. Only if your reference trajectory is persistent, can you have this sort of a condition satisfied if your reference trajectory is just a constant horizontal line. Then most probably you will not get persistence and therefore you will not get. You know, you won't be able to prove that the theta tilde I'm going to consider. OK. So just keep this in mind that parameter convergence or two parameter identification is directly related to your persistence of your trajectory. Yeah. And again, what is persistence of a trajectory? It means that you have to have sufficient number of frequencies. This is a standard identification question. Yeah. It has to have sufficient number of frequencies. OK. Only then it is going to be a persistent reference trajectory. So if your interest is not just in tracking, but also in identifying a parameter, then you must use a persistent trajectory with several frequencies. All right. Excellent. All right. Good. Good. I hope that's evident. OK. So we have this adaptive result then. OK. Which is the using this adaptive backstipping. OK. Now, so now one of the things that we all of course also are able to do is of course to claim that the detectability obstacle was avoided. All right. Why? Because we, for the known system, we constructed a strict Lyapunov function. So backstipping method not just helps you construct a Lyapunov candidate or any Lyapunov candidate. It helps you construct a strict Lyapunov function. OK. So this is important. Yeah. So once you do that for the known case, you know that for the unknown case, things are going to be nice. Yeah. Not a problem. All right. So now, I mean, we want to introduce another different kind of problem. All right. Now these are the kind of problems where now, or take a construction and such may or may not be usable and backstepping still gives you a very, you know, formal or very clear path on how to design an adaptive control. All right. So this is the case of parameter which is unmatched with the control. Yeah. Until now, your parameter was always appearing in the same dynamics as the control. OK. So here we have sort of, you know, changed the problem. I mean, for a good reason, right? And it may not always be the case that your unknown parameter always appears in the same dynamics as the control, right? It may so happen that the parameter appears in a different piece of that animal. So we've sort of flipped the problem. So we still have x1 dot is x2, x2 dot is u, like a double integrated type system. But then you have a theta fx1 appearing in the first piece. That is x1 dot is x2 plus theta fx1. And now this theta is, as always, denoting the unknown. OK. So that's why this is called parameter is unmatched with the control. The unknown parameter does not appear in the same dynamics as the control. OK. Now, because we are sort of just demonstrating how back stepping can be used, we are just doing the stabilization problem. That is, we just want to drive x1 and x2 to 0. Now, remember that the tracking problem is not different, honestly speaking. It just involves you adding a trajectory term, and so on and so forth. But it's not going to change anything significantly. So that's not why too much about doing the tracking problem instead of stabilization problem. So the method that we illustrate here are going to remain exactly the same. So it's not going to significantly impact this. So let's see what we would do in the known parameter case, how we would do the back stepping controller design. So first thing is we want to make sure, as always, we look at just the first piece, and we want to ensure that x1 goes to 0. And we, of course, assume that x2 is the control. This is what we do. We basically think of the second state as the control for the first state. And then we try to stabilize the system. What do we do to stabilize? We try to have it track an ideal system. And what do I do? Simple. Cancel this, introduce a good term. So that's it. Cancel this, introduce a good term. All right? Simple. OK, so x2 is x2 desired. So we call it x2 desired because this is not really x2. But we want it to be this. Yeah, therefore, we call it x2 desired, and we construct this as such. Once we construct it as such, you get x1 dot is minus k1 x1. And we get a corresponding v1, which is 1 half x squared, x1 squared. We don't even try to compute the derivative because we know what I do. Minus k1 x1 squared. Yeah, so this is corresponding to this. Yeah, this is the same as last time. This two are not different. The only difference is earlier x2 was just this piece, but now there is an additional piece because of the fact that there is an additional piece of dynamics. Again, this is the known parameter case. So theta is known, so therefore implementable. So this is denoted as x2 desired. And what do we do? As we do in all back stepping, we construct a v2, which is just the error between the true value of x2 and the desired value. Because I know that I cannot actually have x2 to be identically equal to x2 desired. So what do I do? Do the next best thing. Try x2 to track x2 desired. And how do we do that? Just choose a v2, which is a quadratic function of x2 minus x2 desired. Again, same as what we did last time. The only difference being x2 desired has a different definition. Slightly more complicated. In fact, even as a nonlinearity. And what do we get for v2 dot? It's just x2 minus x2 desired times u minus x2 desired dot. So the x2 dot is of course simpler. That is just u. And x2 desired dot, I have written as this. We have not really expanded it because there are known quantities, derivatives of known quantities, can implement them. No problem. All right. So what happens here? So what do we do? We choose the control as something that cancels this. And introduces a nice negative term. Okay. That's it. All right. Introduces a nice negative term here. And then things are rather straightforward. I mean, we'll again continue this subsequent session, but things are straightforward. We take v as v1 plus v2. And then you compute the derivative, this x1 x1 dot plus k2. And then v2 dot is just minus k2 x2 minus x2 desired dot squared because of this choice. Right. Because of this choice. And then x1 dot is x2. And now because we've changed the states, we have to write x2 in terms of x2 minus x2 desired. That's what we do. Right. That's what we do. And we will, of course, look at this subsequently. So the Lyapunov analysis essentially looks very similar to what we've been doing until now for back stepping. All right. So great. Great. So the Lyapunov analysis is where we will continue from the subsequent session. Right. So what we have seen today is we sort of did the adaptive version of the back stepping control design from last time. Yeah. And we also looked at a new problem where the control and the unknown parameter are unmatched. And we are starting to look at how to do a back stepping base adaptive controller design for subsystems. All right. So we will look at this unmatched problem again in the next session. And we will try to see how the adaptive control design looks and possibly differs from the previous matched design case. All right. Thank you.