In Lesson 1, we saw that ordinary state feedback can stabilize and shape the internal modes of a plant, but it does not automatically guarantee zero steady-state tracking error for constant references or constant disturbances. The central idea of integral action is to make the controller accumulate the tracking error. If the output remains below or above the reference, the accumulated error continues to grow and changes the input until the steady-state error is forced to zero.

For a continuous-time LTI plant \( \dot{\mathbf{x} } = A\mathbf{x}+B\mathbf{u} \), \( \mathbf{y}=C\mathbf{x}+D\mathbf{u} \), define the tracking error and its integral as

\[ \mathbf{e}(t)=\mathbf{r}(t)-\mathbf{y}(t), \qquad \mathbf{q}(t)=\int_0^t \mathbf{e}(\sigma)\,d\sigma. \]

The new state \( \mathbf{q}(t) \) is called the integral state. Its differential equation is

\[ \dot{\mathbf{q} }(t)=\mathbf{r}(t)-\mathbf{y}(t) =-\;C\mathbf{x}(t)-D\mathbf{u}(t)+\mathbf{r}(t). \]

Thus, instead of controlling only \( \mathbf{x}(t)\in\mathbb{R}^{n} \), the controller will later act on the augmented state \( \mathbf{x}_a(t)=\begin{bmatrix}\mathbf{x}(t)' & \mathbf{q}(t)'\end{bmatrix}' \). If the system has \( p \) tracked outputs, then \( \mathbf{q}(t)\in\mathbb{R}^{p} \), so the augmented dimension is \( n+p \).

flowchart TD
  R["reference r"] --> SUM["error: e = r - y"]
  Y["output y"] --> SUM
  SUM --> INT["integrator: q_dot = e"]
  X["plant state x"] --> FB["state feedback"]
  INT --> FB
  FB --> U["control input u"]
  U --> P["plant: x_dot = A x + B u"]
  P --> X
  P --> Y
        

Start from the plant

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

The integral state obeys

\[ \dot{\mathbf{q} }=\mathbf{r}-C\mathbf{x}-D\mathbf{u}. \]

Therefore the augmented system with \( \mathbf{x}_a=\begin{bmatrix}\mathbf{x}\\ \mathbf{q}\end{bmatrix} \) is

\[ \begin{bmatrix}\dot{\mathbf{x} }\\ \dot{\mathbf{q} }\end{bmatrix} = \begin{bmatrix} A & 0\\ -C & 0 \end{bmatrix} \begin{bmatrix}\mathbf{x}\\ \mathbf{q}\end{bmatrix} + \begin{bmatrix} B\\ -D \end{bmatrix}\mathbf{u} + \begin{bmatrix} 0\\ I_p \end{bmatrix}\mathbf{r}. \]

We define

\[ A_a=\begin{bmatrix} A & 0\\ -C & 0 \end{bmatrix}, \qquad B_a=\begin{bmatrix} B\\ -D \end{bmatrix}, \qquad B_r=\begin{bmatrix}0\\ I_p\end{bmatrix}, \qquad C_a=\begin{bmatrix}C & 0\end{bmatrix}. \]

The augmented open-loop model becomes

\[ \dot{\mathbf{x} }_a=A_a\mathbf{x}_a+B_a\mathbf{u}+B_r\mathbf{r}, \qquad \mathbf{y}=C_a\mathbf{x}_a+D\mathbf{u}. \]

In many control-design examples, \( D=0 \). Then the integral state equation simplifies to \( \dot{\mathbf{q} }=\mathbf{r}-C\mathbf{x} \), and the augmented input matrix becomes \( B_a=\begin{bmatrix}B\\0\end{bmatrix} \).

The ordinary state \( \mathbf{x} \) describes the internal energy-storage variables of the plant. The integral state \( \mathbf{q} \) is different: it is a memory of the tracking error. If a constant reference \( \mathbf{r}_0 \) is applied and the closed-loop system reaches equilibrium, then \( \dot{\mathbf{q} }=0 \). From the integral equation,

\[ \dot{\mathbf{q} }=0 \quad\Longrightarrow\quad \mathbf{r}_0-\mathbf{y}_{ss}=0 \quad\Longrightarrow\quad \mathbf{y}_{ss}=\mathbf{r}_0. \]

Therefore, if the augmented closed-loop system is internally stable and an equilibrium exists, the integral state enforces zero steady-state error for constant references.

A common feedback form for the augmented state is

\[ \mathbf{u}=-K_x\mathbf{x}+K_i\mathbf{q}. \]

Equivalently, with \( K_a=\begin{bmatrix}K_x & -K_i\end{bmatrix} \), we can write

\[ \mathbf{u}=-K_a\mathbf{x}_a. \]

The actual selection of \( K_x \) and \( K_i \) is the main topic of Lesson 3. This lesson focuses on forming the augmented state-space model correctly and checking whether the augmented pair is suitable for state-feedback design.

The augmented pair \( (A_a,B_a) \) must be controllable if we want arbitrary pole placement for the augmented servo system. The controllability matrix is

\[ \mathcal{C}_a= \begin{bmatrix} B_a & A_aB_a & A_a^2B_a & \cdots & A_a^{n+p-1}B_a \end{bmatrix}. \]

The direct rank test is

\[ \operatorname{rank}(\mathcal{C}_a)=n+p. \]

However, for servo augmentation there is a more revealing condition. The augmented system is controllable if the original plant is controllable and the plant has no invariant zero at the origin. In rank form, the zero-at-origin condition is

\[ \operatorname{rank} \begin{bmatrix} A & B\\ C & D \end{bmatrix} =n+p. \]

This condition says that the plant must be able to generate the desired constant output at equilibrium. If the Rosenbrock matrix above loses rank, then some constant tracking command is structurally incompatible with the plant and the integral state introduces an uncontrollable mode at the origin.

The PBH controllability test states that \( (A_a,B_a) \) is controllable if and only if

\[ \operatorname{rank}\begin{bmatrix}\lambda I_{n+p}-A_a & B_a \end{bmatrix}=n+p \quad \text{for every eigenvalue } \lambda \text{ of } A_a. \]

Since \( A_a=\begin{bmatrix}A&0\\-C&0\end{bmatrix} \) and \( B_a=\begin{bmatrix}B\\-D\end{bmatrix} \), the PBH matrix becomes

\[ \begin{bmatrix} \lambda I_n-A & 0 & B\\ C & \lambda I_p & D \end{bmatrix}. \]

For \( \lambda\neq 0 \), the block \( \lambda I_p \) is nonsingular. Any uncontrollable left eigenvector of the augmented system would imply an uncontrollable left eigenvector of \( (A,B) \). Hence the original controllability of \( (A,B) \) eliminates all nonzero-eigenvalue failures.

The special case is \( \lambda=0 \). Substituting \( \lambda=0 \) gives the rank requirement

\[ \operatorname{rank} \begin{bmatrix} -A & 0 & B\\ C & 0 & D \end{bmatrix} =n+p. \]

The zero column block corresponds to the integral state. Removing this structurally zero block leaves the equivalent condition

\[ \operatorname{rank} \begin{bmatrix} A & B\\ C & D \end{bmatrix} =n+p. \]

Thus, assuming \( (A,B) \) is controllable, the augmented pair is controllable exactly when the plant has no invariant zero at the origin.

flowchart TD
  A["Start with plant A, B, C, D"] --> B["Choose tracked outputs"]
  B --> C["Create q_dot = r - y"]
  C --> D["Build Aa, Ba, Br, Ca"]
  D --> E["Check rank of ctrb(A, B)"]
  E --> F["Check rank of [A B; C D] at zero"]
  F --> G["Build augmented controllability matrix"]
  G --> H["Ready for augmented feedback design"]
        

Consider the second-order plant

\[ A=\begin{bmatrix}0&1\\-2&-3\end{bmatrix}, \qquad B=\begin{bmatrix}0\\1\end{bmatrix}, \qquad C=\begin{bmatrix}1&0\end{bmatrix}, \qquad D=0. \]

With \( q(t)=\int_0^t(r-y)d\sigma \), the augmented matrices are

\[ A_a= \begin{bmatrix} 0&1&0\\ -2&-3&0\\ -1&0&0 \end{bmatrix}, \qquad B_a=\begin{bmatrix}0\\1\\0\end{bmatrix}, \qquad B_r=\begin{bmatrix}0\\0\\1\end{bmatrix}. \]

The augmented controllability matrix is

\[ \mathcal{C}_a= \begin{bmatrix} B_a & A_aB_a & A_a^2B_a \end{bmatrix} = \begin{bmatrix} 0&1&-3\\ 1&-3&7\\ 0&0&-1 \end{bmatrix}. \]

Its determinant is

\[ \det(\mathcal{C}_a)=1\neq 0. \]

Hence \( (A_a,B_a) \) is controllable. The Rosenbrock zero-at-origin check also succeeds:

\[ \operatorname{rank} \begin{bmatrix} 0&1&0\\ -2&-3&1\\ 1&0&0 \end{bmatrix} =3=n+p. \]

The augmentation itself is only block-matrix construction, so it can be implemented from scratch. However, later design steps usually require reliable numerical linear algebra and pole-placement routines.

• Python: numpy, scipy.signal, python-control, matplotlib.
• C++: from-scratch matrices for small educational examples; Eigen or Armadillo for practical numerical work.
• Java: from-scratch arrays for teaching; EJML or Apache Commons Math for larger systems.
• MATLAB/Simulink: Control System Toolbox commands such as ctrb, rank, place, ss, and step; Simulink for block-level implementation.
• Wolfram Mathematica: symbolic and numerical matrix construction using ArrayFlatten, MatrixRank, Eigenvalues, and NDSolve.

Chapter26_Lesson2.py

import numpy as np
from scipy.signal import place_poles, StateSpace, lsim
import matplotlib.pyplot as plt

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

def augment_with_error_integral(A, B, C, D=None):
    A = np.asarray(A, dtype=float)
    B = np.asarray(B, dtype=float)
    C = np.asarray(C, dtype=float)
    if D is None:
        D = np.zeros((C.shape[0], B.shape[1]))
    D = np.asarray(D, dtype=float)

    n = A.shape[0]
    p = C.shape[0]

    Aa = np.block([
        [A, np.zeros((n, p))],
        [-C, np.zeros((p, p))]
    ])
    Ba = np.vstack([B, -D])
    Br = np.vstack([np.zeros((n, p)), np.eye(p)])
    Ca = np.hstack([C, np.zeros((p, p))])
    Da = D.copy()
    return Aa, Ba, Br, Ca, Da

A = np.array([[0.0, 1.0], [-2.0, -3.0]])
B = np.array([[0.0], [1.0]])
C = np.array([[1.0, 0.0]])
D = np.array([[0.0]])

Aa, Ba, Br, Ca, Da = augment_with_error_integral(A, B, C, D)

print("Aa =", Aa)
print("Ba =", Ba)
print("rank ctrb(A,B) =", np.linalg.matrix_rank(controllability_matrix(A, B)))
print("rank ctrb(Aa,Ba) =", np.linalg.matrix_rank(controllability_matrix(Aa, Ba)))
print("rank [A B; C D] =", np.linalg.matrix_rank(np.block([[A, B], [C, D]])))

desired_poles = np.array([-2.0, -3.0, -4.0])
Kaug = place_poles(Aa, Ba, desired_poles).gain_matrix
Kx = Kaug[:, :A.shape[0]]
Ki = -Kaug[:, A.shape[0]:]

print("Kaug for u = -Kaug [x; q] =", Kaug)
print("Kx =", Kx)
print("Ki for u = -Kx x + Ki q =", Ki)

Acl = Aa - Ba @ Kaug
sys_cl = StateSpace(Acl, Br, Ca, np.zeros((1, 1)))

t = np.linspace(0.0, 8.0, 500)
r = np.ones_like(t)
tout, yout, xout = lsim(sys_cl, U=r, T=t)

print("final output =", yout[-1])
print("final tracking error =", 1.0 - yout[-1])

plt.figure()
plt.plot(tout, yout, label="y(t)")
plt.plot(tout, r, "--", label="r(t)")
plt.xlabel("time [s]")
plt.ylabel("output")
plt.title("Integral-augmented state feedback: unit-step tracking")
plt.grid(True)
plt.legend()
plt.show()
      

Chapter26_Lesson2.cpp

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

using Mat3 = std::array<std::array<double, 3>, 3>;
using Vec3 = std::array<double, 3>;

Mat3 eye3() {
    return { { {1, 0, 0}, {0, 1, 0}, {0, 0, 1} } };
}

Mat3 add(const Mat3& A, const Mat3& B) {
    Mat3 C{};
    for (int i = 0; i != 3; ++i)
        for (int j = 0; j != 3; ++j)
            C[i][j] = A[i][j] + B[i][j];
    return C;
}

Mat3 scale(const Mat3& A, double s) {
    Mat3 C{};
    for (int i = 0; i != 3; ++i)
        for (int j = 0; j != 3; ++j)
            C[i][j] = s * A[i][j];
    return C;
}

Mat3 mul(const Mat3& A, const Mat3& B) {
    Mat3 C{};
    for (int i = 0; i != 3; ++i)
        for (int j = 0; j != 3; ++j)
            for (int k = 0; k != 3; ++k)
                C[i][j] += A[i][k] * B[k][j];
    return C;
}

Vec3 mat_vec(const Mat3& A, const Vec3& x) {
    Vec3 y{};
    for (int i = 0; i != 3; ++i)
        for (int j = 0; j != 3; ++j)
            y[i] += A[i][j] * x[j];
    return y;
}

double det3(const Mat3& M) {
    return M[0][0]*(M[1][1]*M[2][2] - M[1][2]*M[2][1])
         - M[0][1]*(M[1][0]*M[2][2] - M[1][2]*M[2][0])
         + M[0][2]*(M[1][0]*M[2][1] - M[1][1]*M[2][0]);
}

Mat3 inverse3(const Mat3& M) {
    double d = det3(M);
    Mat3 inv{};
    inv[0][0] =  (M[1][1]*M[2][2] - M[1][2]*M[2][1]) / d;
    inv[0][1] = -(M[0][1]*M[2][2] - M[0][2]*M[2][1]) / d;
    inv[0][2] =  (M[0][1]*M[1][2] - M[0][2]*M[1][1]) / d;
    inv[1][0] = -(M[1][0]*M[2][2] - M[1][2]*M[2][0]) / d;
    inv[1][1] =  (M[0][0]*M[2][2] - M[0][2]*M[2][0]) / d;
    inv[1][2] = -(M[0][0]*M[1][2] - M[0][2]*M[1][0]) / d;
    inv[2][0] =  (M[1][0]*M[2][1] - M[1][1]*M[2][0]) / d;
    inv[2][1] = -(M[0][0]*M[2][1] - M[0][1]*M[2][0]) / d;
    inv[2][2] =  (M[0][0]*M[1][1] - M[0][1]*M[1][0]) / d;
    return inv;
}

Vec3 row_times_mat(const Vec3& r, const Mat3& M) {
    Vec3 y{};
    for (int j = 0; j != 3; ++j)
        for (int k = 0; k != 3; ++k)
            y[j] += r[k] * M[k][j];
    return y;
}

int main() {
    Mat3 Aa = { { {0, 1, 0}, {-2, -3, 0}, {-1, 0, 0} } };
    Vec3 Ba = {0, 1, 0};

    Vec3 c1 = Ba;
    Vec3 c2 = mat_vec(Aa, Ba);
    Vec3 c3 = mat_vec(Aa, c2);

    Mat3 Cc = { { {c1[0], c2[0], c3[0]},
                {c1[1], c2[1], c3[1]},
                {c1[2], c2[2], c3[2]} } };

    std::cout << "det controllability(Aa,Ba) = "
              << det3(Cc) << "\\n";

    Mat3 Aa2 = mul(Aa, Aa);
    Mat3 Aa3 = mul(Aa2, Aa);
    Mat3 phiAa = add(add(Aa3, scale(Aa2, 9.0)),
                     add(scale(Aa, 26.0), scale(eye3(), 24.0)));

    Vec3 en = {0, 0, 1};
    Mat3 CcInv = inverse3(Cc);
    Vec3 temp = row_times_mat(en, CcInv);
    Vec3 Kaug = row_times_mat(temp, phiAa);

    std::cout << "Kaug = [ "
              << Kaug[0] << " "
              << Kaug[1] << " "
              << Kaug[2] << " ]\\n";
    std::cout << "Ki in u = -Kx*x + Ki*q is "
              << -Kaug[2] << "\\n";

    return 0;
}
      

Chapter26_Lesson2.java

public class Chapter26_Lesson2 {
    static double[][] mul(double[][] A, double[][] B) {
        int n = A.length, p = B.length, m = B[0].length;
        double[][] C = new double[n][m];
        for (int i = 0; i != n; i++)
            for (int j = 0; j != m; j++)
                for (int k = 0; k != p; k++)
                    C[i][j] += A[i][k] * B[k][j];
        return C;
    }

    static double[] matVec(double[][] A, double[] x) {
        double[] y = new double[A.length];
        for (int i = 0; i != A.length; i++)
            for (int j = 0; j != x.length; j++)
                y[i] += A[i][j] * x[j];
        return y;
    }

    static double det3(double[][] M) {
        return M[0][0]*(M[1][1]*M[2][2] - M[1][2]*M[2][1])
             - M[0][1]*(M[1][0]*M[2][2] - M[1][2]*M[2][0])
             + M[0][2]*(M[1][0]*M[2][1] - M[1][1]*M[2][0]);
    }

    public static void main(String[] args) {
        double[][] Aa = {
            { 0.0,  1.0, 0.0},
            {-2.0, -3.0, 0.0},
            {-1.0,  0.0, 0.0}
        };
        double[] Ba = {0.0, 1.0, 0.0};

        double[] c1 = Ba;
        double[] c2 = matVec(Aa, Ba);
        double[] c3 = matVec(Aa, c2);

        double[][] Cc = {
            {c1[0], c2[0], c3[0]},
            {c1[1], c2[1], c3[1]},
            {c1[2], c2[2], c3[2]}
        };

        System.out.printf("det controllability(Aa,Ba) = %.6f%n", det3(Cc));
        System.out.println("Because this determinant is nonzero, the augmented SISO pair is controllable.");
    }
}
      

Chapter26_Lesson2.m

clear; clc; close all;

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

n = size(A, 1);
p = size(C, 1);

Aa = [A, zeros(n, p); -C, zeros(p, p)];
Ba = [B; -D];
Br = [zeros(n, p); eye(p)];
Ca = [C, zeros(p, p)];
Da = zeros(p, p);

disp('Aa ='); disp(Aa);
disp('Ba ='); disp(Ba);
disp('rank ctrb(A,B) ='); disp(rank(ctrb(A, B)));
disp('rank ctrb(Aa,Ba) ='); disp(rank(ctrb(Aa, Ba)));
disp('rank [A B; C D] ='); disp(rank([A B; C D]));

desired_poles = [-2 -3 -4];
Kaug = place(Aa, Ba, desired_poles);
Kx = Kaug(:, 1:n);
Ki = -Kaug(:, n+1:end);

disp('Kaug for u = -Kaug*[x; q] ='); disp(Kaug);
disp('Kx ='); disp(Kx);
disp('Ki in u = -Kx*x + Ki*q ='); disp(Ki);

Acl = Aa - Ba*Kaug;
syscl = ss(Acl, Br, Ca, Da);

figure;
step(syscl, 8);
grid on;
title('Integral-augmented state feedback: unit-step tracking');

if exist('simulink', 'file')
    mdl = 'Chapter26_Lesson2_Simulink';
    if bdIsLoaded(mdl)
        close_system(mdl, 0);
    end

    new_system(mdl);
    open_system(mdl);

    add_block('simulink/Sources/Step', [mdl '/Reference Step'], ...
        'Position', [40 80 90 110], 'Time', '0', 'Before', '0', 'After', '1');

    add_block('simulink/Continuous/State-Space', [mdl '/Augmented Closed Loop'], ...
        'Position', [160 65 330 125]);

    add_block('simulink/Sinks/Scope', [mdl '/Output Scope'], ...
        'Position', [400 75 460 115]);

    set_param([mdl '/Augmented Closed Loop'], ...
        'A', mat2str(Acl), ...
        'B', mat2str(Br), ...
        'C', mat2str(Ca), ...
        'D', mat2str(Da));

    add_line(mdl, 'Reference Step/1', 'Augmented Closed Loop/1');
    add_line(mdl, 'Augmented Closed Loop/1', 'Output Scope/1');
    set_param(mdl, 'StopTime', '8');
    save_system(mdl);
end
      

Chapter26_Lesson2.nb

ClearAll["Global`*"];

A = { {0, 1}, {-2, -3} };
B = { {0}, {1} };
Cmat = { {1, 0} };
Dmat = { {0} };

n = Length[A];
p = Length[Cmat];

Aa = ArrayFlatten[{ {A, ConstantArray[0, {n, p}]},
                   {-Cmat, ConstantArray[0, {p, p}]} }];

Ba = Join[B, -Dmat];
Br = Join[ConstantArray[0, {n, p}], IdentityMatrix[p]];
Ca = ArrayFlatten[{ {Cmat, ConstantArray[0, {p, p}]} }];

ControllabilityMatrix[M_, N_] :=
  ArrayFlatten[{Table[MatrixPower[M, k].N, {k, 0, Length[M] - 1}]}];

plantRank = MatrixRank[ControllabilityMatrix[A, B]];
augRank = MatrixRank[ControllabilityMatrix[Aa, Ba]];
rosenbrockZeroRank = MatrixRank[ArrayFlatten[{ {A, B}, {Cmat, Dmat} }]];

{Aa, Ba, Br, plantRank, augRank, rosenbrockZeroRank}

phiM[M_] := MatrixPower[M, 3] + 9 MatrixPower[M, 2] +
            26 M + 24 IdentityMatrix[Length[M]];

Cc = ControllabilityMatrix[Aa, Ba];
Kaug = { {0, 0, 1} } . Inverse[Cc] . phiM[Aa];
KiEquivalent = -Kaug[[1, 3]];

{Kaug, KiEquivalent}

Acl = Aa - Ba.Kaug;
Eigenvalues[Acl]
      

Problem 1: For the plant \( \dot{x}=Ax+Bu,\; y=Cx \), derive the augmented matrices for \( q(t)=\int_0^t(r-y)d\sigma \).

Solution:

\[ \dot{q}=r-Cx. \]

\[ \begin{bmatrix}\dot{x}\\\dot{q}\end{bmatrix} = \begin{bmatrix}A&0\\-C&0\end{bmatrix} \begin{bmatrix}x\\q\end{bmatrix} + \begin{bmatrix}B\\0\end{bmatrix}u + \begin{bmatrix}0\\I_p\end{bmatrix}r. \]

Problem 2: Explain why \( \dot{q}=0 \) implies zero steady-state tracking error for a constant reference.

Solution: Since \( \dot{q}=r-y \), at equilibrium \( \dot{q}=0 \). Therefore \( r-y_{ss}=0 \), so \( y_{ss}=r \). This conclusion is valid if the augmented closed-loop system is stable and has an equilibrium.

Problem 3: For \( A=\begin{bmatrix}0&1\\-2&-3\end{bmatrix} \), \( B=\begin{bmatrix}0\\1\end{bmatrix} \), \( C=\begin{bmatrix}1&0\end{bmatrix} \), construct \( A_a \) and \( B_a \).

Solution:

\[ A_a= \begin{bmatrix} 0&1&0\\ -2&-3&0\\ -1&0&0 \end{bmatrix}, \qquad B_a=\begin{bmatrix}0\\1\\0\end{bmatrix}. \]

Problem 4: Show that the example in Problem 3 has a controllable augmented pair.

Solution:

\[ \mathcal{C}_a= \begin{bmatrix} 0&1&-3\\ 1&-3&7\\ 0&0&-1 \end{bmatrix}, \qquad \det(\mathcal{C}_a)=1\neq 0. \]

Therefore \( \operatorname{rank}(\mathcal{C}_a)=3 \), and the augmented pair is controllable.

Problem 5: State the Rosenbrock rank condition that prevents an uncontrollable integrator mode at the origin.

Solution:

\[ \operatorname{rank} \begin{bmatrix} A&B\\ C&D \end{bmatrix} =n+p. \]

If this rank condition fails, the plant has an invariant zero at the origin. Then integral augmentation creates an uncontrollable mode at zero, so arbitrary augmented pole assignment is impossible.

Integral action is introduced by augmenting the plant state with \( q(t)=\int_0^t(r-y)d\sigma \). The resulting augmented model has dimension \( n+p \) and contains the matrices \( A_a=\begin{bmatrix}A&0\\-C&0\end{bmatrix} \), \( B_a=\begin{bmatrix}B\\-D\end{bmatrix} \), and \( B_r=\begin{bmatrix}0\\I_p\end{bmatrix} \). If the augmented closed loop is stable, the equilibrium condition \( \dot{q}=0 \) forces \( y_{ss}=r \) for constant references. The key structural condition is that the original pair \( (A,B) \) be controllable and that \( \operatorname{rank}\begin{bmatrix}A&B\\C&D\end{bmatrix}=n+p \). Lesson 3 will use this augmented model to compute state-feedback and integral gains.