⚡ electrical engineering

Sparse Representations of Dynamical Networks: A Coprime Factorization Approach

This paper introduces a coprime factorization approach for linear time-invariant dynamical networks that enables shifting between sparsity-preserving representations and facilitates the development of distributed stabilizing controllers for both discrete- and continuous-time systems.

Original authors: Şerban Sabău, Andrei Sperilă, Cristian Oară, Ali Jadbabaie

Published 2026-08-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Şerban Sabău, Andrei Sperilă, Cristian Oară, Ali Jadbabaie

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the modern world, critical infrastructure—from power grids to fleets of autonomous vehicles—relies on vast networks of interconnected systems. These are not monolithic machines but collections of individual components that must work together seamlessly. For decades, engineers have tried to control these complex webs by treating them as a single, giant entity, calculating a massive set of instructions that dictates how every part should behave. However, as these networks grow larger and more spread out, this centralized approach becomes computationally impossible and fragile. If the central computer fails or the communication lines get clogged, the entire system can collapse. The challenge, then, is to design control systems that are distributed, where each component makes its own decisions based on local information and what it hears from its immediate neighbors, yet still guarantees that the whole network remains stable and safe.

A team of researchers has developed a new mathematical framework to solve this problem, offering a way to design these distributed controllers that works for both continuous systems, like the flow of electricity, and discrete systems, like digital data packets. Their work bridges a gap between two previously separate ways of thinking about network control. On one side, there are methods that focus on the raw input and output signals of a network, which are good for design but often hide the internal mechanics of how the system actually moves. On the other side, there are methods that look at the internal state of the system, which are great for understanding stability but have been difficult to apply to large, complex networks without losing their structural simplicity. The researchers have created a unified language that connects these two perspectives, allowing engineers to see the internal state of the network while preserving the sparse, local connections that make distributed control possible.

The core of their discovery is a new way of representing a network's behavior, which they call a System Response-Type Realization. Imagine a network as a series of nodes, like cities in a country, where each city has its own dynamics and talks only to its neighbors. Traditionally, if you tried to write down the equations for how the whole country behaves, the result would be a dense, tangled web where every city seems to depend on every other city, even those far away. This makes it impossible to implement a local control strategy because the math suggests you need information from everywhere. The researchers found a way to rewrite these equations so that the internal structure of the network is preserved. In their new representation, the equations clearly show which nodes talk to which, keeping the "sparsity" or the emptiness of the connections intact. This is crucial because it allows a controller to be built that respects the physical reality of the network: a node only needs to listen to its neighbors, not the entire world.

What makes this approach particularly powerful is that it works for both continuous-time systems, which change smoothly over time, and discrete-time systems, which change in steps. Previous methods often had to choose one or the other, or they relied on assumptions that didn't hold up in the real world. The team proved that their new representation is mathematically robust, ensuring that if the controller is designed correctly, the network will not just appear stable but will actually remain stable even if there are small disturbances or communication delays. They demonstrated that this method allows for the creation of controllers that are not only stable but also "strongly stabilizing," meaning the system will return to a calm state from any starting point, not just stay within a safe boundary. This is a significant leap forward because it removes the need for the network to be perfectly designed from the start; the controller can handle a wider variety of starting conditions and still bring the system to order.

To prove their theory, the researchers applied their method to a specific example of a ring network, a common structure where nodes are connected in a circle, like a chain of vehicles driving in a platoon. In this scenario, each vehicle can only see the one directly in front of it and the one directly behind it. Using their new framework, they were able to design a controller that maintained this ring structure. Instead of a massive, complicated set of rules, the controller for each vehicle turned out to be a simple, low-order equation that only used data from its immediate neighbors. The simulation showed that this distributed controller successfully stabilized the entire network, keeping the vehicles in formation and preventing them from crashing or drifting apart. The results confirmed that the new representation could take a complex, high-dimensional problem and break it down into manageable, local pieces without losing the global stability guarantees.

The implications of this work extend beyond just the mathematics of control theory. By providing a clear, unified way to move between different types of network representations, the researchers have given engineers a practical toolkit for designing the next generation of smart infrastructure. Whether it is coordinating a swarm of drones, managing a smart grid, or guiding a fleet of self-driving cars, the ability to design controllers that are both distributed and mathematically guaranteed to be stable is a critical step forward. The paper does not claim to have solved every problem in network control, but it has removed a major barrier that previously forced engineers to choose between theoretical elegance and practical implementation. By showing that these two goals can be achieved simultaneously, the work opens the door to more resilient, efficient, and scalable systems that can operate reliably in the complex, interconnected world of the future.

Technical Summary: Sparse Representations of Dynamical Networks: A Coprime Factorization Approach

Problem Statement

The paper addresses the challenge of designing distributed controllers for Linear Time-Invariant (LTI) dynamical networks. While recent research has shifted from imposing sparsity on the Transfer Function Matrix (TFM) of controllers toward state-space-based decentralized laws, significant limitations persist in the literature. Existing methods often struggle with scalability for large-scale systems, as constructing interconnected plant models from node realizations does not scale gracefully. Furthermore, many approaches are restricted to either continuous-time or discrete-time domains, and those that bridge both (such as the Network Realization Function or NRF framework) often lack transparency regarding the underlying state dynamics of the network. The authors identify a need for a representation that preserves the sparsity structure of network interconnections, ensures closed-loop stability, and offers a unified framework for both continuous- and discrete-time systems while maintaining insight into state dynamics.

Methodology

The authors propose a new factorized representation called the System Response-Type Realization (SRTR). This approach is built upon a specific state-space partitioning of the network's minimal realization.

State-Space Partitioning: The paper begins by transforming a standard state-space realization $(A, B, C, D)$ into a specific form where the output matrix $C$ is partitioned to isolate manifest variables ( $y$ ) from internal/hidden variables ( $q$ ). This results in a system where the manifest variables satisfy a differential/difference equation involving a TFM $W(\lambda)$ and an input TFM $V(\lambda)$ .
Definition of SRTR: An SRTR is defined as a pair of proper TFMs, $(W(\lambda), V(\lambda))$ , satisfying the relation $G(\lambda) = (\lambda I_p - W(\lambda))^{-1}V(\lambda)$ . This structure mirrors the state iteration equations found in System-Level Synthesis (SLS) but is generalized for both continuous and discrete time.
Coprime Factorization Analysis: The core theoretical contribution involves analyzing the relationship between SRTR pairs and classical coprime factorizations. The authors prove that for a minimal realization, the pair $(\lambda I_p - W(\lambda), V(\lambda))$ constitutes a Fully Left Coprime Factorization (FLCF) of the system's TFM. This is a critical distinction from NRF pairs, which are not guaranteed to be coprime.
Interconversion Framework: The paper establishes numerically tractable procedures to shift between:
- Classical Left Coprime Factorizations (LCF) over the stability domain $S$ .
- NRF pairs (Input-Output based).
- SRTR pairs (State-dynamics based).
  These conversions rely on solving algebraic Riccati equations (specifically the Continuous-Time Non-Symmetric Algebraic Riccati Equation, CTNARE) to find stabilizing solutions that preserve the desired properties.
Sparsity Enforcement: To achieve distributed implementation, the authors provide conditions (Theorem 4.20) under which a matrix $K$ can be selected to enforce a specific sparsity pattern on the SRTR pair $(W, V)$ . This allows the resulting controller to inherit the network's topology (e.g., ring, line) without requiring the underlying realization to be sparse.

Key Contributions

Unified Representation (SRTR): The introduction of the SRTR, which captures both the dynamics and the structure of the network regardless of whether the system is modeled in continuous or discrete time. Unlike NRF representations, SRTRs provide a direct link to the state dynamics of the plant.
Intrinsic Coprimeness: The proof that SRTR pairs naturally yield fully left coprime factorizations of the system TFM. This property facilitates the commutation between SRTR representations and classical coprime factorizations, a feature not guaranteed in NRF-based approaches.
Distributed Stabilization: The development of specialized distributed implementations for stabilizing controllers. The paper demonstrates that controllers implemented via SRTR feedback schemes guarantee closed-loop internal stability.
Continuous-Time Extension: The paper extends distributed control guarantees to continuous-time systems. It addresses the specific challenge that, unlike in discrete-time where $1/z$ is stable, $1/s$ is not stable in continuous time. The authors show that while the TFM of the distributed controller may be unstable in continuous time, the state-space implementation can still asymptotically stabilize the closed-loop system's state dynamics.
Numerical Tractability: The provision of explicit state-space formulas and conditions (involving orthogonal matrices and Riccati solutions) to compute SRTR pairs with desired sparsity structures and low-order realizations for each node.

Results

The theoretical results are validated through a numerical example involving a ring network of 6 nodes with homogeneous dynamics.

Controller Synthesis: The authors synthesized a controller for the network using procedures from prior work to obtain a stabilizing controller with a specific NRF sparsity structure.
SRTR Conversion: They successfully converted this controller into an SRTR representation.
Sparsity Preservation: The resulting SRTR-based control laws preserved the ring topology of the network. Specifically, each node's control signal depended only on its own state and the state of its immediate predecessor in the ring.
Stability Verification: The numerical example confirmed that the derived SRTR pair was stable and that the resulting distributed implementation (using the state-space realization of the SRTR) asymptotically stabilized the network's state dynamics, even in the continuous-time setting.

Significance and Claims

The paper claims to provide a "unitary mathematical framework" that bridges the gap between input-output oriented methods (like NRF and SLS) and state-space-based methods.

Transparency: The authors argue that SRTR offers "notably keener insight into the state dynamics" compared to NRF, which is primarily designed for synthesis and often opaque regarding internal states.
Flexibility: The framework allows for the design of controllers that can be implemented as specific network topologies (e.g., rings or lines) without the computational burden of constructing highly structured realizations for the entire plant.
Robustness: By leveraging coprime factorization properties, the approach ensures that the distributed implementation inherits the stability guarantees of the centralized design.
Generality: The work explicitly unifies continuous and discrete-time treatments, addressing a limitation in previous literature where methods were often time-domain specific.

The paper concludes that this approach paves the way for distributed implementations of control laws that are both stabilizing and structurally aligned with the physical or logical interconnections of the network, validating the framework's capacity for practical controller design.