Computing Scaled Relative Graphs of Discrete-time LTI Systems from Data

This paper presents methods to compute the Scaled Relative Graph (SRG) of discrete-time linear-time-invariant systems exactly from state-space models and exclusively from input-output data, while also introducing a robust SRG formulation capable of handling noisy trajectories.

The Gist

Imagine you are trying to understand a mysterious black box machine. You don't know how it's built inside, but you can push buttons (inputs) and watch what comes out the other side (outputs). In the world of engineering and control theory, this machine is a system, and understanding its behavior is crucial to making sure it doesn't go haywire.

For decades, engineers have used maps and diagrams (like Nyquist and Bode plots) to visualize how these machines behave. A new, more powerful tool has recently emerged called the Scaled Relative Graph (SRG). Think of the SRG not just as a map, but as a "shape of behavior."

If you feed the machine a specific signal, the SRG tells you two things:

1. How much the machine amplifies or shrinks the signal (Gain).
2. How much the machine delays or shifts the signal (Phase).

When you plot all possible signals on a graph, they form a shape (like a circle, a blob, or a line). If this shape stays within certain safe boundaries, the machine is stable. If it spills over, the machine might crash or oscillate wildly.

This paper by Talitha Nauta and Richard Pates is about how to draw this "shape of behavior" accurately, even when you don't have the blueprints of the machine. They offer three ways to do it:

1. The Blueprint Method (When you know the math)

Imagine you have the exact architectural drawings of the machine (the state-space equations).

• The Old Way: You might have to simulate the machine with thousands of different inputs to guess the shape.
• The New Way: The authors show you can use a specific mathematical recipe (called Linear Matrix Inequalities, or LMIs) to calculate the exact shape instantly. It's like having a calculator that instantly tells you the perimeter and area of a complex shape without you having to measure every single side.

2. The "Black Box" Method (When you only have data)

Now, imagine you lost the blueprints. You only have a video recording of the machine running: a list of inputs you pushed and outputs you saw.

• The Challenge: How do you draw the shape without knowing the internal gears?
• The Solution: The authors show that if your video recording is "rich" enough (meaning you pushed enough different buttons in a complex pattern), you can use the same mathematical recipe to draw the shape directly from the data. You don't need to know the internal math; the data itself contains the secret. It's like being able to guess the shape of a hidden object just by feeling its shadow.

3. The "Noisy Weather" Method (When the data is messy)

Real life is messy. Your video recording might have static, or the machine might be jiggling due to wind or vibration (noise).

• The Problem: If you try to draw the shape using messy data, your drawing might be wrong, and you might think the machine is safe when it's actually dangerous.
• The Solution: The authors created a "Robust SRG." Instead of drawing a single, thin line for the shape, they draw a thick, fuzzy cloud around it.
  • The Analogy: Imagine you are trying to draw a circle on a piece of paper while someone is shaking the table. You can't draw a perfect thin line. Instead, you draw a thick, fuzzy ring that is guaranteed to cover the real circle, no matter how much the table shakes.
  • This "fuzzy ring" is slightly larger than the perfect shape, but it guarantees that the actual machine's behavior is safely inside it. This ensures that even with noisy data, you won't accidentally think a dangerous machine is safe.

Why does this matter?

The paper also shows some cool tricks with these shapes:

• Different machines, same shape: Two completely different machines (like a low-pass filter and a high-pass filter) can have the exact same "shape of behavior" (SRG). This means they will react to stability tests in the exact same way, even if they sound or look different.
• Different shapes, same noise: However, if you add noise to those two machines, their "fuzzy rings" (Robust SRGs) look different. This tells engineers that while the machines behave similarly in a perfect world, they react differently to real-world messiness.

The Big Picture

In short, this paper gives engineers a new set of tools to:

1. Calculate the safety shape of a machine if they have the math.
2. Discover the safety shape if they only have a video of the machine running.
3. Protect themselves against bad data by drawing a "safety buffer" around the shape.

It turns a complex, abstract mathematical problem into a visual, geometric one, making it easier to design systems that are safe, stable, and reliable, whether you are building a self-driving car, a power grid, or a robot.

Technical Summary

Here is a detailed technical summary of the paper "Computing Scaled Relative Graphs of Discrete-Time LTI Systems from Data" by Talitha Nauta and Richard Pates.

1. Problem Statement

The Scaled Relative Graph (SRG) is an emerging graphical tool in control theory used for the stability and robustness analysis of dynamical systems, particularly for Non-Linear Multi-Input Multi-Output (MIMO) systems. While SRGs have been established for continuous-time Linear Time-Invariant (LTI) systems and bounded linear operators, there is a gap in the literature regarding:

1. Discrete-time LTI systems: Existing methods primarily focus on continuous-time or abstract operator theory.
2. Data-driven computation: Most SRG construction methods require an explicit state-space model. There is a lack of rigorous methods to compute SRGs directly from input-output data, especially when the system model is unknown or corrupted by noise.
3. Robustness: There is no established framework for computing SRGs that account for process noise, ensuring the resulting graph contains the true system's SRG.

The paper aims to bridge these gaps by providing exact and robust methods to compute SRGs for discrete-time LTI systems using both state-space representations and raw data trajectories.

2. Methodology

The authors propose a three-pronged approach based on Linear Matrix Inequalities (LMIs) and Dissipativity Theory.

A. Theoretical Foundation

The paper defines the SRG for operators associated with discrete-time systems. Two specific operators are considered:

• $T_\tau$: An operator defined on truncated $\ell_2$ spaces (finite horizon).
• $T$: An operator defined on the infinite $\ell_2$ space.
  The SRG is characterized by the set of complex numbers representing the gain ($\|y\|/\|u\|$) and phase shift ($\angle(u, y)$) between input and output. The authors utilize Corollary 1, which states that the SRG can be constructed by computing the maximum and minimum gains of the shifted operator $(T - \alpha I)$ over a grid of real scalars $\alpha$.

B. Approach 1: State-Space Representation (Known Model)

When the system matrices $(A, B, C, D)$ are known, the authors derive LMIs to compute the maximum ($\bar{\sigma}$) and minimum ($\underline{\sigma}$) gains.

• Maximum Gain: Computed via a Bounded Real Lemma formulation involving a positive semi-definite matrix $P$.
• Minimum Gain: Computed by transforming the problem into a maximum gain problem for the inverse system (if $D$ is non-singular) or by analyzing the dual LMI.
• Result: These LMIs allow for the exact computation of the SRG boundaries.

C. Approach 2: Data-Driven Computation (Noise-Free)

When the system model is unknown, the authors leverage Data-Driven Control techniques (specifically referencing Koch et al. [8]).

• Persistent Excitation: The input data must be sufficiently rich (persistently exciting of a specific order).
• Lag Definition: The method requires knowledge of a "lag" parameter $l$ (related to the system order) to construct Hankel-like matrices from input-output trajectories.
• Data Matrices: The input-output data is organized into matrices $\Xi$ (state-like regressors), $U_\Xi$, and $Y_\Xi$.
• Result: The LMIs are reformulated using these data matrices. The authors prove that solving these data-based LMIs yields the exact same SRG as the model-based approach, provided the data is sufficiently exciting.

D. Approach 3: Robust SRG from Noisy Data

To handle real-world scenarios with process noise, the authors introduce a Robust SRG.

• Noise Modeling: The noise is modeled as an unknown sequence belonging to a specific set defined by a quadratic constraint (Assumption 1).
• Set Membership: The unknown system matrices are treated as belonging to a set $\Sigma$ consistent with the noisy data and the noise bounds.
• Robust LMI: Using a Matrix S-Lemma and duality arguments, the authors derive a robust LMI (Theorem 3). This LMI ensures that the computed gain bounds hold for all systems consistent with the noisy data.
• Outcome: The resulting SRG is an over-approximation (a superset) that is guaranteed to contain the true SRG of the underlying noise-free system.

3. Key Contributions

1. Discrete-Time Extension: The paper extends SRG theory from continuous-time to discrete-time LTI systems, providing exact state-space LMI characterizations.
2. Fully Data-Driven SRG: It demonstrates that SRGs can be computed exclusively from input-output trajectories without identifying the system model, using a single trajectory if it is persistently exciting.
3. Robust SRG Framework: It introduces a novel method to compute a "Robust SRG" from noisy data. This graph is a guaranteed superset of the true system's SRG, providing a safety margin for stability analysis in the presence of uncertainty.
4. Unification of Operators: The work clarifies the relationship between SRGs on truncated spaces ($T_\tau$) and infinite spaces ($T$), showing how they converge and how to compute them via LMIs.

4. Results and Validation

The authors validate their theory through numerical examples:

• Unstable MIMO System: They computed the SRG for an unstable system. The results confirmed that the SRG derived from the state-space model (Theorem 1) and the SRG derived from noise-free data (Theorem 2) are identical. The robust SRG (Theorem 3) successfully enveloped the true SRG.
• Low-pass vs. High-pass Filters: Two distinct systems (a low-pass and a high-pass filter) were shown to have identical SRGs (and Nyquist plots) but different robust SRGs when computed from noisy data. This highlights that while the nominal SRG captures the nominal gain/phase, the robust SRG captures the sensitivity to noise, which differs based on the system's frequency response characteristics.

5. Significance

This paper significantly advances the applicability of Scaled Relative Graphs in modern control engineering:

• Practicality: By enabling SRG computation from data, it removes the barrier of needing an accurate parametric model, which is often difficult or impossible to obtain for complex systems.
• Safety and Robustness: The introduction of the Robust SRG allows engineers to perform stability and robustness analysis directly on noisy experimental data, providing a mathematically rigorous guarantee that the true system behavior is contained within the computed graph.
• Bridging Theory and Practice: It connects abstract operator theory (Hilbert spaces, SRGs) with practical data-driven control techniques (LMIs, persistent excitation), making these powerful graphical tools accessible for discrete-time system analysis.

In summary, Nauta and Pates provide a comprehensive toolkit for analyzing discrete-time systems graphically, moving from theoretical model-based definitions to practical, noise-robust, data-driven implementations.