System Level Constraints (SLCs) in Control Synthesis

• System Level Constraints (SLCs) are convex restrictions on closed-loop response maps within SLS that encode spatiotemporal, structural, and robustness requirements.
• They enable scalable controller synthesis by enforcing finite impulse response, locality, and norm-based performance metrics useful for distributed and constrained systems.
• Applications of SLCs span power grids, sparse sensor/actuator designs, and distributed energy resources, achieving near-centralized performance with localized computation.

System Level Constraints (SLCs) are convex restrictions imposed directly on the closed-loop system response maps within the System Level Synthesis (SLS) framework. SLCs encode structural, spatiotemporal, and robustness requirements in controller synthesis for large-scale, distributed, and constrained systems. Their introduction enables scalable, flexible, and transparent optimal and robust control design substantially beyond the reach of classical Youla or Quadratic-Invariance (QI)–based methods, encompassing locality, communication delay, finite impulse response, norm-based performance/robustness, and explicit actuator/sensor structural constraints. This article provides a rigorous overview of the mathematical foundations, canonical classes, algorithmic implications, and representative application domains of SLCs, synthesizing developments from core SLS literature (Anderson et al., 2019), distributed MPC (Alonso et al., 2019), separable synthesis (Wang et al., 2017), and robust constraint enforcement (Matni et al., 2019), among others.

1. Mathematical Definition and System-Level Role

In the SLS framework, a linear time-invariant (LTI) plant

$x[t+1] = A x[t] + B u[t] + \delta_x[t], \qquad y[t] = x[t] + \delta_y[t}$

combined with an output-feedback law $u[t] = K y[t]$ induces closed-loop disturbance-to-state and disturbance-to-control response maps:

$$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$

which, via stacking, yield

$$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$

These maps are internally stabilizing if and only if they satisfy the affine achievability (or system-level parameterization, SLP) constraint:

$$\left[ zI - A \;\; -B \right] \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} = I, \qquad \Phi_x, \Phi_u \in 1/z \; RH_\infty$$

System Level Constraints (SLCs) are any convex restrictions on $(\Phi_x, \Phi_u)$ that encode desired spatiotemporal, robustness, or architectural properties of the closed-loop response (Anderson et al., 2019). The SLS problem then becomes

$$\min_{\Phi_x, \Phi_u} J(\Phi_x, \Phi_u) \quad \text{subject to} \quad \left[ zI - A \;\; -B \right] \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} = I, \quad (\Phi_x, \Phi_u) \in SLC$$

The ability to directly impose SLCs on the system responses, while retaining convexity, is the core technical advance enabling SLS-based scalable and structured controller synthesis (Wang et al., 2016).

2. Canonical SLC Classes: Spatiotemporal and Robustness Constraints

Various SLC families are expressible as convex constraints on the system response transfer matrices and their impulse responses:

• Finite Impulse Response (FIR) SLC: Impose $\Phi_x[z], \Phi_u[z]$ are FIR of horizon $T$:

$$\Phi_x(z) = \sum_{t=1}^{T} z^{-t} \Phi_x[t],\quad \Phi_u(z) = \sum_{t=1}^{T} z^{-t} \Phi_u[t]; \quad \Phi_x[t], \Phi_u[t] = 0 \;\forall t > T$$

This is an affine subspace in the impulse response coefficients (Anderson et al., 2019).

• Spatial Locality (Sparsity): For network nodes $u[t] = K y[t]$0 and distance function, enforce

$u[t] = K y[t]$1

This yields a fixed-pattern zero SLC encoding communication and actuation limitations (Wang et al., 2017).

• Communication Delays: Impose structural constraints reflecting delayed information exchange, e.g. for delays $u[t] = K y[t]$2:

$u[t] = K y[t]$3

Convex support constraints enforce causality under nonzero communication delays (Anderson et al., 2019).

• Norm-Based Robustness/Performance: Classical closed-loop design metrics:
  • Weighted $u[t] = K y[t]$4:

  $u[t] = K y[t]$5 - $u[t] = K y[t]$6 (worst-case gain):

  $u[t] = K y[t]$7 - Robust performance: To account for plant error $u[t] = K y[t]$8:

  $u[t] = K y[t]$9

Small-gain constraints guarantee robust stability against bounded parametric uncertainty (Anderson et al., 2019, Matni et al., 2019).

3. Computational Methods and Decomposition for Large-Scale Systems

SLCs, via their convexity and structure, enable scalable and distributed solution of high-dimensional synthesis problems:

• Column/Row Separability: Many SLCs (e.g., FIR, block-sparsity, group penalties) and objectives split into independent subproblems across block-columns or block-rows. For instance, the $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$0-norm with uncorrelated disturbances is column-wise separable; group-sparse penalties for sensor or actuator selection yield row- or column-separability (Wang et al., 2017).
• Block Decomposition: Imposing locality and FIR constraints, one can solve $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$1 independent subproblems, each involving only local plant data, with per-subproblem complexity $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$2 in the global system size. ADMM and related methods efficiently handle partial separability (mixed constraints/objectives) by operating alternating minimization on redundant variables, preserving locality and enabling parallelization (Anderson et al., 2019, Wang et al., 2017).
• Explicit Control Law Derivation: For DLMPC with SLCs, explicit piecewise-affine control laws with a fixed (e.g., three) number of regions per scalar are obtainable per local subproblem, drastically reducing online computational cost and complexity irrespective of global network size (Alonso et al., 2020, Alonso et al., 2019).

These computational strategies enable practical, scalable synthesis for systems with tens of thousands of degrees of freedom.

4. Enforcement of Hard State/Input Constraints and Robust Guarantees

SLCs generalize to incorporate state/input constraints as convex sets over system responses, allowing robust optimization-based synthesis:

• State/Input Polytopic Constraints: Robust satisfaction of polyhedral constraints $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$3 for all disturbance realizations is encoded as:

$$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$4

Dualization introduces auxiliary variables which inherit the SLC sparsity pattern, enabling distributed primal-dual solution (Chen et al., 2019).

• Nonlinear and Uncertain Plants: For systems with polynomial or norm-bounded nonlinearities, robust SLCs are constructed by combining linearization, state/input tubal tightening, and Hessian-based overbounds on remainders, resulting in second-order cone or linear program representations guaranteeing robust constraint satisfaction for all admissible disturbances and state deviations (Leeman et al., 2023).
• Tube-Based MPC and SLS: The SLP reformulation enables online optimization over “tube” controllers, achieving significant reductions in conservatism and improvements in feasible region of attraction and average closed-loop cost compared to classical fixed-tube MPC (Sieber et al., 2021).
• Nonlinear Operator Perspective: In fully nonlinear settings, SLCs characterize sets of closed-loop maps as solutions to operator equations, with robust stability ensured via small-gain conditions on the (approximate) residual operator (Ho, 2020).

5. Practical Impact and Representative Case Studies

The systematic application of SLCs underpins the performance-transparency, scalability, and flexibility of SLS-based approaches:

• Power Grids: Large IEEE-type power grids with locality $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$5, communication delay = 2, and FIR $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$6 achieve closed-loop $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$7 performance within 0.1% of the fully centralized optimal, while controller complexity and communication remain localized and scalable (Anderson et al., 2019).
• Sparse Actuation/Sensing Design: Regularized SLS with group penalties enables principled trade-offs between the number of actuators/sensors and closed-loop cost, e.g., removing up to 43% of actuators and 46% of sensors at < 10% cost increase (Wang et al., 2017, Anderson et al., 2019).
• Distributed Energy Resources: In virtual power plant applications, SLS with SLCs enables distributed, privacy-preserving synthesis of distributed controllers that enforce device-level constraints and inter-agent fairness objectives, with distributed optimization converging to within $$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$8 of centralized cost (Grontas et al., 2022).
• Delayed and Adaptive Control Architectures: SLCs encode communication delays, locality, and model uncertainty, ensuring robust, scalable adaptation and learning in large, sparsely interconnected systems (Ho et al., 2019).

A summary of SLC types and impacts is shown below:

SLC Type	Mathematical Form	Main Impact
FIR (Finite Horizon)	$$\Phi_x(z) = (zI - A - BK)^{-1}, \quad \Phi_u(z) = K(zI - A - BK)^{-1}$$9	Makes SLS finite-dimensional, tractable
Locality (Sparsity)	$$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$0 if dist > d	Enforces communication/actuator limits
Norm-Based (H₂/L₁/∞)	$$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$1	Robustness/performance/convex design
State/Input Polyhedral	$$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$2	Robust constraint enforcement
Communication Delay	Support restriction on $$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$3	Models network timing/latency

6. Theoretical Generality and Relationship to Other Frameworks

SLCs encompass and extend classical controller structure constraints:

• Quadratic Invariance (QI): Any QI constraint (on a controller subspace $$\begin{bmatrix} x \ u \end{bmatrix} = \begin{bmatrix} \Phi_x & \Phi_u \end{bmatrix} \begin{bmatrix} \delta_x \ \delta_y \end{bmatrix}$$4) is representable as a convex SLC on the closed-loop response map; SLCs further allow non-QI, non-classical, and heterogeneous structural constraints to be convexly enforced (Wang et al., 2016, Zheng et al., 2019).
• Convexity and Generality: Any convex set of operator constraints, including subspaces (for locality) and convex norm bounds (for performance/robustness), leads to a convex SLS feasibility region (Wang et al., 2017, Anderson et al., 2019).
• Infinite/Continuous-Time Extension: Recent work extends SLS and SLCs to continuous-time systems via partial-fraction and simple-pole approximations, adapting locality, sparsity, and performance SLCs directly in the Laplace domain and for infinite-dimensional problems (Du et al., 2024).
• Output Feedback and Dynamic Programming: SLCs generalize for output-feedback synthesis, including multi-sided constraints, with scalable solution via dynamic programming and affine state parametrizations (Conger et al., 2021, Tseng et al., 2020).

7. Summary and Significance

System Level Constraints formalize the direct, convex, and transparent imposition of distributed structure, spatiotemporal locality, communication delay, finite-horizon behavior, and norm-bounded robustness in the closed-loop system responses, as parameterized in the SLS framework. By shifting focus from direct controller synthesis to design of the closed-loop maps, SLCs expand the field of tractable, scalable, and implementable optimal and robust control well beyond classical methods, while providing fine-grained control over performance–complexity–robustness trade-offs and enabling principled large-scale, distributed, and constrained controller architectures (Anderson et al., 2019, Wang et al., 2017, Wang et al., 2016, Matni et al., 2019).