📊 statistics

Towards Uncertainty-Aware Federated Granger Causal Learning

This paper introduces an uncertainty-aware framework for Federated Granger Causal Learning that derives closed-form expressions for steady-state uncertainty propagation in distributed time-series systems, enabling principled hypothesis testing to distinguish genuine cross-client interactions from spurious edges while outperforming existing deterministic baselines.

Original authors: Ayush Mohanty, Nazal Mohamed, Nagi Gebraeel

Published 2026-05-13

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Ayush Mohanty, Nazal Mohamed, Nagi Gebraeel

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

The Big Picture: The "Secret Handshake" of Machines

Imagine a massive, complex factory with many different departments: the power grid, the assembly line, and the shipping dock. Each department is run by a different team (a "client"). These teams are constantly talking to each other; if the power flickers, the assembly line slows down. If the assembly line jams, the shipping dock gets backed up.

The problem? These teams are not allowed to share their private notebooks (raw data) with each other due to privacy rules. They can only send short, encrypted summaries to a central manager (the "server").

The goal is to figure out exactly who influences whom. Does the power grid cause the assembly line to slow down? Or is it the other way around? This is called Granger Causality.

A previous method (called FedGC) allowed these teams to figure out these connections without sharing their notebooks. However, it had a major flaw: it gave a "Yes" or "No" answer with no confidence meter. It was like a weather forecaster saying, "It will rain tomorrow," without telling you if there was a 10% chance or a 99% chance. Operators didn't know if they could trust the answer.

This paper introduces Uncertainty-Aware FedGC. It adds a "confidence meter" to the system, telling operators exactly how much they can trust each discovered connection.

The Core Problem: Why Was the Old System "Blind"?

In the old system, the teams and the manager played a game of "telephone" to learn the connections.

The Teams look at their own data and guess what the other teams are doing.
The Manager collects these guesses, updates the map of connections, and sends the new map back.
The Teams update their guesses based on the new map.

The problem was that every time they passed a note, noise got mixed in.

Aleatoric Uncertainty (The "Static"): This is the natural fuzziness of the real world. Machines vibrate, sensors glitch, and data is never perfectly clean. This is like static on a radio line.
Epistemic Uncertainty (The "Guess"): This is the lack of knowledge because the teams started with different initial guesses (priors). This is like two people starting a puzzle with different pictures in their heads.

The old method just gave a final answer, ignoring how much "static" or "bad guessing" had piled up during the process.

The Solution: Tracking the "Noise" Like a Detective

The authors realized that in this specific game of telephone, the noise doesn't just disappear; it travels in a loop. The noise from the team's data affects the manager's guess, which affects the team's next guess, which affects the manager again.

They built a mathematical model to track exactly how this noise moves. Think of it like a traffic control system for uncertainty.

1. The "Closed-Form" Map

The team derived a set of equations (a "closed-form" solution) that acts like a map. This map predicts exactly how much uncertainty will exist at the end of the process, based on:

How noisy the data is (the static).
How many times they played the game (iterations).
How the teams and manager talk to each other.

2. The Big Discovery: "The Guesses Wash Out"

One of the most surprising findings is about the "Guesses" (Epistemic uncertainty).

The Analogy: Imagine you and a friend are trying to guess the weight of a watermelon. You start with very different guesses (one thinks it's 5lbs, the other 50lbs). But as you both measure it, weigh it, and compare notes over and over, your initial guesses stop mattering. Eventually, you both agree on the weight based only on the actual measurements.
The Result: The paper proves that as the system trains, the uncertainty caused by the teams' initial "guesses" disappears. The final uncertainty depends only on the "static" in the data (Aleatoric uncertainty). It doesn't matter how the system started; it only matters how messy the data is.

3. The "Truth Detector" (Hypothesis Testing)

Because they can now calculate the exact amount of uncertainty, they can build a Truth Detector.

Old Way: "Is this connection real? Yes, the number is not zero." (Even if the number is tiny and likely just noise).
New Way: "Is this connection real? We calculated the noise level. This number is 10 times bigger than the noise. Yes, it's real."
If the number is small and close to the noise level, the system says, "This is probably just a glitch. Ignore it."

How They Tested It

They didn't just do math; they ran experiments to prove their map was accurate.

Synthetic Data (The "Fake Factory"): They created a computer simulation of a factory with known connections. They added different levels of "static" (noise) to the data.
- Result: The predicted uncertainty matched the actual noise perfectly. The "confidence meter" worked exactly as the math said it would.
- Comparison: They compared their method to other "federated" learning methods. The old methods missed real connections or invented fake ones. The new method found the real connections and correctly ignored the fake ones.
Real-World Data (The "Real Factories"): They tested it on data from real industrial systems (like a power grid and a chemical plant).
- Result: When they used their new method to find the root cause of a machine failure, they were better at pinpointing the exact problem than the other methods.

Summary of the Takeaway

This paper solves a trust issue in distributed machine learning.

Before: We could find connections between different systems without sharing data, but we didn't know if the connections were real or just random noise.
Now: We have a mathematical way to track exactly how much noise is in the system.
The Benefit: Operators can now say, "We are 95% sure this machine is causing that problem," rather than just guessing. This makes the system safer and more reliable for critical tasks like managing power grids or manufacturing networks.

The paper concludes that by understanding how uncertainty flows through the system, we can filter out the "fake news" (spurious connections) and keep only the "hard facts" (genuine causal links).

Technical Summary: Towards Uncertainty-Aware Federated Granger Causal Learning

Problem Statement
In distributed industrial systems such as smart grids and supply chains, subsystems interact through tightly coupled physical and operational dependencies, forming a decentralized causal structure. Identifying these cross-client causal interactions (Granger causality) is critical for fault diagnosis and risk mitigation. However, data sovereignty constraints prevent the sharing of raw time-series data across clients. While Federated Granger Causality (FedGC) has been introduced to recover these interactions without data sharing, existing methods return only deterministic point estimates. This lack of calibrated uncertainty leaves operators without a principled basis to distinguish genuine cross-client interactions from spurious edges, particularly in the presence of finite-sample effects and heterogeneous noise.

Methodology
The paper proposes an Uncertainty-Aware FedGC framework that characterizes how uncertainty propagates through the coupled client-server feedback loop of the FedGC architecture. The methodology is built upon a linear time-invariant (LTI) state-space model where clients observe vertically partitioned features.

Uncertainty Decomposition: The authors partition stochastic elements into two sources:
- Aleatoric Uncertainty: Irreducible noise inherent in client data (measurement and process noise).
- Epistemic Uncertainty: Uncertainty arising from the randomness of model parameters (initial priors for client augmentation matrices $\theta_m$ and server causal matrices $\hat{A}_{mn}$ ).
Propagation Analysis: The core technical contribution is the derivation of closed-form covariance recursions that track uncertainty propagation across four distinct channels:
- Within-Client: Evolution of client parameter variance ( $\Sigma^t_{\theta_m}$ ) and state variance ( $\Sigma^t_{h_m}$ ).
- Within-Server: Evolution of server parameter variance ( $\Sigma^t_{A_{mn}}$ ).
- Client-to-Server: Propagation of client state uncertainty to the server.
- Server-to-Client: Propagation of server gradient uncertainty back to the client.
Crucially, the analysis identifies four previously unrecognized cross-covariance terms ( $\Omega^t_m, \Lambda^t_m, \Gamma^t_{mn}, \Psi^t_{mn}$ ) that couple data noise and parameter uncertainties across the architecture.
Steady-State Characterization: Under mild stability conditions (spectral radius of gain matrices $< 1$ ), the authors prove that the system converges to a steady state. A central theoretical finding is that the steady-state uncertainty depends exclusively on client data statistics (aleatoric uncertainty) and is independent of the initial epistemic priors. As training converges, the influence of initial parameter randomness decays, leaving the data noise as the sole driver of steady-state behavior.
Downstream Utility: Leveraging the asymptotic covariance $\Sigma^\infty_{A_{mn}}$ , the authors construct a post-training hypothesis testing procedure. This test evaluates the significance of inferred edges ( $H_0: A_{mn} = 0$ ) using the derived standard deviations, allowing for the statistical pruning of spurious edges.

Key Contributions

Theoretical Foundation: The first formalization of uncertainty quantification in vertically partitioned federated learning for coupled dynamical systems, explicitly distinguishing between aleatoric and epistemic effects.
Closed-Form Recursions: Derivation of explicit expressions for uncertainty propagation, identifying four new cross-covariance terms that govern the interaction between client data, client parameters, and server parameters.
Convergence Guarantees: Establishment of spectral-radius-based convergence conditions yielding closed-form solutions for steady-state variances at both client and server nodes.
Independence from Priors: Proof that asymptotic uncertainty is determined solely by client data distribution, rendering the final model's uncertainty independent of initialization.
Statistical Edge Selection: Development of a hypothesis testing framework that uses the derived uncertainty to distinguish genuine causal edges from noise, addressing a key limitation of deterministic FedGC.

Experimental Results
The framework was validated on synthetic datasets and three real-world industrial datasets: HAI (HIL-based Augmented ICS), TEP (Tennessee Eastman Process), and SMD (Server Machine Dataset).

Theory Validation: Experiments confirmed that the predicted uncertainty propagation matches theoretical dynamics across various noise regimes. The results demonstrated that steady-state covariances are unaffected by the variance of initial parameter priors, validating the independence from epistemic uncertainty.
Causal Discovery: On synthetic data with known ground truth, the Uncertainty-Aware FedGC significantly reduced False Positives (FP) compared to "Vanilla FedGC" (which recovers all true edges but predicts many spurious ones) while maintaining zero False Negatives. It outperformed baselines like FedPC, FedDAG, and NOTEARS-ADMM, which failed to model cross-client interactions effectively.
Root Cause Analysis: On real-world datasets, the proposed method improved the accuracy of localizing anomaly root causes (measured by AC@k) compared to baselines, demonstrating the practical utility of the inferred causal graphs.

Significance and Claims
The paper claims to provide the first theoretical foundation for analyzing uncertainties in federated Granger causal learning. Its primary significance lies in transforming FedGC from a deterministic point-estimation tool into a statistically principled framework. By proving that steady-state uncertainty is driven solely by data characteristics rather than initialization, the authors provide a defensible basis for operators to trust or reject inferred cross-client interactions. The proposed hypothesis testing mechanism offers a rigorous method to filter spurious edges, directly addressing the challenge of identifying reliable causal structures in data-siloed, vertically partitioned environments.

Limitations
The authors acknowledge that the theoretical results rely on linear time-invariant dynamics and Gaussian noise assumptions. While extensions to nonlinear models (via EKF and Gaussian Processes) are discussed structurally, rigorous convergence guarantees and the "aleatoric-only" steady-state property have not been formally established for the nonlinear regime. Additionally, the independence of server parameters across block-rows is assumed, which may not hold in systems with shared latent confounders. Finally, the hypothesis test relies on asymptotic covariance, and finite-sample bounds quantifying the gap between training-time and steady-state uncertainty are not derived.