System Level Synthesis for Optimal Control

This direction is split into other directions: closed-loop response parameterization. Its last version stays readable and citable here.

Version 1 of 172 papers78 conceptsfrozen 2026-10-04

In classical control theory, the designer’s goal is to find a controller $K$ that maps observed states to control actions. While this works well for centralized systems, it becomes notoriously difficult when dealing with large-scale networks or strict safety constraints. The fundamental problem is that the relationship between the controller parameters and the resulting system behavior is often non-convex and non-linear.

System Level Synthesis (SLS), and the broader family of closed-loop parameterizations, flips this perspective. Instead of searching for the controller $K$ directly, researchers like Nikolai Matni and James Anderson propose searching for the closed-loop responses—the maps that describe exactly how external disturbances propagate through the system to become future states and control inputs.

From Gains to Responses

To understand why this shift is powerful, consider a linear system $x_{t+1} = Ax_t + Bu_t + w_t$, where $w_t$ is noise. In a traditional setup, we seek a feedback law $u = Kx$. The "closed-loop" behavior is then governed by the matrix $(A + BK)$. If we want to ensure the system is stable or follows a specific path, we have to tune $K$, which appears inside a complex matrix power series.

As Yang Zheng explains, SLS parameterizes the system using two transfer matrices, $\Phi_x$ and $\Phi_u$, which satisfy the identity $(zI - A)\Phi_x - B\Phi_u = I$. Here, $\Phi_x$ represents the map from a disturbance $w$ to the state $x$, and $\Phi_u$ represents the map from $w$ to the control input $u$.

The magic of this approach is that these "system-level" responses are linearly related to the system dynamics. This transformation turns hard, non-convex control design problems into convex optimization problems that can be solved efficiently using Semidefinite Programming (SDP), as demonstrated by Nicola Elia.

Why It Works: The Power of Locality

The most significant advantage of SLS is how it handles locality and communication constraints. In a massive power grid or a swarm of drones, it is impossible for every node to talk to every other node instantly. We need "localized" control.

In the traditional $K$ framework, enforcing a "sparsity" constraint (e.g., drone A only talks to drone B) is mathematically grueling and often non-convex. However, in the SLS framework, Carmen Amo Alonso and Jing Shuang Li show that these constraints become simple linear constraints on the responses $\Phi_x$ and $\Phi_u$.

If you want a disturbance in one part of the network to only affect its immediate neighbors, you simply constrain the responses to be spatially localized. This allows for Distributed and Localized Model Predictive Control (DLMPC), where the computational cost for each controller stays constant even as the total network grows to millions of nodes Amo Alonso et al..

Minimizing Regret in Uncertain Environments

Beyond just staying stable, modern control often aims to be "regret-optimal." Regret is the performance gap between your real-time controller and an "omniscient" controller that knew the future disturbances in advance.

By using SLS to parameterize the space of all possible responses, researchers like Gautam Goel and Andrea Martin have developed controllers that minimize this gap. Because SLS provides a convex way to describe how a system reacts to noise, it becomes possible to optimize for the "Best of Both Worlds": a controller that performs well on average but also guarantees safety against worst-case adversarial noise Zhou and Tzoumas.

Safety Filters and Nonlinear Extensions

The flexibility of the SLS framework has led to its adoption as a "safety layer" for black-box systems. Antoine P. Leeman and Melanie Zeilinger have developed Predictive Safety Filters that use SLS to wrap around complex neural network controllers. The filter monitors the intended action and, using the system-level parameterization, minimally adjusts it only when a violation of safety constraints is imminent.

While originally designed for linear systems, recent work by Lauren Conger has extended SLS to nonlinear polynomial systems. By spreading the cancellation of nonlinearities over a finite time horizon—rather than trying to cancel them all at once—these methods achieve high performance with significantly less control effort.

Summary of Intuition

System Level Synthesis works because it stops trying to find the "rule" (the controller) and starts designing the "outcome" (the system response). By shifting the math into the space of closed-loop maps:

  1. Constraints become linear: Sparsity, delay, and safety limits are easier to enforce.
  2. Optimization becomes convex: We can use powerful, off-the-shelf solvers to find globally optimal behaviors.
  3. Complexity becomes local: Large-scale systems can be controlled by solving small, independent sub-problems.

Papers in this version

Showing 60 of 72 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_system_level_synthesis_for_optimal_contr_0e5ab6e0,
  title = {System Level Synthesis for Optimal Control},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/system-level-synthesis-for-optimal-control/rdr_0e5ab6e009494cb3a2c88325a1a99864},
  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_system_level_synthesis_for_optimal_contr_0e5ab6e0_v1,
  title = {System Level Synthesis for Optimal Control},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/system-level-synthesis-for-optimal-control/rdr_0e5ab6e009494cb3a2c88325a1a99864/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}