Module 3 - Introduction to Linear State-Space Control Theory

#Physics #Engineering #Robotics #Control_Theory #Linear_Algebra #Math

🔙 Previous Part | Next Part 🔜

↩️ Go Back

Table of Contents:

A) Introduction to Linear Systems and State-Space Representation (🎦 video 3.1)

A.1) Goals of this Module: Linear Systems Overview

This module focuses on:

• Systematic design choices.
• Modeling systems with [[linear systems]] for compact and general representations.
  

Key Objectives:

1. Develop a model that is:
   • Rich: Captures robotic system behavior.
   • Manageable: Simple enough for practical use.
2. Use linear systems for general and effective modeling.
   • Linear Systems: Represent dynamic systems compactly and effectively.
   • Transition from specific systems (e.g., point masses) to state-space representations.

A.2) Point Mass Dynamics (A Simple Robot)

A.2.1) Initial Representation: using derivatives to model our System

• Robot Position: $p$
• Control Input: $u$
• Acceleration: $\ddot{p}=u$

A.2.2) State-Space Transformation

1. Define state variables:
   • $x_1=p$ (position).
   • $x_2=\dot{p}$ (velocity).
2. Dynamics of state variables:
   

Now we can rewrite our model, in State-Space Form:

• State vector (position and velocity):

  $$x=\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]$$

• Dynamics in vector form:

  $$\dot{x}=\left[\begin{array}{c}{\dot{x}}_1\\ {\dot{x}}_2\end{array}\right]=\left[\begin{array}{c}{x}_2\\ u\end{array}\right]$$

• Dynamics in matrix form:

  $$\dot{x}=\left[\begin{array}{c}{\dot{x}}_1\\ {\dot{x}}_2\end{array}\right]=\left[\begin{array}{cc}0& 1\\ 0& 0\end{array}\right]x+\left[\begin{array}{c}0\\ 1\end{array}\right]u=\left[\begin{array}{c}{x}_2\\ u\end{array}\right]$$

• We can rename our output in general as $y_{output}$ (e.g., measured position):$$p=x_1=\left[\begin{array}{cc}1& 0\end{array}\right]x=y_{output}$$

Summary:

A.2.2.1) State-Space Generalization

Matrices:

1. A: System dynamics.
2. B: Input matrix.
3. C: Output matrix.

General State-Space Equations:

1. State Dynamics:$$\dot{x}=Ax+Bu$$
2. Output:$$y=Cx$$

A.3) Example: 2D Point Mass (model with State-Space Equations)

System Description

• Position: $p_x$ and $p_y$.
• Inputs: Accelerations $u_x$ and $u_y$.

Extended State Variables

1. $x_1=p_x$ (position in $x$-direction).

2. $x_2={\dot{p}}_x$ (velocity in $x$-direction).

3. $x_3=p_y$ (position in $y$-direction).

4. $x_4={\dot{p}}_y$ (velocity in $y$-direction).

5. $u_1=u_x$ (controlled acceleration in $x$-direction).

6. $u_2=u_y$ (controlled acceleration in $y$-direction).

7. $y_1=p_x$ (position in $x$-direction - observed output). //same as x_1

8. $y_2=p_y$ (position in $y$-direction - observed output). //same as x_3

Write the matrices:

A.3.1) State-Space Matrices

• State vector:$$x=\left[\begin{array}{c}{x}_1\\ x_2\\ x_3\\ x_4\end{array}\right]$$
• Dynamics:$$\dot{x}=\left[\begin{array}{cccc}0& 1& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 0& 0\end{array}\right]x+\left[\begin{array}{cc}0& 0\\ 1& 0\\ 0& 0\\ 0& 1\end{array}\right]u$$
• Output:$$y=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\end{array}\right]x$$

Again, these are our [[General State-Space Equations]]:

A.4) Conclusion: LTI Systems and Dimensions

[[Linear Time-Invariant (LTI) Systems]]: Foundation for analyzing robotic control systems.

General Dimensions

1. State Vector ($x$):
   • $x\in {\mathbb{R}}^n$.
2. Input Vector ($U$):
   • $u\in {\mathbb{R}}^m$.
3. Output Vector ($Y$):
   • $y\in {\mathbb{R}}^p$.

Matrix Dimensions

1. $A$: $n\times n$ (State dynamics).
2. $B$: $n\times m$ (Input mapping).
3. $C$: $p\times n$ (Output mapping).

Dimensional Validations

B) State-Space Models (Linear vs Non-Linear Systems) (🎦 video 3.2)

B.1) Recap: Linear Time-Invariant (LTI) Systems in State-Space Form

This lecture explores, the generality of the LTI model:

Key components:

• State ($x$): Describes the current system behavior.
• Input ($u$): Controls or influences the system.
• Output ($y$): Observables or measurements of the system.

System Matrices:

• $A$: Encodes the system's inherent dynamics (e.g., physics).
• $B$: Describes how inputs influence the system (e.g., actuators).
• $C$: Describes how outputs are measured (e.g., sensors).

Note: the system dynamics $A$, are given to us, it is the nature of the system. But $B$ and $C$ are designed by us when selecting the actuators and sensors used.

Question: How do we select the input $u$ to control the output $y$ of the system?

B.2) Revisiting the Car Model in State Space Form

B.2.1) Example1: Designing a Cruise Controller (velocity measurement)

Remember from [[Module 1 - Introduction to Controls and Dynamical Models]]

Dynamic Equation: $$
\dot{v} = \frac{c}{m} u - \gamma v

A = -\gamma, \quad B = \frac{c}{m}, \quad C = 1

\dot{v} = \frac{c}{m} u - \gamma v

x = \begin{bmatrix} p \ v \end

\dot{x} = \begin{bmatrix} 0 & 1 \ 0 & -\gamma \end{bmatrix} x + \begin{bmatrix} 0 \ \frac{c}{m} \end{bmatrix} u

y = \begin{bmatrix} 1 & 0 \end{bmatrix} x

\ddot{\theta} = -\frac{g}{L} \sin(\theta) + C U

\delta x = \begin{bmatrix} \delta\theta \ \delta\dot{\theta} \end{bmatrix}
$$

• Dynamics (around a small $\theta$):$$\delta \dot{x}=\left[\begin{array}{cc}0& 1\\ -\frac{g}{L}& 0\end{array}\right]\delta x+\left[\begin{array}{c}0\\ c\end{array}\right]\delta u$$
• Output ($\theta$ Pendulum angle):$$\delta y=\left[\begin{array}{cc}1& 0\end{array}\right]\delta x$$

B.4) Example: Two Robots on a Line (Swarm robotics)

And we can control the velocities of these robots,

• State Variables:

  $$x=\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]$$
  • $x_1$: Position of Robot 1.
  • $x_2$: Position of Robot 2.

• Dynamics:

  $$\dot{x}=\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right]x+\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]u=Iu$$

• Output (we measure the positions of each robot):

  $$y=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]x=Ix$$

B.4.1) The Rendezvous Problem

• Objective: Robots meet at the same position.

• Control Law:$$u_1=x_2-x_1,u_2=x_1-x_2$$
• Closed-Loop Dynamics:$$\dot{x}=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]\left[\begin{array}{c}{x}_2-x_1\\ x_1-x_2\end{array}\right]=\left[\begin{array}{c}-x_1+x_2\\ x_1-x_2\end{array}\right]=\left[\begin{array}{cc}-1& 1\\ 1& -1\end{array}\right]x$$
• Outcome: Robots move toward each other and meet.
  

B.5) Unicycle Robot (non-linear system)

• Non Linear Dynamics:$$\begin{array}{rl}\dot{x}& =v\cos (\varphi )\\ \dot{y}& =v\sin (\varphi )\\ \dot{\varphi }& =\omega \end{array}$$

B.5.1) Challenges - small angle is not a silver bullet

Small Angle Approximation (dumb idea, but let's try it)

• $\cos (\varphi )\approx 1,\sin (\varphi )\approx \varphi$.

• Nonlinear terms remain (e.g., $v\varphi$).
• Simplification does not lead to a linear system.

B.6) Key Takeaways: LTI and Non Linear Models

1. LTI Models:
   • General representation of dynamic systems.
   • Compactly encode system dynamics with $A$, $B$, $C$ matrices.
2. Simplifications:
   • Approximations (e.g., small angles) may not always yield valid LTI models.
3. Next Steps:
   • Develop systematic approaches for deriving LTI models from [[nonlinear systems]].

C) Producing Linear Models from Nonlinear Systems (🎦 video 3.3)

C.1) Introduction: Linearizations

Linearization: The process of creating linear models from nonlinear systems.

Analogy: Classifying systems as "linear" and "nonlinear" is like classifying objects as "bananas" and "non-bananas":

• In other words, most systems are nonlinear, but many behave like linear systems around specific operating points.

Goal:

• Generate linear models from nonlinear state-space models
• Create local descriptions of these nonlinear systems around operating points.

Let's see how to do this.

C.2) Process of Linearization

Goal:

• Generate linear models from nonlinear state-space models
• Create local descriptions of these nonlinear systems around operating points.

Here is a [[non-linear model]],

where:

• $f(x,u)$, is a non linear function
• $y=h(x)$ is also a non linear function

C.2.1) Find a "local description" around a operating point

1. Define Operating Points: Choose points where the system operates (e.g., pendulum straight down or up).

   • The actual state is the operating point ($x_o$) plus a small deviation ($\delta x$).

• The control input is the nominal operating input point ($u_o$) plus a small deviation ($\delta u$). $$ u = u_o + \delta u $$

2. Linearize the Model:

• The new equations of motion become: $$ \delta \dot{x} = \dot{x} - \dot{x_o} = \dot{x} - 0 = f(x_o + \delta x, u_o + \delta u)$$
• Taylor expand $f$ around $(x_o,u_o)$:
  

Remember from: [[Module 1 - Introduction to Controls and Dynamical Models]]

So, with the following assumptions, we can simplify,

There, our Linear Approximation becomes,

• Where the [[Jacobians]] are,

• Similarly for output:

• Where the [[Jacobian]] is,

3. Result:

• Linearized system: $$ \delta \dot{x} = A \delta x + B \delta u, \quad \delta y = C \delta x $$

Summary:

Now, we can compute the [[Jacobians]],

C.3) Example 1: Inverted Pendulum

C.3.1) System Description (Inverted Pendulum)

• Dynamics: $$
  \ddot{\theta} = \frac{g}{L} \sin(\theta) + u \cos(\theta)$$$$$$x=\left[\begin{array}{c}{x}_1\\ x_2\end{array}\right]=\left[\begin{array}{c}\theta \\ \dot{\theta }\end{array}\right]$$
• Output (the angle of the pendulum):$$y=\theta =x_1$$

Therefore, the [[non-linear system]], can be written like this,

C.3.2) Linearization (Inverted Pendulum) - good model!

Pick an operating point, for example, when the pendulum is straight and balanced,

• Operating Point: ${\theta }_o=0$, ${\dot{\theta }}_o=0$, $u_o=0$.
  

• Linearized Matrices ([[Jacobians]]):

Let's compute $A$,

Let's compute $B$,

Let's compute $C$,

After computing the [[Jacobians]], we get,

Now we have a Linearized system around the Operating Point: ${\theta }_o=0$, ${\dot{\theta }}_o=0$, $u_o=0$.

we can expand this model like this,

finally,

Interpretation:

1. $\delta \dot{\theta }$: is the angular velocity, (as expected from the state representation).

2. $\delta \ddot{\theta }=\frac{g}{L}\delta \theta +\delta u$, this is the linearized second-order equation of motion.

   • This term shows that:
     • The pendulum's angular acceleration ($\delta \ddot{\theta }$) depends on:
       • $\delta \theta$ (the angular displacement) scaled by $\frac{g}{L}$.
       • $\delta u$ (the input control).

C.4) Example 2: Unicycle Robot (non-linear system)

C.4.1) System Description (Unicycle Robot)

• Dynamics:$$\begin{array}{rl}\dot{x}& =v\cos (\theta )\\ \dot{y}& =v\sin (\theta )\\ \dot{\theta }& =\omega \end{array}$$
• State Variables:

In other words,

• Inputs to the Robot:

• Output that we can measure (thanks to [[odometry]]):

C.4.2) Linearization (Unicycle Robot) - it still doesn't give us a good model

• Operating Point:

  • straight at the origin, looking at the x direction: $x_o=0$, $y_o=0$, ${\varphi }_o=0$,
  • without moving: $v_o=0$, ${\omega }_o=0$.

• We then obtain the Linearized Matrices:

  $$A=\left[\begin{array}{ccc}0& 0& 0\\ 0& 0& 0\\ 0& 0& 0\end{array}\right],B=\left[\begin{array}{cc}1& 0\\ 0& 0\\ 0& 1\end{array}\right],C=\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& 1\end{array}\right]$$

And if we use this matrices for our Linearized system around the Operating Point, we get this,

Which is really weird, since the small change in velocity in the y direction($\delta \dot{y}$), is $0$, it means that the Unicycle Robot now can use the throttle to move in the x axis, it can steer a little bit, but all that is not enough to move to the y direction.

Understanding the Result:

1. $\delta \dot{y}=0$:

   • This implies that small changes in the control inputs (linear velocity $\delta v$ or angular velocity $\delta \omega$) have no direct effect on $\delta y$.
   • Why?
     The model is linearized at a point where the robot is not moving, and the heading angle $\varphi =0$. In this scenario:
     • Motion in the $y$-direction arises from the coupling between angular motion ($\omega$) and linear velocity ($v$).
     • Since $\varphi =0$, changes in $\omega$ do not result in $y$-direction motion during the linearized approximation.

2. Physical Interpretation:

   • At the operating point:
     • Small changes in the linear velocity $\delta v$ only affect motion along the $x$-axis.
     • Small changes in the angular velocity $\delta \omega$ result in changes in orientation $\delta \varphi$, but without coupling to $\delta y$ in the linearized model.
   • This means that in this linearized framework, the unicycle cannot directly move in the $y$-direction.

3. Limitations of the Linearization:

   • The linearized model loses important nonlinear dynamics, such as how angular velocity $\omega$ over time contributes to motion in the $y$-direction via a curved trajectory.
   • Reality: If the robot rotates (nonlinear behavior), its orientation would change, leading to movement in the $y$-direction. However, this is not captured in the linearized dynamics around the rest state.

Conclusion:
This linearized model is valid at the specific operating point, but it does not mean that the robot is fundamentally incapable of moving in the $y$-direction.

C.5) Key Takeaways: Linearization Process

1. Linearization Process:

   • Approximate nonlinear systems around operating points.
   • Resulting models are simpler but only valid locally.

2. Challenges:

   • Linearization may fail to capture essential nonlinear behaviors (e.g., unicycle model).

3. Practical Use:

   • Linear models provide insights and simplify analysis.
   • Lessons from linear models often apply to nonlinear systems with modifications.

4. Next Steps:

   • Explore systematic methods for deriving useful linear models.

D) Behavior and Solutions of Homogeneous LTI Systems (doing the Math) (🎦 video 3.4)

D.1) Introduction: Studying LTI System Behavior

In this lecture, we focus on understanding how [[LTI systems]] behave by finding their solutions and examining their dynamics.

The solutions we derive will allow us to talk about the system's behavior systematically.

Starting Point: Simplifying the System: We begin by simplifying the system,

• Ignoring input and output,

• we focus purely on the system's inherent behavior, described by:

• Assume an initial condition $x(t_0)$ at some starting time $t_0$.

This setup represents the physical dynamics of the system without external interference.
It is also known as a [[homogeneous linear system]], as there is no external forcing term.

D.2) Case 1: Using Scalars to Building Intuition

Let’s first analyze a scalar version of the [[homogeneous system]], where $x$ is a single number, not a vector:

Note: this is a [[first-order linear differential equation]], and to solve it we can notice it is a [[separable differential equation]], so we apply that method to find a solution.

The solution to this equation is:

where:

• $x_0$ is the initial condition at $t_0$.
• $e^{a(t-t_0)}$ is the scalar exponential.

D.2.1) Verifying the Solution of the ODE

To confirm this solution:

1. Check the initial condition:
   Substitute $t=t_0$:

   $$x(t_0)=e^{a(t_0-t_0)}{x}_0=x_0$$

   This satisfies the initial condition.
   

2. Check the dynamics:
   Compute the time derivative of $x(t)$:

   $$\frac{d}{dt}x(t)=a{e}^{a(t-t_0)}{x}_0$$
   Remember...

Video: https://youtu.be/m2MIpDrF7Es

Then, substituting back:

This matches the original equation $\dot{x}=ax$.

Thus, the solution is valid. ✅

D.3) Case 2: Solving the Matrix Case (Extending to Higher Dimensions)

For systems where $x\in {\mathbb{R}}^n$, the dynamics are:

The solution remains similar but uses a [[matrix exponential]]:

Here, $e^{A(t-t_0)}$ is the [[matrix exponential]], defined as a [[Taylor Series]]:

This extends the scalar exponential to matrices.

D.3.1) Why Matrix Exponentials Work

Definition of the exponential as a [[Taylor Series]] expansion:

• For a scalar exponential:$$e^{at}=\sum _{k=0}^{\mathrm{\infty }}\frac{(at{)}^k}{k!}$$
• For a matrix $A$:$$e^{At}=\sum _{k=0}^{\mathrm{\infty }}\frac{(At{)}^k}{k!}$$

The [[matrix exponential]] allows us to generalize the behavior of exponentials to multidimensional systems.

Especially, we care about the derivative, we can do Term-by-Term Differentiation to this Infinite Series,

Note1: take the derivative with respect to $t$,

(use the [[power rule]])

Note2: We can Re-indexing the summation to adjust the index and simplify the series.

Important observations:

• The time derivative of the [[matrix exponential]] behaves like a [[scalar exponential]]:$$\frac{d}{dt}{e}^{At}=A{e}^{At}$$
• Identity at $t=t_0$, it simplifies to the identity matrix:$$e^{A(t_0-t_0)}=I$$

D.3.2) State Transition Matrix (fancy name for the Matrix Exponential)

The matrix exponential $e^{A(t-t_0)}$ is also called the [[State Transition Matrix]] and is often denoted:

So we can rewrite our differential equation, using this new definition,

We can use $t_0$,

or in general, use $\tau$,

Just as before, the properties of the [[matrix exponential]] still apply,

D.4) Including Inputs: Find the General Solution for a Controlled System

For systems with inputs:

The solution incorporates the input's influence:

Key Terms:

• $\mathrm{\Phi }(t,t_0)$: The [[state transition matrix]].
• ${\int }_{t_0}^t\mathrm{\Phi }(t,\tau )Bu(\tau )d\tau$: The effect of the input $u(\tau )$ on the state over time. Also known as a [[Convolution Integral]].

D.4.1) Validation of General Solution

1. Check Initial Condition:
   At $t=t_0$, the integral term vanishes:

   $$x(t_0)=\mathrm{\Phi }(t_0,t_0)x(t_0)=x(t_0)$$

   This satisfies the initial condition.
   

2. Check Dynamics:
   Differentiating $x(t)$:

   • The first term contributes $Ax$.
     
   • The second term,
     
     requires us to use the [[Leibniz's Integral rule]] for differentiation under the integral sign:$$\frac{d}{dt}{\int }_{t_0}^t\mathrm{\Phi }(t,\tau )Bu(\tau )d\tau =\mathrm{\Phi }(t,t)Bu(t)+{\int }_{t_0}^t\frac{d}{dt}\mathrm{\Phi }(t,\tau )Bu(\tau )d\tau$$

   After simplification,
   

   this matches the equation $\dot{x}=Ax+Bu$.
   

Thus, the solution is valid. ✅

D.5) Using the General Solution for the Output Equation

General LTI System:

1. State dynamics:$$\dot{x}=Ax+Bu$$with General Solution,$$$$

y = Cx

x(t) = \Phi(t, t_0) x(t_0) + \int_{t_0}^t \Phi(t, \tau) B u(\tau) , d\tau

\Phi(t, t_0) = e^

y(t) = Cx(t)

x(t) = \Phi(t, t_0) x(t_0) + \int_{t_0}^t \Phi(t, \tau) B u(\tau) , d\tau

\dot{x} = ax

x(t) = e^{at} x(0)

x(t) \to 0 \quad \forall x(0)
$$

2. [[Instability]]:
   • The system is unstable if the initial condition that blows up the system exist:$$\mathrm{\exists }x(0)\text{s.t. }x(t)\to \mathrm{\infty }$$

3. [[Critical Stability]]:
   • The system is critically stable if:
     • $x(t)$ neither blows up nor converges to zero
       

E.4) Generalizing to Matrices: how do we determine stability?

Systems of the Form (with no controller input)

remember, these system have the solution,

• Here, $x$ is a vector, and $A$ is a matrix.
• For matrices, we can’t just say $A>0$ or $A<0$ because those terms don’t apply to matrices.
• Instead, we use [[eigenvalues]]! but why?!

E.4.1) Recap: What are Eigenvalues?

For those of you who don't know/or do not remember what [[eigenvalues]] are.

What Are Eigenvalues?

• [[Eigenvalues]] ($\lambda$) are special numbers associated with matrices that help describe how matrices transform vectors.
• If you have a matrix $A$ and a vector $v$, and their product can be expressed as:$$Av=\lambda v$$
  • This means that applying $A$ to $v$ scales the vector $v$ by the factor $\lambda$ (the eigenvalue).
  • The vector $v$ is called an [[eigenvector]], and $\lambda$ is the corresponding [[eigenvalue]].
    

Key Points About Eigenvalues:

1. Nature:

   • [[Eigenvalues]] can be complex numbers (not limited to real numbers).
     
   • They generalize the concept of scaling factors for transformations in higher dimensions.

2. Intuition:

   • [[Eigenvalues]] describe how the matrix $A$ acts in the directions of its [[eigenvectors]].
   • Along the [[eigenvector]] direction, the matrix scales the vector by $\lambda$.
   • You can think of [[eigenvectors]] as "directions" and [[eigenvalues]] as "magnitudes" in those directions.

Why Are Eigenvalues Important?

• They are fundamental tools for understanding matrix behavior in systems.
• In many cases, matrix systems can be thought of as a combination of scalar systems in the directions of eigenvectors.

How to Compute Eigenvalues?

• If you’re using computational tools, finding eigenvalues is straightforward:
  • MATLAB: Use the eig(A) command to compute the eigenvalues of a matrix $A$.
    
  • Python (NumPy): Use np.linalg.eig(A).
  • Most programming languages or libraries for linear algebra have similar commands.
  • You can also get the [[eigenvalues]] by solving the [[characteristic equation]]
    

E.4.2) Example: Matrix Systems (Saddle Points and Instability)

For the system:

we know the solution is:

where:

We also know that the matrix exponential is given by the infinite series:

Now...
Computing $\mathrm{\Phi }(t,t_0)$ is computationally heavy for most $A$ matrices.

But...
There is one category of $A$ matrices that simplifies the computations.
These are the [[diagonal matrices]].

Properties of Diagonal Matrices:
There are some interesting properties of diagonal matrices.

First, recall the definition of the [[eigenvectors]] and [[eigenvalues]] of a matrix:

which can be rewritten as:

where the [[eigenvalues]] are calculated using:

It turns out that for [[diagonal matrices]], we can always find the [[eigenvalues]] in their columns with their corresponding [[eigenvectors]].

For example, consider the following [[diagonal matrix]] $A$:

where ${\lambda }_1$ and ${\lambda }_2$ are the eigenvalues, and:

is the eigenvector associated with ${\lambda }_1$, and:

is the eigenvector associated with ${\lambda }_2$.

How does this property help us?
Well, consider the same [[diagonal matrix]] $A$,

As part of our model,

The computations simplify to the form:

We can notice that these polynomials are special since they fit the definition:

Therefore, we can simplify even further and say:

Note: This analytical solution will save us time from computing the infinite series.

Visualize this solution:

which simplifies to,

this creates the Saddle Point in the [[Phase portrait]],

Source here

This solution gives us the following intuition:

1. The eigenvalues of the diagonal matrix $A$ ( ${\lambda }_1$ and ${\lambda }_2$ ) directly control the behavior of the system, as seen in the exponential terms $e^{{\lambda }_1(t-t_0)}$ and $e^{{\lambda }_2(t-t_0)}$.
2. Diagonal matrices simplify matrix exponentials because there is no need for off-diagonal computations, reducing computational overhead significantly.
   

E.4.3) Example: Matrix Systems (Imaginary Eigenvalues and Center Fixed Points)

Pendulum


Source here

Inverted Pendulum: unstable

E.4.4) Stability Conditions in Matrix Systems (using Eigenvalues)

For the system,

Conditions:

1. Asymptotic Stability:
   • The system is asymptotically stable if and only if:$$\text{Re}(\lambda )<0\mathrm{\forall }\lambda \in \text{eig}(A)$$

2. Instability:
   • The system is unstable if:$$\mathrm{\exists }\lambda \in \text{eig}(A)\text{s.t. }\text{Re}(\lambda )>0$$

3. Critical Stability:
   • The system is critically stable if:
     • $\text{Re}(\lambda )\le 0\mathrm{\forall }\lambda \in \text{eig}(A)$, (at least one eigenvalue has $\text{Re}(\lambda )=0$).
     • OR
     • two purely imaginary eigenvalues and the rest have negative real part.
       

E.5) Key Takeaways: Stability of Linear Systems

1. Stability depends on the eigenvalues of $A$:
   • Asymptotically Stable: $\text{Re}(\lambda )<0\mathrm{\forall }\lambda$.
   • Unstable: $\mathrm{\exists }\lambda \text{s.t. }\text{Re}(\lambda )>0$.
   • Critically Stable: Eigenvalues have $\text{Re}(\lambda )\le 0$, with at least one on the imaginary axis.

2. Eigenvalues give insight into system behavior:

   • Negative real parts: Stable behavior.
   • Positive real parts: Unstable behavior.
   • Zero or purely imaginary eigenvalues: Critical stability.

3. Design Goal: Ensure the closed-loop system has eigenvalues with negative real parts to guarantee stability.

F) Swarm Robotics Control: The Consensus Equation (🎦 video 3.6)

F.1) Recap: Stability and Eigenvalues

From the previous lecture, we learned that [[eigenvalues]] play a fundamental role in understanding the [[stability]] properties of linear systems.

Specifically:

• If all eigenvalues have strictly negative real parts, the system is asymptotically stable.
• If any eigenvalue has a positive real part, the system becomes unstable.
• If eigenvalues are purely imaginary or zero, the system may exhibit critical stability.

The focus today is to use these ideas to address a fundamental problem in swarm robotics:
The Rendezvous Problem.

More info here

F.2) The Rendezvous Problem in Swarm Robotics

Problem Statement:
In swarm robotics, we have a collection of mobile robots that:

1. Measure relative displacement of their neighbors (e.g., $x_i-x_j$).
2. Lack global positioning information, meaning they do not know their absolute positions.

Goal:
Achieve rendezvous: make all robots meet at the same position without pre-specifying the meeting point.

Challenge:
Robots do not know their global location (e.g., "the origin"). Instead, they must rely on local relative measurements of their neighbors.

F.2.1) The Two-Robot Case (check for stability)

For two robots ($x_1,x_2$):

1. Define control laws (the agents simply aim towards each other):

2. Write the system dynamics:

   $$\dot{x}=Ax,A=\left(\begin{array}{cc}-1& 1\\ 1& -1\end{array}\right).$$

3. Eigenvalues of $A$:

   • Using MATLAB (or similar), we find:$$
     \lambda_1 = 0, \quad \lambda_2 = -2.$$$$
     • One eigenvalue is 0.
     • The other eigenvalue is negative.

4. Stability Analysis:
   • A zero eigenvalue suggests [[critical stability]].

F.2.1.1) Null Space of "A" (the rendezvous meeting point)

Did you know?: The critically stable system does not converge to the origin but instead to the null space of $A$.

Let's recap....
The null space of $A$ is defined as:

It means, that the [[null space]] of $A$ is the set of all vectors $x$ that satisfy $Ax=0$

So, when our system is,

1. If ${\lambda }_i=0$, then $e^{{\lambda }_{i}t}=1$, so this component remains constant.
2. If ${\lambda }_i$​ has a negative real part, then $e^{{\lambda }_{i}t}\to 0$ as $t\to \infty$

Thus, all components of $x(t)$ corresponding to eigenvalues with negative real parts decay to zero over time. The only remaining component is the one associated with $\lambda =0$. And this remaining components in $x$ are located in the [[Null space]] (when $\dot{x}=Ax=0$)

Example: The Two-Robot Case

For two robots ($x_1,x_2$):

with $A=\left(\begin{array}{cc}-1& 1\\ 1& -1\end{array}\right)$:

Interpretation: the states $x_1$ and $x_2$ evolve into the null-space of $A$.

• Both robots ($x_1,x_2$) converge to the same position ($x_1=x_2=\alpha$).
• The difference between the robots ($x_1-x_2$) approaches 0.

Thus, rendezvous is achieved, even though the final position ($\alpha$) is unknown. It is somewhere in the [[Null Space]] of $A$

F.2.2) Extending to Multiple Robots

General Control Law:
For multiple robots, let each robot $i$ move toward the centroid of its neighbors (this is known as the [[consensus equation]]):

Stacked System:
Stacking all robot positions into a vector $x$,

the system can be written as:

where $L$ is the [[Graph Laplacian Matrix]], describing the communication structure (who talks to whom).

Graph Laplacian Properties:

1. $L$ has:
   • One zero eigenvalue (${\lambda }_1=0$) if the graph is connected.
   • All other eigenvalues are positive (${\lambda }_2,{\lambda }_3,\cdots >0$).
2. $-L$ has:
   • One zero eigenvalue (${\lambda }_1=0$).
   • All other eigenvalues are negative (${\lambda }_2,{\lambda }_3,\cdots <0$).
   • Therefore the multiple-robot case has Critical Stability

F.2.2.1) Null Space of "L" (the rendezvous meeting point)

The null space of $L$ determines the consensus value. If the graph is connected:

Key Insight:

• All agents converge to the same value ($\alpha$).
• This ensures consensus (e.g., all robots agree on position).

The corresponding system is critically stable, as $-L$ has the necessary eigenvalue properties.

F.3) Real-World Implementations

Practical Example:- Two robots executing the algorithm in real-time

• Robots align their movement toward consensus.
• The state of the system asymptotically approaches the null space of the system matrix.

Control Design: Use a simple PID go-to-goal controller:

• Robots share relative positions.
• Consensus equations define intermediary goal points.
  

Key Result:

• The robots successfully achieve rendezvous and demonstrate the effectiveness of the consensus equation.

Other Simulation: In simulation, robots:

1. Navigate their environment.
2. Avoid obstacles.
3. Achieve rendezvous or other formations.

F.4) Conclusion: Solution to the Rendezvous Problem

1. The rendezvous problem is solved using:

   $$\dot{x}=-Lx.$$

2. Critical stability ensures convergence to the null space of $L$.

More info here

4. The [[consensus equation]] can be extended to solve more complex multi-robot tasks, including:
   • Splitting into subgroups.
   • Avoiding obstacles.
   • Discovering missing agents.

By building on these foundations, you can design sophisticated algorithms for swarm robotics and network control systems.

G) Attempting Linear System Stability with Output Feedback Control: Eigenvalue Analysis (🎦 video 3.7)

G.1) Recap: Stability and Eigenvalues

[[Stability of a linear system]] depends on the eigenvalues of its system matrix.

• Asymptotic Stability: All eigenvalues must have strictly negative real parts.
• Critical Stability: At least one eigenvalue has zero real part, and the rest have non-positive real parts.
• Instability: Any eigenvalue with a positive real part causes the system to "blow up."

Today, we aim to achieve asymptotic stability by designing a feedback controller.

G.2) State-Space System and Output Feedback

We start with a linear system in state-space form:

where:

• $x$: State vector (e.g., position and velocity of a robot),
• $u$: Control input,
• $y$: System output.

Goal:
Design a feedback controller that uses the output $y$ to stabilize the system.

G.3) Example1: World's Simplest Robot

We revisit the simple robot system, which is a point mass on a line:

with the states being,

remember the State Dynamics written in the form,

then we can obtain the matrices,

which is simply,

State Variables:

• $x_1$: Position of the robot. <---- is the output
• $x_2$: Velocity of the robot.
• $u$: Acceleration (control input).

Now our job is to try to find a way to connect $y$ with $u$,

G.3.1) Idea 1: Create a Simple Position-Based Controller (part1)

Position-Based Control:
Our goal is to stabilize the system, meaning we want to drive the state of the robot to zero, or equivalently, to the origin.

• If the position of the robot ($y$) is negative (i.e., the robot is on the left side of the origin), we should apply a positive input ($u$) to push the robot to the right.
• Conversely, if $y$ is positive (i.e., the robot is on the right side of the origin), we should apply a negative input ($u$) to push the robot to the left.

Behavior:

• When $y<0$, $u>0$: The robot moves toward the origin from the left.
• When $y>0$, $u<0$: The robot moves toward the origin from the right.
  

in other words,
The control input $u$ should be proportional to the negative of the position $y$.

In general, this simple proportional controller can be written mathematically as,

where $K>0$ is a proportional gain.
Note: $K$ is a scalar right now, in the future we will see in which case $K$ can be a matrix gain.

G.3.1.1) How does this Output Feedback change the System Dynamics?

Recall the system is,

By applying the control law $u=-Ky$, we modify the system dynamics.

1. Recall that the output is:

   $$y=Cx.$$

2. Rewriting the control law $u$ in terms of $x$:

   $$u=-Ky$$

   in terms of $x$,

   $$u=-Ky=-K(Cx),$$

3. Substituting $u=-K(Cx)$ into the state equation: