When something breaks in a power grid, a chemical plant, or a sensor network, diagnostic tools usually assume exactly one thing broke. This "single-fault assumption" shrinks the search from all $2^N$ subsets of $N$ components to $N$ candidates. It fails badly when several components break together, because their symptoms interfere: one fault masks another, or two faults produce a waveform that looks like neither. The usual fix is to simulate or collect examples of many fault combinations and train a classifier on them. That cost grows combinatorially, and it is impossible wherever combinations cannot be simulated or observed.
This note proposes a different route. The symptoms of multiple faults do not add up, but in many physical systems the faults themselves do add up at the level of the system's equations of motion. Removing a transmission line deletes one term from a sum over lines in each generator's acceleration. The nonlinear mixing of symptoms happens afterwards, when those equations are integrated through time. We therefore learn a neural ordinary differential equation (a network that models the time derivative of the system state, integrated by an ODE solver) on the system's graph, with one gate per component that can switch that component's contribution off. We train it only on healthy and single-fault trajectories. We then diagnose $k$ simultaneous or sequential faults by fitting a sparse set of gates, plus the times they switched, to the observed transient. The bet is that putting the fault structure into the derivative, rather than into the classifier output, lets single-fault training generalize to multi-fault diagnosis. It is a dynamic, nonlinear, learned descendant of sparse line-outage recovery.
Core Claim
The claim is that a graph neural ODE whose vector field is factored into per-edge contributions, each multiplied by a fault gate, recovers sets of $k \geq 2$ concurrent or cascading line outages from post-disturbance transients after being trained only on $k \le 1$ data. Its exact-set recovery should degrade gracefully in $k$, while classifiers trained on the same data collapse. Concretely, the node states $x_i(t)$ (for a grid, rotor angle and frequency at bus $i$) evolve as
$$\frac{dx_i}{dt} = f_\theta(x_i, u_i) + \sum_{j \in \mathcal{N}(i)} \big(1 - s_{ij}(t)\big)\, g_\theta(x_i, x_j, e_{ij}),$$
where $f_\theta$ is a learned local term driven by injection $u_i$, $g_\theta$ is a learned coupling term for the edge between $i$ and $j$ with features $e_{ij}$, and $s_{ij}(t) \in [0,1]$ is an outage gate that steps from 0 to $\bar s_{ij}$ at a trip time $\tau_{ij}$. Diagnosis solves
$$\min_{\bar s,\, \tau}\; \sum_{m} \big\| y(t_m) - h\big(x(t_m; \bar s, \tau)\big) \big\|^2 + \lambda \|\bar s\|_1,$$
where $y(t_m)$ are measurements at possibly irregular times $t_m$, $h$ is the known measurement map, and $\lambda$ sets the sparsity. Gradients come from the adjoint method of Neural Ordinary Differential Equations, which integrates a backward ODE for the sensitivities. Trip times $\tau$ enter as event times, so continuous time does real work here. The model infers which lines failed and also when, which separates a simultaneous $N-k$ event from a cascade where one trip caused the next.
Relation to Prior Work
Three lines of work motivate the gap. Static multi-outage identification shows that the combinatorial search can be avoided. Lassoing Line Outages in the Smart Power Grid treats outages as a sparse perturbation of the DC power-flow Laplacian and recovers three simultaneous outages on IEEE 118 by $\ell_1$ regression. Our objective has the same shape, but it replaces a linear algebraic snapshot with a learned nonlinear transient, which the file lists as an open problem for Lasso methods. A Learning-to-Infer Method for Real-Time Power Grid Multi-Line Outage Identification trains a classifier on simulated outage combinations and reaches 0.997 accuracy on IEEE 300 with 11.6 concurrent outages on average. It pays for this with a combinatorial offline library and static snapshots. We deliberately withhold combinations from training. Adversarially robust learning for security-constrained optimal power flow relaxes discrete outages into continuous partial outages and differentiates through steady-state power flow. We borrow that relaxation idea and move it into dynamics. Its admitted weakness also constrains our design: relaxed gradient search can stall in local optima, and rounding back to discrete outages is heuristic. We address this with a regularization path and a small discrete refinement step, described below.
The method's machinery comes from continuous graph dynamics. Graph Neural Ordinary Differential Equations defines message passing as an ODE and handles irregular observations with hybrid flow-and-jump updates, but it assumes a fixed graph. Physics-Inspired Neural Graph ODE for Long-term Dynamical Simulation shows that modeling second-order dynamics (accelerations) gives more stable rollouts, which suits the swing dynamics of generators. Neither paper models edges disappearing. Neural Ordinary Differential Equation Models of Circuits: Capabilities and Pitfalls supplies a stability reparameterization (input-to-state stability) that we reuse so that gated vector fields cannot blow up when gates are opened in combinations never seen in training.
Other work shows that the single-fault assumption breaks. Tureis improves multi-sensor fault localization by up to +35.4% F1 through iterative detect-and-mask over 5-minute windows. That greedy sequential masking is a natural comparison for our joint sparse fit. Real-Time Risky Fault-Chain Search using Time-Varying Graph RNNs models cascades in discrete stages for adversarial search. We address diagnosis rather than search, and in continuous time.
Research Program
We will build a transient testbed, because the steady-state tools in the file (MATPOWER, PYPOWER, and the Cascades simulator used by PowerGraph) do not produce sub-second trajectories. On the IEEE 39-bus and 118-bus topologies, with line and generator parameters taken from the standard cases, we will integrate the classical second-order swing model with a stiff solver. We will add two kinds of events: simultaneous $k$-line outages, and cascades in which overloaded lines trip after a delay. A lighter companion testbed uses coupled-oscillator dynamics from arnaudon/simplicial-kuramoto. There we can sweep graph size and nonlinearity strength cheaply and test exactly when vector-field compositionality holds.
Training uses healthy trajectories and all single-line outages, with each gate fixed to its known value. The gates are meant to compose because each gate only ever multiplies its own edge's term, so the training data never needs to cover combinations.
Inference proceeds in three steps. An amortized encoder, a small graph network over the first few hundred milliseconds of measurements, proposes initial gates and trip times. A short adjoint-based optimization then refines them along a decreasing-$\lambda$ path. Finally, the top $2k$ gates are rounded and the $\binom{2k}{k}$ discrete candidates are re-scored by forward simulation. This final step is small enough to enumerate, and it guards against the rounding failures documented for relaxed outage search.
We will also measure solver cost (function evaluations and wall-clock time), because the file flags stiffness as a source of latency.
Baselines
The naive reference is a multi-label classifier trained on the same healthy and single-fault transients. It is a graph network over the measurement time series with independent sigmoid outputs per line, so a $k$-fault prediction is whatever lines exceed threshold. This is the single-fault-trained approach the multi-fault literature warns against. Beating it means higher exact-set recovery at every $k \geq 2$.
The strongest existing method is the learning-to-infer approach of A Learning-to-Infer Method for Real-Time Power Grid Multi-Line Outage Identification. Its reported figure is a test accuracy of 0.997 on IEEE 300 with 11.6 concurrent outages on average, but on static snapshots and with training on combinations. We will reimplement it on our transients in two settings. In the first it gets single faults only, matching our data. In the second it gets simulated combinations with a matched simulation budget measured in trajectories generated. We will sweep that budget upward until it beats us or reaches the full combinatorial library. Every model gets the same hyperparameter search budget and the same measurement subsets. Beating it means winning outright in the single-fault-data setting. In the combination setting, it means matching it while using an order of magnitude fewer simulated trajectories.
Two physics-based baselines follow. A dynamic Lasso fits the same sparse objective using the true swing equations linearized around the pre-fault operating point. This is the honest extension of Lassoing Line Outages in the Smart Power Grid to transients; no reported result found on Lasso for transient-based multi-outage recovery. An oracle fits the sparse objective through the true nonlinear simulator. The oracle is an upper bound on accuracy and a reference for latency, not a competitor.
A Tureis-style greedy detect-and-mask loop over our gated model isolates the value of fitting all gates jointly rather than one at a time.
The key ablation keeps the identical per-edge gating but uses a discrete-time graph recurrent update in place of the ODE, on uniformly resampled data. If this ablation matches the full model on regularly sampled data, then the gain comes from the factorization, and continuous time must justify itself through irregular sampling and trip-time inference alone.
Why not just…?
Why not just simulate all the combinations and train a classifier? For grids with a trusted simulator, this is a real threat. The budget sweep against the learning-to-infer baseline exists to settle it. If a combination-trained classifier matches us at modest budget for $k \le 5$ on IEEE 118, our contribution shrinks to the regimes where combinations cannot be enumerated. Those regimes are $k$ beyond the training range and systems learned from logged single-fault data. We will report that outcome plainly rather than argue around it.
Why not just invert the true physics model with sparse regression? When the model is exactly known, the oracle simulator fit should be at least as accurate as ours. Our value would then be speed and differentiability, plus robustness when the parameters are wrong. We test that last point by perturbing line reactances and inertias by 10–30% in the physics baselines while our model learns from data generated with the true values. The linearized Lasso should break down in the large-swing transients that matter most. That breakdown is the same DC-linearity limitation the file records for static Lasso.
Why not just use a discrete recurrent model with the same gates? This is the ablation above, and it may well tie on clean, regularly sampled data. Continuous time is expected to matter in two places. The first is asynchronous measurements: we drop up to 70% of samples at random, the regime where Graph Neural Ordinary Differential Equations reports RMSE 10.95 versus 11.20 for a discrete counterpart on traffic. The second is estimating trip times finer than the discrete step. If neither gap appears, we will say that the factorization, not the ODE, carries the result.
Proposed Experiments
The decisive experiment is a compositional generalization curve. Every method trains on $k \le 1$ and is tested at $k = 2$ through $5$ on IEEE 39 and IEEE 118. Metrics are exact-set recovery, line-level F1, and trip-time error. The hypothesis predicts a slow decline for the gated ODE and a sharp drop for the single-fault classifier at $k=2$.
The falsification test runs on the oscillator testbed. We increase the coupling nonlinearity until edge contributions stop being separable, for example by adding protection logic whose behavior depends on the joint state of several lines. The claim predicts that recovery should fall exactly as separability fails. If recovery falls well before that point, the mechanism is not what we say it is.
A cascade test asks whether the model can tell a simultaneous outage from a two-stage cascade with identical final topology, using trip-time estimates alone.
Finally, we report latency: amortized initial guess only, guess plus refinement, and the oracle. Function-evaluation counts are reported under stiff transients, to check whether diagnosis within one second, which is operationally relevant, is achievable on IEEE 118.
References
- Neural Ordinary Differential Equations
- Lassoing line outages in the smart power grid
- A Learning-to-Infer Method for Real-Time Power Grid Multi-Line Outage Identification
- Adversarially robust learning for security-constrained optimal power flow
- Graph Neural Ordinary Differential Equations
- SEGNO: Generalizing Equivariant Graph Neural Networks with Physical Inductive Biases
- Neural Ordinary Differential Equation Models of Circuits: Capabilities and Pitfalls
- Tureis: Transformer-based Unified Resilience for IoT Devices in Smart Homes
- Real-Time Risky Fault-Chain Search using Time-Varying Graph RNNs
- PowerGraph: A power grid benchmark dataset for graph neural networks