---
title: System Error Propagation Graph (SEPG)
url: https://www.emergentmind.com/topics/system-error-propagation-graph-sepg
type: topic
---

# System Error Propagation Graph (SEPG)

Searching arXiv for recent and foundational papers on System Error Propagation Graphs and closely related error-propagation graph models.
System Error Propagation Graph (SEPG) denotes a graph-based abstraction for representing how an initiating error, fault, or attack propagates through an interconnected system and produces downstream error states, functional failures, or physical-world consequences. In the literature, the term is used explicitly for gate-level soft-error analysis in digital circuits, as an abstraction for attack-error-impact reasoning in autonomous vehicles, and as a practical error-propagation graph for code-level root-cause reconstruction in cloud services; closely related directed-graph models also appear in robotic navigation, industrial fault diagnosis, cascading-failure analysis, and staged AI-system reliability modeling [2104.01908] [2509.11120] [2509.26463] [2602.07846] [2302.06473] [2503.09904] [2603.18201].

## 1. Conceptual scope

At its most general, an SEPG organizes propagation structure rather than isolated error events. The common idea is that an upstream perturbation is rarely terminal at the point of injection: it traverses intermediate components, is filtered or amplified by system structure, and may eventually appear as a downstream functional error, execution error, or safety impact. In circuit reliability, this is expressed as a graph whose nodes are gates and flip-flops and whose edges preserve signal directionality from inputs to outputs [2104.01908]. In autonomous-vehicle security, the SEPG is a structured demonstration tool for tracing sensor attacks through internal error states to physical-world consequences [2509.11120]. In cloud service systems, the reconstructed propagation path is a sequence of functions linked by error wrapping, returning, rethrowing, or cross-service transfer [2509.26463].

The abstraction is useful precisely because propagation is not purely local. In biplanar X-ray-guided robotic navigation, installation-induced structural perturbations introduced at the perception stage are progressively amplified along the perception reconstruction execution chain and dominate execution level error and tail risk behavior [2602.07846]. In AI systems with sequential functional stages, upstream errors may propagate to downstream stages, ultimately affecting overall system reliability [2603.18201]. In industrial plants and power systems, directed graphs are used to capture fault or failure interactions that are not reducible to static physical topology alone [2302.06473] [2503.09904].

A plausible implication is that SEPG is best understood as a family of graph-based system models rather than a single canonical formalism. The literature preserves the same analytical intent—explicit representation of admissible propagation channels—while varying node semantics, edge semantics, and quantitative annotations according to domain.

## 2. Graph structures and formal semantics

In gate-level soft-error analysis, the circuit netlist is transformed into a directed graph,
$$
G = (\nu, \varepsilon),
$$
where vertices represent gates and flip-flops and edges represent circuit connections between gates or flip-flops, preserving directionality from inputs to outputs [2104.01908]. The graph-based abstraction inherently captures the SEPG: nodes are potential fault origin or destination points, and edges are channels for error propagation. The same work maps the extracted netlist to a Probabilistic Bayesian Graph in GML format through a custom Verilog Procedural Interface-based extraction pipeline [2104.01908].

In autonomous-vehicle sensor-attack analysis, the SEPG is formalized as a directed hypergraph,
$$
\graph = (\nodes, \transitions),
$$
with disjoint node sets for Physical Attack Vectors, Errors of System Components, and Physical-World Consequences [2509.11120]. Transitions are directed hyperedges and are typed as attack-to-error, error-to-error, and error-to-impact. Nodes are further enriched with attributes such as Precision, Continuity, Intensity, DynamicTarget, DynamicImpact, DistanceImpactToTarget, and ScenarioDependence; transitions carry preconditions and postconditions expressed as Boolean conditions over source and target attributes [2509.11120]. Under this formulation, a path from an attack node to an impact node is feasible only when all transition preconditions are satisfied.

In cloud service systems, propagation is represented over a function call graph,
$$
\mathcal{G} = (\mathcal{F}, \mathcal{E}),
$$
where an edge indicates that one function calls another [2509.26463]. The error path is defined as a sequence
$$
\langle f_n, f_{n-1}, \ldots, f_1 \rangle,
$$
where \(f_n\) is the function that logs the error and \(f_1\) is the originator. The recovered path is a subgraph through the SEPG from error source to the log emission point [2509.26463].

In staged AI-system reliability modeling, the graph is stage-wise rather than code- or topology-centric: nodes denote modules at different stages, and edges represent potential error propagation paths from upstream modules to downstream modules [2603.18201]. This suggests that the defining property of an SEPG is not any specific graph class, but the explicit encoding of propagation admissibility across system structure.

## 3. Propagation mechanisms and quantitative models

A central quantitative formulation appears in single-event-upset analysis of digital circuits. For flip-flop \(i\), the Functional Failure Rate per SEU is modeled as
$$
FFR_{i,seu} = FIT_{i,seu} \cdot \prod_{j \in T,L,F}DR_{ij},
$$
with aggregate circuit-level rate
$$
FFR_{seu} = \sum_{i \in FF} FFR_{i,seu}.
$$
The derating factors quantify Temporal, Logical, and Functional masking, so the product captures compounded masking effects in various domains [2104.01908]. The SEPG interpretation here is probabilistic: propagation along graph structure is filtered by masking before a fault becomes an observable functional failure.

In robotic navigation, error propagation is modeled analytically across projection matrix estimation, triangulation, and coordinate mapping. For first-order uncertainty propagation, the covariance of an output parameter vector is approximated by
$$
\Sigma_f \approx J_f \, \Sigma_a \, J_f^T,
$$
and analogous Jacobian-based forms are used for projection matrices and triangulated targets [2602.07846]. Because the pipeline is strongly nonlinear and exhibits error coupling, Monte Carlo simulation is used to characterize tail-risk such as 95th percentile and higher worst-case errors [2602.07846]. The paper states that system-level error is not a simple superposition of installation error and perception noise.

In AI-system reliability, propagation is modeled by a multivariate point process. For module \(m_s\) at stage \(s\), the total conditional intensity is decomposed into primary and propagated components:
$$
\lambda_{m_s}(t|\mathbf{t}_{m_s}) = \lambda^0_{m_s}(t|\mathbf{t}^0_{m_s}) + \sum_{m_{s-1}=1}^{M_{s-1}} \lambda^p_{m_s, m_{s-1}}(t|\mathbf{t}^p_{m_{s-1}}),
$$
with propagated intensity parameterized as
$$
\lambda^p_{m_s, m_{s-1}}(t|\mathbf{t}^p_{m_{s-1}}) = \sum_{t_{m_{s-1}^j}<t} \alpha_{m_s, m_{s-1}} \cdot \exp\left[-\beta_{m_s, m_{s-1}}(t-t_{m_{s-1}^j})\right].
$$
Here \(\alpha\) is the EP strength and \(\beta\) is the decay rate of the propagation effect in time [2603.18201]. This formulation separates intrinsic stage-specific failures from downstream failures triggered by upstream events.

A related but more combinatorial perspective appears in zero forcing. There, any error in the sampled entries \(\mathbf{x}_S\) affects the error of \(\mathbf{x}\) exponentially in the propagation time, with worst-case amplification bounded by
$$
[\kappa'(A)\,\Delta]^T\,\epsilon,
$$
where \(T\) is the propagation time [1709.08740]. The same work introduces the error polynomial vector and variance polynomial vector as finer measures of vertex-wise error amplification [1709.08740]. This is not presented as the canonical SEPG formalism, but it supplies a precise graph-theoretic vocabulary for propagation depth and amplification.

## 4. Construction and inference methodologies

SEPG construction is domain-dependent and often hybrid. In circuit analysis, the pipeline begins from gate-level abstractions extracted from the netlist. A custom Verilog Procedural Interface maps the netlist to graph form, and GraphSAGE is then used as a scalable and inductive type representation learning algorithm on graphs for extracting structural features of the gate-level netlist [2104.01908]. The method samples \(K\)-hop neighborhoods with \(K=2\), aggregates local neighborhood information, and outputs a feature matrix \(X\) used by a downstream fully-connected DNN to predict \(FFR_{i,seu}\) [2104.01908]. The pooling aggregator is written as
$$
AGGRE_{k}^{pool} = \max\left( \{ \sigma(W_{pool}h_{u_i}^{k} + b), \forall{u_i}\in N_k(v)\} \right).
$$

In cloud services, ErrorPrism combines static analysis with an LLM agent. Its pipeline comprises code repository static analysis, log template extraction, and error propagation tracking [2509.26463]. Static analysis builds the function call graph, extracts error-related string constants from SSA, and constructs a constant transitive closure
$$
\mathcal{C}_k(f) =
\begin{cases}
\sigma(f), & \text{if } k = 0 \\
\sigma(f) \cup \bigcup_{(f,g)\in\mathcal{E}} \mathcal{C}_{k-1}(g), & \text{if } k \ge 1
\end{cases}
$$
with \(k=3\) typically used as the call depth limit [2509.26463]. The LLM agent then performs an iterative backward search in a BFS manner, starting from the log-generating function and using tools such as `view_callee_closure(function)`, `check_function_code(function)`, and `fuzzy_search_in_closure(keyword)` [2509.26463].

In autonomous-vehicle security analysis, SEPG construction may be manual, automated, or hybrid. Experts identify the attack entry, internal error states, and physical-world consequences, annotate node attributes and transition conditions, and then compare or refine these graphs with LLM-generated candidates [2509.11120]. The workflow described is: input attack scenario and pipeline architecture to the LLM with prompts introducing the SEPG schema; obtain a structured graph; perform expert review and refinement; and use an automated checker to parse the graph for unmet conditions, feasibility bottlenecks, and underexplored attack paths [2509.11120]. The paper reports that LLM outputs generally satisfied the SEPG schema, surfaced additional error nodes or scenario factors missed by humans in about 60% of cases, and were used as a baseline for expert review [2509.11120].

In AI-system reliability, inference centers on latent source attribution rather than graph extraction. Each observed error event is assigned a latent indicator specifying whether it is primary or triggered by an upstream event, and parameters are estimated by a composite likelihood expectation-maximization algorithm [2603.18201]. The method is described as computationally efficient, theoretically guaranteed, and capable of reducing computational complexity from quadratic to linear in number of events [2603.18201].

## 5. Representative applications and empirical findings

The literature uses SEPGs and SEPG-like models in several distinct technical settings.

| Setting | Graph semantics | Reported result |
|---|---|---|
| Digital circuit soft errors | Gates and flip-flops as vertices; circuit connections as directed edges | MAE \(0.0186\), \(R^2 = 0.96\), test/training time \(<10\) minutes [2104.01908] |
| Biplanar robotic navigation | Multi-stage geometric chain from reference structure to TCP error | Rot. \(0^\circ\): mean \(0.018\) mm, P95 \(0.045\) mm; Rot. \(2^\circ\): mean \(0.075\) mm, P95 \(0.086\) mm [2602.07846] |
| Cloud microservices | Functions as nodes; wrapping/returning/cross-service transfer as propagation relations | 97.0% accuracy on 102 real-world errors across 67 production microservices [2509.26463] |
| Autonomous-vehicle sensor attacks | Directed hypergraph from attack nodes through error nodes to impact nodes | Seven key findings and eleven previously overlooked attack vectors [2509.11120] |

In the 10-Gigabit Ethernet MAC (IEEE 802.3) circuit with 1100 flip-flops across multiple functional blocks, the GraphSAGE + DNN framework was trained using about 40% of the data and evaluated on a 60% hold-out set [2104.01908]. The reported Mean Absolute Error is 0.0186 and the Coefficient of Determination is 0.96. The same framework predicts Functional Failure Rate in less than 10 minutes of test or training time and requires 1 Modelsim instance versus up to 7 for exhaustive fault injection [2104.01908].

In reference-based robotic navigation, rotational installation error is identified as a primary driver of system-level error amplification, while translational misalignment of comparable magnitude plays a secondary role under typical biplanar geometries [2602.07846]. Real bench-top experiments are reported to confirm that the predicted amplification trends persist under realistic imaging conditions [2602.07846]. The reported summary table gives mean and P95 execution errors for Rot. \(0^\circ\), Rot. \(2^\circ\), and Trans. 1–5 mm [2602.07846].

In production microservices at ByteDance, ErrorPrism achieves 97.0% accuracy in reconstructing paths for 102 real-world errors across 67 production microservices [2509.26463]. The detailed summary also reports average inference time per error of about 5.93 seconds and notes that the method outperformed existing static analysis and LLM-based approaches [2509.26463]. Here the SEPG is not a hardware or physical-system graph; it is a code-level causal path that converts a flattened wrapped error log into an end-to-end diagnostic chain.

In the autonomous-vehicle security survey, the SEPG is used to expose the conditions and dependencies that determine attack feasibility [2509.11120]. The study reports seven key findings, identifies eleven previously overlooked attack vectors exploiting inter-module interactions, validates several of these through proof-of-concept experiments, and demonstrates that large language models can automate aspects of SEPG construction and cross-validate expert analysis [2509.11120].

## 6. Related models, misconceptions, and analytical boundaries

Several recurrent misconceptions are directly challenged by the literature. One is that local mean-error control is sufficient for system reliability. The robotic navigation study states that traditional component-wise error models are inadequate because they focus on local mean errors and ignore system-level coupling and amplification; it further argues for moving from mean error metrics to tail-risk evaluation [2602.07846]. Another is that propagation is additive. The same work states that system-level error is not a simple superposition of installation error and perception noise [2602.07846].

A third misconception is that comparable graph-theoretic solutions are interchangeable once they have the same size or nominal depth. In zero forcing, different zero forcing sets can have the same size and propagation time yet produce different error and variance growth, and the optimal set depends on whether the criterion is worst-case absolute error or variance [1709.08740]. This suggests that, for SEPG-informed design, minimizing graph size or propagation depth alone need not minimize amplification.

SEPG also sits within a broader ecosystem of directed propagation graphs that are not identical to the term but are methodologically adjacent. Industrial fault-diagnosis work uses weighted, directed graphs with SOURCE, USER, HUB, and SWITCH nodes, logical edge relations SINGLE, AND, OR, and a recursive fault-propagation procedure based on predecessors and redundancy [2302.06473]. Cascading-failure analysis in power systems constructs a left stochastic interaction matrix \(W\) over failure states, with directed edges weighted by empirical conditional probabilities and eigen-analysis used to identify persistent, trivial, and transient modes of failure propagation [2503.09904]. These frameworks do not define SEPG in the same way as the autonomous-vehicle hypergraph or the gate-level circuit graph, but they demonstrate that the essential analytical problem—capturing directionality, conditioning, and amplification of downstream failures—extends across application domains.

A plausible implication is that SEPG should be treated as a systems-analysis viewpoint rather than a single mature standard. The literature already supports multiple instantiations: deterministic or probabilistic edges, ordinary directed graphs or directed hypergraphs, symbolic path reconstruction or continuous-time intensities, and manual or AI-assisted graph construction. What remains consistent is the insistence that reliability, diagnosis, and safety analysis require explicit modeling of how upstream errors traverse structure, interact with masking or conditioning, and become downstream failures.

Source: https://www.emergentmind.com/topics/system-error-propagation-graph-sepg