Consider the continuous-time LTI state-space model

\[ \dot{\mathbf{x} }(t)=\mathbf{A}\mathbf{x}(t)+\mathbf{B}\mathbf{u}(t), \qquad \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{u}(t). \]

Here \(\mathbf{x}(t)\in\mathbb{R}^{n}\) is the state, \(\mathbf{u}(t)\in\mathbb{R}^{m}\) is the control input, and \(\mathbf{y}(t)\in\mathbb{R}^{p}\) is the measured output. A full-state feedback law assumes that every component of \(\mathbf{x}(t)\) is available to the controller:

\[ \mathbf{u}(t)=-\mathbf{K}\mathbf{x}(t)+\mathbf{r}(t), \qquad \mathbf{K}\in\mathbb{R}^{m\times n}, \qquad \mathbf{r}(t)\in\mathbb{R}^{m}. \]

The term \(-\mathbf{K}\mathbf{x}\) is the corrective feedback action. The term \(\mathbf{r}\) is an external command injected at the input channel. In this lesson, \(r\) is not yet a carefully designed tracking prefilter; it is simply an additive command signal in the same dimension and physical units as the plant input.

Substituting the feedback law into the plant gives the closed-loop state equation:

\[ \dot{\mathbf{x} } = \mathbf{A}\mathbf{x} + \mathbf{B}(-\mathbf{K}\mathbf{x}+\mathbf{r}) = (\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{x} + \mathbf{B}\mathbf{r}. \]

Therefore the feedback gain \(\mathbf{K}\) changes the internal state matrix from \(\mathbf{A}\) to \(\mathbf{A}-\mathbf{B}\mathbf{K}\). The reference term \(\mathbf{r}\) enters through the same input distribution matrix \(\mathbf{B}\).

The feedback law is a static linear map from the current state to the current input. It is called static because it contains no additional controller states. It is called state feedback because the controller uses the state vector rather than only the output vector.

flowchart TD
  R["command r"] --> S["sum: r plus negative feedback"]
  X["state x"] --> K["gain K"]
  K --> NEG["negative sign"]
  NEG --> S
  S --> U["input u = -Kx + r"]
  U --> P["plant: xdot = A x + B u"]
  P --> X
  P --> Y["output y = C x + D u"]
        

For a single-input system, \(m=1\), the feedback gain is a row vector:

\[ \mathbf{K} = \begin{bmatrix} k_1 & k_2 & \cdots & k_n \end{bmatrix}, \qquad u=-k_1x_1-k_2x_2-\cdots-k_nx_n+r. \]

For a multi-input system, \(m>1\), the gain matrix has one row per actuator:

\[ \begin{bmatrix} u_1\\ u_2\\ \vdots\\ u_m \end{bmatrix} = - \begin{bmatrix} k_{11} & k_{12} & \cdots & k_{1n}\\ k_{21} & k_{22} & \cdots & k_{2n}\\ \vdots & \vdots & \ddots & \vdots\\ k_{m1} & k_{m2} & \cdots & k_{mn} \end{bmatrix} \begin{bmatrix} x_1\\ x_2\\ \vdots\\ x_n \end{bmatrix} + \begin{bmatrix} r_1\\ r_2\\ \vdots\\ r_m \end{bmatrix}. \]

Each actuator can depend on all states. In practice, sparsity, sensor availability, communication delay, actuator limits, and safety constraints may restrict this ideal dense-feedback form.

Define the closed-loop matrix

\[ \mathbf{A}_{cl}=\mathbf{A}-\mathbf{B}\mathbf{K}. \]

Then the closed-loop system is

\[ \dot{\mathbf{x} }=\mathbf{A}_{cl}\mathbf{x}+\mathbf{B}\mathbf{r}, \qquad \mathbf{y}=(\mathbf{C}-\mathbf{D}\mathbf{K})\mathbf{x}+\mathbf{D}\mathbf{r}. \]

If \(\mathbf{D}=\mathbf{0}\), the output equation keeps the simpler form \(\mathbf{y}=\mathbf{C}\mathbf{x}\). If \(\mathbf{D}\neq\mathbf{0}\), then state feedback also changes the direct state-to-output map because \(\mathbf{u}\) appears directly in the output.

With zero command input, \(\mathbf{r}(t)=\mathbf{0}\), the closed-loop homogeneous solution is

\[ \mathbf{x}(t)=e^{(\mathbf{A}-\mathbf{B}\mathbf{K})t}\mathbf{x}(0). \]

Thus the natural modes of the feedback-controlled system are governed by the eigenvalues of \(\mathbf{A}-\mathbf{B}\mathbf{K}\). Later lessons will study how those eigenvalues can be deliberately moved when the pair \((\mathbf{A},\mathbf{B})\) has sufficient controllability.

Suppose \(\mathbf{r}(t)=\bar{\mathbf{r} }\) is constant. A closed-loop equilibrium \(\bar{\mathbf{x} }\) satisfies

\[ \mathbf{0} = (\mathbf{A}-\mathbf{B}\mathbf{K})\bar{\mathbf{x} } + \mathbf{B}\bar{\mathbf{r} }. \]

If \(\mathbf{A}-\mathbf{B}\mathbf{K}\) is nonsingular, the equilibrium is

\[ \bar{\mathbf{x} } = -(\mathbf{A}-\mathbf{B}\mathbf{K})^{-1}\mathbf{B}\bar{\mathbf{r} }. \]

The corresponding steady-state output is

\[ \bar{\mathbf{y} } = \left[-\mathbf{C}(\mathbf{A}-\mathbf{B}\mathbf{K})^{-1}\mathbf{B} + \mathbf{D}\right]\bar{\mathbf{r} }. \]

This formula is important: the command \(\bar{\mathbf{r} }\) does not automatically become the output reference. It is merely injected at the input channel. Exact steady-state tracking usually requires a separate feedforward scaling or integral action, which will be developed in later chapters.

For the regulation case \(\mathbf{r}=\mathbf{0}\), the origin is an equilibrium of the closed-loop system. The stability of this equilibrium is determined by \(\mathbf{A}_{cl}\).

Theorem: The origin of \(\dot{\mathbf{x} }=(\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{x}\) is asymptotically stable if and only if every eigenvalue of \(\mathbf{A}-\mathbf{B}\mathbf{K}\) has strictly negative real part.

\[ \operatorname{Re}\lambda_i(\mathbf{A}-\mathbf{B}\mathbf{K})<0 \quad\text{for all }i \quad\Longleftrightarrow\quad \lim_{t\to\infty}\mathbf{x}(t)=\mathbf{0}. \]

Proof: The solution is \(\mathbf{x}(t)=e^{\mathbf{A}_{cl}t}\mathbf{x}(0)\). From the Jordan form of \(\mathbf{A}_{cl}\), each modal term has the form \(t^q e^{\lambda_i t}\) for some integer \(q\ge0\). Such terms converge to zero for every initial condition exactly when all real parts are strictly negative. Hence \(e^{\mathbf{A}_{cl}t}\to\mathbf{0}\), and the origin is asymptotically stable. Conversely, if any eigenvalue has positive real part, or if a nondecaying imaginary-axis mode remains, there exists an initial condition whose response does not converge to zero.

State feedback is coordinate dependent. Suppose a change of state coordinates is made:

\[ \mathbf{x}=\mathbf{T}\mathbf{z}, \qquad \det(\mathbf{T})\neq0. \]

The transformed model is

\[ \dot{\mathbf{z} } = \mathbf{T}^{-1}\mathbf{A}\mathbf{T}\mathbf{z} + \mathbf{T}^{-1}\mathbf{B}\mathbf{u}. \]

If the same physical input is written in the transformed coordinates as \(\mathbf{u}=-\mathbf{K}_z\mathbf{z}+\mathbf{r}\), then consistency with \(\mathbf{u}=-\mathbf{K}\mathbf{x}+\mathbf{r}\) requires

\[ \mathbf{K}_z=\mathbf{K}\mathbf{T}. \]

Therefore a numerical gain matrix has meaning only relative to the chosen state coordinates and units. Scaling a position state from meters to millimeters, for example, changes the corresponding gain coefficient.

Before using the law \(u=-Kx+r\), the engineer must verify that the mathematical assumptions match the physical implementation.

flowchart TD
  A["Plant model: A, B, C, D"] --> B["Choose state vector and units"]
  B --> C["Check state availability"]
  C --> D["Select feedback gain K"]
  D --> E["Form Acl = A - B K"]
  E --> F["Check stability and response"]
  F --> G["Check actuator magnitude and saturation"]
  G --> H["Implement u = -Kx + r"]
  H --> I["Validate with simulation and experiment"]
        

The most common hidden assumptions are: full state measurement, negligible sampling delay, no actuator saturation, exact model parameters, and compatible units between \(\mathbf{K}\mathbf{x}\) and \(\mathbf{r}\).

The following Python file simulates a mass-spring-damper system with state feedback. It computes \(\mathbf{A}-\mathbf{B}\mathbf{K}\), its eigenvalues, the constant-command equilibrium, and a numerical closed-loop trajectory using RK4 integration.

Chapter22_Lesson1.py

# Chapter22_Lesson1.py
# Structure of state-feedback law: u = -K x + r
# Requires: numpy; optional matplotlib for plotting

import numpy as np

def rk4_step(f, t, x, h):
    k1 = f(t, x)
    k2 = f(t + 0.5*h, x + 0.5*h*k1)
    k3 = f(t + 0.5*h, x + 0.5*h*k2)
    k4 = f(t + h, x + h*k3)
    return x + (h/6.0)*(k1 + 2*k2 + 2*k3 + k4)

def controllability_rank(A, B):
    n = A.shape[0]
    blocks = [B]
    Ak = np.eye(n)
    for _ in range(1, n):
        Ak = Ak @ A
        blocks.append(Ak @ B)
    Ctrb = np.hstack(blocks)
    return np.linalg.matrix_rank(Ctrb), Ctrb

def simulate_closed_loop(A, B, C, K, r_value=1.0, x0=None, tf=8.0, h=0.01):
    n = A.shape[0]
    if x0 is None:
        x0 = np.zeros(n)
    x = x0.astype(float).copy()
    Acl = A - B @ K
    r_vec = np.array([[r_value]], dtype=float)

    def f(t, x_vec):
        x_col = x_vec.reshape(-1, 1)
        dx = Acl @ x_col + B @ r_vec
        return dx.ravel()

    ts = np.arange(0.0, tf + h, h)
    xs = np.zeros((len(ts), n))
    us = np.zeros(len(ts))
    ys = np.zeros(len(ts))

    for i, t in enumerate(ts):
        xs[i, :] = x
        x_col = x.reshape(-1, 1)
        u = float((-K @ x_col + r_vec)[0, 0])
        y = float((C @ x_col)[0, 0])
        us[i] = u
        ys[i] = y
        if i + 1 < len(ts):
            x = rk4_step(f, t, x, h)

    return ts, xs, us, ys, Acl

def main():
    A = np.array([[0.0, 1.0],
                  [-2.0, -0.4]])
    B = np.array([[0.0],
                  [1.0]])
    C = np.array([[1.0, 0.0]])

    K = np.array([[4.0, 2.6]])

    rank, Ctrb = controllability_rank(A, B)
    print("Controllability matrix:\n", Ctrb)
    print("Rank:", rank)

    ts, xs, us, ys, Acl = simulate_closed_loop(
        A, B, C, K, r_value=1.0, x0=np.array([0.2, 0.0])
    )

    print("A - B K =\n", Acl)
    print("Closed-loop eigenvalues:", np.linalg.eigvals(Acl))

    r_value = 1.0
    x_bar = -np.linalg.solve(Acl, B * r_value)
    y_bar = C @ x_bar
    print("Equilibrium x_bar:", x_bar.ravel())
    print("Equilibrium y_bar:", float(y_bar[0, 0]))

    try:
        import matplotlib.pyplot as plt
        plt.figure()
        plt.plot(ts, ys, label="y = Cx")
        plt.plot(ts, us, label="u = -Kx + r")
        plt.xlabel("time [s]")
        plt.grid(True)
        plt.legend()
        plt.title("Chapter22 Lesson1: State-feedback structure")
        plt.show()
    except Exception as exc:
        print("Plot skipped:", exc)

if __name__ == "__main__":
    main()
      

The C++ implementation uses fixed-size arrays and RK4 integration. It is intentionally written without an external linear algebra library so that the feedback interconnection is visible.

Chapter22_Lesson1.cpp

// Chapter22_Lesson1.cpp
// Structure of state-feedback law: u = -K x + r
// Compile: g++ -std=c++17 Chapter22_Lesson1.cpp -O2 -o Chapter22_Lesson1

#include <array>
#include <cmath>
#include <iostream>

using Vec2 = std::array<double, 2>;
using Mat2 = std::array<std::array<double, 2>, 2>;

Vec2 add(Vec2 a, Vec2 b) {
    return {a[0] + b[0], a[1] + b[1]};
}

Vec2 scale(double s, Vec2 a) {
    return {s * a[0], s * a[1]};
}

Vec2 mat_vec(Mat2 M, Vec2 x) {
    return {
        M[0][0] * x[0] + M[0][1] * x[1],
        M[1][0] * x[0] + M[1][1] * x[1]
    };
}

Vec2 dynamics(const Mat2& A, const Vec2& B, const Vec2& K, double r, Vec2 x) {
    double u = -K[0] * x[0] - K[1] * x[1] + r;
    Vec2 Ax = mat_vec(A, x);
    return {Ax[0] + B[0] * u, Ax[1] + B[1] * u};
}

Vec2 rk4_step(const Mat2& A, const Vec2& B, const Vec2& K, double r, double h, Vec2 x) {
    Vec2 k1 = dynamics(A, B, K, r, x);
    Vec2 k2 = dynamics(A, B, K, r, add(x, scale(0.5 * h, k1)));
    Vec2 k3 = dynamics(A, B, K, r, add(x, scale(0.5 * h, k2)));
    Vec2 k4 = dynamics(A, B, K, r, add(x, scale(h, k3)));

    return add(x, scale(h / 6.0, add(add(k1, scale(2.0, k2)), add(scale(2.0, k3), k4))));
}

int main() {
    Mat2 A = { { {0.0, 1.0}, {-2.0, -0.4} } };
    Vec2 B = {0.0, 1.0};
    Vec2 C = {1.0, 0.0};
    Vec2 K = {4.0, 2.6};
    double r = 1.0;

    Mat2 Acl = A;
    for (int i = 0; i < 2; ++i) {
        Acl[i][0] -= B[i] * K[0];
        Acl[i][1] -= B[i] * K[1];
    }

    std::cout << "A - B K =\n";
    std::cout << Acl[0][0] << " " << Acl[0][1] << "\n";
    std::cout << Acl[1][0] << " " << Acl[1][1] << "\n";

    double tr = Acl[0][0] + Acl[1][1];
    double det = Acl[0][0] * Acl[1][1] - Acl[0][1] * Acl[1][0];
    double disc = tr * tr - 4.0 * det;
    std::cout << "trace = " << tr << ", determinant = " << det << "\n";
    if (disc >= 0.0) {
        std::cout << "eigenvalues = "
                  << 0.5 * (tr + std::sqrt(disc)) << ", "
                  << 0.5 * (tr - std::sqrt(disc)) << "\n";
    } else {
        std::cout << "eigenvalues = " << 0.5 * tr << " +/- "
                  << 0.5 * std::sqrt(-disc) << " i\n";
    }

    Vec2 x = {0.2, 0.0};
    double h = 0.01;
    double tf = 8.0;

    std::cout << "t,x1,x2,u,y\n";
    for (int step = 0; step <= static_cast<int>(tf / h); ++step) {
        double t = step * h;
        double u = -K[0] * x[0] - K[1] * x[1] + r;
        double y = C[0] * x[0] + C[1] * x[1];

        if (step % 100 == 0) {
            std::cout << t << "," << x[0] << "," << x[1] << "," << u << "," << y << "\n";
        }
        x = rk4_step(A, B, K, r, h, x);
    }

    return 0;
}
      

The Java version mirrors the C++ version and uses explicit vector and matrix operations for a two-state plant.

Chapter22_Lesson1.java

// Chapter22_Lesson1.java
// Structure of state-feedback law: u = -K x + r
// Compile: javac Chapter22_Lesson1.java
// Run:     java Chapter22_Lesson1

public class Chapter22_Lesson1 {
    static double[] add(double[] a, double[] b) {
        return new double[] {a[0] + b[0], a[1] + b[1]};
    }

    static double[] scale(double s, double[] a) {
        return new double[] {s * a[0], s * a[1]};
    }

    static double[] matVec(double[][] M, double[] x) {
        return new double[] {
            M[0][0] * x[0] + M[0][1] * x[1],
            M[1][0] * x[0] + M[1][1] * x[1]
        };
    }

    static double[] dynamics(double[][] A, double[] B, double[] K, double r, double[] x) {
        double u = -K[0] * x[0] - K[1] * x[1] + r;
        double[] Ax = matVec(A, x);
        return new double[] {Ax[0] + B[0] * u, Ax[1] + B[1] * u};
    }

    static double[] rk4Step(double[][] A, double[] B, double[] K, double r, double h, double[] x) {
        double[] k1 = dynamics(A, B, K, r, x);
        double[] k2 = dynamics(A, B, K, r, add(x, scale(0.5 * h, k1)));
        double[] k3 = dynamics(A, B, K, r, add(x, scale(0.5 * h, k2)));
        double[] k4 = dynamics(A, B, K, r, add(x, scale(h, k3)));

        return add(x, scale(h / 6.0, add(add(k1, scale(2.0, k2)), add(scale(2.0, k3), k4))));
    }

    public static void main(String[] args) {
        double[][] A = {
            {0.0, 1.0},
            {-2.0, -0.4}
        };
        double[] B = {0.0, 1.0};
        double[] C = {1.0, 0.0};
        double[] K = {4.0, 2.6};
        double r = 1.0;

        double[][] Acl = new double[2][2];
        for (int i = 0; i < 2; i++) {
            Acl[i][0] = A[i][0] - B[i] * K[0];
            Acl[i][1] = A[i][1] - B[i] * K[1];
        }

        System.out.println("A - B K:");
        System.out.println(Acl[0][0] + " " + Acl[0][1]);
        System.out.println(Acl[1][0] + " " + Acl[1][1]);

        double trace = Acl[0][0] + Acl[1][1];
        double determinant = Acl[0][0] * Acl[1][1] - Acl[0][1] * Acl[1][0];
        double discriminant = trace * trace - 4.0 * determinant;
        System.out.println("trace = " + trace + ", determinant = " + determinant);
        if (discriminant >= 0.0) {
            System.out.println("eigenvalues = "
                + 0.5 * (trace + Math.sqrt(discriminant)) + ", "
                + 0.5 * (trace - Math.sqrt(discriminant)));
        } else {
            System.out.println("eigenvalues = " + 0.5 * trace
                + " +/- " + 0.5 * Math.sqrt(-discriminant) + " i");
        }

        double[] x = {0.2, 0.0};
        double h = 0.01;
        double tf = 8.0;

        System.out.println("t,x1,x2,u,y");
        for (int step = 0; step <= (int)(tf / h); step++) {
            double t = step * h;
            double u = -K[0] * x[0] - K[1] * x[1] + r;
            double y = C[0] * x[0] + C[1] * x[1];

            if (step % 100 == 0) {
                System.out.println(t + "," + x[0] + "," + x[1] + "," + u + "," + y);
            }

            x = rk4Step(A, B, K, r, h, x);
        }
    }
}
      

MATLAB is especially convenient for state-space calculations because matrix syntax directly matches the equations. The optional Simulink section shows how the same feedback structure can be assembled using block diagrams.

Chapter22_Lesson1.m

% Chapter22_Lesson1.m
% Structure of state-feedback law: u = -K x + r
% Requires MATLAB. Control System Toolbox and Simulink sections are optional.

clear; clc; close all;

A = [0 1; -2 -0.4];
B = [0; 1];
C = [1 0];
D = 0;

K = [4 2.6];
Acl = A - B*K;

disp('A - B*K =');
disp(Acl);
disp('Closed-loop eigenvalues:');
disp(eig(Acl));

r = 1.0;
xbar = -Acl\(B*r);
ybar = C*xbar;
disp('Constant-r equilibrium xbar:');
disp(xbar);
disp('Constant-r equilibrium ybar:');
disp(ybar);

x0 = [0.2; 0.0];
f = @(t,x) A*x + B*(-K*x + r);
[t,x] = ode45(f, [0 8], x0);
u = zeros(length(t),1);
y = zeros(length(t),1);
for i = 1:length(t)
    u(i) = -K*x(i,:)' + r;
    y(i) = C*x(i,:)';
end

figure;
plot(t,y,'LineWidth',1.5); hold on;
plot(t,u,'LineWidth',1.5);
grid on;
xlabel('time [s]');
legend('y = Cx','u = -Kx + r');
title('Chapter22 Lesson1: State-feedback structure');

sys_cl = ss(Acl, B, C, D);
figure;
step(sys_cl, 8);
grid on;
title('Closed-loop response from r to y');

% Optional Simulink construction sketch.
% model = 'Chapter22_Lesson1_Simulink';
% new_system(model); open_system(model);
% add_block('simulink/Sources/Constant', [model '/r']);
% set_param([model '/r'], 'Value', '1');
% add_block('simulink/Continuous/State-Space', [model '/Plant']);
% set_param([model '/Plant'], 'A', mat2str(A), 'B', mat2str(B), ...
%     'C', mat2str(eye(2)), 'D', mat2str(zeros(2,1)));
% add_block('simulink/Math Operations/Gain', [model '/-K']);
% set_param([model '/-K'], 'Gain', mat2str(-K));
% add_block('simulink/Math Operations/Sum', [model '/Sum']);
% set_param([model '/Sum'], 'Inputs', '++');
% add_block('simulink/Sinks/Scope', [model '/Scope']);
% save_system(model);
      

Mathematica can compute closed-loop matrices, eigenvalues, equilibria, and numerical solutions symbolically or numerically.

Chapter22_Lesson1.nb

A = { {0, 1}, {-2, -0.4} };
B = { {0}, {1} };
Cmat = { {1, 0} };
K = { {4, 2.6} };

Acl = A - B.K;
MatrixForm[Acl]
Eigenvalues[Acl]

r = 1;
xbar = -LinearSolve[Acl, B r];
ybar = Cmat.xbar;
{xbar, ybar}

sol = NDSolve[
  {
    x1'[t] == x2[t],
    x2'[t] == -2 x1[t] - 0.4 x2[t] + (-K[[1, 1]] x1[t] - K[[1, 2]] x2[t] + r),
    x1[0] == 0.2,
    x2[0] == 0
  },
  {x1, x2},
  {t, 0, 8}
];

Plot[
  Evaluate[x1[t] /. sol],
  {t, 0, 8},
  PlotLabel -> "Closed-loop output y = x1",
  AxesLabel -> {"t", "y"}
]
      

Problem 1: Let \(\dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u}\) and \(\mathbf{u}=-\mathbf{K}\mathbf{x}+\mathbf{r}\). Derive the closed-loop state equation and output equation.

Solution: Substitute the feedback law:

\[ \dot{\mathbf{x} } = \mathbf{A}\mathbf{x} + \mathbf{B}(-\mathbf{K}\mathbf{x}+\mathbf{r}) = (\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{x} + \mathbf{B}\mathbf{r}. \]

Also,

\[ \mathbf{y} = \mathbf{C}\mathbf{x} + \mathbf{D}(-\mathbf{K}\mathbf{x}+\mathbf{r}) = (\mathbf{C}-\mathbf{D}\mathbf{K})\mathbf{x} + \mathbf{D}\mathbf{r}. \]

Problem 2: For the SISO system

\[ \mathbf{A}= \begin{bmatrix} 0 & 1\\ -2 & -0.4 \end{bmatrix}, \qquad \mathbf{B}= \begin{bmatrix} 0\\ 1 \end{bmatrix}, \qquad \mathbf{K}= \begin{bmatrix} 4 & 2.6 \end{bmatrix}, \]

compute \(\mathbf{A}_{cl}\).

Solution:

\[ \mathbf{B}\mathbf{K} = \begin{bmatrix} 0\\ 1 \end{bmatrix} \begin{bmatrix} 4 & 2.6 \end{bmatrix} = \begin{bmatrix} 0 & 0\\ 4 & 2.6 \end{bmatrix}. \]

\[ \mathbf{A}_{cl} = \mathbf{A}-\mathbf{B}\mathbf{K} = \begin{bmatrix} 0 & 1\\ -6 & -3 \end{bmatrix}. \]

Problem 3: For the matrix in Problem 2, determine whether the closed-loop origin is asymptotically stable.

Solution: The characteristic polynomial is

\[ \det(s\mathbf{I}-\mathbf{A}_{cl}) = \det \begin{bmatrix} s & -1\\ 6 & s+3 \end{bmatrix} = s(s+3)+6 = s^2+3s+6. \]

The roots are

\[ s_{1,2} = \frac{-3\pm\sqrt{9-24} }{2} = -1.5\pm j\frac{\sqrt{15} }{2}. \]

Both eigenvalues have negative real part. Therefore the closed-loop origin is asymptotically stable.

Problem 4: Suppose \(\mathbf{r}(t)=\bar{\mathbf{r} }\) is constant and \(\mathbf{A}-\mathbf{B}\mathbf{K}\) is nonsingular. Derive the equilibrium state.

Solution: At equilibrium, \(\dot{\mathbf{x} }=\mathbf{0}\). Thus

\[ \mathbf{0} = (\mathbf{A}-\mathbf{B}\mathbf{K})\bar{\mathbf{x} } + \mathbf{B}\bar{\mathbf{r} }. \]

Solving for \(\bar{\mathbf{x} }\) gives

\[ \bar{\mathbf{x} } = -(\mathbf{A}-\mathbf{B}\mathbf{K})^{-1}\mathbf{B}\bar{\mathbf{r} }. \]

Problem 5: Under the coordinate transformation \(\mathbf{x}=\mathbf{T}\mathbf{z}\), find the transformed gain \(\mathbf{K}_z\) that produces the same physical input.

Solution: Since \(\mathbf{u}=-\mathbf{K}\mathbf{x}+\mathbf{r}\) and \(\mathbf{x}=\mathbf{T}\mathbf{z}\),

\[ \mathbf{u} = -\mathbf{K}\mathbf{T}\mathbf{z} + \mathbf{r}. \]

Comparing with \(\mathbf{u}=-\mathbf{K}_z\mathbf{z}+\mathbf{r}\), we get

\[ \mathbf{K}_z=\mathbf{K}\mathbf{T}. \]

The state-feedback law \(\mathbf{u}=-\mathbf{K}\mathbf{x}+\mathbf{r}\) converts the open-loop matrix \(\mathbf{A}\) into the closed-loop matrix \(\mathbf{A}-\mathbf{B}\mathbf{K}\). The feedback term changes internal dynamics, while the command term enters through \(\mathbf{B}\). Constant commands produce equilibria determined by \(-(\mathbf{A}-\mathbf{B}\mathbf{K})^{-1}\mathbf{B}\bar{\mathbf{r} }\) when the inverse exists. The numerical value of \(\mathbf{K}\) depends on the chosen state coordinates and units. Later lessons will use controllability to determine when and how \(\mathbf{K}\) can be chosen to relocate closed-loop modes.