Distributed Finite-Horizon LQR

• Distributed finite-horizon LQR is an optimal control framework that minimizes a quadratic performance index over a finite time horizon while incorporating network-induced locality constraints.
• It employs methodologies such as localized response-based design and data-driven predictive control to enforce spatial sparsity and manage communication delays.
• The framework achieves competitive performance via decentralized optimization, scalable local computations, and privacy-preserving mechanisms in multi-agent settings.

Searching arXiv for relevant papers on distributed finite-horizon LQR and closely related formulations. Distributed finite-horizon linear quadratic regulator (LQR) denotes the class of optimal control problems in which a linear system is regulated over a finite horizon under quadratic performance criteria, while the controller synthesis or implementation is constrained by network structure, locality, communication delays, privacy requirements, or restricted information patterns. In the distributed setting, the classical finite-horizon objective is retained, but the admissible controller class is narrowed by architectural constraints, leading to formulations based on localized closed-loop responses, local predictive trajectories reconstructed from data, structured time-varying gains, cooperative multi-agent Riccati-like recursions, or privacy-aware neighbor interactions (Wang et al., 2014, Allibhoy et al., 2020, Furieri et al., 2019, Duan et al., 2021, Ma et al., 15 Sep 2025).

1. Canonical formulations and problem classes

The standard finite-horizon LQR problem for a linear system

$x_{t+1} = A x_t + B u_t + w_t$

or, in disturbance-free form,

$x(t+1)=A x(t)+B u(t),$

seeks to minimize a quadratic performance index over a horizon $T$. One representative form is

$$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$

while another uses a terminal equality constraint $x(T)=0$ and omits an explicit terminal cost (Wang et al., 2014, Allibhoy et al., 2020).

What distinguishes the distributed finite-horizon case is not the stage cost itself, but the controller class. In localized response-based design, the optimization is carried out directly over closed-loop disturbance-to-state and disturbance-to-input maps $(R,M)$ subject to finite impulse response (FIR) and spatial support constraints (Wang et al., 2014). In data-based predictive control, the same finite-horizon quadratic objective is reformulated from a single measured trajectory through local Hankel constraints, without explicit knowledge of $A,B$ (Allibhoy et al., 2020). In cooperative multi-input regulation, each input channel is assigned to an agent that possesses only its local $B_i$ and $R_i$, and neighbor-only information fusion replaces a centralized Riccati recursion (Duan et al., 2021). In distributed output-feedback, a finite-horizon controller is constrained to a linear subspace $\mathcal{K}$ encoding causality and information structure, with tractability tied to Quadratic Invariance (QI) (Furieri et al., 2019).

A useful way to classify the literature is by the object being optimized.

Formulation family	Main optimization variable	Representative work
Localized response-based design	Closed-loop responses $x(t+1)=A x(t)+B u(t),$0	(Wang et al., 2014)
Data-based predictive control	Local trajectory coefficients $x(t+1)=A x(t)+B u(t),$1 and predicted trajectories	(Allibhoy et al., 2020)
Subspace-constrained output-feedback	Causal controller $x(t+1)=A x(t)+B u(t),$2	(Furieri et al., 2019)

This taxonomy suggests that distributed finite-horizon LQR is not a single algorithmic template. It is a family of structurally constrained optimal control problems whose solvability depends on whether the imposed information pattern admits a tractable reformulation.

2. Locality and system-level response parameterization

A central response-based formulation is the localized LQR (LLQR), developed for localizable distributed systems (Wang et al., 2014). The key design variables are strictly proper closed-loop response operators $x(t+1)=A x(t)+B u(t),$3 and $x(t+1)=A x(t)+B u(t),$4 satisfying

$x(t+1)=A x(t)+B u(t),$5

where $x(t+1)=A x(t)+B u(t),$6 maps disturbances to states and $x(t+1)=A x(t)+B u(t),$7 maps disturbances to inputs. The system is state-feedback localizable over radius $x(t+1)=A x(t)+B u(t),$8 and horizon $x(t+1)=A x(t)+B u(t),$9 if these responses satisfy four conditions: plant consistency, FIR temporal support, spatial sparsity, and implementability under communication delays that do not exceed plant propagation (Wang et al., 2014).

Spatial locality is encoded through graph neighborhoods. For adjacency support $T$0, the forward neighborhood of node $T$1 with radius $T$2 is

$T$3

and the backward neighborhood is

$T$4

These sets separate disturbance propagation from information aggregation. Intuitively, a disturbance injected at state $T$5 affects only a forward cone of states and actuators for $T$6 steps, while the controller exchanges only locally estimated disturbances over compatible backward cones (Wang et al., 2014).

The localized FIR constraint spaces $T$7 require that $T$8 and $T$9 vanish after $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$0 steps and obey support relations aligned with $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$1 and $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$2. The dynamics consistency constraints are

$$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$3

with $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$4 and $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$5 for $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$6. In compact system-level synthesis (SLS) form,

$$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$7

where $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$8 are block-lower-triangular operators representing the horizon-stacked responses. This equality encodes exactly the closed-loop maps from disturbances to state and input consistent with the plant (Wang et al., 2014).

The significance of this representation is that locality is imposed on the achieved closed-loop behavior rather than on the controller matrix alone. This is a substantive shift. A sparse controller gain need not produce localized state propagation, whereas localized closed-loop responses guarantee both bounded disturbance spread and finite settling time.

3. Local decomposition, realization, and analytic LLQR synthesis

The localized formulation admits a local-global equivalence that is central to scalability. For a disturbance injected at node $$J = \sum_{t=0}^{T-1} x_t^\top Q\,x_t + u_t^\top R\,u_t + x_T^\top Q_f\,x_T,$$9, all nonzero state and input trajectories lie within $x(T)=0$0 and $x(T)=0$1. Restricting the dynamics to these neighborhoods yields reduced variables $x(T)=0$2, $x(T)=0$3 and a reduced plant $x(T)=0$4, together with an affine horizon-stacked relation

$x(T)=0$5

Theorem-level equivalence states that a feasible local solution corresponds, through zero-padding embeddings $x(T)=0$6, to the $x(T)=0$7-th columns of a globally feasible $x(T)=0$8, and conversely any globally feasible $x(T)=0$9 induces feasible local solutions (Wang et al., 2014).

The LLQR objective is then posed directly in the response variables: $(R,M)$0 subject to the response dynamics and support constraints. This is a convex quadratic program with linear equalities and structured sparsity. After eliminating zero-supported components, each reduced local problem becomes a quadratic program with equality constraints, and the unique optimum is obtained from a linear KKT system: $(R,M)$1 The per-source design therefore reduces to independent local linear solves, and the complexity scales with the horizon $(R,M)$2 and neighborhood size rather than the global plant dimension (Wang et al., 2014).

Implementation is receding-horizon-like but is expressed through an internal disturbance estimator $(R,M)$3 and a reference generator $(R,M)$4: $(R,M)$5

$(R,M)$6

Under exact feasibility, one obtains $(R,M)$7, so the achieved closed-loop maps are exactly $(R,M)$8 and $(R,M)$9. Under approximate feasibility errors $A,B$0, the estimator satisfies

$A,B$1

and a small-gain argument yields bounded $A,B$2, $A,B$3, and $A,B$4 for small $A,B$5, even when $A,B$6 is unstable (Wang et al., 2014).

The response-based cost also has an $A,B$7 interpretation. For additive white Gaussian noise with identity covariance, the long-run average LQR cost equals the response-based objective in expectation. This links impulse-response synthesis and mean-square performance without changing the local decomposition (Wang et al., 2014).

The benchmark reported for a 59-state tridiagonal chain with $A,B$8, sparse $A,B$9 actuation, $B_i$0, and communication speed $B_i$1, is frequently used to illustrate the trade-off between locality and performance (Wang et al., 2014).

Controller	Normalized objective value
Ideal $B_i$2 (no delay, full communication)	1.0000
Delayed centralized $B_i$3 ($B_i$4, same graph)	126.7882
Optimal distributed $B_i$5 with QI constraints ($B_i$6)	1.1061
LLQR ($B_i$7, $B_i$8, $B_i$9)	1.1142

These values support the paper’s claim that LLQR can achieve performance comparable to distributed or centralized $R_i$0 controllers while guaranteeing locality, FIR settling, and distributed implementability (Wang et al., 2014).

4. Data-driven and learning-based formulations

A second major direction replaces explicit model knowledge by data. In distributed data-based predictive control, a single persistently exciting trajectory $R_i$1 is used to build local Hankel matrices $R_i$2, and each agent enforces local data consistency constraints of the form

$R_i$3

with predicted future trajectories coupled only through neighbor state variables (Allibhoy et al., 2020). The finite-horizon cost is block-diagonal and separable across agents, while the coupling appears in the local Hankel equalities and the terminal constraints $R_i$4. Under controllability and identifiability conditions—either global persistent excitation of order $R_i$5, or locally verifiable a posteriori excitation conditions—the distributed data-based problem is an exact reformulation of the centralized finite-horizon LQR with terminal equality, without needing $R_i$6 (Allibhoy et al., 2020).

The distributed solver in that framework is a continuous-time primal-dual saddle-point flow on the local quadratic program,

$R_i$7

combined with a distributed stopping certificate. If each agent ensures

$R_i$8

then the aggregate input deviation satisfies $R_i$9. The associated receding-horizon implementation is stabilizing for sufficiently small $\mathcal{K}$0 (Allibhoy et al., 2020).

A different strand studies distributed finite-horizon output-feedback under subspace constraints $\mathcal{K}$1. In this setting, the controller is block-lower-triangular and constrained by a linear subspace encoding causality and information structure. When $\mathcal{K}$2 is QI with respect to $\mathcal{K}$3, the finite-horizon problem admits a Youla-type convexification via

$\mathcal{K}$4

and the transformed objective is strongly convex in the Youla-like variable $\mathcal{K}$5 (Furieri et al., 2019). This geometric property enables model-free zeroth-order learning of a globally optimal distributed output-feedback policy with explicit sample-complexity bounds. The paper states that the model-free sample complexity scales as

$\mathcal{K}$6

up to constants (Furieri et al., 2019).

Further learning-oriented adaptations appear in structured policy iteration and distributed zeroth-order reinforcement learning. A finite-horizon S-PI adaptation consistent with the derivations of "Structured Policy Iteration for Linear Quadratic Regulator" uses backward recursions

$\mathcal{K}$7

forward covariance recursions

$\mathcal{K}$8

and proximal updates on $\mathcal{K}$9 to enforce lasso, group-lasso, nuclear-norm, or proximity structure (Park et al., 2020). An implementation-oriented finite-horizon adaptation of asynchronous distributed zeroth-order block coordinate descent uses a learning graph $x(t+1)=A x(t)+B u(t),$00 so that each agent can estimate its local policy gradient by local cost evaluation, without consensus, using episodic finite-horizon returns and block-wise randomized perturbations (Jing et al., 2021).

Taken together, these works show that model-based Riccati recursions are only one route to distributed finite-horizon LQR. Exact data-driven reformulations, QI-based convexification, structured proximal policy updates, and local zeroth-order learning all become viable once the information structure is encoded explicitly.

5. Cooperative, privacy-preserving, and other distributed architectures

In cooperative finite-horizon LQR for multi-input systems, each input channel is controlled by an agent that possesses only its local $x(t+1)=A x(t)+B u(t),$01 and $x(t+1)=A x(t)+B u(t),$02, while the shared plant evolves according to

$x(t+1)=A x(t)+B u(t),$03

The controller design uses a distributed information fusion strategy with one neighbor exchange per backward design step and one neighbor exchange per forward control step (Duan et al., 2021). The backward phase computes coupled Riccati-like matrices

$x(t+1)=A x(t)+B u(t),$04

$x(t+1)=A x(t)+B u(t),$05

while the forward phase propagates virtual local states $x(t+1)=A x(t)+B u(t),$06 whose sum equals the plant state. The local feedback law is

$x(t+1)=A x(t)+B u(t),$07

Only joint controllability of the aggregate pair $x(t+1)=A x(t)+B u(t),$08 is required; individual local pairs may be uncontrollable (Duan et al., 2021). The framework provides boundedness of gains in the time-varying case, convergence in the time-invariant case, and a finite-horizon performance upper bound

$x(t+1)=A x(t)+B u(t),$09

A more recent direction incorporates differential privacy into distributed finite-horizon LQR consensus. For single-integrator agents

$x(t+1)=A x(t)+B u(t),$10

each agent solves, at every time $x(t+1)=A x(t)+B u(t),$11, a horizon-$x(t+1)=A x(t)+B u(t),$12 quadratic tracking problem with local weights $x(t+1)=A x(t)+B u(t),$13, while broadcasting noisy neighbor states $x(t+1)=A x(t)+B u(t),$14 (Ma et al., 15 Sep 2025). The first optimal control move has the form

$x(t+1)=A x(t)+B u(t),$15

and privacy is enforced by consensus-error-dependent Laplace noise: $x(t+1)=A x(t)+B u(t),$16 Under assumptions on the graph, bounded gain sensitivity, and the co-designed sequences $x(t+1)=A x(t)+B u(t),$17 and $x(t+1)=A x(t)+B u(t),$18, the mechanism at time $x(t+1)=A x(t)+B u(t),$19 is $x(t+1)=A x(t)+B u(t),$20-differentially private with $x(t+1)=A x(t)+B u(t),$21, the overall privacy leakage is $x(t+1)=A x(t)+B u(t),$22, and the disagreement process remains bounded in mean square (Ma et al., 15 Sep 2025). The privacy-induced performance degradation scales as $x(t+1)=A x(t)+B u(t),$23.

A distributed-parameter extension appears in finite-horizon LQR control of the Lighthill-Whitham-Richards traffic PDE with in-domain variable speed limits. There the feedback law

$x(t+1)=A x(t)+B u(t),$24

is obtained from a space-time Riccati PDE rather than a matrix Riccati recursion (Block et al., 2 Jun 2026). Although this is not a networked multi-agent architecture, it shows that the finite-horizon LQR paradigm extends naturally to spatially distributed systems with localized actuation.

6. Assumptions, misconceptions, and active directions

Several assumptions recur across the literature. LLQR assumes state-feedback access, stabilizability of $x(t+1)=A x(t)+B u(t),$25, feasibility of the locality constraint pair $x(t+1)=A x(t)+B u(t),$26, and communication not slower than the imposed forward-cone locality (Wang et al., 2014). The distributed data-based approach assumes controllability, full state measurements, feasibility for all valid past windows, and persistent excitation conditions strong enough to identify finite-horizon trajectories from a single sample trajectory; it does not include regularization or slack variables for noisy data (Allibhoy et al., 2020). The output-feedback learning framework assumes bounded noises and exploits local gradient dominance on compact sublevel sets; the strongest guarantees are established for QI information structures (Furieri et al., 2019). The cooperative multi-input method assumes a strongly connected communication graph, uniform controllability of the aggregate input pair, and bounded system matrices (Duan et al., 2021). The privacy-preserving consensus framework assumes single-integrator dynamics, bounded sensitivity of local gains, and summability conditions on $x(t+1)=A x(t)+B u(t),$27 and $x(t+1)=A x(t)+B u(t),$28 (Ma et al., 15 Sep 2025).

A common misconception is that distributed finite-horizon LQR is simply a decentralized Riccati recursion with sparse gains. The surveyed formulations show otherwise. Response-based LLQR optimizes closed-loop maps rather than gains; data-based predictive control replaces model matrices by local Hankel equalities; subspace-constrained output-feedback treats structure as a geometric property of the admissible controller space; and privacy-preserving consensus modifies the cost and communication channels themselves (Wang et al., 2014, Allibhoy et al., 2020, Furieri et al., 2019, Ma et al., 15 Sep 2025).

A second misconception is that model-free or data-based methods remove structural conditions. In fact, exact recovery of finite-horizon optimal trajectories from data requires persistent excitation and feasibility; global optimality of model-free distributed output-feedback learning relies on QI or related geometric regularity; and asynchronous zeroth-order distributed RL depends on the locality properties encoded by the learning graph (Allibhoy et al., 2020, Furieri et al., 2019, Jing et al., 2021).

The current research frontier is defined in the source material with unusual consistency. Reported extensions include output-feedback LLQR and robust variants; infinite-horizon localized LQR and model predictive control connections; time-varying plants and disturbance models; stronger robustness guarantees and explicit delay-locality tradeoffs; data-based terminal costs and terminal sets; noisy-data formulations with regularization or slack variables; extensions to sub-Gaussian noises; and safety-constrained learning and control (Wang et al., 2014, Allibhoy et al., 2020, Furieri et al., 2019). This suggests that the central open problem is no longer whether finite-horizon LQR can be distributed, but which structural assumptions permit exactness, scalability, robustness, and implementability simultaneously.