Recall from Lesson 1 that a state is a minimal internal summary of the past that, together with the future input, determines future behavior. For continuous-time LTI models, the most general finite-dimensional representation with state \( \mathbf{x}(t) \), input \( \mathbf{u}(t) \), and output \( \mathbf{y}(t) \) is

\[ \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). \]

The quadruple \( (\mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D}) \) is called a state-space realization. The first equation is the state equation; the second is the output equation.

flowchart TD
  S["Start: define signals x(t), u(t), y(t)"] --> D1["Choose state dimension n (how many state variables?)"]
  D1 --> D2["Write xdot = A x + B u (constant A,B)"]
  D2 --> D3["Write y = C x + D u (constant C,D)"]
  D3 --> C1["Check dimensions: A n×n, B n×m, C p×n, D p×m"]
  C1 --> V1["Validate: linearity + time invariance"]
  V1 --> SIM["Simulate/Analyze using software (state-space objects)"]
        

Throughout this chapter we assume signals are sufficiently regular for the differential equation to admit a unique solution for any initial condition \( \mathbf{x}(t_0) \) (this is consistent with the existence/uniqueness results from Chapter 3).

Let the state, input, and output live in Euclidean spaces of dimensions \( n \), \( m \), and \( p \): \( \mathbf{x}(t)\in\mathbb{R}^n \), \( \mathbf{u}(t)\in\mathbb{R}^m \), \( \mathbf{y}(t)\in\mathbb{R}^p \). Then the matrices must satisfy

\[ \mathbf{A}\in\mathbb{R}^{n\times n},\quad \mathbf{B}\in\mathbb{R}^{n\times m},\quad \mathbf{C}\in\mathbb{R}^{p\times n},\quad \mathbf{D}\in\mathbb{R}^{p\times m}. \]

A quick dimensional proof is immediate from matrix multiplication. Since \( \dot{\mathbf{x}}(t) \) lies in \( \mathbb{R}^n \), both terms \( \mathbf{A}\mathbf{x}(t) \) and \( \mathbf{B}\mathbf{u}(t) \) must also lie in \( \mathbb{R}^n \), forcing \( \mathbf{A} \) to map \( \mathbb{R}^n \) to itself and \( \mathbf{B} \) to map \( \mathbb{R}^m \) into \( \mathbb{R}^n \). Similarly, \( \mathbf{y}(t)\in\mathbb{R}^p \) implies the shapes of \( \mathbf{C},\mathbf{D} \).

For MIMO systems (multiple-input multiple-output), \( m \) and/or \( p \) can exceed 1; the same algebra applies unchanged.

The matrices separate internal (state) dynamics from input action and output formation:

• State matrix \( \mathbf{A} \): governs autonomous evolution when \( \mathbf{u}(t)=\mathbf{0} \). The homogeneous system is \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x} \).
• Input matrix \( \mathbf{B} \): injects inputs into the state derivatives; it encodes actuation directions.
• Output matrix \( \mathbf{C} \): selects/combines states to form measured/performance outputs.
• Feedthrough matrix \( \mathbf{D} \): represents instantaneous (algebraic) dependence of output on input.

flowchart LR
  U["u(t)"] --> B["B"]
  X["x(t)"] --> A["A"]
  A --> SUM1["sum: xdot"]
  B --> SUM1
  SUM1 --> INT["integrator (state)"]
  INT --> X2["x(t)"]
  X2 --> C["C"]
  U --> D["D"]
  C --> SUM2["sum: y"]
  D --> SUM2
  SUM2 --> Y["y(t)"]
        

The diagram emphasizes a key modeling distinction: \( \mathbf{A},\mathbf{B} \) appear in a differential equation (dynamic pathway), while \( \mathbf{D} \) is purely algebraic (instantaneous pathway).

We prove the mapping from \( (\mathbf{x}(t_0),\mathbf{u}(\cdot)) \) to \( \mathbf{x}(\cdot) \), \( \mathbf{y}(\cdot) \) is linear.

Consider two experiments indexed by \( i=1,2 \):

\[ \dot{\mathbf{x}}_i(t) = \mathbf{A}\mathbf{x}_i(t) + \mathbf{B}\mathbf{u}_i(t),\quad \mathbf{y}_i(t) = \mathbf{C}\mathbf{x}_i(t) + \mathbf{D}\mathbf{u}_i(t), \quad \mathbf{x}_i(t_0)=\mathbf{x}_{i0}. \]

Let scalars \( \alpha,\beta\in\mathbb{R} \) and define the combined input and initial condition: \( \mathbf{u}(t)=\alpha\mathbf{u}_1(t)+\beta\mathbf{u}_2(t) \), \( \mathbf{x}(t_0)=\alpha\mathbf{x}_{10}+\beta\mathbf{x}_{20} \). Define \( \mathbf{x}(t)=\alpha\mathbf{x}_1(t)+\beta\mathbf{x}_2(t) \). Differentiate and substitute:

\[ \dot{\mathbf{x}}(t) = \alpha\dot{\mathbf{x}}_1(t) + \beta\dot{\mathbf{x}}_2(t) = \alpha(\mathbf{A}\mathbf{x}_1(t)+\mathbf{B}\mathbf{u}_1(t)) + \beta(\mathbf{A}\mathbf{x}_2(t)+\mathbf{B}\mathbf{u}_2(t)) = \\ \mathbf{A}(\alpha\mathbf{x}_1(t)+\beta\mathbf{x}_2(t)) + \mathbf{B}(\alpha\mathbf{u}_1(t)+\beta\mathbf{u}_2(t)). \]

Hence \( \dot{\mathbf{x}}(t)=\mathbf{A}\mathbf{x}(t)+\mathbf{B}\mathbf{u}(t) \) and \( \mathbf{x}(t_0)=\alpha\mathbf{x}_{10}+\beta\mathbf{x}_{20} \). By uniqueness (Chapter 3), this \( \mathbf{x}(t) \) is exactly the state trajectory produced by the combined experiment. The output is also linear:

\[ \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{u}(t) = \alpha(\mathbf{C}\mathbf{x}_1(t)+\mathbf{D}\mathbf{u}_1(t)) + \beta(\mathbf{C}\mathbf{x}_2(t)+\mathbf{D}\mathbf{u}_2(t)) = \alpha\mathbf{y}_1(t) + \beta\mathbf{y}_2(t). \]

This is the superposition property in state-space form.

Time invariance means that shifting the input in time shifts the state and output responses by the same amount. Let \( \Delta \in \mathbb{R} \) and define a shifted input \( \mathbf{u}_\Delta(t)=\mathbf{u}(t-\Delta) \). Consider the solution \( \mathbf{x}(t) \) under input \( \mathbf{u}(t) \). Define a shifted trajectory \( \mathbf{x}_\Delta(t)=\mathbf{x}(t-\Delta) \).

Differentiate \( \mathbf{x}_\Delta(t) \): \( \dot{\mathbf{x}}_\Delta(t)=\dot{\mathbf{x}}(t-\Delta) \). Using the original dynamics at time \( t-\Delta \):

\[ \dot{\mathbf{x}}_\Delta(t) = \dot{\mathbf{x}}(t-\Delta) = \mathbf{A}\mathbf{x}(t-\Delta) + \mathbf{B}\mathbf{u}(t-\Delta) = \mathbf{A}\mathbf{x}_\Delta(t) + \mathbf{B}\mathbf{u}_\Delta(t). \]

Thus the shifted state satisfies the same differential equation with the shifted input. Similarly, the shifted output \( \mathbf{y}_\Delta(t)=\mathbf{y}(t-\Delta) \) obeys \( \mathbf{y}_\Delta(t)=\mathbf{C}\mathbf{x}_\Delta(t)+\mathbf{D}\mathbf{u}_\Delta(t) \). Since \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \) do not depend on time, the system is time invariant.

Chapter 2 introduced changes of coordinates. In state-space modeling, a change of state coordinates does not alter the underlying input-output behavior; it only changes the internal description. Let \( \mathbf{T}\in\mathbb{R}^{n\times n} \) be invertible and define a new state \( \mathbf{z}(t) \) by \( \mathbf{x}(t)=\mathbf{T}\mathbf{z}(t) \).

Theorem (State coordinate transformation): If \( \mathbf{x}(t)=\mathbf{T}\mathbf{z}(t) \), then the system can be rewritten as

\[ \dot{\mathbf{z}}(t) = \underbrace{\mathbf{T}^{-1}\mathbf{A}\mathbf{T}}_{\mathbf{A}_z}\mathbf{z}(t) + \underbrace{\mathbf{T}^{-1}\mathbf{B}}_{\mathbf{B}_z}\mathbf{u}(t),\qquad \mathbf{y}(t) = \underbrace{\mathbf{C}\mathbf{T}}_{\mathbf{C}_z}\mathbf{z}(t) + \mathbf{D}\mathbf{u}(t). \]

Proof: Differentiate \( \mathbf{x}(t)=\mathbf{T}\mathbf{z}(t) \): \( \dot{\mathbf{x}}(t)=\mathbf{T}\dot{\mathbf{z}}(t) \). Substitute into \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \):

\[ \mathbf{T}\dot{\mathbf{z}}(t) = \mathbf{A}\mathbf{T}\mathbf{z}(t) + \mathbf{B}\mathbf{u}(t) \;\;\Rightarrow\;\; \dot{\mathbf{z}}(t) = \mathbf{T}^{-1}\mathbf{A}\mathbf{T}\mathbf{z}(t) + \mathbf{T}^{-1}\mathbf{B}\mathbf{u}(t). \]

The output equation follows immediately: \( \mathbf{y}(t)=\mathbf{C}\mathbf{T}\mathbf{z}(t)+\mathbf{D}\mathbf{u}(t) \). This is a similarity transformation of \( \mathbf{A} \), and consistent transformations of \( \mathbf{B},\mathbf{C} \). The matrix \( \mathbf{D} \) is unchanged because it directly maps input to output.

This result is foundational: later chapters will exploit coordinate changes to obtain canonical forms and to reason about equivalence between realizations.

The term \( \mathbf{D}\mathbf{u}(t) \) implies that the output can depend on the input at the same time instant. In physical modeling, this may represent sensors measuring an actuator command directly, or algebraic constraints in lumped models.

A practical implication (especially in block-diagram simulation) is the possibility of an algebraic loop when the input is computed instantaneously from the output. Consider a static output feedback-like interconnection \( \mathbf{u}(t) = -\mathbf{F}\mathbf{y}(t) + \mathbf{r}(t) \), where \( \mathbf{r}(t) \) is an external command. Substituting into \( \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{u}(t) \) yields

\[ \mathbf{y}(t) = \mathbf{C}\mathbf{x}(t) + \mathbf{D}\big(-\mathbf{F}\mathbf{y}(t)+\mathbf{r}(t)\big) \;\;\Rightarrow\;\; (\mathbf{I}+\mathbf{D}\mathbf{F})\mathbf{y}(t) = \mathbf{C}\mathbf{x}(t) + \mathbf{D}\mathbf{r}(t). \]

For this algebraic relation to define \( \mathbf{y}(t) \) uniquely, we require \( \det(\mathbf{I}+\mathbf{D}\mathbf{F}) \neq 0 \). If \( \mathbf{D}=\mathbf{0} \) (a strictly proper state-space model), the algebraic loop disappears.

This is not yet a design lesson; the key takeaway is structural: \( \mathbf{D}\neq\mathbf{0} \) introduces instantaneous pathways that must be handled carefully in interconnections and simulation.

The goal here is not controller design, but correct construction and simulation of \( (\mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D}) \). We illustrate a small MIMO example with \( n=2, m=1, p=1 \).

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

8.1 Python (NumPy/SciPy and python-control)

Common libraries: numpy, scipy, control (python-control), and optionally slycot for advanced routines.

import numpy as np
from scipy.integrate import solve_ivp
from scipy.signal import StateSpace, lsim

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]])

# Define an input u(t): a unit step
def u_of_t(t):
    return 1.0

# State ODE: xdot = A x + B u
def f(t, x):
    u = u_of_t(t)
    return (A @ x + (B.flatten() * u))

t0, tf = 0.0, 5.0
x0 = np.array([0.5, 0.0])

sol = solve_ivp(f, (t0, tf), x0, dense_output=True, max_step=1e-2)

t = np.linspace(t0, tf, 1001)
x = sol.sol(t).T
u = np.ones_like(t)  # step input
y = (x @ C.T).flatten() + (D.flatten()[0] * u)

print("x(tf) =", x[-1])
print("y(tf) =", y[-1])

# Optional: use scipy.signal StateSpace for lsim (continuous-time)
sys = StateSpace(A, B, C, D)
tout, yout, xout = lsim(sys, U=u, T=t, X0=x0)
print("lsim y(tf) =", yout[-1])
      

8.2 MATLAB (State-Space Objects) and Simulink

MATLAB’s Control System Toolbox represents systems via ss(A,B,C,D). For simulation, common commands include initial, lsim, and step.

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

sys = ss(A,B,C,D);

t = linspace(0,5,1001);
u = ones(size(t));     % step input
x0 = [0.5; 0.0];

[y,tout,x] = lsim(sys,u,t,x0);

disp("x(tf) ="); disp(x(end,:).');
disp("y(tf) ="); disp(y(end));
      

Simulink note (State-Space block):

• Open Simulink and place a State-Space block (Continuous).
• Set parameters A, B, C, D exactly as defined above.
• Use a Step block as u(t), connect to the State-Space block input.
• Use a Scope block to view y(t).
• If \( \mathbf{D}\neq\mathbf{0} \) and you create direct algebraic feedback, Simulink may report an algebraic loop; resolve by adding a dynamic element (e.g., a transfer function with state) or ensuring well-posedness.

8.3 C++ (Eigen + RK4 from scratch)

Common choices: Eigen for linear algebra and either (i) your own integrator, or (ii) Boost.Odeint for numerical ODE integration. Below is a minimal RK4 integrator using Eigen. Note: all < and > are HTML-escaped.

#include <Eigen/Dense>
#include <iostream>
#include <vector>

struct LTISystem {
  Eigen::MatrixXd A, B, C, D;

  Eigen::VectorXd xdot(const Eigen::VectorXd& x, const Eigen::VectorXd& u) const {
    return A * x + B * u;
  }

  Eigen::VectorXd y(const Eigen::VectorXd& x, const Eigen::VectorXd& u) const {
    return C * x + D * u;
  }
};

// Classic RK4 step for xdot = f(x,t)
Eigen::VectorXd rk4_step(
    const LTISystem& sys,
    const Eigen::VectorXd& x,
    const Eigen::VectorXd& u,
    double h)
{
  Eigen::VectorXd k1 = sys.xdot(x, u);
  Eigen::VectorXd k2 = sys.xdot(x + 0.5*h*k1, u);
  Eigen::VectorXd k3 = sys.xdot(x + 0.5*h*k2, u);
  Eigen::VectorXd k4 = sys.xdot(x + h*k3, u);
  return x + (h/6.0)*(k1 + 2.0*k2 + 2.0*k3 + k4);
}

int main() {
  LTISystem sys;
  sys.A.resize(2,2);
  sys.B.resize(2,1);
  sys.C.resize(1,2);
  sys.D.resize(1,1);

  sys.A << 0.0, 1.0,
          -2.0, -3.0;
  sys.B << 0.0,
           1.0;
  sys.C << 1.0, 0.0;
  sys.D << 0.0;

  double t0 = 0.0, tf = 5.0, h = 1e-3;
  int N = static_cast<int>((tf - t0)/h);

  Eigen::VectorXd x(2); x << 0.5, 0.0;
  Eigen::VectorXd u(1); u << 1.0; // step input

  for (int k = 0; k < N; ++k) {
    x = rk4_step(sys, x, u, h);
  }

  Eigen::VectorXd y = sys.y(x, u);
  std::cout << "x(tf) =\n" << x << "\n";
  std::cout << "y(tf) =\n" << y << "\n";
  return 0;
}
      

8.4 Java (EJML) — State-Space Simulation Skeleton

Common libraries: EJML (Efficient Java Matrix Library) or ojAlgo. Below is a compact RK4-style skeleton using EJML. Note: generics and angle brackets are HTML-escaped.

import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;

public class LTISim {

  static DMatrixRMaj xdot(DMatrixRMaj A, DMatrixRMaj x, DMatrixRMaj B, DMatrixRMaj u) {
    DMatrixRMaj Ax = new DMatrixRMaj(A.numRows, 1);
    DMatrixRMaj Bu = new DMatrixRMaj(B.numRows, 1);
    CommonOps_DDRM.mult(A, x, Ax);
    CommonOps_DDRM.mult(B, u, Bu);
    CommonOps_DDRM.addEquals(Ax, Bu);
    return Ax;
  }

  static DMatrixRMaj rk4Step(DMatrixRMaj A, DMatrixRMaj B, DMatrixRMaj x, DMatrixRMaj u, double h) {
    DMatrixRMaj k1 = xdot(A, x, B, u);

    DMatrixRMaj x2 = x.copy(); CommonOps_DDRM.addEquals(x2, 0.5*h, k1);
    DMatrixRMaj k2 = xdot(A, x2, B, u);

    DMatrixRMaj x3 = x.copy(); CommonOps_DDRM.addEquals(x3, 0.5*h, k2);
    DMatrixRMaj k3 = xdot(A, x3, B, u);

    DMatrixRMaj x4 = x.copy(); CommonOps_DDRM.addEquals(x4, h, k3);
    DMatrixRMaj k4 = xdot(A, x4, B, u);

    DMatrixRMaj sum = k1.copy();
    CommonOps_DDRM.addEquals(sum, 2.0, k2);
    CommonOps_DDRM.addEquals(sum, 2.0, k3);
    CommonOps_DDRM.addEquals(sum, 1.0, k4);

    DMatrixRMaj xNext = x.copy();
    CommonOps_DDRM.addEquals(xNext, h/6.0, sum);
    return xNext;
  }

  public static void main(String[] args) {
    DMatrixRMaj A = new DMatrixRMaj(new double[][]{ {0,1},{-2,-3} });
    DMatrixRMaj B = new DMatrixRMaj(new double[][]{ {0},{1} });
    DMatrixRMaj C = new DMatrixRMaj(new double[][]{ {1,0} });
    DMatrixRMaj D = new DMatrixRMaj(new double[][]{ {0} });

    double t0 = 0.0, tf = 5.0, h = 1e-3;
    int N = (int)((tf - t0)/h);

    DMatrixRMaj x = new DMatrixRMaj(new double[][]{ {0.5},{0.0} });
    DMatrixRMaj u = new DMatrixRMaj(new double[][]{ {1.0} });

    for (int k = 0; k < N; k++) {
      x = rk4Step(A, B, x, u, h);
    }

    // y = Cx + Du
    DMatrixRMaj y = new DMatrixRMaj(1,1);
    CommonOps_DDRM.mult(C, x, y);
    DMatrixRMaj Du = new DMatrixRMaj(1,1);
    CommonOps_DDRM.mult(D, u, Du);
    CommonOps_DDRM.addEquals(y, Du);

    System.out.println("x(tf)=\n" + x);
    System.out.println("y(tf)=\n" + y);
  }
}
      

8.5 Wolfram Mathematica (Control Systems Functions)

Mathematica includes state-space modeling in its control systems functionality. Below is a compact example of defining a state-space model and computing a response.

A = { {0, 1}, {-2, -3} };
B = { {0}, {1} };
C = { {1, 0} };
D = { {0} };

sys = StateSpaceModel[{A, B, C, D}];

(* Step input u(t)=1, initial state x(0)={0.5,0} *)
tmax = 5;
x0 = {0.5, 0.0};

y[t_] := OutputResponse[sys, 1, {t, 0, tmax}, x0][[1]];

(* Sample output over time *)
ts = Subdivide[0, tmax, 1000];
ys = y /@ ts;

{ts[[1]], ys[[1]], ts[[-1]], ys[[-1]]}
      

Problem 1 (Dimensional consistency): Let \( \mathbf{x}(t)\in\mathbb{R}^4 \), \( \mathbf{u}(t)\in\mathbb{R}^2 \), \( \mathbf{y}(t)\in\mathbb{R}^3 \). Determine the required dimensions of \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \).

Solution: By definition, \( \mathbf{A}\in\mathbb{R}^{n\times n} \), \( \mathbf{B}\in\mathbb{R}^{n\times m} \), \( \mathbf{C}\in\mathbb{R}^{p\times n} \), \( \mathbf{D}\in\mathbb{R}^{p\times m} \). With \( n=4 \), \( m=2 \), \( p=3 \):

\[ \mathbf{A}\in\mathbb{R}^{4\times 4},\quad \mathbf{B}\in\mathbb{R}^{4\times 2},\quad \mathbf{C}\in\mathbb{R}^{3\times 4},\quad \mathbf{D}\in\mathbb{R}^{3\times 2}. \]

Problem 2 (Superposition verification): Suppose \( (\mathbf{x}_1(t),\mathbf{y}_1(t)) \) is the response to \( (\mathbf{x}_{10},\mathbf{u}_1(t)) \) and \( (\mathbf{x}_2(t),\mathbf{y}_2(t)) \) is the response to \( (\mathbf{x}_{20},\mathbf{u}_2(t)) \) for the same \( (\mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D}) \). Prove that the response to \( (\alpha\mathbf{x}_{10}+\beta\mathbf{x}_{20},\alpha\mathbf{u}_1(t)+\beta\mathbf{u}_2(t)) \) is \( \alpha\mathbf{x}_1(t)+\beta\mathbf{x}_2(t) \) and \( \alpha\mathbf{y}_1(t)+\beta\mathbf{y}_2(t) \).

Solution: This is exactly the computation in Section 4: define \( \mathbf{x}(t)=\alpha\mathbf{x}_1(t)+\beta\mathbf{x}_2(t) \) and show \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \) with the combined input \( \mathbf{u}=\alpha\mathbf{u}_1+\beta\mathbf{u}_2 \). The output linearity follows from \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \).

Problem 3 (Coordinate change): Let \( \mathbf{T} \) be invertible and define \( \mathbf{x}(t)=\mathbf{T}\mathbf{z}(t) \). Derive the transformed matrices \( (\mathbf{A}_z,\mathbf{B}_z,\mathbf{C}_z,\mathbf{D}_z) \).

Solution: From Section 6:

\[ \mathbf{A}_z=\mathbf{T}^{-1}\mathbf{A}\mathbf{T},\quad \mathbf{B}_z=\mathbf{T}^{-1}\mathbf{B},\quad \mathbf{C}_z=\mathbf{C}\mathbf{T},\quad \mathbf{D}_z=\mathbf{D}. \]

The derivation is by substituting \( \mathbf{x}=\mathbf{T}\mathbf{z} \) into the original equations and premultiplying the state equation by \( \mathbf{T}^{-1} \).

Problem 4 (Well-posedness with feedthrough): Consider the algebraic interconnection \( \mathbf{u}(t) = -\mathbf{F}\mathbf{y}(t) + \mathbf{r}(t) \). Assuming \( \mathbf{D}\neq\mathbf{0} \), derive a condition ensuring \( \mathbf{y}(t) \) is uniquely defined from \( \mathbf{x}(t) \) and \( \mathbf{r}(t) \).

Solution: Substitute into the output equation:

\[ \mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\big(-\mathbf{F}\mathbf{y}(t)+\mathbf{r}(t)\big) \;\;\Rightarrow\;\; (\mathbf{I}+\mathbf{D}\mathbf{F})\mathbf{y}(t)=\mathbf{C}\mathbf{x}(t)+\mathbf{D}\mathbf{r}(t). \]

A unique solution exists if and only if \( \mathbf{I}+\mathbf{D}\mathbf{F} \) is invertible, i.e., \( \det(\mathbf{I}+\mathbf{D}\mathbf{F})\neq 0 \). Then

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

Problem 5 (Equilibrium under constant input): Suppose \( \mathbf{u}(t)\equiv\mathbf{u}_\star \) is constant. An equilibrium state \( \mathbf{x}_\star \) satisfies \( \dot{\mathbf{x}}(t)=\mathbf{0} \). Derive the equilibrium condition and solve for \( \mathbf{x}_\star \) when \( \mathbf{A} \) is invertible.

Solution: At equilibrium, \( \mathbf{0}=\mathbf{A}\mathbf{x}_\star+\mathbf{B}\mathbf{u}_\star \), hence

\[ \mathbf{A}\mathbf{x}_\star = -\mathbf{B}\mathbf{u}_\star. \]

If \( \mathbf{A} \) is invertible, multiply both sides by \( \mathbf{A}^{-1} \):

\[ \mathbf{x}_\star = -\mathbf{A}^{-1}\mathbf{B}\mathbf{u}_\star. \]

The corresponding equilibrium output is \( \mathbf{y}_\star=\mathbf{C}\mathbf{x}_\star+\mathbf{D}\mathbf{u}_\star \).

We established the general continuous-time LTI state-space model \( \dot{\mathbf{x}}=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u} \), \( \mathbf{y}=\mathbf{C}\mathbf{x}+\mathbf{D}\mathbf{u} \), including strict dimensional requirements and the structural interpretation of \( \mathbf{A},\mathbf{B},\mathbf{C},\mathbf{D} \). We proved superposition (linearity) and time invariance directly from the equations, and showed how invertible coordinate changes transform the realization via similarity transformations. Finally, we implemented the model across major scientific computing environments and verified simulation workflows.