So in the previous lecture, we did a lot of technical push ups to end up with end

up with a description of what the solution to a general LTI system is. the reason for

that is, is that I really, really enjoy rule, even though I do. but that it will

actually help us to characterize what these systems are doing. And today, I want

to talk about stability, because as you probably recall when we did a control

design, first order of business is to design controllers so that systems don't

blow up. If they blow up, there's nothing we can do about it. The quad rotors just

fall out of the air. The robots drive off to infinity. The cars smash into things.

We don't want them to blow up, because the deciding objectives are almost always

layered in this sense. First order of business is stability. Then we want to

track whatever reference character or reference point we have. We also want it

to be robust to parameter uncertainties, and possibly noise. And then we can wrap

other objectives around it, like when you want to move as fast, quickly as you can,

or use as little energy when you're moving, or things like this. But,

regardless of which, stability is always the first order of business. So let's

start with scalar systems, no inputs. So only the A matrix now, in this case x dot

is little ax, which means that it's scalar. Well then the solution x of t is e

to the a, we said t minus t naught x of t naught. Here I simply picked t naught to

be equal to 0. So this is the solution. Okay, lets plot what this solution looks

like. If a is positive, then x of t it starts nicely and then pabaah. Its, its

blowing up as far as I can tell. So if a is positive this system blows up. Well, if

a is negative, then e to the at, this is a decaying exponential. So we get x to just

go, , nice down to zero. What happens if a is zero in between these 2? Well, then you

have e to the zero t, which is 1. So then, x of t is simply equal to x naught. x

never changes. So here, it didn't blow up, but it didn't

actually go down to zero. And in fact, what we have its, its really a sitution

where three possible things can happen you blow up, you go down to zero, or you stay

put. So let's talk about these three cases. The first case is what is called

asymptotic, stability. So the system is asymptotically stable if x goes to zero

For all initial conditions, so this fancy upside down a, is known as the universal

quantifier. All we need to know is that when we see and upside down a the way we

pronounce it is for all x nought. So asymptotic stability means that we go to

zero and almost always what we want to design our system so that x actually goes

to 0 no matter where we start, that's asymptotically stability and as you

recall, in the scalar case, a strictly negative corresponds to asymptotically

stability. And then we have unstability, instability where the system being

unstable. What that means is there exists an initial condition, so the flipped e,

and to speak for the existential quantifier, which we read it as exists. So

it's unstable if there exists so many extra conditions from which the system

actually blows up. In the scaler case, we had A positive corresponding to

instability. and then we have something we call critical stability, which is somehow

in between. The system doesn't blow up. But it doesn't go to zero either, and in

fact, for the scalar system, this corresponded, corresponded to the, a equal

to zero case. So if you summarize that, if you have a scalar system then a positive

means the system is unstable. A negative means that the system is asymptotically

stable, which is code for saying that the state goes to zero. And a zero means

critically stable. Okay. Let use this way of thinking now on the

matrix case. X. is ax, capital A. So this is now, x is a vector, a is a matrix. What

do we do there? Well, we can't just say. Oh, a is positive, or a is negative.

Because a is a matrix. It's not positive or negative. But what we can do is we can

go for the next best thing, which is the eigenva lues.

And, in fact, almost always, the intuition you get from a scalar system translates

into the behavior of the eigenvalues of these matrices. And for those of you who

don't know what eigenvalues are, these are the special things that are associated

with matrices. So, if I have a matrix A; N by N, and I multiply it by a vector an N

by 1 vector, if I can write it as the same vector times a scalar, then what this

means is that the way that A acts on this vector is basically scaling it. And the

scaling factor is given by lambda. If I can, if I can find lambda of v to satisfy

this, then what I have is a lambda that is called an eigenvalue. And it's actually

not a real number. It's typically a complex number. So it's a, a slightly more

general object than just a real number, but that's an eigenvalue. And v is known

as an eigenvector. And eigenvalues and eigenvectors are really these fundamental

objects in, in when you're dealing with matrices and when you want to understand

how they behave. And, whenever you think scalar first, you can almost always

translate it into what do the eigenvalues, eigenvalues do for your systems. And, the

eigenvalues actually would tell you how the matrix a acts in the directions of eh

eigenvectors. So, you can almost think of them as scalar systems in the directions

of the different eigenvectors. And, you know, sometimes you may want to compute

eigenvalues. I don't. So, if you use MATLAB. You would just

write, eig(A), and out pops the eigenvalues. whatever software you, your

comfortable with, you want to use C, or Python, or whatever, there is almost

always a library that allows you to compute eigenvalues. And, the command is

typically something like eig(A). So, this would give you what eigenvalues

are, given a particular matrix. Okay. Let's see what this actually means. Let's

take a simple example here. Here's my a system. 1, 0, o minus 1. if you take eig a

of this. you get 1 eigenvalue being 1. And the other eigenvalue being negative 1. And

the correspo nding eigenvectors are 1, 0, and 0, 1. Okay.

What does this mean? It actually means the following. So let's say that this is x1,

and this is x2. Okay. V2 was 0, 1. So this was this direction.

So here is what, v2 is. This is the direction in which v2 is pointing. Well,

the eigenvalue there is negative 1, which means that, if you recall the scalar

system, when a was negative, we had stability. So if I start here, my

trajectory is going to pull me down to zero. Nice and stable, and in fact, if I

start here, it's going to pull me up to zero, nice and stable. Right.

So, if I'm starting. on the x2 axis, my system is well behaved. If I start on the

x1 axis, I have lambda 1 being positive, which corresponds to little a being

positive in the scalar case, which means that the system actually blows up. So,

here, the system goes off to infinity. And, in fact, if I start here, my x2

component is going to shrink but my x1 component is going to go off to infinity.

So what I have is this is what the system actually looks like. So the eigen vectors

in this case will tell me what happens along different dimensions of, of the

system. So after all of this, if I have x dot as big AX, and I can find a solution,

then the system is asymptotically stable, if and only if, for the scalar case, we

had that little a had to be negative. What we need in the matrix case is that the

real part, remember that Lambda are complex, the real part of Lambda is

strictly negative for all eigenvalues to a. For all, this is what asymptotic

stability means for linear systems. Unstable means that there is one or more,

but one single bad eigenvalue spoils the whole bunch. So a single eigenvalue that

has positive real part. This is an, a sufficient condition for instability. And

we have critical stability only if so this is a, a necessary condition that says the

real part has to be less than or equal to 0 for all igon values. But where we are

going to be spending our time is Typically up here in the asymptotically stabl e

domain, because what we want to do, is we want to design our system or our

controllers in such a way that the closed loop system is asymptotically stable. So

we're going to somehow make the eigen values have negative real part That's

going to be one of the design objectives that we're interested in. And I want to

point out something about critical stability that if one eigenvalue is 0 and

the rest of the eigenvalues have negative real part, or if you have two purely

imaginary eigenvalues So they have no real part, and the rest have negative real

part, then you have critical stability. and we will actually see that a little bit

later on, but the thing that I really want to take, you to take with you based on

this slide, is, you look at the a matrix, you compute the eigenvalues. If the real

part of the eigenvalues are all negative You're free and clear, the system is

asymptotically stable. If one or more eigenvalues have positive real part, you

toast, your system blows up. That is bad. So, let's end with a tale of two pendula.

Here is the normal pendula, well if you compute the of this, you get this matrix.

And the eigenvalues are j and negative j. Well, I don't know if you remember, but on

the previous slide, there was a bullet that said if you have 2 purely imaginary

eigenvalues, which we have here. We have 2 purely imaginary eigenvalues and then no

more, then we have critical stability. What this actually means is that, this

pendulum, clearly, there is no friction or grav-, or damping here. It's just going to

oscillate forever. It's not going to blow up. And it's, , excuse me. And it's not

going to go down to zero. It's just going to keep oscillating forever and ever. It's

critically stable system. Now, let's look at the inverted pendulum

where I'm moving the base, but in that case, a is 0110. We already know, this

things is going to fall over. Right? So, if you compute the Eigen values you get

one Eigen value to be equal to negative 1 and 1 to be positive 1, which means that,

we have one Rothton eigenvalue. This eigenvalue that's going to spoil the

system. So this in an unstable system. So now that we understand that eigenvalues

really matter, and they really influence the behavior of the system, let's see, ,

excuse me, how we can use this to our advantage when we do control design.