---
title: B-Spline-Based Model Predictive Control
url: https://www.emergentmind.com/topics/b-spline-based-model-predictive-control-mpc
type: topic
---

# B-Spline-Based Model Predictive Control

Searching arXiv for recent and relevant papers on B-spline-based MPC to ground the article and verify related work.
Searching arXiv for "B-spline model predictive control", "Bézier MPC", and "flatness-based MPC B-splines".
B-spline-based Model Predictive Control (MPC) denotes a class of receding-horizon control methods in which the predicted state, input, or flat-output trajectories are parameterized by spline basis functions rather than by a dense sequence of time-sampled decision variables. In the pusher-slider setting studied by Neve et al., the combination of differential flatness with a B-splines transcription replaces a large direct-transcription nonlinear program by a compact optimization over spline control points, yielding empirical computational acceleration up to \(65\%\) relative to a Direct Multiple Shooting baseline [2302.11860]. Across adjacent strands of the literature, closely related spline parameterizations include Bézier curves for convex multi-rate MPC and control Lyapunov function tracking [2204.00152], dual-space cubic Hermite spline parameterizations within sampling-based MPC [2511.19204], and cubic-Hermite B-spline observables in adaptive predictive control [2602.05263]. Taken together, these works situate B-spline-based MPC as a family of trajectory-parameterized predictive controllers rather than a single algorithmic template.

## 1. Conceptual basis and relation to direct transcription

In standard MPC, at each sampling instant one solves a finite-horizon optimal control problem
\[
\text{minimize over }u(\cdot):\quad
J=\phi(x(T))+\int_0^T \ell(x(t),u(t))\,dt
\]
subject to
\[
\dot x(t)=f(x(t),u(t)),\qquad x(0)=x_0,\qquad x(T)=x_{\text{goal}},\qquad h(x(t),u(t))\le 0.
\]
After solving, the first portion of the optimal control \(u^*(t)\) is applied, and at the next sampling instant the horizon is shifted, the plant is re-measured, and a new optimal control problem is solved [2302.11860].

The classical alternative emphasized in the pusher-slider work is “direct” transcription, exemplified by Direct Multiple Shooting. There, the horizon is discretized into \(N\) intervals, one introduces both states \(x_0,\dots,x_N\) and controls \(u_0,\dots,u_{N-1}\) as optimization variables, and the dynamics are enforced through equality constraints
\[
x_{k+1}-\Phi(x_k,u_k)=0,\qquad k=0,\dots,N-1,
\]
where \(\Phi\) is a discrete-time integration map such as Runge–Kutta. The resulting nonlinear program typically has \(O(N\cdot(n_x+n_u))\) variables and \(O(N\cdot n_x)\) equality constraints, so for real-time applications with sampling times in the tens of milliseconds, online solution can be prohibitive [2302.11860].

B-spline-based MPC changes the discretization philosophy. Instead of optimizing every state-control sample directly, it parameterizes a continuous trajectory by a comparatively small set of spline coefficients. In the flatness-based pusher-slider formulation, the decision variable is the vector of spline control points \(c=[P_0,\dots,P_n]\), with \(c\in\mathbb{R}^{2(n+1)}\) because each \(P_i\in\mathbb{R}^2\) [2302.11860]. This suggests that the principal computational benefit comes not from eliminating constraints altogether, but from decoupling the number of optimization variables from the number of collocation points.

## 2. B-spline trajectory parameterization and flatness-based lifting

For the quasi-static pusher-slider, one may choose the Cartesian coordinates of the slider’s center \(p(t)=(x(t),y(t))^T\) as flat outputs. Differential flatness means that all states \(x\) and inputs \(u\) can be written as algebraic functions of a flat output \(y\) and a finite number of its derivatives:
\[
y=y(x,u,\dots,u^{(q)}),\qquad
x=F_x(y,\dot y,\dots,y^{(r)}),\qquad
u=F_u(y,\dot y,\dots,y^{(s)}).
\]
For the pusher-slider, the remaining state \(c\) and orientation \(\phi\), as well as the tangential and normal push velocities \(v_t,v_n\), can be expressed via derivatives of \(x(t)\) and \(y(t)\) [2302.11860]:
\[
c=\beta^2[\dot x \ddot y-\ddot x \dot y]/\|( \dot x,\dot y)\|^3,
\]
\[
\phi=-\operatorname{atan2}(\dot x,\dot y),
\]
\[
v_t=\left(1+\beta^2(\ddot x \dot y-\dot x \ddot y)^2/\|(\dot x,\dot y)\|^6\right)\cdot \|(\dot x,\dot y)\|,
\]
while \(v_n\) depends on third-order derivatives. Because of flatness, any sufficiently smooth \(p(t)\) uniquely defines \(x(t),\phi(t),c(t),u(t)\) without additional inter-node continuity constraints [2302.11860].

The spline transcription begins by choosing a nondecreasing knot vector
\[
\tau=[t_0,t_1,\dots,t_{m+p+1}],
\]
where \(p\) is the spline degree. For a clamped uniform B-spline, one sets \(t_0=\cdots=t_p=0\), \(t_{m+1}=\cdots=t_{m+p+1}=T\), and places the interior knots equispaced in \((0,T)\). The B-spline basis functions \(B_{i,p}(t)\) are defined by the Cox–de Boor recursion [2302.11860]:
\[
B_{i,0}(t)=1 \text{ if } t_i\le t<t_{i+1}, \text{ else } 0,
\]
\[
B_{i,p}(t)=\frac{t-t_i}{t_{i+p}-t_i}B_{i,p-1}(t)+
\frac{t_{i+p+1}-t}{t_{i+p+1}-t_{i+1}}B_{i+1,p-1}(t).
\]

The flat trajectory is then parameterized over \([0,T]\) by \(n+1\) control points \(P_i\in\mathbb{R}^2\):
\[
p(t)=\sum_{i=0}^n P_i B_{i,p}(t).
\]
Hence
\[
p_x(t)=\sum P_{i,x}B_{i,p}(t),\qquad
p_y(t)=\sum P_{i,y}B_{i,p}(t).
\]
The derivatives \(\dot x(t),\ddot x(t),\dots\) are obtained by differentiating the B-splines, which remain B-splines of degree \(p-1,p-2,\dots\) [2302.11860]. At any time \(t\), once \(p,\dot x,\dot y,\ddot x,\ddot y,\dots\) are known, one computes
\[
c(t)=F_c(p,\dot x,\dot y,\ddot x,\ddot y),\qquad
\phi(t)=F_\phi(p,\dot x,\dot y),
\]
\[
v_t(t)=F_{v_t}(p,\dot x,\dot y,\ddot x,\ddot y),\qquad
v_n(t)=F_{v_n}(p,\dot x,\dot y,\ddot x,\ddot y,\dddot x,\dddot y).
\]
The entire state-input trajectory is therefore a deterministic function of the control-point vector \(c=[P_0,\dots,P_n]\) [2302.11860].

A closely related construction appears in the multi-rate framework of “Multi-Rate Planning and Control of Uncertain Nonlinear Systems: Model Predictive Control and Control Lyapunov Functions,” which uses Bézier curves, explicitly described there as a special case of B-spline, to stitch together \(N\) segments of order \(2n-1\) over subintervals of length \(T\) [2204.00152]. In that setting, adjoining segments match in value and derivative up to order \(n-1\), and each Bézier segment lies in the convex hull of its control points. The common structural point is that spline control points parameterize a continuous admissible trajectory while moving continuity and smoothness properties into the basis itself [2204.00152].

## 3. Finite-dimensional optimization forms

Once the trajectory is parameterized by spline coefficients, the infinite-dimensional optimal control problem becomes a finite-dimensional optimization problem defined over those coefficients. In the pusher-slider transcription, one chooses collocation times \(\{t_k\}_{k=0..N}\), such as Greville points or uniformly spaced points in \([0,T]\), and enforces boundary and path constraints there. Boundary conditions include
\[
p(0)=x_{\text{start}},\qquad p(T)=x_{\text{goal}},
\]
and, if needed, \(\phi(0)=\phi_{\text{start}}\) and \(\phi(T)=\phi_{\text{goal}}\). Path constraints are imposed on state and input:
\[
g_x(p(t_k),\dot x(t_k),\dots)\le 0,\qquad
g_u(v_t(t_k),v_n(t_k))\le 0.
\]
Since the flatness relations eliminate the need for dynamic-continuity constraints, the only equality constraints are the boundary conditions plus any path equality constraints. When written in affine form in the control-point vector \(c\), the constraints become
\[
A_{\text{eq}}c=b_{\text{eq}},\qquad A_{\text{ineq}}c\le b_{\text{ineq}}.
\]
Here, \(A_{\text{eq}}\) and \(A_{\text{ineq}}\) collect combinations of \(B_{i,p}(t_k)\) and their derivatives [2302.11860].

The cost can be expressed directly in the spline coefficients. In the flatness-based pusher-slider case,
\[
J(c)=\sum_{k=0}^N
\Bigl[
(x(c,t_k)-x_{\text{ref}}(t_k))^TQ(x(c,t_k)-x_{\text{ref}}(t_k))
+
(u(c,t_k))^TR(u(c,t_k))
\Bigr]
+
w_{\text{reg}}\sum_{i=0}^{n-1}\|P_{i+1}-P_i\|^2.
\]
Each \(x(c,t_k)\) and \(u(c,t_k)\) is a nonlinear but smooth function of \(c\). One can form a Gauss–Newton approximation or use a full-SQP solver; if \(\ell\) and \(\phi\) are quadratic and the flatness maps are linearized, one obtains a local quadratic “QP-like” subproblem in \(c\) [2302.11860]. The resulting compact formulation is
\[
\text{minimize } J(c)\qquad
\text{subject to }A_{\text{eq}}c=b_{\text{eq}},\;A_{\text{ineq}}c\le b_{\text{ineq}}.
\]

The multi-rate Bézier framework yields a different optimization structure. There, the planner operates over discrete waypoints \(x_0,\dots,x_N\) with \(x_N=0\), while the Bézier control points are implicitly determined by adjacent waypoint pairs via the linear relation
\[
\xi_k^T=[x_k^T\;x_{k+1}^T]D^{-1}.
\]
State constraints are handled by convex-hull tightening over the control points, and input constraints are cast as second-order cone constraints involving auxiliary slacks \(s_k\in\mathbb{R}^2\). If the stage and terminal costs are quadratic, the entire problem is an SOCP [2204.00152].

The literature therefore contains multiple finite-dimensional optimization archetypes under the broader heading of spline-based MPC: compact nonlinear programs over B-spline coefficients [2302.11860], convex SOCPs over waypoints with Bézier lifting [2204.00152], and, in a different computational regime, sampling-based path-integral optimization over cubic Hermite control points [2511.19204]. A plausible implication is that the spline representation itself is orthogonal to the final solver class.

## 4. Constraint handling, smoothness, and continuity

A central technical advantage of spline parameterizations is that continuity is encoded by basis construction rather than by explicit continuity constraints between all discretization nodes. In the pusher-slider formulation, flatness plus B-spline parameterization means that any sufficiently smooth flat output \(p(t)\) induces a unique state-input trajectory, and “the need for dynamic-continuity constraints” is eliminated [2302.11860]. This shifts the constrained optimization burden toward endpoint conditions and collocated path constraints.

Smoothness requirements can be stringent. In the pusher-slider system, \(v_n\) depends on third-order derivatives, so the implementation chooses B-spline degree \(p=5\) “to ensure continuity up to 4th derivatives, needed for \(v_n\)” [2302.11860]. This is an instance of a more general design principle: spline degree is determined not only by interpolation quality but by the derivative order required in state or input reconstruction.

In the multi-rate Bézier framework, constraint handling exploits the convex-hull property. Each Bézier segment \(r_k(\tau)\) lies in the convex hull of its \(2n\) control points \(\zeta_{k,i}\), and if those control points lie in the tightened polytope \(X\ominus E\), then the nonlinear state remains in \(X\) for all time under the low-level CLF tracker [2204.00152]. Input limits are enforced through second-order cone constraints derived from bounds on the low-level feedback law. The paper states that the planned tube \(x_d\oplus E\) remains in \(X\), the CLF tracker never violates \(u_{\max}\), and the shifted previous solution remains feasible at every replan under the theorem’s assumptions [2204.00152].

The sampling-based work on reference-free locomotion uses a dual-space spline parameterization with position and velocity control points \(\theta_k^q,\theta_k^v\), reconstructing
\[
q(t)=\sum_{k=0}^{K-1}\bigl[\theta_k^q\mathcal{H}_k(t)+\theta_k^v\dot{\mathcal{H}}_k(t)\bigr],
\]
\[
v(t)=\dot q(t)=\sum_{k=0}^{K-1}\bigl[\theta_k^q\dot{\mathcal{H}}_k(t)+\theta_k^v\ddot{\mathcal{H}}_k(t)\bigr].
\]
There, “intrinsic smoothness” is highlighted explicitly: by construction, any Hermite-interpolated trajectory is continuously differentiable, which cuts down wasted samples that would otherwise be spiky or physically infeasible [2511.19204]. Although that framework is not posed as a classical deterministic NLP, it reinforces the same underlying point: spline bases regularize admissible trajectory shape before optimization begins.

## 5. Computational scaling and real-time operation

The best-documented computational comparison in the supplied literature is the pusher-slider case study. Direct Multiple Shooting with \(N\) shooting nodes uses \(N\cdot n_x + N\cdot n_u\) decision variables plus \(N\cdot n_x\) equality constraints, whereas B-spline MPC uses only \((n+1)\cdot n_u\) variables, independent of the number of collocation points \(N\); only the number of constraints grows with \(N\) [2302.11860]. Typical experiments choose \(n\ll N\), such as \(n=6\) and \(N=20\) [2302.11860]. In simulations on the pusher-slider, Neve et al. report “up to 65% reduction in average solve time per cycle” compared to a standard DMS-based MPC using IPOPT, attributing the speedup to the reduced variable count and sparser Jacobians and Hessians [2302.11860].

The reported real-time configuration in that work uses a horizon \(T=1\,\text{s}\), \(N+1=21\) collocation points with \(\Delta t=0.05\,\text{s}\), spline degree \(p=5\), and \(n+1=6\) control points with a clamped uniform knot vector with \(12\) knots [2302.11860]. The solver is IPOPT called via CasADi, warm-starting from the previous \(c\) for faster convergence. A shrinking-horizon strategy is used: by re-parameterizing the continuous spline on \([0,T-k\Delta t]\) each cycle, one avoids rebuilding continuity constraints; only \(A_{\text{eq}},b_{\text{eq}}\) change at the endpoints [2302.11860].

The convex Bézier-based multi-rate architecture emphasizes a different computational profile. Its constraints are all convex—linear dynamics, linear inequalities on the Bézier control points, and second-order cone constraints for input—and the paper notes that one obtains an SOCP of modest size, solvable by MOSEK, ECOS, and similar solvers; the simulations use MOSEK via Yalmip [2204.00152].

By contrast, the reference-free sampling-based work argues for sample efficiency and CPU real-time operation through low-dimensional spline parameterization. Instead of sampling a high-frequency sequence of torques, it samples only \(K\) nodes per degree of freedom, reducing the number of random variables from \((H/dt)\times d\) down to \(K\times 2d\ll(H/dt)\times d\). The paper states that with only \(30\)–\(70\) rollouts per \(20\)–\(30\) ms on a multicore CPU, it achieves \(50\) Hz MPC without a GPU [2511.19204]. The computational message common to all three formulations is not a single complexity theorem, but a recurring dimensionality argument: spline coefficients can be substantially fewer than dense time-grid decision variables.

## 6. Variants, neighboring formulations, and interpretive issues

B-spline-based MPC is not restricted to flatness-based nonlinear programming. One neighboring formulation uses Bézier curves, described explicitly as “a special case of B-spline,” to enable planning continuous trajectories respecting constraints by planning a sequence of discrete points [2204.00152]. Another uses cubic Hermite interpolation; the locomotion paper states that a cubic Hermite interpolant can also be written “in the standard B-spline language by introducing an appropriate knot vector and repeated knots at the boundaries,” though the dual-space design with explicit velocity control points is easier to impose directly in the Hermite basis [2511.19204]. These works indicate that the term “B-spline-based MPC” often encompasses a broader spline-parameterized design space rather than only uniform B-splines in the Cox–de Boor form.

A related but distinct use of splines appears in adaptive predictive control. “Nonlinear Predictive Cost Adaptive Control of Pseudo-Linear Input-Output Models Using Polynomial, Fourier, and Cubic Spline Observables” employs cubic-Hermite B-spline observables in both online identification and receding-horizon optimization [2602.05263]. There, the scalar argument \(x\in[s_0,s_{n+1}]\) is divided into \(n\) equal subintervals, and at each internal knot \(s_i\) two local cubic-Hermite shape functions \(p_i(x)\) and \(m_i(x)\) define the two-component basis
\[
b_i(x)=[p_i(x),\, s_d m_i(x)]^T\in\mathbb{R}^2,
\]
which is stacked into the \(2n\)-dimensional spline basis
\[
b_{c,n}(x)=[b_1(x)^T,\dots,b_n(x)^T]^T\in\mathbb{R}^{2n}.
\]
This basis becomes the observable \(g(x)\) in a pseudo-linear input-output model \(\hat y_{k+1}=\phi_k^T\theta_k\), with parameters updated by SIFt-RLS and then used within iterative MPC [2602.05263]. In Example 4, the cubic Hermite spline controller with four segments, denoted CB\(_4\), achieved the smallest command-following error \(\log_{10}|r_k-y_k|\) and the lowest one-step prediction error across \(k\), and in Examples 5 and 6 it again outperformed the polynomial and Fourier alternatives listed in the paper [2602.05263].

Several misconceptions are therefore best avoided. First, spline-based MPC is not inherently convex: the pusher-slider formulation is a compact nonlinear program [2302.11860], the multi-rate Bézier formulation is an SOCP under quadratic costs [2204.00152], and the reference-free locomotion approach is zero-order MPPI rather than gradient-based optimization [2511.19204]. Second, spline use does not imply that only outputs are parameterized; depending on the formulation, the coefficients may represent flat outputs [2302.11860], stitched state trajectories [2204.00152], joint positions and velocities simultaneously [2511.19204], or nonlinear observables for system identification [2602.05263]. Third, computational savings arise from reduced decision dimension and structured smoothness, not from any claim that constraints disappear; in most formulations, constraints remain central and are transferred to control points, collocation points, tightened sets, or sampled trajectories.

Taken together, the cited works portray B-spline-based MPC as a methodological pattern with three recurring ingredients: low-dimensional continuous trajectory parameterization, derivative-structured smoothness inherited from the basis, and a receding-horizon optimizer whose burden shifts from dense node-by-node dynamics enforcement to a smaller set of spline coefficients. In the pusher-slider example this pattern enabled real-time MPC with documented \(65\%\) empirical speedup over a Direct Multiple Shooting baseline [2302.11860]. In adjacent formulations it supports convex constraint handling through the convex-hull property [2204.00152], sampling-based real-time locomotion without predefined contact schedules [2511.19204], and adaptive pseudo-linear predictive control through cubic-spline observables [2602.05263].

Source: https://www.emergentmind.com/topics/b-spline-based-model-predictive-control-mpc