Consider the continuous-time LTI system \( \dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \), where \( \mathbf{x}\in\mathbb{R}^n \) and \( \mathbf{u}\in\mathbb{R}^m \). In MIMO pole placement, the feedback matrix \( \mathbf{K}\in\mathbb{R}^{m\times n} \) contains more degrees of freedom than are required by the characteristic polynomial alone. A state transformation can turn those degrees of freedom into a structured design problem.

\[ \mathbf{x}=\mathbf{T}\mathbf{z},\qquad \mathbf{T}\in\mathbb{R}^{n\times n},\qquad \det(\mathbf{T})\ne 0 \]

The transformed model is \( \dot{\mathbf{z} }=\bar{\mathbf{A} }\mathbf{z}+\bar{\mathbf{B} }\mathbf{u} \), with

\[ \bar{\mathbf{A} }=\mathbf{T}^{-1}\mathbf{A}\mathbf{T}, \qquad \bar{\mathbf{B} }=\mathbf{T}^{-1}\mathbf{B}. \]

If feedback is designed in transformed coordinates as \( \mathbf{u}=-\mathbf{F}\mathbf{z} \), then the corresponding original-coordinate gain is

\[ \boxed{\mathbf{K}=\mathbf{F}\mathbf{T}^{-1} }. \]

flowchart TD
  A["Original plant: xdot = A x + B u"] --> B["Choose nonsingular state basis T"]
  B --> C["Transform: Abar = inv(T) A T, Bbar = inv(T) B"]
  C --> D["Design transformed feedback: u = -F z"]
  D --> E["Map back: K = F inv(T)"]
  E --> F["Closed-loop matrix: A - B K"]
  F --> G["Verify poles, conditioning, and control effort"]
        

Similarity transformations do not change the intrinsic pole-placement feasibility of a system. The controllability matrix of the original pair is

\[ \mathcal{C}(\mathbf{A},\mathbf{B})= \begin{bmatrix}\mathbf{B} & \mathbf{A}\mathbf{B} & \cdots & \mathbf{A}^{n-1}\mathbf{B}\end{bmatrix}. \]

For the transformed pair, using \( \bar{\mathbf{A} }=\mathbf{T}^{-1}\mathbf{A}\mathbf{T} \) and \( \bar{\mathbf{B} }=\mathbf{T}^{-1}\mathbf{B} \),

\[ \mathcal{C}(\bar{\mathbf{A} },\bar{\mathbf{B} })= \mathbf{T}^{-1}\mathcal{C}(\mathbf{A},\mathbf{B}). \]

Therefore,

\[ \operatorname{rank}\mathcal{C}(\bar{\mathbf{A} },\bar{\mathbf{B} })= \operatorname{rank}\mathcal{C}(\mathbf{A},\mathbf{B}). \]

The closed-loop matrices are also similar:

\[ \bar{\mathbf{A} }-\bar{\mathbf{B} }\mathbf{F} =\mathbf{T}^{-1}(\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{T}, \qquad \mathbf{K}=\mathbf{F}\mathbf{T}^{-1}. \]

Hence \( \mathbf{A}-\mathbf{B}\mathbf{K} \) and \( \bar{\mathbf{A} }-\bar{\mathbf{B} }\mathbf{F} \) have the same eigenvalues, characteristic polynomial, trace, determinant, and Jordan block sizes.

Proof. Since \( \mathbf{T} \) is nonsingular,

\[ \det\left(s\mathbf{I}-(\mathbf{A}-\mathbf{B}\mathbf{K})\right) =\det\left(s\mathbf{I}-\mathbf{T}(\bar{\mathbf{A} }-\bar{\mathbf{B} }\mathbf{F})\mathbf{T}^{-1}\right) =\det\left(s\mathbf{I}-(\bar{\mathbf{A} }-\bar{\mathbf{B} }\mathbf{F})\right). \]

Therefore, state transformations cannot create controllability, but they can expose controllability in a basis where feedback synthesis is simpler.

A useful transformation is built from independent columns selected from the block controllability matrix. For MIMO systems, the columns can be organized into input-generated chains such as \( \mathbf{b}_i,\mathbf{A}\mathbf{b}_i,\dots,\mathbf{A}^{\nu_i-1}\mathbf{b}_i \). The positive integers \( \nu_i \) are controllability indices, and for a controllable system they satisfy

\[ \nu_1+\nu_2+\cdots+\nu_m=n. \]

In a Brunovsky-like basis, the system decomposes into controllable chains:

\[ \dot{z}_{i,1}=z_{i,2},\quad \dot{z}_{i,2}=z_{i,3},\quad \dots,\quad \dot{z}_{i,\nu_i}=v_i + \text{coupling terms}. \]

If the coupling terms have been removed or are weak, each chain can be assigned a local monic polynomial

\[ p_i(s)=s^{\nu_i}+a_{i,\nu_i-1}s^{\nu_i-1}+ \cdots+a_{i,1}s+a_{i,0}. \]

The transformed-coordinate row of feedback contains the coefficients of this polynomial in the corresponding chain. This is the MIMO analogue of the SISO companion-form idea, but it is not unique because the input channels can be mixed and the controllability basis can be chosen in many ways.

A more direct MIMO interpretation is to choose a transformation matrix whose columns are desired closed-loop eigenvectors. Suppose \( \boldsymbol{\Lambda} \) is the desired closed-loop matrix in transformed coordinates and \( \mathbf{X} \) is nonsingular. If

\[ (\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{X} =\mathbf{X}\boldsymbol{\Lambda}, \]

then \( \mathbf{X} \) is a state transformation from modal coordinates to physical coordinates. Rearranging gives

\[ \mathbf{A}\mathbf{X}-\mathbf{X}\boldsymbol{\Lambda} =\mathbf{B}\mathbf{G},\qquad \mathbf{G}=\mathbf{K}\mathbf{X}. \]

Once a feasible pair \( (\mathbf{X},\mathbf{G}) \) is found, the gain is

\[ \boxed{\mathbf{K}=\mathbf{G}\mathbf{X}^{-1} }. \]

For each desired eigenvalue \( \lambda_i \), a column pair \( (\mathbf{x}_i,\mathbf{g}_i) \) must satisfy

\[ (\mathbf{A}-\lambda_i\mathbf{I})\mathbf{x}_i =\mathbf{B}\mathbf{g}_i. \]

This equation explains the additional freedom in MIMO design: for a fixed eigenvalue, there may be many admissible eigenvectors because \( \mathbf{g}_i\in\mathbb{R}^m \) is free. Good choices try to keep \( \mathbf{X} \) well-conditioned and feedback magnitudes moderate.

A robust workflow separates feasibility, coordinate selection, feedback synthesis, and numerical verification.

flowchart TD
  S["Start with A, B, desired poles"] --> R["Check rank of controllability matrix"]
  R --> Q["Choose basis: controllability chains, Schur basis, or desired eigenvectors"]
  Q --> T["Compute transformed pair Abar, Bbar"]
  T --> F["Design F using chain polynomials or library pole assignment"]
  F --> K["Map K = F inv(T)"]
  K --> V["Verify eig(A-BK), cond(T), cond(X), and ||K||"]
  V --> E["Accept or redesign basis"]
        

The key numerical warning is that a mathematically valid transformation can still be poor for computation. If \( \kappa(\mathbf{T})=\|\mathbf{T}\|\|\mathbf{T}^{-1}\| \) is large, small numerical errors in \( \mathbf{F} \) or measurements of \( \mathbf{x} \) may produce large errors in the implemented gain \( \mathbf{K}=\mathbf{F}\mathbf{T}^{-1} \).

\[ \frac{\|\Delta\mathbf{z}\|}{\|\mathbf{z}\|} \lesssim \kappa(\mathbf{T}) \frac{\|\Delta\mathbf{x}\|}{\|\mathbf{x}\|}. \]

For this reason, orthonormal or near-orthonormal transformations are often preferred in numerical software, even when canonical forms are cleaner on paper.

Let the transformed system consist of two double-integrator chains:

\[ \bar{\mathbf{A} }=\begin{bmatrix} 0&1&0&0\\ 0&0&0&0\\ 0&0&0&1\\ 0&0&0&0 \end{bmatrix},\qquad \bar{\mathbf{B} }=\begin{bmatrix} 0&0\\ 1&0\\ 0&0\\ 0&1 \end{bmatrix}. \]

Choose chain-1 desired poles \( -2,-3 \) and chain-2 desired poles \( -4,-5 \). Then

\[ (s+2)(s+3)=s^2+5s+6,\\ (s+4)(s+5)=s^2+9s+20. \]

Thus the transformed feedback matrix is

\[ \mathbf{F}=\begin{bmatrix} 6&5&0&0\\ 0&0&20&9 \end{bmatrix}. \]

With any nonsingular \( \mathbf{T} \), define \( \mathbf{A}=\mathbf{T}\bar{\mathbf{A} }\mathbf{T}^{-1} \) and \( \mathbf{B}=\mathbf{T}\bar{\mathbf{B} } \). The implemented physical-coordinate gain is \( \mathbf{K}=\mathbf{F}\mathbf{T}^{-1} \), and the closed-loop poles remain \( -2,-3,-4,-5 \) because the two closed-loop matrices are similar.

The following files implement the worked example. Python, MATLAB, and Mathematica compute the eigenvalues directly. The C++ and Java versions avoid external numerical libraries and verify the similarity identity by computing a Frobenius-norm residual.

Chapter24_Lesson3.py

# Chapter24_Lesson3.py
# State transformations for MIMO pole placement
# Requires: numpy. Optional: scipy/control for alternative pole-placement routines.

import numpy as np

np.set_printoptions(precision=5, suppress=True)

A_bar = np.array([
    [0.0, 1.0, 0.0, 0.0],
    [0.0, 0.0, 0.0, 0.0],
    [0.0, 0.0, 0.0, 1.0],
    [0.0, 0.0, 0.0, 0.0]
])
B_bar = np.array([
    [0.0, 0.0],
    [1.0, 0.0],
    [0.0, 0.0],
    [0.0, 1.0]
])

T = np.array([
    [1.0, 0.2, 0.0, 0.1],
    [0.1, 1.0, 0.2, 0.0],
    [0.0, 0.1, 1.0, 0.3],
    [0.2, 0.0, 0.1, 1.0]
])
T_inv = np.linalg.inv(T)

A = T @ A_bar @ T_inv
B = T @ B_bar

F = np.array([
    [6.0, 5.0, 0.0, 0.0],
    [0.0, 0.0, 20.0, 9.0]
])

K = F @ T_inv
A_cl = A - B @ K
A_bar_cl = A_bar - B_bar @ F

print("A in original coordinates:\n", A)
print("B in original coordinates:\n", B)
print("State feedback gain K = F T^{-1}:\n", K)
print("Closed-loop eigenvalues in original coordinates:", np.linalg.eigvals(A_cl))
print("Closed-loop eigenvalues in transformed coordinates:", np.linalg.eigvals(A_bar_cl))

similarity_error = T_inv @ A_cl @ T - A_bar_cl
print("Similarity verification ||T^{-1}(A-BK)T - (A_bar-B_bar F)||_F =",
      np.linalg.norm(similarity_error, ord="fro"))
      

Chapter24_Lesson3.cpp

// Chapter24_Lesson3.cpp
// State transformations for MIMO pole placement without external libraries.
// Compile: g++ -std=c++17 Chapter24_Lesson3.cpp -o Chapter24_Lesson3

#include <cmath>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <vector>

using Matrix = std::vector<std::vector<double>>;

Matrix zeros(int r, int c) { return Matrix(r, std::vector<double>(c, 0.0)); }

Matrix multiply(const Matrix& A, const Matrix& B) {
    int r = (int)A.size(), n = (int)B.size(), c = (int)B[0].size();
    Matrix C = zeros(r, c);
    for (int i = 0; i < r; ++i)
        for (int k = 0; k < n; ++k)
            for (int j = 0; j < c; ++j)
                C[i][j] += A[i][k] * B[k][j];
    return C;
}

Matrix subtract(const Matrix& A, const Matrix& B) {
    Matrix C = A;
    for (size_t i = 0; i < A.size(); ++i)
        for (size_t j = 0; j < A[0].size(); ++j)
            C[i][j] -= B[i][j];
    return C;
}

Matrix inverse(Matrix A) {
    int n = (int)A.size();
    Matrix aug = zeros(n, 2*n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) aug[i][j] = A[i][j];
        aug[i][n+i] = 1.0;
    }
    for (int col = 0; col < n; ++col) {
        int pivot = col;
        for (int r = col + 1; r < n; ++r)
            if (std::fabs(aug[r][col]) > std::fabs(aug[pivot][col])) pivot = r;
        if (std::fabs(aug[pivot][col]) < 1e-12) throw std::runtime_error("Singular matrix");
        std::swap(aug[pivot], aug[col]);
        double div = aug[col][col];
        for (int j = 0; j < 2*n; ++j) aug[col][j] /= div;
        for (int r = 0; r < n; ++r) {
            if (r == col) continue;
            double factor = aug[r][col];
            for (int j = 0; j < 2*n; ++j) aug[r][j] -= factor * aug[col][j];
        }
    }
    Matrix inv = zeros(n, n);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            inv[i][j] = aug[i][n+j];
    return inv;
}

void printMatrix(const std::string& name, const Matrix& M) {
    std::cout << name << "\n";
    for (const auto& row : M) {
        for (double v : row) std::cout << std::setw(12) << std::setprecision(6) << std::fixed << v << " ";
        std::cout << "\n";
    }
}

double frobeniusNorm(const Matrix& M) {
    double s = 0.0;
    for (const auto& row : M)
        for (double v : row) s += v * v;
    return std::sqrt(s);
}

int main() {
    Matrix Abar = {
        {0,1,0,0},
        {0,0,0,0},
        {0,0,0,1},
        {0,0,0,0}
    };
    Matrix Bbar = {
        {0,0},
        {1,0},
        {0,0},
        {0,1}
    };
    Matrix T = {
        {1.0,0.2,0.0,0.1},
        {0.1,1.0,0.2,0.0},
        {0.0,0.1,1.0,0.3},
        {0.2,0.0,0.1,1.0}
    };
    Matrix F = {
        {6.0,5.0,0.0,0.0},
        {0.0,0.0,20.0,9.0}
    };

    Matrix Tinv = inverse(T);
    Matrix A = multiply(multiply(T, Abar), Tinv);
    Matrix B = multiply(T, Bbar);
    Matrix K = multiply(F, Tinv);
    Matrix Acl = subtract(A, multiply(B, K));
    Matrix Abarcl = subtract(Abar, multiply(Bbar, F));
    Matrix check = subtract(multiply(multiply(Tinv, Acl), T), Abarcl);

    printMatrix("K = F*T^{-1}:", K);
    printMatrix("A - B*K:", Acl);
    std::cout << "Similarity residual Frobenius norm = " << frobeniusNorm(check) << "\n";
    std::cout << "Expected poles from the transformed design: -2, -3, -4, -5\n";
    return 0;
}
      

Chapter24_Lesson3.java

// Chapter24_Lesson3.java
// State transformations for MIMO pole placement without external libraries.
// Compile: javac Chapter24_Lesson3.java
// Run:     java Chapter24_Lesson3

public class Chapter24_Lesson3 {
    static double[][] multiply(double[][] A, double[][] B) {
        int r = A.length, n = B.length, c = B[0].length;
        double[][] C = new double[r][c];
        for (int i = 0; i < r; i++)
            for (int k = 0; k < n; k++)
                for (int j = 0; j < c; j++)
                    C[i][j] += A[i][k] * B[k][j];
        return C;
    }

    static double[][] subtract(double[][] A, double[][] B) {
        double[][] C = new double[A.length][A[0].length];
        for (int i = 0; i < A.length; i++)
            for (int j = 0; j < A[0].length; j++)
                C[i][j] = A[i][j] - B[i][j];
        return C;
    }

    static double[][] inverse(double[][] A) {
        int n = A.length;
        double[][] aug = new double[n][2*n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) aug[i][j] = A[i][j];
            aug[i][n+i] = 1.0;
        }
        for (int col = 0; col < n; col++) {
            int pivot = col;
            for (int r = col + 1; r < n; r++)
                if (Math.abs(aug[r][col]) > Math.abs(aug[pivot][col])) pivot = r;
            if (Math.abs(aug[pivot][col]) < 1e-12) throw new RuntimeException("Singular matrix");
            double[] temp = aug[pivot]; aug[pivot] = aug[col]; aug[col] = temp;
            double div = aug[col][col];
            for (int j = 0; j < 2*n; j++) aug[col][j] /= div;
            for (int r = 0; r < n; r++) {
                if (r == col) continue;
                double factor = aug[r][col];
                for (int j = 0; j < 2*n; j++) aug[r][j] -= factor * aug[col][j];
            }
        }
        double[][] inv = new double[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                inv[i][j] = aug[i][n+j];
        return inv;
    }

    static double frobeniusNorm(double[][] M) {
        double s = 0.0;
        for (double[] row : M)
            for (double v : row) s += v*v;
        return Math.sqrt(s);
    }

    static void printMatrix(String name, double[][] M) {
        System.out.println(name);
        for (double[] row : M) {
            for (double v : row) System.out.printf("%12.6f ", v);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        double[][] Abar = {
            {0,1,0,0},
            {0,0,0,0},
            {0,0,0,1},
            {0,0,0,0}
        };
        double[][] Bbar = {
            {0,0},
            {1,0},
            {0,0},
            {0,1}
        };
        double[][] T = {
            {1.0,0.2,0.0,0.1},
            {0.1,1.0,0.2,0.0},
            {0.0,0.1,1.0,0.3},
            {0.2,0.0,0.1,1.0}
        };
        double[][] F = {
            {6.0,5.0,0.0,0.0},
            {0.0,0.0,20.0,9.0}
        };

        double[][] Tinv = inverse(T);
        double[][] A = multiply(multiply(T, Abar), Tinv);
        double[][] B = multiply(T, Bbar);
        double[][] K = multiply(F, Tinv);
        double[][] Acl = subtract(A, multiply(B, K));
        double[][] Abarcl = subtract(Abar, multiply(Bbar, F));
        double[][] check = subtract(multiply(multiply(Tinv, Acl), T), Abarcl);

        printMatrix("K = F*T^{-1}:", K);
        printMatrix("A - B*K:", Acl);
        System.out.println("Similarity residual Frobenius norm = " + frobeniusNorm(check));
        System.out.println("Expected poles from the transformed design: -2, -3, -4, -5");
    }
}
      

Chapter24_Lesson3.m

% Chapter24_Lesson3.m
% State transformations for MIMO pole placement in MATLAB/Octave.

clear; clc;

A_bar = [
    0 1 0 0;
    0 0 0 0;
    0 0 0 1;
    0 0 0 0
];
B_bar = [
    0 0;
    1 0;
    0 0;
    0 1
];

T = [
    1.0 0.2 0.0 0.1;
    0.1 1.0 0.2 0.0;
    0.0 0.1 1.0 0.3;
    0.2 0.0 0.1 1.0
];

A = T*A_bar/T;
B = T*B_bar;

F = [
    6 5 0 0;
    0 0 20 9
];

K = F/T;
Acl = A - B*K;
Abar_cl = A_bar - B_bar*F;

fprintf('K = F/T:\n'); disp(K);
fprintf('eig(A - B*K):\n'); disp(eig(Acl));
fprintf('eig(A_bar - B_bar*F):\n'); disp(eig(Abar_cl));
fprintf('Similarity residual Frobenius norm = %.3e\n', norm(T\Acl*T - Abar_cl, 'fro'));

% Alternative direct MIMO pole placement if Control System Toolbox is available:
% desired_poles = [-2 -3 -4 -5];
% K_place = place(A, B, desired_poles);
      

Chapter24_Lesson3.nb

(* Chapter24_Lesson3.nb *)
(* Wolfram Mathematica code for transformation-based MIMO pole placement. *)

ClearAll["Global`*"];

Abar = { {0, 1, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 0} };
Bbar = { {0, 0}, {1, 0}, {0, 0}, {0, 1} };
T = { {1.0, 0.2, 0.0, 0.1}, {0.1, 1.0, 0.2, 0.0}, {0.0, 0.1, 1.0, 0.3}, {0.2, 0.0, 0.1, 1.0} };

A = T . Abar . Inverse[T];
B = T . Bbar;

F = { {6.0, 5.0, 0.0, 0.0}, {0.0, 0.0, 20.0, 9.0} };
K = F . Inverse[T];
Acl = A - B . K;
Abarcl = Abar - Bbar . F;

Print["K = "];
MatrixForm[K]

Print["Closed-loop eigenvalues in original coordinates:"];
Eigenvalues[Acl]

Print["Closed-loop eigenvalues in transformed coordinates:"];
Eigenvalues[Abarcl]

Print["Similarity residual norm:"];
Norm[Inverse[T] . Acl . T - Abarcl, "Frobenius"]
      

Problem 1 (Gain Mapping): Let \( \mathbf{x}=\mathbf{T}\mathbf{z} \) and \( \mathbf{u}=-\mathbf{F}\mathbf{z} \). Derive the original-coordinate feedback gain.

Solution: Since \( \mathbf{z}=\mathbf{T}^{-1}\mathbf{x} \), the same input is \( \mathbf{u}=-\mathbf{F}\mathbf{T}^{-1}\mathbf{x} \). Therefore

\[ \mathbf{K}=\mathbf{F}\mathbf{T}^{-1}. \]

Problem 2 (Closed-Loop Similarity): Prove that the matrices \( \mathbf{A}-\mathbf{B}\mathbf{K} \) and \( \bar{\mathbf{A} }-\bar{\mathbf{B} }\mathbf{F} \) have identical eigenvalues.

Solution: Substitute \( \bar{\mathbf{A} }=\mathbf{T}^{-1}\mathbf{A}\mathbf{T} \), \( \bar{\mathbf{B} }=\mathbf{T}^{-1}\mathbf{B} \), and \( \mathbf{K}=\mathbf{F}\mathbf{T}^{-1} \):

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

Similar matrices have equal characteristic polynomials and therefore equal eigenvalues.

Problem 3 (Two Double-Integrator Chains): For the two-chain transformed system in Section 6, compute \( \mathbf{F} \) for desired poles \( -1,-6 \) in chain 1 and \( -2,-7 \) in chain 2.

Solution: The two polynomials are

\[ (s+1)(s+6)=s^2+7s+6, \qquad (s+2)(s+7)=s^2+9s+14. \]

Hence

\[ \mathbf{F}=\begin{bmatrix} 6&7&0&0\\ 0&0&14&9 \end{bmatrix}. \]

Problem 4 (Controllability Invariance): Show that controllability is invariant under a nonsingular state transformation.

Solution: The transformed controllability matrix is

\[ \mathcal{C}(\bar{\mathbf{A} },\bar{\mathbf{B} })= \begin{bmatrix}\bar{\mathbf{B} }&\bar{\mathbf{A} }\bar{\mathbf{B} }&\cdots& \bar{\mathbf{A} }^{n-1}\bar{\mathbf{B} }\end{bmatrix} =\mathbf{T}^{-1}\mathcal{C}(\mathbf{A},\mathbf{B}). \]

Since left multiplication by a nonsingular matrix does not change rank, the original and transformed pairs have the same controllability rank.

Problem 5 (Conditioning): Suppose \( \kappa(\mathbf{T}) \) is very large. Explain why the transformed design may be numerically poor even when the theoretical pole placement is correct.

Solution: Large \( \kappa(\mathbf{T}) \) means that the coordinate map strongly amplifies perturbations. Because \( \mathbf{K}=\mathbf{F}\mathbf{T}^{-1} \), small perturbations in \( \mathbf{T} \), state measurements, or computed feedback coefficients can become large perturbations in the implemented input. The eigenvalues may still be correct in exact arithmetic, while the controller is fragile in finite precision.

State transformations preserve controllability and closed-loop spectra, but they can make MIMO pole placement substantially easier by exposing controllability chains, separating input channels, or allowing direct eigenstructure assignment. The essential implementation rule is simple: design \( \mathbf{F} \) in transformed coordinates and implement \( \mathbf{K}=\mathbf{F}\mathbf{T}^{-1} \) in physical coordinates. In practical MIMO design, the quality of the transformation matters as much as the assigned pole locations because ill-conditioned coordinate bases can produce fragile gains.