Consider a continuous-time LTI system \( \dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \), \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \), where \( \mathbf{x}\in\mathbb{R}^{n} \), \( \mathbf{u}\in\mathbb{R}^{m} \), and \( \mathbf{y}\in\mathbb{R}^{p} \). In the simplest case \( \mathbf{D}=\mathbf{0} \), the two feedback laws are:

\[ \text{state feedback:}\quad \mathbf{u}=-\mathbf{K}\mathbf{x}+\mathbf{r}, \qquad \text{output feedback:}\quad \mathbf{u}=-\mathbf{F}\mathbf{y}+\mathbf{r}. \]

The resulting closed-loop state matrices are:

\[ \mathbf{A}_{sf}=\mathbf{A}-\mathbf{B}\mathbf{K}, \qquad \mathbf{A}_{of}=\mathbf{A}-\mathbf{B}\mathbf{F}\mathbf{C}. \]

Therefore output feedback behaves like state feedback with an effective state gain \( \mathbf{K}_{eff}=\mathbf{F}\mathbf{C} \). This observation is the central mathematical distinction of the lesson: state feedback can choose \( \mathbf{K} \) directly, whereas static output feedback can only choose gains that factor through \( \mathbf{C} \).

flowchart TD
  P["Plant: x_dot = A x + B u, y = C x"] --> S["State feedback"]
  P --> O["Output feedback"]
  S --> S1["Uses x directly"]
  S1 --> S2["u = -K x + r"]
  S2 --> S3["Closed-loop matrix: A - B K"]
  O --> O1["Uses measured y only"]
  O1 --> O2["u = -F y + r"]
  O2 --> O3["Closed-loop matrix: A - B F C"]
  O3 --> O4["Effective gain is F C, not arbitrary K"]
        

The state-feedback gain and output-feedback gain have different dimensions:

\[ \mathbf{K}\in\mathbb{R}^{m\times n}, \qquad \mathbf{F}\in\mathbb{R}^{m\times p}, \qquad \mathbf{F}\mathbf{C}\in\mathbb{R}^{m\times n}. \]

If \( p=n \) and \( \mathbf{C} \) is nonsingular, then \( \mathbf{y}=\mathbf{C}\mathbf{x} \) contains all state information. In that case, every state-feedback law can be implemented through output feedback:

\[ \mathbf{u}=-\mathbf{K}\mathbf{x} = -\mathbf{K}\mathbf{C}^{-1}\mathbf{y}, \qquad \mathbf{F}=\mathbf{K}\mathbf{C}^{-1}. \]

If \( p<n \), the output generally contains fewer coordinates than the state. Then output feedback cannot independently assign feedback weights to all state components. The missing information may still be inferable over time if the system is observable, but that requires a dynamic reconstruction mechanism, not simple static output feedback.

Assume \( \mathbf{D}=\mathbf{0} \). A static output feedback law \( \mathbf{u}=-\mathbf{F}\mathbf{y} \) implements the same closed-loop matrix as a state-feedback law \( \mathbf{u}=-\mathbf{K}\mathbf{x} \) precisely when:

\[ \mathbf{K}=\mathbf{F}\mathbf{C}. \]

This is possible if and only if every row of \( \mathbf{K} \) lies in the row space of \( \mathbf{C} \). Equivalently:

\[ \operatorname{row}(\mathbf{K})\subseteq \operatorname{row}(\mathbf{C}), \qquad \operatorname{rank}\!\begin{bmatrix} \mathbf{C}\\ \mathbf{K} \end{bmatrix} = \operatorname{rank}(\mathbf{C}). \]

Proof. If \( \mathbf{K}=\mathbf{F}\mathbf{C} \), then each row of \( \mathbf{K} \) is a linear combination of rows of \( \mathbf{C} \), so \( \operatorname{row}(\mathbf{K})\subseteq \operatorname{row}(\mathbf{C}) \). Conversely, if every row of \( \mathbf{K} \) lies in the row space of \( \mathbf{C} \), then for each row \( \mathbf{k}_i \) there exists a coefficient row \( \mathbf{f}_i \) such that \( \mathbf{k}_i=\mathbf{f}_i\mathbf{C} \). Stacking these coefficient rows gives \( \mathbf{F} \), hence \( \mathbf{K}=\mathbf{F}\mathbf{C} \).

A useful consequence is that static output feedback can reproduce every possible state-feedback gain only when \( \operatorname{rank}(\mathbf{C})=n \). This means that the measured output must contain a full-rank representation of the state.

In state feedback, the characteristic polynomial is

\[ \chi_{sf}(s) = \det\!\left(s\mathbf{I}-\mathbf{A}+\mathbf{B}\mathbf{K}\right). \]

In static output feedback, the characteristic polynomial becomes:

\[ \chi_{of}(s) = \det\!\left(s\mathbf{I}-\mathbf{A}+\mathbf{B}\mathbf{F}\mathbf{C}\right). \]

Although these formulas look similar, their design freedom is very different. In state feedback, \( \mathbf{K} \) is an arbitrary \( m\times n \) matrix subject to controllability restrictions. In static output feedback, \( \mathbf{K}_{eff}=\mathbf{F}\mathbf{C} \) must lie in a lower-dimensional affine family determined by \( \mathbf{C} \). Therefore static output feedback generally cannot assign closed-loop modes as freely as state feedback.

This is why the state-feedback problem is structurally cleaner: controllability determines which modes can be moved. Static output feedback combines controllability with measurement restrictions, making the pole-dependence problem much more constrained.

If the output equation includes direct feedthrough, \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \), then the static output-feedback law produces:

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

Rearranging:

\[ (\mathbf{I}+\mathbf{F}\mathbf{D})\mathbf{u} = -\mathbf{F}\mathbf{C}\mathbf{x}+\mathbf{r}. \]

If \( \mathbf{I}+\mathbf{F}\mathbf{D} \) is nonsingular, then:

\[ \mathbf{u} = -(\mathbf{I}+\mathbf{F}\mathbf{D})^{-1}\mathbf{F}\mathbf{C}\mathbf{x} + (\mathbf{I}+\mathbf{F}\mathbf{D})^{-1}\mathbf{r}. \]

Thus the closed-loop state matrix is:

\[ \mathbf{A}_{of,D} = \mathbf{A} - \mathbf{B}(\mathbf{I}+\mathbf{F}\mathbf{D})^{-1} \mathbf{F}\mathbf{C}. \]

The matrix \( \mathbf{I}+\mathbf{F}\mathbf{D} \) represents an algebraic feedback-loop condition. For the rest of this lesson, we use \( \mathbf{D}=\mathbf{0} \) to keep the conceptual comparison focused.

Consider the second-order system:

\[ \dot{\mathbf{x} } = \begin{bmatrix} 0 & 1\\ -2 & -0.4 \end{bmatrix}\mathbf{x} + \begin{bmatrix} 0\\ 1 \end{bmatrix}u, \qquad y= \begin{bmatrix} 1 & 0 \end{bmatrix}\mathbf{x}. \]

The output measures only the first state, which may be interpreted as position. The second state, often interpreted as velocity, is not directly measured.

With state feedback \( \mathbf{K}=[\,k_1\;k_2\,] \), the closed-loop matrix is:

\[ \mathbf{A}-\mathbf{B}\mathbf{K} = \begin{bmatrix} 0 & 1\\ -(2+k_1) & -(0.4+k_2) \end{bmatrix}. \]

Its characteristic polynomial is:

\[ \chi_{sf}(s) = s^2+(0.4+k_2)s+(2+k_1). \]

Therefore state feedback changes both the stiffness-like coefficient \( 2+k_1 \) and damping-like coefficient \( 0.4+k_2 \). If \( \mathbf{K}=[\,4\;2.6\,] \), then:

\[ \chi_{sf}(s)=s^2+3s+6. \]

Now use static output feedback \( u=-fy \). Since \( y=[\,1\;0\,]\mathbf{x} \), the effective gain is:

\[ \mathbf{K}_{eff}=f\begin{bmatrix}1 & 0\end{bmatrix} = \begin{bmatrix}f & 0\end{bmatrix}. \]

The closed-loop matrix becomes:

\[ \mathbf{A}-\mathbf{B}f\mathbf{C} = \begin{bmatrix} 0 & 1\\ -(2+f) & -0.4 \end{bmatrix}, \qquad \chi_{of}(s)=s^2+0.4s+(2+f). \]

The output-feedback gain can change the stiffness-like term but not the damping-like term. This is not a numerical accident; it follows from the row-space restriction:

\[ \operatorname{row}(\mathbf{F}\mathbf{C}) \subseteq \operatorname{row} \begin{bmatrix} 1 & 0 \end{bmatrix}. \]

flowchart TD
  X1["State vector has position and velocity"] --> C1["Output measures position only"]
  C1 --> R1["Available gain rows have form: f 0"]
  R1 --> M1["Position feedback possible"]
  R1 --> M2["Velocity feedback \nnot possible"]
  X1 --> S1["Full state measurement"]
  S1 --> R2["Available gain rows have form: k1 k2"]
  R2 --> M3["Position and velocity \nfeedback possible"]
        

From earlier chapters, observability tells us whether the initial state can be reconstructed from the output history. Static output feedback, however, does not use an output history; it uses only the instantaneous value \( \mathbf{y}(t) \). Therefore observability alone does not make static output feedback equivalent to state feedback.

The distinction can be summarized as follows:

\[ \text{state feedback uses } \mathbf{x}(t), \qquad \text{static output feedback uses } \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t). \]

If \( \mathbf{C} \) has a nontrivial null space, then there exist states \( \mathbf{v}\neq\mathbf{0} \) such that:

\[ \mathbf{C}\mathbf{v}=\mathbf{0}. \]

Static output feedback cannot distinguish \( \mathbf{x} \) from \( \mathbf{x}+\mathbf{v} \) at the same instant, because both produce the same output:

\[ \mathbf{C}(\mathbf{x}+\mathbf{v}) = \mathbf{C}\mathbf{x} + \mathbf{C}\mathbf{v} = \mathbf{C}\mathbf{x}. \]

Later observer-based control will address this limitation by constructing a dynamic estimate of the state. In this lesson, the key point is that static output feedback is not merely state feedback with fewer symbols; it is a structurally restricted control architecture.

The following implementations compute and compare open-loop, state-feedback, position-only static output-feedback, and full-output feedback matrices for the example system.

Chapter22_Lesson3.py

"""
Chapter22_Lesson3.py
State Feedback vs Output Feedback (Concept Only)

This script compares full-state feedback u = -K x + r with static output
feedback u = -F y + r for a small continuous-time LTI system.
"""

import numpy as np


def eig_summary(matrix: np.ndarray, name: str) -> None:
    eigvals = np.linalg.eigvals(matrix)
    print(f"{name} =")
    print(matrix)
    print(f"eigenvalues({name}) = {eigvals}")
    print(f"stable? {np.all(np.real(eigvals) < 0)}")
    print()


def main() -> None:
    # Continuous-time plant: x_dot = A x + B u, y = C x
    A = np.array([[0.0, 1.0], [-2.0, -0.4]])
    B = np.array([[0.0], [1.0]])
    C_full = np.eye(2)                 # full state is measured: y = x
    C_position = np.array([[1.0, 0.0]]) # only position is measured

    # Full-state feedback u = -K x.
    K = np.array([[4.0, 2.6]])
    A_state = A - B @ K

    # Static output feedback u = -F y = -F C x.
    # With position-only output, the effective gain has the restricted form [f, 0].
    F_position = np.array([[4.0]])
    A_output_position = A - B @ F_position @ C_position

    # If the full state is measured as y = x, static output feedback is equivalent
    # to state feedback by selecting F = K.
    F_full = K.copy()
    A_output_full = A - B @ F_full @ C_full

    eig_summary(A, "A_open_loop")
    eig_summary(A_state, "A_state_feedback")
    eig_summary(A_output_position, "A_static_output_feedback_position_only")
    eig_summary(A_output_full, "A_static_output_feedback_full_output")

    # Geometry: which state gains can be implemented as F C?
    # K_implementable iff K lies in the row space of C.
    rank_C = np.linalg.matrix_rank(C_position)
    rank_augmented = np.linalg.matrix_rank(np.vstack([C_position, K]))
    print("C_position rank:", rank_C)
    print("rank([C_position; K]):", rank_augmented)
    print("K implementable as F*C_position?", rank_augmented == rank_C)

    # Least-squares static output gain: minimize ||K - F C||_F.
    # For C = [1 0], the closest F C to K=[4 2.6] is [4 0].
    F_ls = K @ C_position.T @ np.linalg.pinv(C_position @ C_position.T)
    K_projected = F_ls @ C_position
    print("Least-squares F for output feedback:", F_ls)
    print("Projected effective gain F*C:", K_projected)


if __name__ == "__main__":
    main()
      

Chapter22_Lesson3.cpp

/*
Chapter22_Lesson3.cpp
State Feedback vs Output Feedback (Concept Only)

A minimal 2x2 implementation without external libraries.
Compile: g++ Chapter22_Lesson3.cpp -std=c++17 -O2 -o Chapter22_Lesson3
*/

#include <cmath>
#include <complex>
#include <iostream>
#include <string>

struct Matrix2 {
    double a11, a12, a21, a22;
};

std::pair<std::complex<double>, std::complex<double>> eigenvalues2x2(const Matrix2& M) {
    double tr = M.a11 + M.a22;
    double det = M.a11 * M.a22 - M.a12 * M.a21;
    std::complex<double> disc = std::complex<double>(tr * tr - 4.0 * det, 0.0);
    std::complex<double> root = std::sqrt(disc);
    return {(tr + root) / 2.0, (tr - root) / 2.0};
}

void printSummary(const Matrix2& M, const std::string& name) {
    auto [l1, l2] = eigenvalues2x2(M);
    std::cout << name << " = [[" << M.a11 << ", " << M.a12 << "], ["
              << M.a21 << ", " << M.a22 << "]]\n";
    std::cout << "eigenvalues(" << name << ") = " << l1 << ", " << l2 << "\n";
    std::cout << "stable? " << ((l1.real() < 0.0 && l2.real() < 0.0) ? "true" : "false") << "\n\n";
}

int main() {
    // Plant: x_dot = A x + B u, y = C x
    Matrix2 A{0.0, 1.0, -2.0, -0.4};

    // B = [0; 1]. State feedback K = [k1 k2].
    double k1 = 4.0;
    double k2 = 2.6;
    Matrix2 A_state{A.a11, A.a12, A.a21 - k1, A.a22 - k2};

    // Static output feedback with y = position = [1 0] x and F = [f].
    // Effective gain F*C = [f 0], so velocity feedback is impossible here.
    double f = 4.0;
    Matrix2 A_output_position{A.a11, A.a12, A.a21 - f, A.a22};

    // Full output y = x makes static output feedback equivalent to state feedback.
    Matrix2 A_output_full = A_state;

    printSummary(A, "A_open_loop");
    printSummary(A_state, "A_state_feedback");
    printSummary(A_output_position, "A_static_output_feedback_position_only");
    printSummary(A_output_full, "A_static_output_feedback_full_output");

    std::cout << "Geometry note:\n";
    std::cout << "For C = [1 0], every static output gain has K_eff = F*C = [f 0].\n";
    std::cout << "Therefore K = [4 2.6] is not implementable from position alone.\n";

    return 0;
}
      

Chapter22_Lesson3.java

/*
Chapter22_Lesson3.java
State Feedback vs Output Feedback (Concept Only)

Compile: javac Chapter22_Lesson3.java
Run:     java Chapter22_Lesson3
*/

public class Chapter22_Lesson3 {
    static class Matrix2 {
        double a11, a12, a21, a22;
        Matrix2(double a11, double a12, double a21, double a22) {
            this.a11 = a11;
            this.a12 = a12;
            this.a21 = a21;
            this.a22 = a22;
        }
    }

    static class Complex {
        double re, im;
        Complex(double re, double im) { this.re = re; this.im = im; }
        public String toString() {
            if (Math.abs(im) < 1e-12) return String.format("%.6f", re);
            return String.format("%.6f%+.6fi", re, im);
        }
    }

    static Complex[] eigenvalues2x2(Matrix2 m) {
        double tr = m.a11 + m.a22;
        double det = m.a11 * m.a22 - m.a12 * m.a21;
        double disc = tr * tr - 4.0 * det;
        if (disc >= 0.0) {
            double root = Math.sqrt(disc);
            return new Complex[] { new Complex((tr + root) / 2.0, 0.0), new Complex((tr - root) / 2.0, 0.0) };
        }
        double root = Math.sqrt(-disc);
        return new Complex[] { new Complex(tr / 2.0, root / 2.0), new Complex(tr / 2.0, -root / 2.0) };
    }

    static void printSummary(Matrix2 m, String name) {
        Complex[] lambda = eigenvalues2x2(m);
        System.out.printf("%s = [[%.3f, %.3f], [%.3f, %.3f]]%n", name, m.a11, m.a12, m.a21, m.a22);
        System.out.printf("eigenvalues(%s) = %s, %s%n", name, lambda[0], lambda[1]);
        System.out.printf("stable? %s%n%n", (lambda[0].re < 0.0 && lambda[1].re < 0.0));
    }

    public static void main(String[] args) {
        // Plant: x_dot = A x + B u, y = C x
        Matrix2 A = new Matrix2(0.0, 1.0, -2.0, -0.4);

        // B = [0; 1]. State feedback K = [k1 k2].
        double k1 = 4.0;
        double k2 = 2.6;
        Matrix2 AState = new Matrix2(A.a11, A.a12, A.a21 - k1, A.a22 - k2);

        // Static output feedback with y = position = [1 0] x and F = [f].
        // Effective gain F*C = [f 0], so velocity feedback is impossible here.
        double f = 4.0;
        Matrix2 AOutputPosition = new Matrix2(A.a11, A.a12, A.a21 - f, A.a22);

        // Full output y = x makes static output feedback equivalent to state feedback.
        Matrix2 AOutputFull = AState;

        printSummary(A, "A_open_loop");
        printSummary(AState, "A_state_feedback");
        printSummary(AOutputPosition, "A_static_output_feedback_position_only");
        printSummary(AOutputFull, "A_static_output_feedback_full_output");

        System.out.println("Geometry note:");
        System.out.println("For C = [1 0], every static output gain has K_eff = F*C = [f 0].");
        System.out.println("Therefore K = [4 2.6] is not implementable from position alone.");
    }
}
      

Chapter22_Lesson3.m

% Chapter22_Lesson3.m
% State Feedback vs Output Feedback (Concept Only)
%
% This script compares full-state feedback u = -K*x + r with static output
% feedback u = -F*y + r for a small continuous-time LTI plant.

clear; clc;

A = [0 1; -2 -0.4];
B = [0; 1];
C_full = eye(2);
C_position = [1 0];

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

F_position = 4;
A_output_position = A - B*F_position*C_position;

F_full = K;
A_output_full = A - B*F_full*C_full;

print_summary(A, 'A_open_loop');
print_summary(A_state, 'A_state_feedback');
print_summary(A_output_position, 'A_static_output_feedback_position_only');
print_summary(A_output_full, 'A_static_output_feedback_full_output');

rank_C = rank(C_position);
rank_augmented = rank([C_position; K]);
fprintf('C_position rank: %d\n', rank_C);
fprintf('rank([C_position; K]): %d\n', rank_augmented);
fprintf('K implementable as F*C_position? %d\n', rank_augmented == rank_C);

F_ls = K*C_position'/(C_position*C_position');
K_projected = F_ls*C_position;
disp('Least-squares F for output feedback:'); disp(F_ls);
disp('Projected effective gain F*C:'); disp(K_projected);

function print_summary(M, name)
    fprintf('%s =\n', name);
    disp(M);
    lambda = eig(M);
    fprintf('eigenvalues(%s) =\n', name);
    disp(lambda);
    fprintf('stable? %d\n\n', all(real(lambda) < 0));
end
      

Chapter22_Lesson3.nb

(* Chapter22_Lesson3.nb *)
(* State Feedback vs Output Feedback (Concept Only) *)

A = { {0, 1}, {-2, -0.4} };
B = { {0}, {1} };
Cfull = IdentityMatrix[2];
Cposition = { {1, 0} };

K = { {4, 2.6} };
Astate = A - B.K;

Fposition = { {4} };
AoutputPosition = A - B.Fposition.Cposition;

Ffull = K;
AoutputFull = A - B.Ffull.Cfull;

cases = {
  {"open loop", A},
  {"state feedback", Astate},
  {"position output feedback", AoutputPosition},
  {"full output feedback", AoutputFull}
};

summary = Table[
  {
    cases[[i, 1]],
    MatrixForm[cases[[i, 2]]],
    Eigenvalues[cases[[i, 2]]],
    And @@ Thread[Re[Eigenvalues[cases[[i, 2]]]] < 0]
  },
  {i, Length[cases]}
];

Grid[Prepend[summary, {"case", "matrix", "eigenvalues", "stable?"}], Frame -> All]

rankC = MatrixRank[Cposition];
rankAugmented = MatrixRank[Join[Cposition, K]];
implementable = rankAugmented == rankC;

Fls = K.Transpose[Cposition].PseudoInverse[Cposition.Transpose[Cposition]];
Kprojected = Fls.Cposition;

{rankC, rankAugmented, implementable, Fls, Kprojected}
      

Problem 1: For \( \mathbf{D}=\mathbf{0} \), show that static output feedback is equivalent to state feedback if and only if \( \mathbf{K}=\mathbf{F}\mathbf{C} \) for some \( \mathbf{F} \).

Solution: State feedback gives \( \mathbf{A}_{sf}=\mathbf{A}-\mathbf{B}\mathbf{K} \). Static output feedback gives \( \mathbf{A}_{of}=\mathbf{A}-\mathbf{B}\mathbf{F}\mathbf{C} \). These are identical for the same plant if \( \mathbf{B}\mathbf{K}=\mathbf{B}\mathbf{F}\mathbf{C} \). A sufficient and architecture-level exact equivalence is \( \mathbf{K}=\mathbf{F}\mathbf{C} \). Under this equality, both feedback laws apply the same control input for every state:

\[ -\mathbf{K}\mathbf{x} = -\mathbf{F}\mathbf{C}\mathbf{x} = -\mathbf{F}\mathbf{y}. \]

Thus the two controllers are behaviorally identical from the viewpoint of the plant input.

Problem 2: Let \( \mathbf{C}=[\,1\;0\,] \) and \( \mathbf{K}=[\,4\;2.6\,] \). Can \( \mathbf{K} \) be implemented as \( \mathbf{F}\mathbf{C} \)?

Solution: Since \( \mathbf{F}\in\mathbb{R}^{1\times 1} \), write \( \mathbf{F}=[\,f\,] \). Then:

\[ \mathbf{F}\mathbf{C} = [\,f\,] \begin{bmatrix} 1 & 0 \end{bmatrix} = \begin{bmatrix} f & 0 \end{bmatrix}. \]

This can equal \( [\,4\;2.6\,] \) only if \( f=4 \) and \( 0=2.6 \), which is impossible. Therefore the desired state-feedback gain is not implementable from position-only static output feedback.

Problem 3: Suppose \( \mathbf{C}\in\mathbb{R}^{p\times n} \). Prove that every state-feedback gain \( \mathbf{K}\in\mathbb{R}^{m\times n} \) can be represented as \( \mathbf{F}\mathbf{C} \) only if \( \operatorname{rank}(\mathbf{C})=n \).

Solution: If every \( \mathbf{K} \) can be written as \( \mathbf{F}\mathbf{C} \), then every row vector in \( \mathbb{R}^{1\times n} \) must be expressible as a linear combination of rows of \( \mathbf{C} \). Therefore:

\[ \operatorname{row}(\mathbf{C})=\mathbb{R}^{1\times n}. \]

Hence the row rank of \( \mathbf{C} \) must be \( n \). Since row rank equals column rank, \( \operatorname{rank}(\mathbf{C})=n \). Conversely, if \( \operatorname{rank}(\mathbf{C})=n \), then the rows of \( \mathbf{C} \) span \( \mathbb{R}^{1\times n} \), so every row of \( \mathbf{K} \) can be generated by some row of \( \mathbf{F} \).

Problem 4: For the second-order example in Section 6, compare the characteristic polynomial under state feedback \( \mathbf{K}=[\,k_1\;k_2\,] \) and output feedback \( u=-fy \), where \( y=[\,1\;0\,]\mathbf{x} \).

Solution: State feedback gives:

\[ \mathbf{A}_{sf} = \begin{bmatrix} 0 & 1\\ -(2+k_1) & -(0.4+k_2) \end{bmatrix}, \qquad \chi_{sf}(s)=s^2+(0.4+k_2)s+(2+k_1). \]

Output feedback gives:

\[ \mathbf{A}_{of} = \begin{bmatrix} 0 & 1\\ -(2+f) & -0.4 \end{bmatrix}, \qquad \chi_{of}(s)=s^2+0.4s+(2+f). \]

Thus state feedback can independently modify two coefficients of the second-order polynomial, while position-only static output feedback modifies only one coefficient.

Problem 5: If \( \mathbf{y}=\mathbf{x} \), show that output feedback and state feedback are the same architecture written in different variables.

Solution: If \( \mathbf{y}=\mathbf{x} \), then \( \mathbf{C}=\mathbf{I} \) and \( \mathbf{D}=\mathbf{0} \). Static output feedback is:

\[ \mathbf{u}=-\mathbf{F}\mathbf{y}+\mathbf{r} = -\mathbf{F}\mathbf{x}+\mathbf{r}. \]

Choosing \( \mathbf{F}=\mathbf{K} \) gives exactly:

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

Therefore the distinction disappears when the complete state is directly measured as the output.

State feedback uses the full internal state and produces the closed-loop matrix \( \mathbf{A}-\mathbf{B}\mathbf{K} \). Static output feedback uses only measured outputs and produces \( \mathbf{A}-\mathbf{B}\mathbf{F}\mathbf{C} \). Therefore static output feedback is equivalent to state feedback only when the desired state gain factors as \( \mathbf{K}=\mathbf{F}\mathbf{C} \). If the output does not contain the full state, this factorization restricts which feedback gains and closed-loop mode changes are possible.

This lesson prepares the next practical question: what is required to implement state feedback when not all state variables are directly measured?