In classical linear control you have studied transfer functions \( G(s) = \dfrac{Y(s)}{U(s)} \), frequency-response tools (Bode, Nyquist), and time-domain specifications (overshoot, settling time, etc.). These tools are powerful for single-input single-output (SISO) systems, but they hide the internal states of the system and become cumbersome for multi-input multi-output (MIMO) dynamics, time-varying parameters, and systematic computer-aided design.

Modern control adopts a vector-matrix description. A continuous-time linear time-invariant (LTI) system is written as

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

where the state vector \( x(t) \in \mathbb{R}^n \) represents the internal configuration of the system, the input \( u(t) \in \mathbb{R}^m \) collects control and disturbance signals, and the output \( y(t) \in \mathbb{R}^p \) collects measured signals. The constant matrices \( A \in \mathbb{R}^{n \times n} \), \( B \in \mathbb{R}^{n \times m} \), \( C \in \mathbb{R}^{p \times n} \), \( D \in \mathbb{R}^{p \times m} \) encode the full linear dynamics.

After studying this lesson you should be able to:

• Explain historically how control theory evolved from mechanical governors to state-space methods.
• Relate an ODE model, a transfer-function model, and a basic state-space model.
• Articulate the limitations of purely input-output (transfer-function) descriptions, especially for MIMO systems.
• Write simple state-space models and represent them in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica using standard libraries.

Modern control theory did not appear in isolation. It is the result of a historical progression driven by engineering needs (stability, performance, robustness) and by mathematical developments (Laplace transforms, complex analysis, linear algebra, probability). At a high level:

• Pre-1940: Empirical control (e.g., centrifugal governors) with limited analytical tools.
• 1940s–1950s: Frequency-domain control — Nyquist, Bode, root locus — for SISO feedback loops.
• Late 1950s–1960s: Space age and aerospace applications require MIMO and optimal control; Kalman introduces state-space and stochastic filtering.
• 1970s–1980s: Digital implementation, multivariable control, and systematic design algorithms.
• 1990s–today: Robust control, model predictive control, and large-scale networked systems, all formulated naturally in state-space form.

The following diagram summarizes this evolution:

flowchart TD
  E0["Pre-1940: mechanical governors, empirical tuning"]
  E1["1940-1957: transfer functions, Bode, Nyquist"]
  E2["Late 1950s-1960s: state space, optimal control"]
  E3["1970s-1980s: digital and multivariable control"]
  E4["1990s-now: robust, MPC, large-scale systems"]
  E0 --> E1 --> E2 --> E3 --> E4
        

Two key turning points for modern control were:

1. The recognition that many important systems are inherently multi-variable (e.g., aircraft, power grids), where SISO loop-by-loop design can be inadequate.
2. The introduction of the state as an abstract object that summarizes all dynamic memory, enabling systematic analysis of reachability, estimation, and optimal control.

In classical linear control, a single-input single-output system is typically described by a linear constant-coefficient differential equation of order \( n \):

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \cdots + a_0 y(t) = b_m \frac{d^m u(t)}{dt^m} + b_{m-1} \frac{d^{m-1} u(t)}{dt^{m-1}} + \cdots + b_0 u(t), \]

where \( u(t) \) is the input, \( y(t) \) is the output, and the coefficients are real constants with \( a_n \neq 0 \). Taking the Laplace transform under zero initial conditions leads to

\[ Y(s)\,\Big(a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0\Big) = U(s)\,\Big(b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0\Big), \]

and the transfer function is defined as

\[ G(s) \triangleq \frac{Y(s)}{U(s)} = \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0} {a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0}. \]

This representation has several advantages:

• Stability is characterized by the roots of the denominator polynomial.
• Time-domain performance (rise time, overshoot) can be related to pole locations.
• Frequency response is obtained by evaluating \( G(j\omega) \).

However, note that \( G(s) \) is purely input-output: internal variables (positions, velocities, currents, etc.) do not appear explicitly. This is the main conceptual limitation that motivates the introduction of state.

Consider a standard mass–spring–damper system with input force \( u(t) \) and measured position \( y(t) \):

\[ m \,\ddot{y}(t) + c \,\dot{y}(t) + k\,y(t) = u(t), \]

where \( m > 0 \), \( c \ge 0 \), \( k > 0 \). A natural choice of state variables is

\[ x_1(t) \triangleq y(t), \qquad x_2(t) \triangleq \dot{y}(t). \]

Then

\[ \dot{x}_1(t) = x_2(t), \qquad \dot{x}_2(t) = -\frac{k}{m} x_1(t) - \frac{c}{m} x_2(t) + \frac{1}{m} u(t), \]

which can be written compactly as

\[ \dot{x}(t) = \begin{bmatrix} 0 & 1 \\ -\dfrac{k}{m} & -\dfrac{c}{m} \end{bmatrix} x(t) + \begin{bmatrix} 0 \\ \dfrac{1}{m} \end{bmatrix} u(t), \qquad y(t) = \begin{bmatrix} 1 & 0 \end{bmatrix} x(t). \]

Here, \( x(t) = [x_1(t)\; x_2(t)]' \) fully characterizes the mechanical configuration: if we know \( x(t_0) \) at some time \( t_0 \) and we know \( u(t) \) for \( t \ge t_0 \), then the future evolution of \( x(t) \) and \( y(t) \) is uniquely determined.

This illustrates the Markov property of the state:

\[ \text{Future behavior depends on the past only through the current state } x(t_0). \]

In classical transfer-function analysis, only the mapping \( u(t) \mapsto y(t) \) is retained; internal variables such as velocity are hidden. Modern control, by contrast, treats the vector state \( x(t) \) as the central object, opening the door to:

• Explicit modeling of multi-variable couplings.
• Systematic design of full-state feedback \( u(t) = -K x(t) \) (studied later).
• State estimation when some components of \( x(t) \) are not measured directly.

The transfer-function view is essentially scalar: even in MIMO systems one typically decomposes the problem into several SISO transfer functions and couples them via block diagrams. In contrast, the state-space view is vectorial and inherently matrix-based. For a general LTI system:

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

with

\[ x(t) \in \mathbb{R}^n, \quad u(t) \in \mathbb{R}^m, \quad y(t) \in \mathbb{R}^p, \]

the dimensions of the matrices are:

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

This structure directly exposes:

• The coupling between states through \( A \) (internal dynamics).
• How each input channel influences each state through \( B \).
• How each output is formed from the states and inputs via \( C \) and \( D \).

The following diagram emphasizes the modeling choices from physics to internal and input-output descriptions:

flowchart TD
  P["Physical system and laws"] --> M1["Differential equation model"]
  M1 --> M2["Input-output description (transfer function)"]
  M1 --> M3["Internal description (state-space)"]
  M2 --> C1["Classical SISO analysis and design"]
  M3 --> C2["Modern MIMO analysis and design"]
        

In subsequent chapters we will systematically exploit linear algebra (vector spaces, eigenvalues, similarity transformations) to analyze stability, controllability, and observability directly in terms of \( A, B, C, D \).

Modern control is tightly linked to numerical computation. Here we show how the mass–spring–damper example can be represented in several programming languages, emphasizing libraries that support state-space models.

6.1 Python (NumPy, SciPy, and python-control)

In Python, matrix computations are handled conveniently by numpy. For control-specific operations, two common libraries are:

• scipy.signal (general signal and systems toolbox).
• control (python-control, a MATLAB-like control library).

import numpy as np
from control import ss, step_response    # python-control library

# Physical parameters
m = 1.0
c = 0.4
k = 2.0

# State-space matrices for the mass-spring-damper
A = np.array([[0.0,        1.0],
              [-k/m,  -c/m]])
B = np.array([[0.0],
              [1.0/m]])
C = np.array([[1.0, 0.0]])   # measure position
D = np.array([[0.0]])

system = ss(A, B, C, D)

# Compute step response of position to a unit step in force
T, y = step_response(system)

# T contains time samples, y contains output samples
print("First 5 time samples:", T[:5])
print("First 5 output samples:", y[0][:5])
      

6.2 MATLAB / Simulink (Control System Toolbox)

MATLAB has built-in support for state-space models via ss, and Simulink provides a graphical block for state-space descriptions.

% Physical parameters
m = 1.0;
c = 0.4;
k = 2.0;

% State-space matrices
A = [0 1;
     -k/m -c/m];
B = [0;
     1/m];
C = [1 0];  % position output
D = 0;

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

% Step response (force input = unit step)
figure;
step(sys);
title('Mass-spring-damper: position response');

% In Simulink:
% 1. Drag a "State-Space" block into the model.
% 2. Set A, B, C, D matrices in the block parameters.
% 3. Connect input (force), output (position), and scopes as needed.
      

6.3 C++ (Eigen for Linear Algebra)

In C++, there is no standard control library, but linear algebra can be handled efficiently by Eigen. A simple explicit Euler step for \( \dot{x}(t) = A x(t) + B u(t) \) is:

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

int main() {
    using namespace Eigen;

    // Matrices (2 states, 1 input)
    Matrix2d A;
    A << 0.0, 1.0,
          -2.0, -0.4;   // assume m = 1, k = 2, c = 0.4
    Vector2d B;
    B << 0.0,
          1.0;          // input gain = 1/m

    // Initial state: position = 0, velocity = 0
    Vector2d x;
    x << 0.0, 0.0;

    double u = 1.0;     // constant input
    double dt = 0.001;
    int steps = 10000;

    for (int k = 0; k < steps; ++k) {
        Vector2d xdot = A * x + B * u;
        x = x + dt * xdot;   // explicit Euler
    }

    std::cout << "Final state x = " << x.transpose() << std::endl;
    return 0;
}
      

Here, Eigen::Matrix2d and Eigen::Vector2d represent the state-space matrices and vectors; more general systems use MatrixXd and VectorXd.

6.4 Java (Apache Commons Math)

Java can represent state-space systems using standard arrays or libraries like Apache Commons Math (RealMatrix and RealVector):

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.ArrayRealVector;
import org.apache.commons.math3.linear.RealMatrix;
import org.apache.commons.math3.linear.RealVector;

public class MassSpringDamper {
    public static void main(String[] args) {
        double[][] Adata = {
            {0.0, 1.0},
            {-2.0, -0.4}  // m = 1, k = 2, c = 0.4
        };
        double[][] Bdata = {
            {0.0},
            {1.0}
        };

        RealMatrix A = new Array2DRowRealMatrix(Adata);
        RealMatrix B = new Array2DRowRealMatrix(Bdata);
        RealVector x = new ArrayRealVector(new double[]{0.0, 0.0});

        double u = 1.0;
        double dt = 0.001;
        int steps = 10000;

        for (int k = 0; k < steps; ++k) {
            RealVector xdot = A.operate(x).add(B.operate(new ArrayRealVector(new double[]{u})));
            x = x.add(xdot.mapMultiply(dt));
        }

        System.out.println("Final state x = " + x);
    }
}
      

6.5 Wolfram Mathematica (StateSpaceModel)

Mathematica has high-level constructs for state-space models.

(* Physical parameters *)
m = 1.0;
c = 0.4;
k = 2.0;

A = { {0, 1}, {-k/m, -c/m} };
B = { {0}, {1/m} };
C = {{1, 0}};
D = {{0}};

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

(* Step response of position to a unit step input *)
resp = OutputResponse[sys, UnitStep[t], {t, 0, 10}];
Plot[resp[[1]], {t, 0, 10}, PlotLabel -> "Position response"]
      

In later lessons, these computational structures will be used to study stability, controllability, observability, and feedback design for more complex systems.

Problem 1 (State-Space Representation of a Second-Order System): Consider the mass–spring–damper system

\[ m \,\ddot{y}(t) + c \,\dot{y}(t) + k\,y(t) = u(t). \]

(a) Choose a two-dimensional state vector \( x(t) \) and derive the matrices \( A, B, C, D \) for a state-space model with output \( y(t) \).
(b) What are the dimensions of \( A, B, C, D \)?

Solution:

(a) A natural choice is

\[ x_1(t) \triangleq y(t), \qquad x_2(t) \triangleq \dot{y}(t), \quad x(t) \triangleq \begin{bmatrix} x_1(t) \\ x_2(t) \end{bmatrix}. \]

Then

\[ \dot{x}_1(t) = x_2(t), \qquad \dot{x}_2(t) = -\frac{k}{m} x_1(t) - \frac{c}{m} x_2(t) + \frac{1}{m} u(t), \]

so in matrix form

\[ \dot{x}(t) = \underbrace{ \begin{bmatrix} 0 & 1 \\ -\dfrac{k}{m} & -\dfrac{c}{m} \end{bmatrix}}_{A} x(t) + \underbrace{ \begin{bmatrix} 0 \\ \dfrac{1}{m} \end{bmatrix}}_{B} u(t), \quad y(t) = \underbrace{ \begin{bmatrix} 1 & 0 \end{bmatrix}}_{C} x(t) + \underbrace{[\,0\,]}_{D} u(t). \]

(b) Here \( n = 2 \), \( m = 1 \), \( p = 1 \), so \( A \in \mathbb{R}^{2 \times 2} \), \( B \in \mathbb{R}^{2 \times 1} \), \( C \in \mathbb{R}^{1 \times 2} \), \( D \in \mathbb{R}^{1 \times 1} \).

Problem 2 (Uniqueness of Future Evolution from State): For the mass–spring–damper system above with state choice \( x_1(t) = y(t), x_2(t) = \dot{y}(t) \), argue briefly why knowing \( x(t_0) \) and the input \( u(t) \) for \( t \ge t_0 \) uniquely determines \( x(t) \) for \( t \ge t_0 \).

Solution:

The state-space model is a linear system of first-order ODEs with continuous right-hand side:

\[ \dot{x}(t) = f(t, x(t)) \triangleq A x(t) + B u(t). \]

For any piecewise continuous input \( u(t) \), the function \( f(t, x) \) is globally Lipschitz in \( x \) (because it is linear). By the standard existence and uniqueness theorem for ODEs, there exists a unique solution \( x(t) \) for \( t \ge t_0 \) satisfying the initial condition \( x(t_0) = x_0 \). Hence the state \( x(t_0) \) together with \( u(t) \) determines the future trajectory uniquely.

Problem 3 (Dimensions in a Simple MIMO System): Consider a system with \( n = 4 \) states, \( m = 2 \) inputs, and \( p = 3 \) outputs. (a) What are the dimensions of \( A, B, C, D \)? (b) How many scalar entries does \( A \) contain?

Solution:

(a) By definition:

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

(b) The matrix \( A \) has \( 4 \times 4 = 16 \) scalar entries.

Problem 4 (Conceptual: Classical vs Modern View): A single-input single-output plant is represented by a strictly proper transfer function \( G(s) \). Explain two situations where a state-space representation is conceptually or practically superior to using only \( G(s) \).

Solution:

Two typical situations are:

• Internal variable constraints: When constraints or performance requirements concern internal variables (e.g., limiting velocity or current), these do not appear explicitly in \( G(s) \) but are components of the state vector. State-space allows direct reasoning about them.
• State feedback and estimation: If one wants to design a feedback law of the form \( u(t) = -K x(t) \) or to reconstruct unmeasured states from outputs, a state-space model is essential; transfer functions alone do not encode how to map between internal variables and measured signals.

Problem 5 (Historical Perspective): Why did the emergence of aerospace and spacecraft control in the 1950s–1960s push the community toward state-space methods rather than relying solely on classical transfer-function techniques?

Solution:

Aerospace and spacecraft systems are naturally multi-input multi-output with strongly coupled dynamics (attitude, position, flexible modes, fuel sloshing, etc.). Designing separate SISO loops for each channel using only transfer functions can lead to poor interaction management and may fail to guarantee stability of the full closed-loop system. Moreover, these applications demanded optimality (fuel, pointing accuracy) and stochastic modeling (sensor noise, disturbances), which are naturally formulated in terms of vector states and matrices. State-space methods provide a compact, mathematically rigorous framework to treat these requirements simultaneously.

In this lesson we motivated the transition from classical transfer-function based control to modern state-space methods. Classical tools, while powerful for SISO systems, hide internal variables and are difficult to scale to coupled MIMO and optimal design problems. By focusing on the state vector \( x(t) \) and the matrix quadruple \( (A, B, C, D) \), modern control creates a unified framework for analysis, design, and computation. The historical development from mechanical governors through frequency-domain control to state-space formulations reflects increasing system complexity and performance demands. Subsequent lessons will build the linear algebra and system-theoretic machinery needed to exploit this framework fully.