Explicit Model Predictive Control

• Explicit MPC is a control strategy that computes the optimal feedback law offline, mapping the state to control via piecewise affine functions over polyhedral regions.
• It employs a multi-parametric quadratic programming approach to partition the state space, ensuring controllable transitions and performance guarantees even under finite precision quantization.
• Design guidelines derived from error analysis inform trade-offs in bit-width allocation and resource usage for robust implementation on embedded hardware.

Explicit Model Predictive Control (MPC) is a control strategy in which the optimal MPC feedback law is computed offline as an explicit mapping from system state to control action, removing the need for online numerical optimization. For constrained linear systems with quadratic cost and polyhedral constraints, explicit MPC results in the partitioning of the state space into a finite set of polyhedral regions, each associated with a unique affine control law. Implementation on resource-constrained hardware often requires controller data to be quantized, raising questions concerning the effect of finite word-length arithmetic on the accuracy of the computed control action. This article provides a detailed exposition of explicit MPC, with rigorous emphasis on the structure of its solution, error analysis under quantization, and resulting design guidelines.

1. Structure of Explicit MPC for Linear Systems

Explicit MPC for discrete-time, linear time-invariant systems with linear state and input constraints is formulated as a multi-parametric quadratic program (mpQP) in the initial state $x_0$. The system is governed by

$x_{k+1} = A x_k + B u_k$

subject to state constraints $H_x x_k \leq K_x$ and input constraints $H_u u_k \leq K_u$. The finite-horizon quadratic cost function is

$$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$

The mpQP is solved ahead of time via parametric programming, resulting in an explicit, piecewise affine (PWA) feedback law: $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$ Here, $\{P_i\}$ denote a partition of the admissible state space $\mathbb{R}^n$ into $n_r$ non-overlapping convex polyhedra. Each $P_i = \{x \mid H_i x \leq K_i\}$ is the intersection of $x_{k+1} = A x_k + B u_k$0 closed half-spaces. Continuity of $x_{k+1} = A x_k + B u_k$1 across shared facets is enforced by the structure of the parametric solution (Knyazev et al., 2015).

2. Quantization Effects and Notation

Controller implementation on digital hardware with restricted memory and computational capacities requires the representation of all controller data with finite-precision arithmetic. This is abstracted as applying a uniform scalar quantizer $x_{k+1} = A x_k + B u_k$2 to any real value $x_{k+1} = A x_k + B u_k$3, resulting in the quantized value $x_{k+1} = A x_k + B u_k$4 with $x_{k+1} = A x_k + B u_k$5. Every component of the explicit controller is quantized:

• Region definition matrices: $x_{k+1} = A x_k + B u_k$6, $x_{k+1} = A x_k + B u_k$7
• Control law parameters: $x_{k+1} = A x_k + B u_k$8, $x_{k+1} = A x_k + B u_k$9
• Measured state: $H_x x_k \leq K_x$0 Each perturbation is bounded: $H_x x_k \leq K_x$1, $H_x x_k \leq K_x$2, $H_x x_k \leq K_x$3, $H_x x_k \leq K_x$4, $H_x x_k \leq K_x$5 (Knyazev et al., 2015).

3. Analysis and Bounding of Control Error under Quantization

The central technical concern is to quantify the resulting maximal deviation $H_x x_k \leq K_x$6 as a function of $H_x x_k \leq K_x$7 and system parameters. Two situations are distinguished:

• Case A (same region): $H_x x_k \leq K_x$8 and $H_x x_k \leq K_x$9 remain in the same region $H_u u_k \leq K_u$0; the error is dominated by the quantization of $H_u u_k \leq K_u$1, $H_u u_k \leq K_u$2, and $H_u u_k \leq K_u$3, and admits a direct bound.
• Case B (facet crossing): $H_u u_k \leq K_u$4 and $H_u u_k \leq K_u$5 straddle a shared facet between $H_u u_k \leq K_u$6 and $H_u u_k \leq K_u$7; this "jump-over" scenario can cause a potentially higher error due to discontinuities in the region location computation.

For case B, assume the separating hyperplane is $H_u u_k \leq K_u$8, with quantization errors $H_u u_k \leq K_u$9, $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$0. Analysis yields

$$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$1

and $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$2, where $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$3 and $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$4. The control error bound is

$$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$5

where $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$6, $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$7 are the gain matrices of the adjacent regions, and $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$8 is the state dimension. The first term captures the facet-jump effect; the second is the quantization error in the affine law (Knyazev et al., 2015).

Two explicit upper bounds are provided:

• A posteriori: using the actually quantized controller coefficients, tighter but requires access to stored quantized data.
• A priori: conservative, using only norms of the unquantized controller data.

4. Bit-Width Selection Guidelines

To guarantee a prescribed control accuracy $$J = x_N^T P x_N + \sum_{j=0}^{N-1} (x_j^T Q x_j + u_j^T R u_j)$$9 over a compact domain $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$0, a control designer computes a monotonic upper bound $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$1 from the above expressions and solves $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$2 for the minimum required quantizer granularity $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$3. In fixed-point arithmetic, $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$4 fractional bits corresponds to $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$5. Advances involve the following practical techniques:

• Employ non-uniform precision: assign higher bit-widths to the most sensitive parameters (e.g., $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$6 on sensitive facets), lowering memory costs.
• Exploit a posteriori evaluation: after quantization, verify if the real bound is below the guarantee and potentially reduce $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$7 by 1–2 bits.
• Input normalization and facet scaling: rescaling $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$8 to satisfy $$u(x) = F_i x + G_i, \quad x \in P_i, \quad i = 1,\ldots,n_r$$9 and normalizing facets so $\{P_i\}$0 reduces the error margin $\{P_i\}$1, further decreasing required bit-width.
• Trade-off between ROM requirements and control fidelity: increased bits enhance accuracy but demand more storage and may slow region search.

5. Case Study: Quantitative Results for a Double-Integrator Example

A canonical double-integrator system, $\{P_i\}$2, with state and input bounds $\{P_i\}$3, $\{P_i\}$4, prediction horizon $\{P_i\}$5, and quadratic cost, is analyzed:

• The explicit controller partitions the state-space into 13 regions.
• Implementing a fixed-point format with $\{P_i\}$6, $\{P_i\}$7 (i.e., $\{P_i\}$8), the maximum control error observed is $\{P_i\}$9, with the a posteriori and a priori bounds at $\mathbb{R}^n$0 and $\mathbb{R}^n$1, respectively.
• Increasing the accuracy to $\mathbb{R}^n$2, $\mathbb{R}^n$3 ($\mathbb{R}^n$4), the observed maximal error decreases to $\mathbb{R}^n$5. These results confirm the theoretical predictions and illustrate the tradeoffs between bit-width, control error, and resource utilization (Knyazev et al., 2015).

6. Implications for Embedded Implementation and Design Practice

Explicit MPC provides an implementation pathway for constrained optimal control in environments where real-time optimization is impractical. The analytical error bounds derived for quantized explicit MPC directly inform hardware design:

• Control architects can specify memory and accuracy constraints upfront and solve for the required word length before deployment.
• The analysis reveals which control law regions, gain matrices, or polyhedral facets are susceptible to quantization-induced degradation, supporting fine-grained resource allocation.
• The procedure extends naturally to non-uniform quantizer allocation and hybrid microcontroller architectures. Ultimate memory vs. performance trade-offs and region-search complexity must be determined in context, using these quantization bounds to enable rigorous certification of embedded explicit MPC performance (Knyazev et al., 2015).

---

Key reference:

“Explicit model predictive control accuracy analysis” (Knyazev et al., 2015)