Explicit MPC & Function Approximation

• Explicit MPC is a control framework that pre-computes control laws offline by converting optimization problems into explicit mappings, ensuring rapid real-time performance.
• Various function approximation architectures—including PWA, lattice, neural networks, and kernel methods—offer distinct trade-offs in accuracy, complexity, and constraint handling.
• Practical applications in robotics, aerospace, and process control demonstrate that explicit MPC enables high-speed, certifiable control in systems with complex constraints and high dimensionality.

Explicit Model Predictive Control (MPC) refers to the paradigm in which the model-based finite-horizon optimization solved at each sampling instant in traditional MPC is instead “compiled” offline into an explicit mapping—most commonly a piecewise-affine (PWA) function or other parametric function approximator—that directly maps the current state, and potentially other predictions, to the optimal control input. This approach aims to eliminate the online computational burden of repeatedly solving optimization problems, enabling rapid and certifiable real-time implementations even for highly constrained or embedded systems. The development of explicit MPC thus naturally motivates the paper of function approximation architectures—such as polytopic partitions, lattice PWA forms, neural networks (NNs), kernel methods, and more—that can accurately, efficiently, and robustly embody these explicit control laws under the stringent requirements of control engineering.

1. Structural Foundations of Explicit MPC

Explicit MPC is rooted in offline solution of parameterized optimal control problems, such as multi-parametric quadratic programs (mp-QPs) for linear systems,

$$\min_{U} \quad \frac{1}{2}U^\top H U + x^\top F U \quad \text{s.t.} \quad G U \le W_x x + w_0,$$

where $x$ is the system state parameter. Under the standing assumptions of quadratic costs, polyhedral constraints, and system controllability, Bemporad and Morari showed that the optimal feedback policy $u^*(x)$ is a continuous piecewise-affine function defined over a polyhedral partition of the feasible state-space. For nonlinear systems, the optimizer is typically only available as an implicit nonlinear mapping, requiring either local linearization, gridding, or direct function approximation to achieve an explicit representation (Lovelett et al., 2018, Wang et al., 2023, Tokmak et al., 2023).

The curse of dimensionality manifests as a rapid, often exponential, increase in the number of partitions or regions as the plant dimension, constraint set cardinality, or horizon length grow. Thus, alternative function approximation architectures are deployed to compress, regularize, or even bypass the explicit enumeration of such partitions.

2. Piecewise-Affine and Lattice Approximation Methods

Piecewise-affine (PWA) architectures are the canonical explicit representation for linear or linearized MPC. Any continuous PWA map can be analytically encoded as either:

• A partitioned PWA (region-based): $u^*(x) = F_i x + g_i$ if $x \in R_i$, where $R_i$ is a polyhedral cell.
• A lattice (max-min) form: $$f(x) = \max_{i=1,...,M}\min_{j \in I_{\ge,i}} \ell_j(x)$$, where the $\ell_j$ are affine functions and the index sets encode the “literal ordering” in the unique order (UO) regions (Xu et al., 2021, Xu et al., 20 Mar 2024).

Lattice PWA approximations avoid explicit storing of regions; instead, the structure is defined by affine pieces and their dominance relations at sampled points. Under mild assumptions—viz. all critical affine pieces are sampled and each sample is interior to a UO-cell—the lattice max-min and min-max forms can be constructed to exactly match the original explicit MPC law, delivering error-free approximations. Offline complexity is polynomial in the sample count and dimension, and the online evaluation entails $O(\tilde N^2)$ time where $\tilde N$ is the (often much reduced) number of lattice terms needed after irredundant removal (Xu et al., 2021). For nonlinear or time-varying systems, lattice architectures are applied after successive linearization and local sampling, providing explicit controllers with significantly reduced computational and memory demands, as demonstrated for both mobile robots and satellite attitude systems (Wang et al., 2023, Xu et al., 20 Mar 2024).

Strategy	Offline Time (min)	Online Time (ms)	Error (m)
Linear MPC	–	5.5	0.0043
Explicit linear MPC	934.7	23.5	0.0043
Lattice PWA NMPC	18.8	0.056	0.0043

Table 1: Performance comparison on mobile robot circular-trajectory tracking (Wang et al., 2023).

3. Neural Network Function Approximators

Neural networks, notably feed-forward architectures with sigmoidal or ReLU activations, can closely approximate or exactly realize explicit MPC laws by exploiting the universal approximation property and the PWA structure of ReLU networks. For instance, ReLU-based architectures can represent any convex PWA function as a sequence of max or min operations implemented via layered ReLU activations and linear maps; more generally, any continuous PWA can be written as the difference of two convex PWA networks, yielding an exact realization in a neural network of depth proportional to the number of convex components and width $n+1$ ($n$=state dimension) (Fahandezh-Saadi et al., 2020, Teichrib et al., 2021).

In practical deployments, both the network topology (layer count, width, activation type) and the training dataset (MPC-generated state-input pairs) must be judiciously chosen. For instance, Kiš and Klaučo demonstrate a compact 3-4×4-1 fully connected network with sigmoidal-type activation achieving sub-percent optimality loss on a chemical reactor, with order-of-magnitude reductions in computational and memory requirements versus traditional online QP-based MPC (Kiš et al., 2019). Closed-loop testing on hundreds of randomized initial conditions confirms strict constraint satisfaction due to output projection onto feasible bounds.

Hybrid strategies such as the dual-mode NN approach embed a linear terminal control law on a maximal constraint-invariant set, thereby ensuring both global approximation power (where active-set changes make the policy highly non-smooth) and exact linear feedback in neighborhoods of the origin. Additional techniques such as safety governors and online convex projections are leveraged to guarantee recursive feasibility and robust constraint adherence for NN-based explicit controllers in high-dimensional systems (Mao et al., 21 Jul 2025).

4. Kernel and Manifold Learning Approaches

Kernel-based methods offer smooth, globally defined approximation with a priori error bounds. The ALKIA-X architecture builds a non-iterative, localized interpolant in a (piecewise) reproducing kernel Hilbert space (RKHS), automatically subdividing the state-space so that the power function times the RKHS norm bounds the worst-case error below a user-prescribed ε (Tokmak et al., 2023). This achieves uniform approximation error, fast online evaluation (tree search for local region, then kernel sum), and closed-loop certified stability, provided the original MPC law is robust to bounded disturbances.

Manifold learning approaches, such as diffusion maps, seek to discover a lower-dimensional intrinsic representation of the MPC policy manifold. Function approximators (polynomials, neural networks, or Gaussian processes) are then trained to map states to these intrinsic variables and from the intrinsic variables to the policy, reducing the curse of dimensionality and potentially improving generalization in the presence of complex active-set patterns (Lovelett et al., 2018).

5. Explicit MPC with Value Function and Reinforcement Learning Integration

Function approximation architectures can also target value functions or Q-functions rather than explicit policy mappings. For linear MPC, tailored ReLU-ANNs can represent piecewise-quadratic (PWQ) optimal value functions exactly by augmenting the input layer with quadratic monomials and arranging the hidden layer structure to “isolate” quadratic bumps in each region (Teichrib et al., 2021). This facilitates “myopic” or “short-horizon” MPC, in which a learned value function serves as a terminal cost for a shortened online optimization, offering substantial speedups while recovering near-optimal performance (Orrico et al., 23 Jan 2024).

In reinforcement learning, MPC-derived local Q-function approximations can be systematically blended with global value-function approximators using parameterized interpolations (TD(λ)-style recursions) (Bhardwaj et al., 2020). Here, neural function approximators are trained via supervised or reinforcement learning on state-action returns, and explicit control sequences are executed via online minimization over the resulting blended cost, granting a robust trade-off between model error and value approximation uncertainty.

6. Architectural Design Principles and Complexity Trade-offs

The efficacy of explicit MPC approximation architectures is governed by key choices:

• PWA/lattice vs. NN: For moderate dimensions or systems with relatively few partition regions, exact PWA or lattice approximations afford provable guarantees and rapid online evaluation. For high-dimensional or highly nonlinear regimes, neural networks or RKHS methods may generalize better and compress complexity.
• Sampling and Resampling: Uniform or adaptive sampling over the feasible domain, along with resampling to ensure coverage of all distinct local affine laws, is critical in lattice PWA and kernel constructions for error-free approximation (Xu et al., 2021).
• Hybridization and Constraint Handling: Dual-mode neural architectures, safety governors, and explicit projection layers are required to preserve hard constraint satisfaction and recursive feasibility under approximation error (Mao et al., 21 Jul 2025).
• Online Evaluation Cost: Forward evaluation in neural networks or lattice PWA controllers results in fixed, predictable latency, well suited for embedded or high-frequency operation, and outperforms traditional region-search or online QP solves (Kiš et al., 2019, Wang et al., 2023, Xu et al., 20 Mar 2024).

Representation Approach	Complexity Scaling	Deterministic Latency	Exactness on PWA	Constraint Handling
PWA (regions)	Exponential in n,N	Region search	Yes	Explicit
Lattice PWA	Polynomial+redundancy removal	Max-min operations	Yes (with resampling)	Explicit
Feed-forward NN	Poly in #params	Forward pass	Yes*	Explicit/projected
Kernel RKHS	Exponential (offline), poly (online)	Sum over local kernels	Yes (with enough samples)	Explicit
Transformer (seq.)	O(1) in horizon	Forward pass	No (approximate)	Post-processing

Table 2: Architectural and computational properties of key function approximation representations for explicit MPC (*exactness holds for sufficiently large, properly constructed ReLU networks in the PWA case).

7. Practical Applications and Future Directions

Explicit MPC via function approximation finds application in domains requiring high-speed, certifiable control: chemical process plants, automotive and autonomous vehicles, mobile robotics, and aerospace systems (Kiš et al., 2019, Wang et al., 2023, Xu et al., 20 Mar 2024, Wu et al., 9 Sep 2025). Transformer-based explicit MPC architectures offer unprecedented flexibility in variable-horizon and multi-context settings, producing entire optimized control sequences in constant time via bidirectional self-attention mechanisms and direct policy optimization (Wu et al., 9 Sep 2025). Safety-critical integration is realized through supporting structures such as kernel-based a priori approximation guarantees, safety governors, and closed-loop validation procedures.

Emerging trends include the blending of explicit MPC policies with reinforcement learning value functions, robustifying explicit controllers to modeling errors, and integrating manifold learning to exploit intrinsic policy low-dimensionality in high-dimensional state spaces (Bhardwaj et al., 2020, Lovelett et al., 2018). Limitations persist in scaling kernel and region-based representations to very high state dimensions, but structured neural architectures, local kernel models, and sampling-based lattice reduction continue to push the tractable frontier.

In sum, explicit MPC and the associated landscape of function approximation architectures provide a rigorous, extensible, and computationally efficient framework for deploying advanced model-based control in real-world, resource-constrained, and safety-critical systems.