Model Predictive Control (MPC) is one of the most successful paradigms in modern control theory. Its core appeal lies in its foresight: instead of simply reacting to current errors, an MPC controller uses a mathematical model of a system to predict future behavior over a specified horizon, optimizing a sequence of control inputs to minimize a cost function while explicitly respecting physical constraints.
However, this predictive power comes with a severe catch. Rather than computing a control law offline, MPC requires solving a complex constrained optimization problem online, at every single time step. As systems become more complex, highly nonlinear, or subject to uncertainty, this online optimization quickly becomes a computational bottleneck, preventing its deployment in high-frequency or resource-constrained applications.
To bring advanced MPC to real-time systems, researchers focus on a shared goal: mitigating or bypassing this computational burden without sacrificing safety or performance guarantees.
The Roots of the Computational Bottleneck
To understand how researchers accelerate MPC, we must first look at what makes the underlying optimization scale poorly. The computational complexity of MPC generally blows up along three dimensions:
- Prediction Horizon ($P$): Looking further into the future allows the controller to make more strategic decisions, but it expands the number of decision variables. As noted by Jiaqi Meng et al., selecting the horizon length forces a strict trade-off: longer horizons improve long-term tracking but increase the computational load, slowing down the system's reaction time.
- Nonlinear Dynamics (NMPC): When a system's dynamics are nonlinear—such as the mechanics of a snake robot (Ji Yin et al.) or an articulated ground vehicle (Erkan Kayacan et al.)—the optimization problem becomes non-convex. Solvers must navigate complex cost landscapes, often requiring iterative algorithms like Sequential Quadratic Programming (SQP) or Iterative Linear Quadratic Regulators (iLQR) that are too slow for millisecond-level control loops (Sleiman Safaoui et al.).
- Robustness and Uncertainty: Operating in the real world means accounting for disturbances and model mismatches. Robust formulations, such as min-max MPC (Zhenghong Yu et al.) or Gaussian Process-based MPC (Andrea Zanelli et al.), must optimize over sets of trajectories or propagate probability distributions. Computing these uncertainty bounds (or "tubes") online adds massive mathematical overhead (Jerome Sieber et al.).
Strategy 1: Asynchronous and Parallel Decoupling
One intuitive way to solve a heavy computational problem is to break it apart and solve the pieces at different speeds or across multiple processors.
In robust control, a major source of latency is calculating how uncertainty propagates over time. Jerome Sieber et al. address this by introducing an asynchronous computation strategy for tube-based MPC. Instead of forcing the controller to calculate both the nominal trajectory and the uncertainty tubes simultaneously within a single tight control loop, they split the math. The intensive tube calculations run in a separate, slower background process, while the nominal trajectory planner runs at a high frequency. This decoupling keeps the controller highly responsive while maintaining safety bounds.
[ Slow Background Process ] ---> Computes Uncertainty Tubes (Asynchronous)
|
v
[ Fast Real-Time Loop ] ---> Optimizes Nominal Trajectory (High Frequency)
For large-scale stochastic problems, such as batch crystallization processes, the optimization can be cast as a massive tree of scenarios. Jia Kang et al. exploit this structure by using a parallel Schur complement method. By distributing the scenario blocks across parallel processors, they achieve the computational speedups necessary to make robust online optimization practical.
Strategy 2: Policy Approximation and Offline Learning
If solving an optimization problem online is too slow, an alternative is to solve it thousands of times offline and train a machine learning model to mimic the optimal control law. At runtime, evaluating a neural network or a lookup table is orders of magnitude faster than running an optimization solver.
However, standard behavior cloning focuses on minimizing the statistical fitting error, which can lead to catastrophic failures if the network makes a small mistake that violates a safety constraint. To fix this, Yi Cao 0002 et al. propose a cost-guided learning framework. Instead of training the neural network to match the exact control inputs of the MPC solver, they train it to directly minimize the closed-loop operational cost. This ensures that the approximated policy retains tight performance and safety guarantees while executing instantly.
Another way to shift the computational burden offline is through smart trajectory parametrization. Gregor Goebel et al. introduce state-dependent input parametrizations for nonlinear MPC. By learning how the structure of the input trajectory changes relative to the system's state offline, they drastically reduce the number of decision variables that the online solver needs to optimize, achieving near-optimal performance with minimal online effort.
Strategy 3: Reformulating the Optimization Space
Sometimes, the bottleneck isn't the solver or the hardware, but how the control problem is mathematically framed. By changing the variables we optimize over, we can make the optimization landscape inherently easier to traverse.
A prime example of this is System Level Synthesis (SLS). Traditional robust MPC optimizes over control inputs ($u$) to counteract disturbances ($w$), which couples the system's states and inputs in a complex, non-convex manner over time. Shaoru Chen et al. leverage SLS to reformulate the optimization to search directly over the closed-loop system responses (how the state and input respond to a disturbance). This mathematical shift linearizes the effect of uncertainties, resulting in a formulation that is significantly less conservative and computationally lighter than traditional tube-MPC.
Similarly, tracking moving targets can cause feasibility issues if the target jumps outside the system's physical capabilities. Pablo Krupa et al. analyze MPC formulations that use an "artificial reference" as an internal decision variable. The optimization smoothly manages the path to the true target, guaranteeing stability and feasibility even during sudden reference changes, though the authors note that care must be taken as adding these reference variables can increase the optimization size.
Strategy 4: Model Order Reduction
When controlling systems governed by complex physics—such as fluid dynamics, thermal fields, or chemical concentrations—the system state is governed by partial differential equations (PDEs). Discretizing these equations results in thousands or millions of state variables, making online MPC impossible.
To overcome this, researchers use Model Order Reduction (MOR) to compress the high-dimensional state space into a compact, low-dimensional approximation that captures the essential dynamics. Gianluigi Rozza utilizes a POD-Galerkin approach to project time-dependent linear-quadratic optimal control problems into a low-dimensional saddle-point formulation. By reducing the mathematical complexity of the underlying physics equations, the optimization can be solved rapidly, opening the door for real-time control of complex physical phenomena.