How Far Should Control Signals Travel in a Power Grid? A New Law for Distributed Systems

A disturbance in a power grid in Texas today doesn’t just affect Houston—it ripples through the network, triggering responses in Dallas, San Antonio, and beyond. But how far should those signals travel? How long should local controllers remember them? And can we design systems that contain disruptions locally, without sacrificing global performance? A new theoretical breakthrough shows that, under realistic assumptions, the answers grow only logarithmically with precision—meaning even vast networks can be managed with surprisingly modest communication and memory.

This isn’t just about power grids. It applies to climate-controlled buildings, traffic systems, industrial plants, and any large-scale network where local decisions must balance global efficiency. The key insight? Optimal control responses decay exponentially in both space and time—so we can truncate them without significant loss. And the cost of doing so scales gently: to halve the performance gap, you don’t need to double your bandwidth—you just need to add a fixed number of extra hops and memory steps, regardless of network size.

The Science

Chenchen Zhou and José Matias, researchers at KU Leuven, tackle one of the central challenges in modern control theory: how to design distributed controllers that approach the performance of a centralized “omniscient” system, without requiring every node to communicate with every other node. Their work, published on arXiv in 2026, focuses on networked linear quadratic regulation (LQR)—a foundational framework for optimizing control performance under quadratic cost functions.

The problem is deceptively simple. In a centralized LQR setup, a single controller has access to the full state of the system and computes globally optimal inputs. But in real-world applications—like a continent-wide power grid or a fleet of autonomous vehicles—this is infeasible. Communication delays, bandwidth limits, and computational overhead make centralized control impractical.

Distributed control offers a solution: each node makes decisions based on local information. But how much information? How far should a node “listen”? How long should it “remember”? These choices define the control architecture—and until now, there was no general way to translate a desired performance loss into concrete bounds on communication range and memory.

Zhou and Matias use System Level Synthesis (SLS), a modern control framework that represents controllers not as feedback gains, but as maps from disturbances to system responses. In SLS, a controller is defined by how it propagates the effects of a disturbance impulse through time and space. This shift in perspective—from gains to responses—enables a precise analysis of spatiotemporal decay.

They study systems defined on graphs, where nodes represent subsystems (e.g., generators, buildings, vehicles) and edges represent physical couplings. The dynamics are locally coupled: each node’s state evolves based only on its neighbors’ states and inputs. The cost function is also local, with quadratic penalties on states and inputs that couple nearby nodes.

Their analysis rests on two key assumptions:

1. Uniform regularity: Local system dimensions, coupling ranges, and matrix norms are bounded independently of network size.
2. Uniform stabilizability and detectability: There exist static feedback and observer gains that stabilize the system, with decay rates uniform across network sizes.

These assumptions ensure that system behavior doesn’t deteriorate as the network grows—a critical requirement for scalable control.

What They Found

The core result is a spatiotemporal decay law for the centralized optimal response. When a disturbance hits a single node, the optimal state and input responses at distant nodes decay exponentially in both time and spatial distance—specifically, outside an “effective coupling cone.”

Mathematically, they prove (Theorem 1) that for all nodes $i,j$ and time steps $t\ge 0$:

$$\Vert {\Phi }_x^{\star }[t+1{]}_{ij}\Vert +\Vert {\Phi }_u^{\star }[t+1{]}_{ij}\Vert \le C_{\mathrm{lc}}{\rho }_{\mathrm{lc}}^{t+c_{\mathrm{lc}}[d_{\mathcal{G}}(i,j)-v_{\mathrm{cone}}t{]}_{+}}$$

Here, ${\Phi }_x^{\star }[t+1{]}_{ij}$ is the optimal state response at node $i$ at time $t+1$ due to a disturbance at node $j$, $d_{\mathcal{G}}(i,j)$ is the graph distance between nodes, and $v_{\mathrm{cone}}$ is the maximum distance a disturbance can propagate in one time step (e.g., 1 hop per step for nearest-neighbor coupling). The constants $C_{\mathrm{lc}}$, ${\rho }_{\mathrm{lc}}\in (0,1)$, and $c_{\mathrm{lc}}>0$ are independent of network size.

This means that the influence of a disturbance fades rapidly: both over time and with distance beyond the causal cone $d_{\mathcal{G}}(i,j)\le v_{\mathrm{cone}}t$. For example, if ${\rho }_{\mathrm{lc}}=0.9$, each additional time step or spatial hop beyond the cone reduces the response magnitude by nearly 10%.

Decay of Optimal Response with Distance and Time

Label	Value
t=1	0.8
t=2	0.64
t=3	0.51
t=4	0.41
t=5	0.33

Simulated decay with ρ_lc = 0.8, showing rapid falloff beyond causal cone

Using this decay, they derive bounds on the performance loss when truncating the optimal response to a local support. For networks with polynomial neighborhood growth—where the number of nodes within distance $r$ grows as $r^d$—they show that to achieve a per-node LQR cost gap of $ϵ$, it suffices to set:

• Immediate communication radius $\kappa \propto \log (1/ϵ)$
• Maximum spatial footprint $\bar{\kappa }\propto \log (1/ϵ)$
• Memory horizon $T\propto \log (1/ϵ)$

In other words, the required communication range, spatial reach, and memory grow only logarithmically with the inverse tolerance—independently of network size. This is a striking result: even for a network of a million nodes, the local controller needs only a few dozen hops of communication and memory to achieve near-optimal performance.

They propose two controller constructions:

1. Direct truncation: Simply discard response coefficients outside the local support. This yields a stable, finite-memory controller under a computable small-gain condition (Theorem 3).
2. Exact localized SLS: Re-optimize the response within the local support while preserving the SLS achievability condition. This yields a controller that confines and eliminates disturbances in finite time and space, under an additional “uniform local deadbeat” assumption (Theorem 4).

Numerical experiments on a thermal mesh system (a grid of coupled rooms) illustrate the trade-offs. For a 10% performance loss, the required communication radius is just 3 hops; for 1%, it’s 5 hops. Meanwhile, the number of nonzero filter taps per node grows polylogarithmically—slower than any polynomial.

Required Communication Radius vs. Performance Tolerance

Label	Value
ε=0.1	3
ε=0.05	4
ε=0.01	5
ε=0.005	6
ε=0.001	7

Radius grows as ~1.4 log(1/ε), enabling scalability

Why This Changes Things

This work transforms how we think about control architecture design. Traditionally, distributed control has been a trade-off between performance and feasibility: you pick a fixed communication graph and hope it’s “good enough.” Now, for the first time, we can reverse-engineer the architecture from performance requirements.

Consider a smart grid operator. They might ask: “How much would it cost to contain a generator failure within 50 miles and 10 seconds?” Zhou and Matias’ framework lets them compute the required communication infrastructure and local memory—without simulating the entire network.

Or imagine urban planners designing a city-wide traffic control system. Instead of assuming fixed communication ranges, they can now ask: “What’s the cheapest way to keep congestion localized after an accident?” The answer, according to this paper, is likely far less expensive than previously thought.

The logarithmic scaling is particularly powerful. In a network with $N$ nodes, the number of nodes within radius $r$ is roughly $r^d$ (for dimension $d$). But the required $r$ grows only as $\log (1/ϵ)$, so the number of neighbors each controller must communicate with is ${\log }^d(1/ϵ)$—a polylogarithmic cost. For $ϵ=10^{-3}$ and $d=2$, that’s about ${\log }^2(1000)\approx 50$ neighbors, regardless of whether $N=10^3$ or $N=10^6$.

This has profound implications for resilience. A system that can contain disturbances locally is inherently more robust. If a cyberattack or equipment failure affects one node, a well-designed localized controller can prevent cascading failures—without waiting for central coordination.

It also enables modularity. New nodes can be added without redesigning the entire control system, as long as the local architecture satisfies the decay-based bounds. This is crucial for renewable energy integration, where solar farms and wind turbines are added incrementally.

Compare this to prior work. Earlier results on gain decay (e.g., Shin et al.) focused on static feedback gains and one-step truncation. Zhang et al. studied spatial decay but with network-size-dependent rates. Predictive SLS bounded regret with fixed communication, but didn’t derive the intrinsic memory and footprint of the optimal response. Zhou and Matias go further: they analyze the joint spatiotemporal decay of the infinite-horizon optimal response and translate it into separate, scalable bounds on communication, footprint, and memory.

What's Next

The theory assumes uniform regularity and polynomial graph growth—reasonable for many physical networks, but not all. Future work could extend it to random graphs, time-varying topologies, or systems with long-range couplings (e.g., high-voltage transmission lines).

The “uniform local deadbeat” assumption for exact localization is strong. It requires that local feedback can eliminate disturbances in finite time—a condition that may not hold in underactuated systems. Relaxing this would broaden applicability.

Real-world deployment will require robustness to model uncertainty and disturbances. While the small-gain condition in Theorem 3 provides some robustness, integrating this with modern robust control methods (e.g., ${\mathcal{H}}_{\infty }$) is an open direction.

Perhaps most exciting is the potential for co-design. The paper suggests using the truncated response energy as a cheap metric to screen control architectures before full synthesis. This could feed into automated design tools that jointly optimize physical layout, communication infrastructure, and control logic—much like how modern chip design tools optimize placement and routing.

Imagine a future where a city planner uploads a map of a new district, specifies performance and resilience targets, and an AI returns not just a control architecture, but a full blueprint for sensors, communication links, and local controllers—all guaranteed to meet the specs. That future is now a little closer.

As Zhou and Matias write: “Numerical experiments illustrate how performance and disturbance containment requirements guide architecture selection.” This is more than a technical result. It’s a new paradigm: control as a service of requirements, not a constraint of topology.