Classical linear control (the subject of this course) is centered on SISO feedback loops in the Laplace domain, with design primarily via root locus, Bode, and Nyquist methods. Advanced courses generalize along several axes:

• State-space (modern) control: vector states, multi-input multi-output (MIMO) systems, controllability/observability.
• Optimal control: design via optimization of performance indices, e.g. linear quadratic regulation.
• Robust control: explicit modeling of uncertainty and worst-case performance guarantees.
• Digital control: sampled-data systems, discrete-time models, implementation on microcontrollers.
• Nonlinear control: dynamics beyond linearity, local linearization, Lyapunov theory, feedback linearization.

At a high level, these areas share a common structure: a model, a performance criterion, and a feedback law. The diagram below summarizes how the techniques you have learned feed into more advanced courses.

flowchart TD
  CLS["Classical linear SISO toolbox"] --> TF["Transfer function models
frequency & root-locus design"]
  TF --> SS["State-space & MIMO control"]
  SS --> OPT["Optimal control \n(LQR, LQG, MPC)"]
  SS --> ROB["Robust control \n(Hinf, mu)"]
  TF --> DIG["Digital & sampled-data control"]
  SS --> NLC["Nonlinear control \n(local linearization, Lyapunov)"]
  ROB --> ADV["Advanced architectures (robust MPC, hybrid)"]
        

The remainder of the lesson introduces the core mathematical forms behind each arrow, without attempting to fully teach the advanced material. Instead, we show recognizable patterns that connect to your existing knowledge of transfer functions, poles, zeros, and sensitivity.

In this course, we used SISO transfer functions \( G(s) = \dfrac{Y(s)}{U(s)} \) as the central modeling object. State-space control instead models the internal dynamics as a system of first-order ODEs:

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

where \( \mathbf{x} \in \mathbb{R}^n \) is the state, \( \mathbf{u} \in \mathbb{R}^m \) is the input, and \( \mathbf{y} \in \mathbb{R}^p \) is the output. Here:

• \(A \in \mathbb{R}^{n \times n}\): state matrix (internal dynamics).
• \(B \in \mathbb{R}^{n \times m}\): input distribution.
• \(C \in \mathbb{R}^{p \times n}\): output selection.
• \(D \in \mathbb{R}^{p \times m}\): direct feedthrough.

For an LTI state-space system, the transfer matrix \( G(s) \) relating \( \mathbf{U}(s) \) to \( \mathbf{Y}(s) \) is

\[ G(s) = C(sI - A)^{-1}B + D, \]

which reduces back to the SISO transfer function when \(m=p=1\). Thus, state-space is a strict generalization of the transfer-function formalism used throughout this course.

As an illustration, consider a standard second-order system with transfer function

\[ G(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

in controllable canonical form:

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

Advanced state-space courses introduce controllability and observability, which determine whether one can place closed-loop poles arbitrarily using state feedback \( \mathbf{u} = -K\mathbf{x} \) and reconstruct \( \mathbf{x} \) from \( \mathbf{y} \) using an observer. These notions generalize the pole-placement and closed-loop stability ideas learned in root-locus design.

In classical design we trade off tracking performance, overshoot, control effort, and robustness by heuristic tuning of gains or compensator parameters. Optimal control formalizes this trade-off as a mathematical optimization problem. For an LTI state-space model \( \dot{\mathbf{x}} = A\mathbf{x}+B\mathbf{u} \), the continuous-time infinite-horizon linear quadratic regulator (LQR) problem is:

\[ \min_{\mathbf{u}(\cdot)} J(\mathbf{x}_0) = \int_0^{\infty} \left( \mathbf{x}(t)^{\top} Q\, \mathbf{x}(t) + \mathbf{u}(t)^{\top} R\, \mathbf{u}(t) \right) dt \]

subject to \( \dot{\mathbf{x}} = A\mathbf{x}+B\mathbf{u} \), and with weighting matrices \(Q \succeq 0\), \(R \succ 0\). The optimal feedback is again static state feedback of the form

\[ \mathbf{u}(t) = -K \mathbf{x}(t), \]

but now the gain matrix \(K\) is computed by solving an algebraic Riccati equation (ARE) rather than by manual tuning:

\[ A^{\top} P + P A - P B R^{-1} B^{\top} P + Q = 0, \quad K = R^{-1} B^{\top} P. \]

Here \(P\) is the unique positive semidefinite solution of the ARE under appropriate conditions, and the closed-loop matrix \(A_{\mathrm{cl}} = A - BK\) is asymptotically stable.

For a scalar system \( \dot{x} = a x + b u \) with scalar weights \(q \ge 0\), \( r > 0 \), the ARE reduces to

\[ 2 a P - \frac{b^2}{r} P^2 + q = 0. \]

Solving yields

\[ P = \frac{a r + \sqrt{a^2 r^2 + b^2 q r}}{b^2}, \quad K = \frac{b}{r} P, \]

where the positive root is chosen to ensure stability (\(A - BK = a - bK < 0\)). This derivation is an excellent starting exercise in an optimal control course and demonstrates how closed-loop pole placement is now dictated by optimization weights \(Q\) and \(R\).

In earlier chapters we used gain margin, phase margin, and the waterbed effect on the sensitivity function \( S(s) = \dfrac{1}{1+L(s)} \), \(L = G_c G_p\), to reason qualitatively about robustness to plant variations and disturbances. Robust control formalizes this idea using operator norms.

Given a stable transfer matrix \(T(s)\), its \(\mathcal{H}_{\infty}\) norm is defined by

\[ \|T\|_{\infty} = \sup_{\omega \in \mathbb{R}} \bar{\sigma}\big(T(\mathrm{j}\omega)\big), \]

where \(\bar{\sigma}\) denotes the largest singular value. Robust stability and performance with respect to structured uncertainty can then be expressed as inequalities on the \(\mathcal{H}_{\infty}\) norms of weighted sensitivity and complementary sensitivity functions, e.g.

\[ \| W_S(s) S(s) \|_{\infty} < 1, \quad \| W_T(s) T(s) \|_{\infty} < 1, \]

where \(W_S\) and \(W_T\) are design weights that encode frequency-dependent performance requirements. The \(\mathcal{H}_{\infty}\) control problem seeks a stabilizing controller \(K(s)\) that minimizes such norms. The resulting feedback laws can often be expressed in state-space by solving Riccati-like matrix equations, extending the LQR framework to worst-case (rather than average) performance.

Real controllers today are almost always implemented in digital hardware: microcontrollers, DSPs, or FPGAs. A digital controller samples the measured output every sampling period \(T_s\), computes a control update, and holds the actuator signal constant between samples (zero-order hold).

Starting from a continuous-time LTI state-space model,

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

the exact discretization under zero-order hold with sampling period \(T_s\) yields a discrete-time model

\[ \mathbf{x}_{k+1} = A_d \mathbf{x}_k + B_d \mathbf{u}_k, \]

where

\[ A_d = e^{A T_s}, \quad B_d = \int_0^{T_s} e^{A \,\tau} B \, d\tau. \]

The discrete-time transfer function \(G(z)\) (via the \(z\)-transform) plays the same role as \(G(s)\) in continuous time. Digital control courses examine:

• Stability in the \(z\)-plane (poles strictly inside the unit circle).
• Mapping between the \(s\)-plane and \(z\)-plane (e.g. \( z = e^{s T_s} \)).
• Discrete-time equivalents of PID, LQR, and observers.
• Implementation details such as quantization and computational delay.

This is tightly connected to Chapter 28 (computer-aided design) and to implementation of your classical controllers in real-time software.

flowchart TD
  C["Continuous-time plant model"] --> D1["Discretize to Ad,Bd,C,D"]
  D1 --> DL["Design discrete controller (PID or state feedback)"]
  DL --> RT["Implement on microcontroller"]
  RT --> P["Physical plant with sampler/hold"]
  P --> C
        

So far we have assumed linear, time-invariant dynamics. A general nonlinear system is written as

\[ \dot{\mathbf{x}} = f(\mathbf{x},\mathbf{u}), \quad \mathbf{y} = h(\mathbf{x},\mathbf{u}), \]

where \(f\) and \(h\) are nonlinear vector functions. Nonlinear control courses study global properties such as:

• Equilibria and their stability via Lyapunov methods.
• Feedback linearization (transforming nonlinear dynamics into equivalent linear ones).
• Input–output linearization and relative degree.

However, a central bridge to this linear course is local linearization. Around an equilibrium \((\mathbf{x}^{\star},\mathbf{u}^{\star})\) with \(f(\mathbf{x}^{\star},\mathbf{u}^{\star}) = 0\), one forms

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

where

\[ A = \left. \frac{\partial f}{\partial \mathbf{x}} \right|_{(\mathbf{x}^{\star},\mathbf{u}^{\star})}, \quad B = \left. \frac{\partial f}{\partial \mathbf{u}} \right|_{(\mathbf{x}^{\star},\mathbf{u}^{\star})}, \quad C = \left. \frac{\partial h}{\partial \mathbf{x}} \right|_{(\mathbf{x}^{\star},\mathbf{u}^{\star})}, \quad D = \left. \frac{\partial h}{\partial \mathbf{u}} \right|_{(\mathbf{x}^{\star},\mathbf{u}^{\star})}. \]

This linearized model is exactly of the type studied in this course, and its stability properties approximate the local behavior of the nonlinear system. Thus, your linear control knowledge forms the first step in analyzing nonlinear systems.

Advanced control courses rely heavily on numerical linear algebra and dedicated control libraries. Typical toolchains include:

• MATLAB/Simulink: Control System Toolbox, Robust Control Toolbox, Model Predictive Control Toolbox.
• Python: python-control, scipy.signal, numpy, and higher-level packages for MPC and robust control.
• C++: Eigen for linear algebra, with custom implementation of controllers and sometimes specialized libraries for embedded MPC or robust control.
• Java: numerical libraries such as Apache Commons Math to build state-space and LQR controllers in JVM environments.
• Wolfram Mathematica: symbolic derivation of Riccati equations, Lyapunov functions, and numerical design via functions in its control systems framework.

In the next sections we provide short code examples in each language to help you recognize how the mathematical structures from this lesson appear in real software.

Consider the standard mass–spring–damper model \( m\ddot{x} + b\dot{x} + kx = u \). With state \(x_1 = x\), \(x_2 = \dot{x}\), we have

\[ \dot{\mathbf{x}} = \begin{bmatrix} 0 & 1 \\ -\frac{k}{m} & -\frac{b}{m} \end{bmatrix} \mathbf{x} + \begin{bmatrix} 0 \\ \frac{1}{m} \end{bmatrix} u, \quad y = \begin{bmatrix} 1 & 0 \end{bmatrix} \mathbf{x}. \]

Below, we build the state-space model, compute a continuous-time LQR gain, and discretize the system.

import numpy as np
from scipy.linalg import solve_continuous_are, expm
from scipy.signal import cont2discrete

# Physical parameters
m = 1.0
b = 0.5
k = 2.0

A = np.array([[0.0,       1.0],
              [-k/m,   -b/m]])
B = np.array([[0.0],
              [1.0/m]])
C = np.array([[1.0, 0.0]])
D = np.array([[0.0]])

# LQR weights
Q = np.diag([10.0, 1.0])   # penalize position and velocity
R = np.array([[1.0]])      # penalize control effort

# Solve the continuous-time ARE
P = solve_continuous_are(A, B, Q, R)
K = np.linalg.inv(R) @ B.T @ P

print("LQR gain K:", K)

# Discretize with sampling period Ts
Ts = 0.01  # 10 ms sampling
Ad, Bd, Cd, Dd, _ = cont2discrete((A, B, C, D), Ts, method="zoh")

print("Ad:\n", Ad)
print("Bd:\n", Bd)

# Simulate one step of discrete-time closed-loop dynamics
x = np.array([[0.1],
              [0.0]])  # initial state
u = -K @ x            # state feedback
x_next = Ad @ x + Bd @ u
print("Next state x_next:", x_next)
      

This example mirrors how advanced courses use the state-space representation directly and connect the abstract Riccati solution to concrete numeric gains.

In embedded or high-performance environments, state feedback is often implemented in C++ or Java. The matrices \(A\), \(B\), \(K\) are typically computed offline (e.g. in MATLAB or Python) and then hard-coded or loaded at run time.

9.1 C++ Example with Eigen

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

int main() {
    // 2-state mass-spring-damper
    Eigen::Matrix2d A;
    A << 0.0, 1.0,
          -2.0, -0.5;
    Eigen::Vector2d B;
    B << 0.0,
          1.0;

    // Precomputed LQR gain K (row vector)
    Eigen::RowVector2d K;
    K << 3.0, 1.2;

    // Current state x
    Eigen::Vector2d x;
    x << 0.1,
          0.0;

    // State-feedback control law u = -K x
    double u = - (K * x)(0);

    std::cout << "Control input u = " << u << std::endl;

    // One-step Euler integration (for illustration only)
    Eigen::Vector2d xdot = A * x + B * u;
    double dt = 0.001;
    Eigen::Vector2d x_next = x + dt * xdot;

    std::cout << "Next state x_next = [" 
              << x_next(0) << ", " << x_next(1) << "]" 
              << std::endl;
    return 0;
}
      

9.2 Java Example with Apache Commons Math

In Java, we may use Apache Commons Math for matrix operations. Again, we assume that \(K\) has been computed offline.

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

public class LqrStateFeedback {
    public static void main(String[] args) {
        double[][] Adata = {
            {0.0, 1.0},
            {-2.0, -0.5}
        };
        double[][] Bdata = {
            {0.0},
            {1.0}
        };
        double[][] Kdata = {
            {3.0, 1.2}  // row vector
        };

        RealMatrix A = new Array2DRowRealMatrix(Adata);
        RealMatrix B = new Array2DRowRealMatrix(Bdata);
        RealMatrix K = new Array2DRowRealMatrix(Kdata);

        double[][] xdata = {
            {0.1},
            {0.0}
        };
        RealMatrix x = new Array2DRowRealMatrix(xdata);

        // u = -K x
        RealMatrix u = K.multiply(x).scalarMultiply(-1.0);
        System.out.println("u = " + u.getEntry(0, 0));

        // one-step Euler integration
        RealMatrix xdot = A.multiply(x).add(B.multiply(u));
        double dt = 0.001;
        RealMatrix xNext = x.add(xdot.scalarMultiply(dt));
        System.out.println("xNext = [" 
            + xNext.getEntry(0, 0) + ", "
            + xNext.getEntry(1, 0) + "]");
    }
}
      

These snippets illustrate how the state-feedback structure \(u = -Kx\) appears identically across languages, reinforcing the central role of the state-space representation.

10.1 MATLAB/Simulink – LQR Design and Discretization

m = 1.0;
b = 0.5;
k = 2.0;

A = [0 1;
    -k/m -b/m];
B = [0;
     1/m];
C = [1 0];
D = 0;

% LQR weights
Q = diag([10 1]);
R = 1;

% Continuous-time LQR
[K, P, e_cl] = lqr(A, B, Q, R);

% Discretize for digital implementation
Ts = 0.01;
sysc = ss(A, B, C, D);
sysd = c2d(sysc, Ts, 'zoh');
Ad = sysd.A;
Bd = sysd.B;

% In Simulink, you would implement:
%  - a State-Space block with Ad,Bd,C,D
%  - a Discrete-Time State-Space or integrator structure
%  - a Gain block implementing -K
      

10.2 Wolfram Mathematica – Symbolic LQR

(* Parameters *)
m = 1; b = 1; k = 2;

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

(* LQR weights *)
Q = { {10, 0},
     {0,  1} };
R = { {1} };

(* Compute LQR gain and closed-loop poles *)
{vals, vecs} = Eigensystem[A];
Print["Open-loop eigenvalues: ", vals];

(* Use built-in LQR design (name may vary by version) *)
{K, P, clpoles} = LQRegulatorGains[{A, B, C, D}, Q, R];

Print["LQR gain K = ", K];
Print["Closed-loop poles: ", clpoles];
      

Symbolic tools such as Mathematica are particularly useful in an advanced course for deriving Riccati equations, Lyapunov functions, and analyzing parameter dependencies.

Problem 1 (Transfer Function to State-Space): Given the SISO transfer function \( G(s) = \dfrac{2}{s^2 + 3s + 2} \), construct a controllable canonical state-space realization \( (A,B,C,D) \).

Solution:

First, factor the denominator: \( s^2 + 3s + 2 = (s+1)(s+2) \). In controllable canonical form for \( G(s) = \dfrac{b_0}{s^2 + a_1 s + a_0} \), we have

\[ A = \begin{bmatrix} 0 & 1 \\ -a_0 & -a_1 \end{bmatrix}, \quad B = \begin{bmatrix} 0 \\ 1 \end{bmatrix}, \quad C = \begin{bmatrix} b_0 & 0 \end{bmatrix}, \quad D = [\,0\,]. \]

Here \(a_1 = 3\), \(a_0 = 2\), \(b_0 = 2\), hence

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

One can verify that \(G(s) = C(sI - A)^{-1}B + D\) equals the original transfer function.

Problem 2 (Scalar LQR Riccati Equation): For the scalar system \( \dot{x} = a x + b u \) with cost \( J = \int_0^{\infty} (q x(t)^2 + r u(t)^2) dt \), derive the scalar algebraic Riccati equation and solve for \(P\) and the optimal feedback gain \(K\).

Solution:

The scalar version of the ARE is

\[ 2 a P - \frac{b^2}{r} P^2 + q = 0. \]

This is a quadratic in \(P\):

\[ -\frac{b^2}{r} P^2 + 2 a P + q = 0. \]

Multiply by \(-r/b^2\) to obtain

\[ P^2 - \frac{2 a r}{b^2} P - \frac{q r}{b^2} = 0. \]

The quadratic formula yields

\[ P = \frac{\frac{2 a r}{b^2} \pm \sqrt{\left(\frac{2 a r}{b^2}\right)^2 + 4 \frac{q r}{b^2}}}{2} = \frac{a r \pm \sqrt{a^2 r^2 + b^2 q r}}{b^2}. \]

The stabilizing solution requires \(a - bK < 0\) with \(K = \dfrac{b}{r} P\), which corresponds to choosing the plus sign in the numerator:

\[ P = \frac{a r + \sqrt{a^2 r^2 + b^2 q r}}{b^2}, \quad K = \frac{b}{r} P. \]

Problem 3 (Discrete-Time Stability via Sampling): Consider a continuous-time stable pole at \( s = -\alpha \) with \( \alpha > 0 \). Under zero-order hold with sampling period \(T_s\), the corresponding discrete-time pole is \( z = e^{-\alpha T_s} \). Show that the discrete-time system is stable and discuss how increasing \(T_s\) affects the pole location in the \(z\)-plane.

Solution:

For stability in discrete time, poles must satisfy \(|z| < 1\). Here

\[ |z| = |e^{-\alpha T_s}| = e^{-\alpha T_s}. \]

Since \(\alpha > 0\) and \(T_s > 0\), we have \(e^{-\alpha T_s} \in (0,1)\), hence \(|z| < 1\) and the discrete-time system is stable. As \(T_s\) increases, \(e^{-\alpha T_s}\) decreases toward 0, so the pole moves radially inward toward the origin in the \(z\)-plane. If \(T_s\) becomes very small, \(z \approx 1 - \alpha T_s\), so the pole is near 1 on the real axis, corresponding to a slowly decaying discrete-time response.

Problem 4 (Local Linearization of a Nonlinear System): Consider the nonlinear system \( \dot{x} = -x^3 + u \), \(y = x\). Linearize the dynamics around the equilibrium \((x^{\star},u^{\star}) = (0,0)\) and write the resulting linear model.

Solution:

Here \(f(x,u) = -x^3 + u\), \(h(x,u) = x\). The equilibrium satisfies \(-x^{\star 3} + u^{\star} = 0\), which holds for \(x^{\star} = 0\), \(u^{\star} = 0\). The Jacobians are

\[ A = \left.\frac{\partial f}{\partial x}\right|_{(0,0)} = \left.-3 x^2\right|_{x=0} = 0, \quad B = \left.\frac{\partial f}{\partial u}\right|_{(0,0)} = 1, \]

\[ C = \left.\frac{\partial h}{\partial x}\right|_{(0,0)} = 1, \quad D = \left.\frac{\partial h}{\partial u}\right|_{(0,0)} = 0. \]

Thus the linearized system in deviations \(\delta x = x - 0\), \(\delta u = u - 0\), \(\delta y = y - 0\) is

\[ \delta \dot{x} = 0\cdot \delta x + 1\cdot \delta u = \delta u, \quad \delta y = 1\cdot \delta x. \]

This matches the intuitive idea that, near the origin, the cubic nonlinearity is negligible and the system behaves like an integrator with input \(\delta u\).

Problem 5 (Sensitivity Weighting and Robustness): Suppose a design requirement for a SISO loop with transfer function \(L(s)\) is \(\left| S(\mathrm{j}\omega) \right| \le 0.1\) for \(\omega \in [0, 10]\) rad/s, where \(S(s) = 1/(1+L(s))\). Define a weighting function \(W_S(s)\) such that the robust performance condition \(\| W_S S \|_{\infty} < 1\) encodes this requirement.

Solution:

We want \(|S(\mathrm{j}\omega)| \le 0.1\) on \([0,10]\) rad/s. One simple choice is

\[ W_S(s) = \begin{cases} 10, & \text{for } \omega \in [0,10]\ \text{(approximately)} \\ \text{small}, & \text{for higher } \omega \end{cases} \]

More concretely, a first-order weight such as

\[ W_S(s) = \frac{10 (s/\omega_b + 1)}{s/\omega_h + 1}, \]

with \(\omega_b \ll 10\), \(\omega_h \gg 10\), approximates a gain of 10 in the band of interest, and near-zero gain outside. Then

\[ \| W_S S \|_{\infty} < 1 \quad \Rightarrow \quad |W_S(\mathrm{j}\omega) S(\mathrm{j}\omega)| < 1 \]

implies approximately \(|S(\mathrm{j}\omega)| \lesssim 0.1\) on the design band, encoding the same specification within the \(\mathcal{H}_{\infty}\) framework.

This lesson has positioned the classical linear control toolbox developed in this course as the foundation for more advanced topics. We showed how:

• State-space models generalize transfer functions and support MIMO systems, controllability, and observability.
• Optimal control (LQR) formalizes trade-offs between performance and control effort via quadratic cost functionals and Riccati equations.
• Robust control reframes classical sensitivity-based reasoning into \(\mathcal{H}_{\infty}\) norm inequalities with explicit uncertainty models.
• Digital control translates continuous-time models into discrete-time via sampling and zero-order hold, connecting \(s\)- and \(z\)-domain notions of stability and performance.
• Nonlinear control builds on local linearization, using the same linear models you have studied as first-order approximations of more complex dynamics.

The coding examples in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrate how these mathematical ideas are realized in practice, preparing you for future courses that deepen each of these advanced topics.