Convex Control Synthesis via Closed Loop Responses

59 concepts43 papers3 proposals

When designing a controller for a dynamic system, the classical approach is to search for a feedback gain matrix $K$ that maps the current state $x_t$ to a control action $u_t = K x_t$. While this formulation feels intuitive, it hides a severe mathematical trap: as soon as you introduce real-world constraints—such as physical limits on actuators, safety boundaries on states, or structural requirements like sparsity for decentralized networks—the optimization problem becomes highly non-convex and computationally intractable.

The non-convexity arises because the controller $K$ is deeply embedded within the system's closed-loop dynamics. The state evolves according to $(A + BK)^t$, meaning the decision variable $K$ is repeatedly multiplied by itself and the system matrices.

To bypass this fundamental bottleneck, a powerful paradigm shift has emerged: Closed-Loop Response Parameterization. Instead of optimizing over the controller $K$, we optimize directly over the closed-loop responses—the maps that dictate how external disturbances propagate to future states and control inputs. By shifting the optimization space from the controller to the resulting system behavior, non-convex control problems are transformed into clean, convex formulations.


The Core Insight: Shifting the Perspective

Consider a standard discrete-time linear system subject to external disturbances $w_t$:

$$x_{t+1} = Ax_t + Bu_t + w_t$$

Instead of searching for a static feedback gain $K$, let us define the closed-loop behavior using two transfer matrices, $\Phi_x$ and $\Phi_u$. These matrices act as operators that map the history of disturbances $w$ directly to the trajectories of the states and control inputs:

$$x = \Phi_x w, \quad u = \Phi_u w$$

As Anton Xue et al. explain, this parameterization shifts the focus from searching for a controller gain to directly synthesizing the desired performance characteristics and impulse responses.

To understand why this makes the problem convex, we can substitute these response maps back into the system dynamics. In the frequency or operator domain, the plant equation $z x = Ax + Bu + w$ translates to:

$$(zI - A)\Phi_x - B\Phi_u = I$$

This relationship is the cornerstone of frameworks like System Level Synthesis (SLS). Crucially, this constraint is affine with respect to the decision variables $\Phi_x$ and $\Phi_u$. Because the system dynamics are enforced through a linear subspace constraint, the set of all achievable closed-loop responses forms a convex set. Once the optimal maps $\Phi_x$ and $\Phi_u$ are found via standard convex optimization solvers, the physical controller can be recovered algebraically via $K = \Phi_u \Phi_x^{-1}$.


Making Hard Constraints Convex

The true power of parameterizing closed-loop responses becomes apparent when we introduce real-world constraints. Because $\Phi_x$ and $\Phi_u$ map disturbances directly to states and inputs, constraints on physical variables map cleanly into constraints on the optimization variables.

Safety and Actuator Bounds

If a system must obey strict state or input limits (e.g., a drone avoiding obstacles or keeping its motor torque within physical bounds), these limits can be expressed as polytopic or norm-based constraints on $\Phi_x$ and $\Phi_u$.

Sarah Dean et al. leveraged this property to solve the problem of safely learning to control a constrained Linear Quadratic Regulator (LQR). By parameterizing the controller via closed-loop responses, they transformed non-convex state and input constraints into a convex optimization problem. This allowed a system to safely inject exploratory noise to learn unknown dynamics without ever risking a violation of its physical safety boundaries.

Structural and Sparsity Constraints

In large-scale decentralized systems, such as power grids or multi-agent robotic swarms, a centralized controller is often impossible due to communication limits. Actuators can only respond to local sensor data, meaning the controller matrix $K$ must obey a strict sparsity pattern.

Historically, finding optimal decentralized controllers was notoriously difficult. While the Youla parameterization could map stabilizing controllers to a convex set under the condition of Quadratic Invariance, as shown by Laurent Lessard et al., enforcing localized or sparse structures remained challenging.

By utilizing system-level and input-output parameterizations, such as those detailed by Luca Furieri et al., structural information constraints (like communication delays or locality) map directly into simple linear subspace constraints on the response parameters $\Phi_x$ and $\Phi_u$. This enables the seamless integration of architectural requirements directly into the optimization objective, allowing practitioners to synthesize sparse or decentralized control structures using efficient linear or quadratic programming (Jared Miller et al.; Aditya Mahajan et al.).


Handling Uncertainty and Data-Driven Control

In practice, the true system matrices $A$ and $B$ are rarely known perfectly. Instead, engineers must work with nominal estimates $(\hat{A}, \hat{B})$ learned from a finite pool of noisy data, leaving an explicit model uncertainty bound $\Delta$.

Closed-loop response parameterization provides an elegant mechanism for robust control under these conditions. Because the relationship between the response maps and the system dynamics is transparent, model uncertainty can be embedded directly into the convex optimization problem as a robust stability constraint.

  [ Noisy System Data ] ──> [ Estimate (Â, B̂) + Uncertainty Δ ]
                                         │
                                         ▼
                    [ Convex Optimization over Responses (Φx, Φu) ]
                     Satisfying: [(zI - Â)Φx - B̂Φu - Δ·Φx = I]
                                         │
                                         ▼
                           [ Robust Stable Controller K ]

Ross Boczar et al. demonstrated that by incorporating these uncertainty bounds directly into the optimization space, the framework guarantees that the resulting controller remains stable and performant even when synthesized from imperfect, finite data. This bridge between data-driven identification and robust synthesis has been extended by Nikolai Matni et al. to provide finite-data sample complexity guarantees for safe reinforcement learning.

For scenarios where the underlying noise distribution is completely unknown or adversarial, the framework adapts naturally to Distributionally Robust Optimization (DRO). By optimizing closed-loop responses over a Wasserstein ambiguity set of data samples, the authors of recent work have shown that infinite-horizon control and state estimation problems can be reduced to computationally tractable programs that remain dependable under worst-case noise distributions (Jean-Sébastien Brouillon et al.; Jean-Sébastien Brouillon et al.).


Broadening the Horizon: MPC, Delays, and Regret

The flexibility of parameterizing closed-loop responses has allowed it to expand into several advanced control domains, solving long-standing computational bottlenecks:

  • Time-Delay Systems: Controlling systems with significant transport lags traditionally requires state augmentation, which triggers a "curse of dimensionality" as the delay horizon grows. Shaoru Chen et al. showed that by optimizing over the transfer functions mapping disturbances to states and inputs, the number of decision variables in a robust Model Predictive Control (MPC) framework remains entirely independent of the delay horizon.
  • Regret-Optimal Control: Instead of minimizing the worst-case ($H_\infty$) or average-case ($H_2$) cost, modern online learning focuses on minimizing dynamic regret—the difference between the online controller's performance and the best possible performance achievable by an oracle with full hindsight of the future disturbances. Alexandre Didier et al. and Andrea Martin et al. demonstrated that system-level parameterization ensures causality is strictly maintained within the optimization variables, enabling the synthesis of regret-optimal controllers under hard state and input constraints.
  • Affine Control Policies: Real-world systems often operate around non-zero equilibrium points or face persistent constant offsets. To handle this, Lukas Schüepp et al. extended the closed-loop parameterization framework by incorporating an additional dimension into the response matrices to represent constant offsets. This mathematical equivalence allows practitioners to utilize the scalability of system-level synthesis for affine control policies without sacrificing the performance of traditional MPC.

Key Foundational Work

Piecewise-affine state feedback for piecewise-affine slab systems using convex optimization (2005) — contributed 2 concept elements to this direction.
An LMI approach to IMC-based robust tunable control (2003) — contributed 1 concept elements to this direction.
A Canonical Form for the Inclusion Principle of Dynamic Systems (2005) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_closed_loop_response_parameterization_b589ca07,
  title = {closed-loop response parameterization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/closed-loop-response-parameterization/rdr_b589ca0742e14f3eaebde70ef5c69690},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_closed_loop_response_parameterization_b589ca07_v1,
  title = {closed-loop response parameterization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/closed-loop-response-parameterization/rdr_b589ca0742e14f3eaebde70ef5c69690/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake