Learning Predictive Control (LPC)

• Learning Predictive Control (LPC) is a framework that embeds iterative, data-driven learning within predictive control schemes to enhance performance and robustness.
• It combines finite-horizon optimization with the adjustment of terminal costs, safe sets, or policies to guarantee recursive feasibility and asymptotic stability.
• Variants include LMPC, LBMPC, and model-free approaches, which are applied in domains such as robotics, building control, autonomous driving, and energy management.

Searching arXiv for recent and foundational papers on Learning Predictive Control and closely related LMPC/LBMPC formulations. First, I’ll retrieve a broad set of LPC / LMPC / LBMPC papers relevant to iterative tasks, robustness, Koopman-based formulations, and multi-objective variants. Learning Predictive Control (LPC) denotes a family of receding-horizon control schemes in which data-driven learning modifies predictive-control ingredients across repeated task executions or during online operation. In the cited arXiv literature, LPC appears concretely as Learning Model Predictive Control (LMPC) for iterative constrained tasks (Rosolia et al., 2017), Learning-Based Model Predictive Control (LBMPC) with separate safety and learned-performance models (Aswani et al., 2011), robust and periodic LMPC variants for uncertain systems and building operation (Rosolia et al., 2019, Shi et al., 2020), output-lifted robust LMPC for difference-flat nonlinear systems (Nair et al., 2023), multi-objective LMPC (Nair et al., 2024), neural and differentiable predictive controllers (Mukherjee et al., 2022), neural-network-supported MPC tuned by Bayesian optimization (Hirt et al., 2024), deep-Koopman LPC for autonomous vehicle motion planning (Zhang et al., 6 Jun 2026), and model-free online LPC for nonlinear systems without explicit dynamics (Zhang et al., 14 Mar 2025). Across these formulations, the common structure is finite-horizon prediction combined with learning from historical or online data to refine terminal ingredients, models, policies, or cost shaping while preserving feasibility, robustness, or stability properties.

1. Scope and recurring mathematical structure

A canonical LPC problem is a constrained optimal control problem for a discrete-time system. In iterative LMPC for linear systems, the plant is

$$x_{t+1}=Ax_t+Bu_t,\qquad x_t\in\mathbb{R}^n,\ u_t\in\mathbb{R}^m,$$

with convex state and input constraint sets, repeated from the same initial condition $x_S$, and with objective

$$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$

where $h$ is continuous, jointly convex, and positive definite around a feasible equilibrium $x_F$ (Rosolia et al., 2017). In robust LBMPC, the true system is

$x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$

with bounded modeling error $g(x,u)\in\mathcal{W}$, and the optimization is performed over a finite horizon while safety is enforced through tube MPC ingredients computed from a nominal disturbed model (Aswani et al., 2011). In periodic building control, the repeated task is one day of operation for a discrete-time linear time-varying periodic system

$x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$

with bounded stochastic disturbances and periodic polytopic constraints (Shi et al., 2020). In model-free online LPC, the plant is an unknown nonlinear system

$x_{k+1}=f(x_k,u_k),$

and the finite-horizon predictive-control problem is rewritten directly in terms of value and Q-functions rather than an explicit prediction model (Zhang et al., 14 Mar 2025).

The learned object is not unique across the literature. In some formulations, LPC learns terminal sets and terminal value approximations while keeping the dynamics fixed (Rosolia et al., 2017). In others, it learns a disturbance oracle or disturbance support while preserving a nominal robust core (Aswani et al., 2011, Nair et al., 2023). Neural variants may instead learn an explicit predictive policy, a Lyapunov certificate, or a stage-cost parametrization inside an MPC loop (Mukherjee et al., 2022, Hirt et al., 2024). This breadth explains why LPC is better understood as an architectural principle—learning embedded in a predictive controller—than as a single algorithm.

2. Canonical iterative LMPC construction

The most influential LPC template in the supplied corpus is the reference-free LMPC for constrained linear systems performing an iterative task. At each iteration $j$, the controller stores the realized state trajectory $x_S$0, input trajectory $x_S$1, and cost-to-go

$x_S$2

From successful iterations,

$x_S$3

it forms the sampled safe set

$x_S$4

and then the convex safe set

$x_S$5

A barycentric terminal cost is defined on $x_S$6 by solving a linear program over convex coefficients $x_S$7, yielding a convex data-driven approximation of the infinite-horizon value function. The online LMPC at time $x_S$8 of iteration $x_S$9 solves

$$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$0

subject to linear dynamics, state and input constraints, and the terminal constraint $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$1, and then applies the receding-horizon control $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$2 (Rosolia et al., 2017).

This construction yields the characteristic LMPC guarantees. Because $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$3 is control invariant and nonempty, recursive feasibility follows. Because the barycentric terminal cost acts as a terminal Lyapunov function and the stage cost is positive definite, the optimal finite-horizon cost decreases along the closed-loop trajectory, which implies asymptotic stability of $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$4. Across iterations, the total cost satisfies

$$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$5

so performance is monotone non-increasing (Rosolia et al., 2017).

The multi-objective extension preserves this iterative structure while replacing the scalar cost with $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$6 convex objectives $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$7. MO-LMPC still builds a convex safe set from past states, but now constructs per-objective terminal cost estimates $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$8 by barycentric interpolation and solves a scalarized MPC with weights $$J_{0\rightarrow\infty}^*(x_S)=\min_{u_0,u_1,\ldots}\sum_{k=0}^{\infty} h(x_k,u_k),$$9, together with additional per-objective inequality constraints ensuring that each finite-horizon objective estimate is no worse than the previous iteration. The resulting controller is recursively feasible, asymptotically stabilizing, improves every objective between iterations, and the converged policy is Pareto optimal (Nair et al., 2024).

3. Safety and robustness architectures

A central line of LPC research separates safety from performance. In LBMPC, the true system

$h$0

is controlled using two models. The nominal model

$h$1

is used for all constraint tightening, tube construction, and terminal invariance, whereas the learned model

$h$2

is used in the cost. Tube sets $h$3 and a maximal disturbance-invariant set $h$4 define the robust feasible region. The optimization enforces all state and input constraints on the nominal model and minimizes a nonnegative Lipschitz cost on the learned trajectory. This decoupling yields deterministic recursive feasibility, robust constraint satisfaction, and robust asymptotic stability under mild assumptions on the oracle. Under sufficient excitation and identifiability, the LBMPC control law converges in probability to the control law of an MPC using the true dynamics (Aswani et al., 2011).

Robust LMPC for uncertain linear iterative tasks extends the terminal-learning idea to systems with bounded additive disturbance. Instead of using visited states directly, it constructs robust reachable sets around stored trajectories under previously computed disturbance-feedback policies, forms a robust convex safe set from the vertices of these reachable sets, and defines a robust Q-function by dynamic programming over those vertices. The controller combines disturbance-feedback actions in the early part of the horizon with a learned safe policy in the tail, and selects the switching point through an adaptive prediction horizon. The resulting closed loop guarantees recursive robust constraint satisfaction, input-to-state stability with respect to a robust invariant set $h$5, monotone improvement of a learned performance upper bound, and domain enlargement over iterations (Rosolia et al., 2019).

Periodic and nonlinear robust variants preserve the same philosophy while changing the objects being learned. For building control with periodically correlated disturbances, the disturbance is decomposed into a low-frequency Fourier or Karhunen–Loève component $h$6 and a residual white-noise term, tube MPC handles the residual, and historical trajectories are shifted across disturbance parameters using feasible disturbance sets $h$7 to construct time-indexed safe sets $h$8 and Q-functions $h$9. Recursive feasibility is maintained for all times and iterations, and the closed-loop daily cost is upper-bounded by any feasible shifted historical trajectory (Shi et al., 2020). For nonlinear systems with additive unmodelled dynamics, robust output-lifted LMPC exploits difference flatness, learns an ellipsoidal outer bound on the disturbance set from data, computes an RPI tube, enlarges tightened constraints across iterations, and constructs a convex safe set and convex value-function approximation in the space of output sequences. This yields robust constraint satisfaction, asymptotic convergence to a desired subset of the state space, and non-decreasing closed-loop performance at each policy update (Nair et al., 2023).

4. Learned ingredients beyond classical terminal learning

Later LPC work broadens the learned component beyond terminal sets and terminal costs. One direction learns the objective inside a predictive controller rather than the value function after the horizon. In neural-network-supported MPC with safe closed-loop learning, the prediction model, horizon, and constraints are fixed, while the stage cost is parameterized by a feedforward neural network and tuned by Bayesian optimization on closed-loop experiments. The learning problem is constrained by a black-box stability metric encoding $x_F$0-practical asymptotic stability, and Gaussian-process confidence bounds are placed directly in the acquisition function. The result is probabilistically safe and stable closed-loop learning of MPC cost parameters under model–plant mismatch (Hirt et al., 2024).

Another direction learns the policy itself while preserving predictive-control structure. Neural Lyapunov Differentiable Predictive Control parameterizes an explicit neural predictive policy and a neural Lyapunov function, embeds system dynamics, state and input constraints, and Lyapunov decrease constraints into one differentiable computational graph, and trains both objects offline by automatic differentiation. Constraint violations and Lyapunov violations enter as differentiable penalties, and a sampling-based Hoeffding bound yields a statistical guarantee that a prescribed fraction of initial conditions satisfy constraints and Lyapunov decrease with high probability (Mukherjee et al., 2022). A related constrained deep-learning formulation learns nonlinear MPC policies with constrained neural-network training, derives recursive feasibility and robust stability conditions, and reports probabilistic feasibility and optimality empirical guarantees (Asadi, 2021).

Autonomous-driving LPC introduces yet another learned ingredient: the predictive state representation. In deep-Koopman LPC for motion planning, a deep encoder lifts nonlinear vehicle dynamics into a linear observable space,

$x_F$1

and finite-horizon actor–critic learning produces a closed-loop state-feedback policy over the prediction interval rather than an open-loop input sequence. Nonconvex road and obstacle constraints are replaced by convex local surrogate representations and potential-field functions whose values and gradients are embedded directly into actor and critic outputs (Zhang et al., 6 Jun 2026). A related representation-learning strand shows that explicit next-observation prediction can be replaced with predictive coding, yielding a decoder-free controllable latent-space model whose latent dynamics are amenable to locally-linear control (Shu et al., 2020).

At the opposite end of the model-knowledge spectrum, model-free online LPC dispenses with explicit dynamics. A finite-horizon optimal-control problem is expressed directly in terms of stage-wise Q-functions and stage-wise actor policies. Both are updated online from an offline dataset and streaming transitions, and an OCP-based optimizer is used in the actor–critic update loop. The paper establishes super-linear convergence of the parameter-update algorithm and uses the first-stage actor as the receding-horizon control law (Zhang et al., 14 Mar 2025).

5. Applications and empirical evidence

The empirical record in the supplied literature is broad and methodologically heterogeneous. In the original convex LMPC for constrained linear systems, a constrained LQR example with

$x_F$2

showed convergence to a steady trajectory by iteration $x_F$3 for $x_F$4 and $x_F$5, with iteration costs decreasing from $x_F$6 at $x_F$7 to $x_F$8 at $x_F$9. Comparison with the exact constrained LQR solution gave a maximum state deviation $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$0 and relative cost difference $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$1. The paper also reported a substantial computational benefit from convexifying the terminal set: the original sampled-safe-set LMPC required about $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$2 hours to converge, whereas the convex LMPC required $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$3 seconds to converge to the same optimal solution (Rosolia et al., 2017). In the robust linear iterative setting, a disturbed double integrator benchmark reduced certainty-equivalent iteration cost from $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$4 to $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$5, while the data-based safe policy achieved about $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$6 higher average cost than full LMPC but reduced per-step computation from about $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$7 s to about $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$8 ms (Rosolia et al., 2019).

Transportation applications are equally prominent. In eco-driving, a predictive cruise controller based on LMPC for a vehicle traveling along the same route every day enforced a fixed arrival time and reduced normalized fuel cost by about $x_{n+1}=Ax_n+Bu_n+g(x_n,u_n),$9 by the eighth trip, while learning a velocity profile that was higher on downhill sections and lower on uphill sections (Kim et al., 2019). For connected autonomous vehicles and platooning, LMPC was adapted to dynamic environments and data-driven communication variables, using an outer-loop candidate trajectory and an inner short-range LMPC. Historical data were used to construct dynamic safe sets and communication-aware cost-to-go terms, so that the follower learned to avoid communication dead zones while maintaining safety constraints (Jafarzadeh et al., 2019).

Building control furnishes a major application domain for robust LPC. In the original LBMPC building experiments, a single-room testbed achieved up to $g(x,u)\in\mathcal{W}$0 energy savings on warm days and $g(x,u)\in\mathcal{W}$1 on cool days relative to a baseline thermostat controller, while a seven-floor office building achieved about $g(x,u)\in\mathcal{W}$2 MWh/day savings (Aswani et al., 2011). In robust periodic LMPC for building control, the single-zone example used a daily period $g(x,u)\in\mathcal{W}$3, a prediction horizon $g(x,u)\in\mathcal{W}$4, periodic comfort and price signals, and disturbances decomposed into structured periodic components plus residual white noise; the difference between optimal robust daily cost and closed-loop LMPC cost decreased over iterations, and room-temperature trajectories approached the optimal daily trajectory for each disturbance realization (Shi et al., 2020).

Autonomous-driving results emphasize both safety and runtime. Deep-Koopman LPC was evaluated in four simulation scenarios and on the HongQi E-HS3 platform. In the straight-road static-obstacle scenario, the reported safety index was $g(x,u)\in\mathcal{W}$5 for LPC versus $g(x,u)\in\mathcal{W}$6 for both CBF-MPC and LMPCC, the real-time index was approximately $g(x,u)\in\mathcal{W}$7–$g(x,u)\in\mathcal{W}$8 for LPC, and the comfort index improved relative to the baselines. In real-world straight-road double-obstacle avoidance, LPC achieved $g(x,u)\in\mathcal{W}$9, $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$0, and $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$1, whereas CBF-MPC yielded $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$2, $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$3, and $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$4. In the curved-road paved-to-gravel transition, LPC achieved $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$5, $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$6, and $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$7, versus $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$8, $x_{t+1}=A_t x_t + B_t u_t + C_t w_t,$9, and $x_{k+1}=f(x_k,u_k),$0 for CBF-MPC (Zhang et al., 6 Jun 2026).

6. Conceptual boundaries, misconceptions, and open directions

A recurring misconception is that LPC is synonymous with reinforcement learning. In the canonical LMPC formulation, learning concerns the terminal safe set and terminal cost, and the controller is explicitly reference-free: there is no pre-specified reference trajectory, no tracking-error penalty, and the target trajectory emerges as the solution of the constrained optimal-control problem itself (Rosolia et al., 2017). In LBMPC, learning is similarly subordinate to a predictive-control backbone: the oracle affects the cost and learned dynamics, but all robustness calculations remain attached to a nominal model with bounded disturbance, so safety does not depend on identification quality (Aswani et al., 2011). By contrast, newer online LPC formulations can be genuinely model-free and actor–critic based, but they still retain a finite-horizon Bellman or Q-function structure rather than a purely infinite-horizon policy-search perspective (Zhang et al., 14 Mar 2025).

A second misconception is that LPC always learns the plant model. The papers surveyed here show a more diverse taxonomy. Some methods learn terminal ingredients only (Rosolia et al., 2017, Rosolia et al., 2019); some learn disturbance structure and safe sets (Shi et al., 2020, Nair et al., 2023); some learn stage-cost parameters while keeping the predictive model fixed (Hirt et al., 2024); some learn explicit neural policies and Lyapunov certificates (Mukherjee et al., 2022, Asadi, 2021); some learn latent linear predictors or lifted observable dynamics (Shu et al., 2020, Zhang et al., 6 Jun 2026); and some eliminate the explicit model entirely in favor of stage-wise Q-functions updated from data (Zhang et al., 14 Mar 2025). The term therefore spans model-based, model-augmented, and model-free regimes, provided the learned object remains embedded in a predictive-control loop.

The open problems identified by the literature are correspondingly varied. Robust iterative LMPC based on reachable-set vertices scales poorly with horizon length because vertex enumeration grows exponentially in $x_{k+1}=f(x_k,u_k),$1 (Rosolia et al., 2019). Periodic robust LMPC requires an initial feasible trajectory and disturbance-parameter estimates for each iteration (Shi et al., 2020). Neural Lyapunov differentiable predictive control offers distribution-dependent statistical guarantees enforced through soft penalties rather than worst-case robust certificates (Mukherjee et al., 2022). Safe Bayesian optimization of neural-network-supported MPC inherits the computational demands of repeated closed-loop evaluations and the scalability limitations of Gaussian-process surrogates in high-dimensional parameter spaces (Hirt et al., 2024). Deep-Koopman LPC reports practical rather than formal safety guarantees for the true system under model mismatch, because obstacle avoidance is enforced through soft potential fields and margins rather than a hard robust certificate (Zhang et al., 6 Jun 2026). These limitations suggest that LPC remains less a closed theory than a structured design space whose main axes are what is learned, how safety is certified, and how computational tractability is maintained.