Model Predictive Control

Introduction

Model Predictive Control (MPC) is one of the most powerful and widely-used advanced control strategies in modern engineering. From chemical plants to self-driving cars, from building climate control to robotic locomotion, MPC has become the go-to approach when you need optimal control that respects real-world constraints.

What makes MPC special? In a nutshell, MPC uses a model of your system to predict what will happen in the future, then solves an optimization problem to find the best control actions. Unlike simpler controllers that only react to the current error, MPC thinks ahead.

This tutorial will build your understanding from the ground up. We'll start with the core idea, develop the mathematical formulation step by step, and build intuition for why MPC works so well in practice.

The Core Idea: Predict, Optimize, Apply

Imagine you're driving a car on a winding road. A simple reactive controller (like cruise control) only looks at your current speed and adjusts the throttle. But you, as a human driver, do something smarter: you look ahead at the road, anticipate the curves, and plan your speed and steering in advance.

MPC works exactly like this. At every moment, it:

The key insight is that while we compute an entire sequence of optimal future controls, we only actually apply the first one. Then we measure again, re-optimize, and repeat. This is called the receding horizon approach, and it's what makes MPC robust to model errors and disturbances.

Why Predict and Re-plan?

You might wonder: why not just compute the optimal control for all future time and be done with it? The answer is that real systems have:

• Model uncertainty: Our model isn't perfect — reality will diverge from predictions
• Disturbances: Unexpected things happen (wind gusts, load changes, etc.)
• Measurement updates: We get new information about the true state

By re-planning at each step, MPC incorporates new information and corrects for any deviations. It's like constantly updating your GPS route based on current traffic.

The System Model

MPC needs a model to make predictions. In discrete-time (the most common setting for MPC), we typically use a state-space model:

where $x_k \in \mathbb{R}^n$ is the state (everything we need to know about the system at time $k$), and $u_k \in \mathbb{R}^m$ is the control input (what we can manipulate). The function $f$ describes how the state evolves.

Linear Models

For many systems, or as an approximation around an operating point, we use linear models:

Here $A$ is the state transition matrix (how the state evolves on its own) and $B$ is the input matrix (how control affects the state). Linear MPC is computationally efficient because the resulting optimization problem is convex.

What Goes in the State?

The state $x_k$ should capture everything about the system's "memory" — everything needed to predict future behavior. For example:

• Mechanical system: positions and velocities
• Thermal system: temperatures at various points
• Chemical reactor: concentrations and temperatures
• Vehicle: position, velocity, heading angle

Prediction Over a Horizon

The heart of MPC is predicting the future. Given the current state $x_k$ and a sequence of planned control inputs $u_k, u_{k+1}, \ldots, u_{k+N-1}$, we can roll out the model to predict future states:

The number $N$ is called the prediction horizon (or control horizon). It determines how far ahead we look.

Choosing the Horizon

The prediction horizon $N$ is a crucial design choice:

• Too short: The controller is myopic — it can't anticipate problems until they're imminent
• Too long: Computationally expensive, and predictions far in the future become unreliable anyway
• Just right: Long enough to capture the relevant dynamics and constraints, short enough to be tractable

A good rule of thumb: the horizon should cover the system's "settling time" — how long it takes to respond to inputs.

The Cost Function

Once we can predict the future, we need to define what "good" means. This is done through a cost function (or objective function) that we want to minimize.

A typical MPC cost function penalizes:

• State deviation: How far are we from the desired state (setpoint)?
• Control effort: How much energy/actuation are we using?
• Control changes: How jerky are our control actions?

The standard quadratic cost function over the prediction horizon is:

Let's break this down:

• $Q \succeq 0$ is the state cost matrix — penalizes deviation from reference $x_{ref}$
• $R \succ 0$ is the input cost matrix — penalizes control effort
• $Q_f \succeq 0$ is the terminal cost matrix — extra penalty on the final predicted state

Tuning Q and R

The matrices $Q$ and $R$ let you express priorities:

• Large Q, small R: "Get to the target quickly, I don't care about control effort" → aggressive control
• Small Q, large R: "Save energy, I can be patient" → gentle, smooth control

Different diagonal entries in $Q$ let you prioritize some states over others (e.g., "temperature matters more than pressure").

Constraints: The MPC Superpower

Here's where MPC truly shines compared to simpler controllers. Real systems have constraints — physical limits that must not be violated:

• Input constraints: Actuator limits (max motor torque, valve positions 0-100%)
• State constraints: Safety limits (max temperature, min tank level)
• Rate constraints: How fast things can change (acceleration limits)

MPC handles these directly in the optimization:

These constraints must hold for all $i = 0, 1, \ldots, N-1$ in the prediction horizon.

Why Constraints Matter

Consider a classic example: controlling the temperature of a chemical reactor. Without constraints, an optimal controller might command the heater to go to 200% power (impossible) or cool so fast that thermal shock damages the equipment (dangerous).

MPC finds the best control that respects all constraints. It automatically backs off when hitting limits, and it plans ahead to avoid constraint violations before they happen.

The Optimization Problem

Putting it all together, at each time step $k$, MPC solves:

This is a constrained optimization problem. The decision variables are the $N$ future control inputs. The dynamics act as equality constraints linking states to inputs.

Solving the Problem

For linear MPC (linear model, quadratic cost, linear constraints), this is a Quadratic Program (QP) — a well-studied problem class with efficient solvers. Modern QP solvers can handle hundreds of variables in milliseconds, enabling real-time control.

For nonlinear MPC (nonlinear model or constraints), we get a general nonlinear program (NLP). These are harder but still tractable with modern solvers for many applications.

Dense vs. Sparse Formulations

There are two common ways to set up the QP:

• Dense: Eliminate state variables using the dynamics, optimize only over inputs. Smaller problem but dense matrices.
• Sparse: Keep both states and inputs as variables with dynamics as constraints. Larger problem but sparse structure that specialized solvers exploit.

How MPC Actually Solves the Problem

Now let's get into the mathematical heart of MPC — how do we actually find the optimal control sequence? There are two elegant approaches: Dynamic Programming (working backwards via Bellman's equation) and Batch Optimization (solving one big quadratic program). Both give the same answer, but offer different insights.

Approach 1: Dynamic Programming and the Bellman Equation

Just like in LQR, we can use Bellman's principle of optimality. Define the cost-to-go (or value function) $V_i(x)$ as the optimal cost starting from state $x$ with $i$ steps remaining in the horizon:

This says: the optimal cost with $i$ steps to go equals the immediate cost plus the optimal future cost, minimized over the current control $u$.

We solve this backwards in time, starting from the terminal condition:

This is the terminal cost — when there are zero steps remaining, we just pay the final state penalty.

The Quadratic Structure Propagates Backwards

Here's the beautiful part (just like LQR): if we assume the cost-to-go is quadratic, $V_i(x) = x^T P_i x$, then the Bellman equation preserves this structure. Let's verify by substituting into the Bellman equation:

Expanding the quadratic term $(Ax + Bu)^T P_{i-1} (Ax + Bu)$:

So our minimization becomes:

This is a quadratic function in $u$ with no constraints (for now). To minimize, we take the gradient with respect to $u$ and set it to zero:

Solving for the optimal control:

The Riccati Recursion

Substituting $u^*_i$ back into the cost expression, after some algebra, we find that $V_i(x) = x^T P_i x$ where $P_i$ satisfies the discrete-time Riccati recursion:

Starting from $P_0 = Q_f$ and iterating backwards $i = 1, 2, \ldots, N$, we get the sequence of cost matrices $P_0, P_1, \ldots, P_N$ and corresponding gains $K_1, K_2, \ldots, K_N$.

This is exactly the same Riccati equation as LQR, but we run it for a finite number of steps rather than until convergence.

Connection to LQR

What happens if we let $N \to \infty$? The Riccati recursion converges to a steady-state $P_\infty$, and all gains become identical: $K_i \to K_\infty$. This is exactly the infinite-horizon LQR solution!

But What About Constraints?

The dynamic programming approach gives us the unconstrained solution elegantly. But MPC's real power is handling constraints. With constraints like $u_{min} \leq u \leq u_{max}$, we can no longer just set the gradient to zero — the optimal $u$ might be at a constraint boundary.

This is where the batch QP formulation becomes essential.

Approach 2: The Batch Quadratic Program

Instead of solving backwards in time, we can stack everything into one big optimization problem. Define the stacked vectors:

The dynamics $x_{k+1} = Ax_k + Bu_k$ can be written in matrix form. Starting from $x_0$:

Or compactly: $\mathbf{X} = \mathbf{A} x_0 + \mathbf{B} \mathbf{U}$

The cost function becomes a quadratic in $\mathbf{U}$:

where $\bar{Q} = \text{diag}(Q, Q, \ldots, Q, Q_f)$ and $\bar{R} = \text{diag}(R, R, \ldots, R)$.

Substituting $\mathbf{X} = \mathbf{A} x_0 + \mathbf{B} \mathbf{U}$:

Expanding and collecting terms:

This is a quadratic function in $\mathbf{U}$: $J = \mathbf{U}^T H \mathbf{U} + 2 x_0^T F^T \mathbf{U} + \text{const}$

The QP with Constraints

Now we add constraints. Input constraints $u_{min} \leq u_k \leq u_{max}$ become:

State constraints $x_{min} \leq x_k \leq x_{max}$ become (using $\mathbf{X} = \mathbf{A} x_0 + \mathbf{B} \mathbf{U}$):

Rearranging: $\mathbf{x}_{min} - \mathbf{A} x_0 \leq \mathbf{B} \mathbf{U} \leq \mathbf{x}_{max} - \mathbf{A} x_0$

The complete MPC problem is now a standard Quadratic Program (QP):

where $H = \mathbf{B}^T \bar{Q} \mathbf{B} + \bar{R}$, $f = \mathbf{B}^T \bar{Q} \mathbf{A} x_0$, and $G, w$ encode all the inequality constraints.

Solving the QP: How the Algorithms Actually Work

We've reduced MPC to solving a Quadratic Program at each time step. But how do QP solvers actually find the optimal $\mathbf{U}^*$? Let's build intuition for the three main approaches.

The Geometry of Constrained Optimization

First, visualize what we're doing. The cost function $J(\mathbf{U}) = \frac{1}{2}\mathbf{U}^T H \mathbf{U} + f^T \mathbf{U}$ is a bowl in the space of control sequences. Without constraints, the minimum is at the bottom of the bowl:

But constraints carve out a feasible region — a polytope (multi-dimensional polygon) defined by the linear inequalities $G\mathbf{U} \leq w$. The constrained optimum is either:

• Inside the feasible region: Same as unconstrained (constraints don't matter)
• On the boundary: The bowl's minimum is outside, so we slide along the boundary to find the best feasible point

Method 1: Active Set Methods

Core idea: Guess which constraints are active, solve the resulting equality-constrained problem, then update our guess.

Imagine you're at a point inside the feasible region. You want to roll downhill on the cost bowl, but walls (constraint boundaries) might block you. The active set method works like this:

The equality-constrained subproblem is easy to solve. If active constraints are $A_{eq}\mathbf{U} = b_{eq}$, we form the KKT system:

This is just a linear system — solve it with standard linear algebra!

Lagrange multipliers $\lambda_i$ have a beautiful interpretation: they measure the "cost" of a constraint. If $\lambda_i > 0$, the constraint is actively limiting us (removing it would improve the cost). If $\lambda_i < 0$, something's wrong — the constraint is in our working set but shouldn't be active.

Pros: Finite convergence (for convex QPs), exact solution, exploits warm-starting (if constraints don't change much between MPC steps, the active set is similar)

Cons: Worst-case exponential in number of constraints (rare in practice), needs a feasible starting point

Method 2: Interior Point Methods

Core idea: Instead of walking along constraint boundaries, stay strictly inside the feasible region and approach the boundary smoothly.

Interior point methods replace the hard inequality constraints with a soft barrier function that goes to infinity as you approach the boundary:

The log barrier $-\log(w_i - g_i^T \mathbf{U})$ is:

• Small when far from the constraint boundary
• Huge (approaching $+\infty$) as you get close to the boundary

The parameter $\mu > 0$ controls the "strength" of the barrier. For large $\mu$, the barrier dominates and we stay far from boundaries. As $\mu \to 0$, the barrier weakens and we can approach the true constrained optimum.

Newton's method for the barrier subproblem linearizes the optimality conditions. At each Newton step, we solve:

where $S$ is a diagonal matrix of slacks and $\Lambda$ is diagonal Lagrange multipliers. Don't worry about the details — the key point is it's still just a linear system!

Pros: Polynomial complexity (guaranteed efficient), handles many constraints well, numerically stable

Cons: Each iteration is expensive (large linear systems), less suited for warm-starting, needs strictly feasible start

Method 3: ADMM and First-Order Methods

Core idea: Avoid solving big linear systems altogether. Use only matrix-vector multiplications and simple operations.

ADMM (Alternating Direction Method of Multipliers) splits the problem into easier pieces. Rewrite our QP as:

where $\mathcal{I}_{\mathcal{C}}(\mathbf{z})$ is the indicator function of the constraint set: 0 if $\mathbf{z} \leq w$, infinity otherwise.

ADMM forms the augmented Lagrangian and alternates between optimizing over $\mathbf{U}$ and $\mathbf{z}$:

Why is this good?

• The U-update solves a fixed linear system $(H + \rho G^T G)$ — we can pre-factorize it!
• The z-update is embarrassingly simple: just clipping values
• Each iteration is cheap; we trade iteration count for per-iteration cost

Pros: Simple operations, low memory, excellent for embedded systems, warm-starting friendly

Cons: Slow convergence to high accuracy (but often good enough for MPC), needs tuning of $\rho$

Which Solver Should You Use?

What the Solution Looks Like

The QP solver returns the optimal control sequence $\mathbf{U}^* = [u_0^*, u_1^*, \ldots, u_{N-1}^*]^T$. We extract and apply only $u_0^*$.

When no constraints are active, the solution is the unconstrained optimum:

This is linear in $x_0$, so extracting the first component gives $u_0^* = -K x_0$ — exactly what dynamic programming predicted!

When constraints are active, the solution is more complex — it's piecewise affine in $x_0$. The state space is partitioned into regions, and in each region the optimal control is an affine function of the state (but with different coefficients in each region).

Summary: Two Views, One Solution

Both approaches reveal that MPC finds a control that balances immediate cost against future cost, respecting the system dynamics. The batch QP is what's actually implemented in practice because it handles constraints directly.

MPC vs. LQR: What's the Difference?

If you know about the Linear Quadratic Regulator (LQR), you might wonder how MPC compares. They're related but serve different purposes:

The Connection

Interestingly, unconstrained linear MPC with infinite horizon is equivalent to LQR. The MPC solution would be $u_k = -Kx_k$ where $K$ is the LQR gain. In this sense, MPC generalizes LQR to handle constraints and finite horizons.

In practice, when constraints aren't active, a well-tuned MPC behaves similarly to LQR. The power of MPC emerges when you need to push the system hard and constraints become active.

Summary: The MPC Recipe

Let's consolidate everything into the complete MPC picture:

Where is MPC Used?

MPC has found success in countless applications:

• Process industries: Chemical plants, refineries, power generation
• Automotive: Adaptive cruise control, autonomous driving, engine management
• Aerospace: Spacecraft attitude control, aircraft autopilots
• Robotics: Legged locomotion, manipulation, drone control
• Buildings: HVAC optimization, energy management
• Finance: Portfolio optimization (a form of MPC!)

Next Steps

To deepen your understanding, explore:

• Stability guarantees: Terminal constraints and costs that ensure closed-loop stability
• Robust MPC: Handling model uncertainty explicitly
• Stochastic MPC: Dealing with probabilistic disturbances
• Explicit MPC: Pre-computing the solution as a piecewise affine function
• Nonlinear MPC: Handling nonlinear dynamics and constraints