Linearizing a nonlinear system means approximating it as a linear system that behaves nearly identically in a small region around a chosen operating point. The core technique uses a first-order Taylor series expansion to replace curved, complex dynamics with straight-line approximations you can analyze with standard linear tools. The process follows a clear sequence: find an equilibrium point, compute partial derivatives there, and build a linear model from those derivatives.
Why Linearization Works
Most nonlinear functions look approximately straight if you zoom in far enough. Linearization exploits this by picking a specific point where the system naturally settles (an equilibrium) and replacing the nonlinear function with its tangent line at that point. The math behind this is the Taylor series, truncated after the first-order term. For a function of a single variable, the approximation is:
f(x) ≈ f(x₀) + f'(x₀) · (x − x₀)
Here, x₀ is the operating point, f(x₀) is the function’s value there, and f'(x₀) is the slope. Everything beyond the first derivative term gets dropped. The result is a linear relationship between how far you move from x₀ and how much f changes. This approximation is only accurate when (x − x₀) stays small, which is why linearization is sometimes called “small-signal analysis.” When signals grow large relative to the operating point, nonlinear effects dominate and the linear model breaks down.
Step 1: Find the Equilibrium Points
An equilibrium point is where the system sits still. Mathematically, if your system is described by dx/dt = f(x), the equilibrium points are the values of x where f(x) = 0. At these points, the rate of change is zero, so the system has no tendency to move.
Finding them is usually straightforward algebra. For example, if your system is dx/dt = x² − x − 6, you set x² − x − 6 = 0 and factor it into (x − 3)(x + 2) = 0. The equilibrium points are x = 3 and x = −2. A more complex system might have three or more equilibria. Each one represents a different operating condition where you could linearize, and the resulting linear model will be different at each point.
For systems with inputs (like a control system where you apply a force or voltage), you also need to find the steady-state input value ū that keeps the system at the desired equilibrium state x̄. The pair (x̄, ū) together define your operating point.
Step 2: Compute the Jacobian Matrix
For systems with multiple state variables, the single derivative f'(x₀) generalizes to a matrix of partial derivatives called the Jacobian. If your system has n state variables and m inputs, you compute two matrices by taking partial derivatives of every equation with respect to every state and every input, then evaluating at the equilibrium point:
A = ∂f/∂x evaluated at (x̄, ū), which is an n×n matrix
B = ∂f/∂u evaluated at (x̄, ū), which is an n×m matrix
These are constant matrices (just numbers, no variables) because you’ve plugged in the specific equilibrium values. The linearized system then takes the standard state-space form:
δẋ(t) = A·δx(t) + B·δu(t)
Here, δx = x − x̄ represents the deviation from the equilibrium state, and δu = u − ū is the deviation from the steady-state input. This is a key detail: the linearized system describes how perturbations evolve, not the absolute state values.
A Concrete Example: The Inverted Pendulum
The inverted pendulum is one of the most common linearization examples in control engineering. The nonlinear equations of motion, written in state-space form with x₁ = angle and x₂ = angular velocity, are:
ẋ₁ = x₂
ẋ₂ = −(Mgl / 2J) · sin(x₁) + (1/J) · T
where M is mass, g is gravity, l is length, J is the moment of inertia, and T is an applied torque. The nonlinearity is the sin(x₁) term.
To linearize around the upright position (x₁ = π), you approximate sin(x₁) near π. Since sin(π) = 0 and cos(π) = −1, the Taylor expansion gives sin(x₁) ≈ −(x₁ − π). Defining new deviation variables Δx₁ = x₁ − π and Δx₂ = x₂, the linearized system becomes:
Δẋ₁ = Δx₂
Δẋ₂ = (Mgl / 2J) · Δx₁ + (1/J) · T
In matrix form, the A and B matrices are:
A = [0, 1; Mgl/2J, 0] and B = [0; 1/J]
Notice the positive sign on Mgl/2J in the A matrix. This tells you the upright equilibrium is unstable: a small push away from vertical causes the pendulum to accelerate further away. That instability is exactly what a controller needs to counteract, and now you can design that controller using linear techniques.
When the Linear Model Is Trustworthy
A linearized model doesn’t always faithfully represent the original system, even near the equilibrium. The conditions under which it does are formalized by the Hartman-Grobman theorem, but the practical takeaways are more useful than the formal math.
The linearization reliably predicts stability when the equilibrium is “hyperbolic,” meaning all eigenvalues of the A matrix have nonzero real parts. If every eigenvalue has a negative real part, the nonlinear system is locally stable. If any eigenvalue has a positive real part, it’s locally unstable. In both cases, the linearized model gives you the correct answer about the system’s behavior near that equilibrium.
The linearization is not reliable when any eigenvalue of A has a real part of exactly zero. This happens in systems with purely oscillatory modes or neutral stability, where the nonlinear terms you dropped actually determine whether the system is stable or not. Systems with switching behavior or sharp thresholds can also violate the smoothness assumptions that linearization depends on.
Regardless of eigenvalue placement, the approximation is only valid locally. It tells you nothing about what happens far from the operating point. If your system experiences large disturbances that push the state well away from equilibrium, the linear model’s predictions will diverge from reality.
How Large Is the Error?
The error from linearization comes from the higher-order Taylor terms you discarded. For a single-variable function, the error is bounded by:
|error| ≤ (M₂ / 2) · h²
where h is the distance from the operating point and M₂ is the maximum value of the second derivative in that neighborhood. Two things matter here. First, the error grows with the square of the distance from the operating point, so doubling your distance roughly quadruples the error. Second, the error depends on how “curvy” the original function is. A function with a large second derivative (tight curvature) produces bigger linearization errors than a gently curving one.
In practice, you can check linearization accuracy by simulating both the nonlinear and linear models for the same input and comparing their outputs. If they diverge significantly for the disturbance sizes you expect, you either need to stay closer to the operating point or use a different approach entirely.
Linearization With Software Tools
For real-world systems with dozens of states, computing Jacobians by hand is impractical. MATLAB and Simulink provide automated linearization tools. In Simulink, you define your nonlinear model as a block diagram, specify the input and output points using analysis point markers, and then call the linearize function to extract a linear state-space model at a chosen operating condition.
The typical workflow involves three steps. First, you find a steady-state operating point by defining the conditions you want (for example, a specific output value) and using a trimming algorithm to solve for the corresponding state and input values. Second, you call the linearize function, which numerically computes the Jacobian at that operating point. Third, you receive a standard linear state-space model you can use directly with control design tools.
For batch linearization, the software can compute linear models at multiple operating points across a range of conditions, giving you a family of linear approximations that together cover a wider operating envelope. This is useful for gain-scheduled controller design, where you use a different linear controller at each operating condition.
The Full Procedure at a Glance
- Write the system in state-space form: Express all dynamics as first-order differential equations, dx/dt = f(x, u).
- Find the equilibrium: Set all derivatives to zero and solve for the state and input values where the system is stationary.
- Compute partial derivatives: Take the Jacobian of f with respect to states (giving the A matrix) and inputs (giving the B matrix), evaluated at the equilibrium.
- Define deviation variables: Rewrite the system in terms of δx = x − x̄ and δu = u − ū to get the linearized model δẋ = Aδx + Bδu.
- Verify validity: Check that eigenvalues of A have nonzero real parts, and confirm the linear model matches the nonlinear simulation for your expected range of perturbations.
Each step builds on the previous one, and skipping the equilibrium calculation or the validity check is a common source of errors. The linearized model is a tool with a specific range of usefulness, and knowing its boundaries is just as important as knowing how to derive it.