5.1 State-space models

State-space models provide a unified framework for describing systems with multiple inputs and outputs using first-order differential (or difference) equations. Unlike transfer functions, which only capture input-output relationships, state-space models also represent the internal dynamics of a system. This makes them essential for modern control design techniques like pole placement, observer design, and optimal control.

State-space representation

A state-space representation describes a physical system as a set of first-order differential equations (continuous-time) or difference equations (discrete-time) that relate input, output, and state variables. This compact matrix formulation lets you apply linear algebra tools directly to analyze and design controllers for systems with multiple inputs and outputs.

State variables

State variables are the smallest set of variables that fully describe a system's condition at any given time. If you know the current state variables and the future inputs, you can predict the system's future behavior.

• For a mechanical system: position and velocity
• For an electrical circuit: capacitor voltage and inductor current
• For a thermal system: temperature at key nodes

The number of state variables equals the system's order, which corresponds to the number of independent energy storage elements.

State equations

State equations describe how the state variables change over time. They relate the current state and input to the rate of change (continuous-time) or the next value (discrete-time) of each state variable.

These are always first-order equations. If your original system involves higher-order derivatives, you introduce new state variables to reduce everything to first order (more on this below).

Output equations

Output equations define how the measurable quantities of the system depend on the current state and input. Not every state variable is directly measurable, so the output equation specifies which combinations of states and inputs you can actually observe.

Matrix notation

State-space models are written compactly using matrices:

Continuous-time:

$\dot{x}(t) = Ax(t) + Bu(t)$

$y(t) = Cx(t) + Du(t)$

Discrete-time:

$x[k+1] = Ax[k] + Bu[k]$

$y[k] = Cx[k] + Du[k]$

Where:

• $x$ is the state vector ($n \times 1$)
• $u$ is the input vector ($m \times 1$)
• $y$ is the output vector ($p \times 1$)
• $A$ is the state matrix ($n \times n$), governing internal dynamics
• $B$ is the input matrix ($n \times m$), mapping inputs to state changes
• $C$ is the output matrix ($p \times n$), mapping states to outputs
• $D$ is the feedthrough (or direct transmission) matrix ($p \times m$), representing direct input-to-output coupling. In many physical systems, $D = 0$.

Linear vs nonlinear models

State-space models fall into two categories based on the nature of their equations.

Linear models have state and output equations that are linear combinations of the state variables and inputs. The matrices $A$, $B$, $C$, and $D$ are constant, and superposition applies. Most of the analysis and design tools in this unit assume linearity.

Nonlinear models contain nonlinear functions of the state variables or inputs (quadratic terms, trigonometric functions, exponentials, etc.). These can capture more complex behaviors, but they require specialized techniques like linearization around an operating point, feedback linearization, or Lyapunov-based methods.

In practice, you often linearize a nonlinear model around an equilibrium point to obtain a linear state-space model that's valid for small deviations from that operating condition.

Continuous-time state-space models

Continuous-time models describe systems that evolve smoothly over time using differential equations. The state variables and outputs are functions of a continuous time variable $t$. These are the natural choice for modeling physical systems like mechanical, electrical, and thermal processes.

First-order differential equations

Each state variable gets one first-order differential equation. The right-hand side is a linear combination of all state variables and inputs, with coefficients drawn from the $A$ and $B$ matrices.

For a two-state system, this looks like:

$\dot{x}_1(t) = a_{11}x_1(t) + a_{12}x_2(t) + b_{11}u(t)$

$\dot{x}_2(t) = a_{21}x_1(t) + a_{22}x_2(t) + b_{21}u(t)$

Higher-order differential equations

Many physical systems are naturally described by higher-order differential equations. A mass-spring-damper system, for example, gives you a second-order ODE:

$m\ddot{y} + c\dot{y} + ky = f(t)$

To convert this into state-space form:

1. Define state variables to capture each derivative up to one less than the system order. Here, let $x_1 = y$ (position) and $x_2 = \dot{y}$ (velocity).

2. Write first-order equations for each state variable:

   • $\dot{x}_1 = x_2$
   • $\dot{x}_2 = \frac{1}{m}(f(t) - cx_2 - kx_1)$

3. Assemble into matrix form to identify $A$, $B$, $C$, and $D$.

This procedure generalizes: an $n$th-order ODE becomes $n$ first-order equations.

Discrete-time state-space models

Discrete-time models describe systems at specific time instants $k = 0, 1, 2, \ldots$ using difference equations. These are used for digital control systems where a computer samples sensor data and updates control signals at regular intervals.

Difference equations

Each state variable has a difference equation that computes its value at the next time step from the current state and input:

$x[k+1] = Ax[k] + Bu[k]$

The structure mirrors the continuous-time case, but derivatives are replaced by forward shifts in time.

Sampling and discretization

To implement a continuous-time controller digitally, or to simulate a continuous-time plant on a computer, you need to convert the continuous-time model to discrete-time. The steps are:

1. Choose a sampling period $T_s$. This should be small enough to capture the system's dynamics (a common rule of thumb: 10 to 20 samples per rise time).
2. Apply a discretization method to convert the continuous-time $A$ and $B$ matrices to their discrete-time equivalents.

Common discretization methods:

• Zero-order hold (ZOH): Assumes the input is held constant between samples. This is the most common method and gives exact results for piecewise-constant inputs.
• Tustin (bilinear) approximation: Maps the continuous-time frequency response to discrete-time more accurately at higher frequencies, preserving stability.

A sampling period that's too large can introduce aliasing and degrade stability. Too small, and you waste computational resources without meaningful improvement.

State-space model properties

Three properties are fundamental to understanding what you can and cannot do with a given system: controllability, observability, and stability.

Controllability

Controllability answers the question: Can you drive the system from any initial state to any desired state in finite time using the available inputs?

To test controllability, form the controllability matrix:

$\mathcal{C} = [B \quad AB \quad A^2B \quad \cdots \quad A^{n-1}B]$

where $n$ is the number of state variables. If $\text{rank}(\mathcal{C}) = n$, the system is controllable. If the rank is less than $n$, some states cannot be influenced by the input, and you won't be able to place all closed-loop poles arbitrarily.

Observability

Observability answers the question: Can you determine the system's initial state from the output measurements over a finite time interval?

To test observability, form the observability matrix:

$\mathcal{O} = \begin{bmatrix} C \\ CA \\ CA^2 \\ \vdots \\ CA^{n-1} \end{bmatrix}$

If $\text{rank}(\mathcal{O}) = n$, the system is observable. If not, some internal states are "hidden" from the output, and you cannot design an observer that estimates all states.

Stability

Stability characterizes whether the system's state remains bounded and eventually settles to equilibrium.

The test is based on the eigenvalues of the state matrix $A$:

• Continuous-time: The system is asymptotically stable if all eigenvalues have strictly negative real parts (i.e., they lie in the open left-half of the complex plane).
• Discrete-time: The system is asymptotically stable if all eigenvalues have magnitude less than 1 (i.e., they lie strictly inside the unit circle).

If even one eigenvalue violates these conditions, the system is unstable (or marginally stable if eigenvalues sit exactly on the boundary).

State-space model transformations

Transformations change the state variables while preserving the system's input-output behavior. They're used to simplify analysis, decouple dynamics, or convert models into standard forms that make controller design more straightforward.

Similarity transformations

A similarity transformation applies a nonsingular matrix $T$ to define new state variables $z = Tx$. The transformed system matrices become:

• $\tilde{A} = TAT^{-1}$
• $\tilde{B} = TB$
• $\tilde{C} = CT^{-1}$
• $\tilde{D} = D$

The key point: similarity transformations preserve eigenvalues, controllability, observability, and the transfer function. The system looks different internally, but its external behavior is identical.

Canonical forms

Canonical forms are standardized matrix structures obtained through specific similarity transformations. They simplify design by giving the matrices a predictable pattern.

Controllable canonical form

In this form, the state matrix $A$ is a companion matrix and the input matrix $B$ has a single 1 in its last row (for SISO systems). The coefficients of the characteristic polynomial appear directly in the last row of $A$.

This form is particularly useful for pole placement via state feedback, because the relationship between the feedback gains and the desired characteristic polynomial becomes transparent.

The transformation matrix is constructed from the controllability matrix $\mathcal{C}$.

Observable canonical form

This is the dual of the controllable canonical form. Here, the state matrix $A$ is again a companion matrix, and the output matrix $C$ has a simple structure (a single 1 in its first column for SISO systems).

This form is useful for observer design, since the observer gain selection maps directly to choosing the observer's characteristic polynomial.

The transformation matrix is constructed from the observability matrix $\mathcal{O}$.

Coordinate transformations

Coordinate transformations are a broader category that includes any change of basis for the state variables. Beyond canonical forms, you might use:

• Diagonalization (using eigenvectors) to decouple modes
• Scaling to normalize state variables to similar magnitudes
• Jordan form when the state matrix isn't diagonalizable

These transformations help align the mathematical representation with physical intuition or numerical convenience.

State-space model analysis

Eigenvalues and eigenvectors

The eigenvalues $\lambda_i$ of the state matrix $A$ are the solutions to $\det(A - \lambda I) = 0$. Each eigenvalue has an associated eigenvector $v_i$ satisfying $Av_i = \lambda_i v_i$.

What eigenvalues tell you:

• Real part (continuous-time) or magnitude (discrete-time) determines stability
• Imaginary part determines oscillation frequency
• Complex conjugate pairs correspond to oscillatory modes; purely real eigenvalues correspond to exponential decay or growth

The eigenvectors define the directions in state space along which these modes act.

Modal decomposition

If $A$ has $n$ linearly independent eigenvectors, you can diagonalize it:

$\Lambda = V^{-1}AV$

where $V$ is the matrix of eigenvectors and $\Lambda$ is diagonal with eigenvalues on the diagonal.

In the transformed coordinates $z = V^{-1}x$, each state evolves independently:

$\dot{z}_i = \lambda_i z_i$

This decoupling lets you analyze each mode separately. For mechanical or structural systems, the modes correspond to natural frequencies and damping ratios, which directly relate to physical vibration patterns.

Lyapunov stability

Lyapunov stability analysis extends beyond eigenvalue tests, especially for nonlinear systems. The idea is to find a Lyapunov function $V(x)$ that acts like a generalized energy function:

1. $V(x) > 0$ for all $x \neq 0$ (positive definite)
2. $V(0) = 0$
3. $\dot{V}(x) \leq 0$ along system trajectories (negative semidefinite for stability, strictly negative definite for asymptotic stability)

If such a function exists, the equilibrium is stable. For linear systems, a common choice is the quadratic form $V(x) = x^T P x$, where $P$ is a positive definite matrix satisfying the Lyapunov equation:

$A^T P + PA = -Q$

for some positive definite $Q$. If a solution $P > 0$ exists, the system is asymptotically stable.

State-space model design

Pole placement

Pole placement designs a state feedback gain $K$ so that the closed-loop system $\dot{x} = (A - BK)x$ has eigenvalues at specified locations. The procedure:

1. Determine the desired closed-loop pole locations based on performance specs (settling time, damping ratio, natural frequency).
2. Verify that the system is controllable (required for arbitrary pole placement).
3. Compute the gain matrix $K$ using Ackermann's formula or direct matching of the characteristic polynomial.

The closed-loop characteristic polynomial becomes $\det(sI - A + BK) = 0$, and you choose $K$ so this polynomial has the desired roots.

State feedback control

State feedback control uses the law $u = -Kx + r$, where $r$ is a reference input. This requires access to the full state vector. If some states aren't measurable, you need an observer (see below) and use the estimated state instead: $u = -K\hat{x}$.

Common extensions:

• Integral action: Augment the state with the integral of the tracking error to eliminate steady-state error
• Feedforward: Add a term based on the reference to improve transient tracking
• Separation principle: Design the controller gain $K$ and observer gain $L$ independently; the combined system remains stable as long as each is designed for stability

State observers

Observers estimate unmeasured states from available outputs and the known system model. The general structure is:

$\dot{\hat{x}} = A\hat{x} + Bu + L(y - C\hat{x})$

The term $L(y - C\hat{x})$ is a correction that drives the estimate toward the true state. The estimation error $e = x - \hat{x}$ evolves as $\dot{e} = (A - LC)e$, so the observer gain $L$ is chosen to make $A - LC$ stable with fast eigenvalues.

Full-order observers

Full-order observers estimate all $n$ states, including those that are directly measured. They have the same dimension as the original system. The observer gain $L$ is designed so the error dynamics $A - LC$ have eigenvalues that converge faster than the controller's closed-loop poles (a common guideline: observer poles 2 to 6 times faster than controller poles).

Reduced-order observers

Reduced-order observers only estimate the unmeasured states, using the measured outputs directly. For a system with $p$ measured outputs and $n$ states, the observer has order $n - p$. This is computationally cheaper and avoids redundantly estimating states you already know. The tradeoff is a more complex derivation.

Optimal control

Optimal control finds the input that minimizes a cost function, balancing performance against control effort.

Linear quadratic regulator (LQR)

LQR minimizes the cost function:

$J = \int_0^{\infty} (x^T Q x + u^T R u) \, dt$

where $Q \geq 0$ weights state deviations and $R > 0$ weights control effort. Larger $Q$ penalizes state error more aggressively (faster response); larger $R$ penalizes control effort (more conservative actuation).

The optimal control law is $u = -Kx$, where $K = R^{-1}B^T P$ and $P$ is the positive definite solution to the continuous-time algebraic Riccati equation (CARE):

$A^T P + PA - PBR^{-1}B^T P + Q = 0$

LQR guarantees closed-loop stability and provides good robustness margins (at least 60° phase margin and infinite gain margin for SISO systems).

Kalman filter

The Kalman filter is the optimal state estimator for linear systems with Gaussian process noise $w$ and measurement noise $v$:

$\dot{x} = Ax + Bu + w, \quad y = Cx + v$

It operates in two recursive steps:

1. Predict: Propagate the state estimate and its covariance forward using the system model.
2. Update: Correct the prediction using the new measurement, weighted by the Kalman gain $K_f$, which balances trust in the model versus trust in the measurement based on their respective noise covariances.

The Kalman gain is computed from the solution of a Riccati equation analogous to the LQR case. The Kalman filter is the dual of LQR: LQR optimizes control, while the Kalman filter optimizes estimation. Together, they form the Linear Quadratic Gaussian (LQG) controller, combining optimal control with optimal estimation.