Fault Trees & Influence Diagrams

• Fault trees and influence diagrams are graphical modeling paradigms that distinctly capture system failure propagation and decision processes under uncertainty.
• Fault trees decompose failures using hierarchical logic gates like AND and OR, while influence diagrams integrate chance, decision, and utility nodes to model probabilistic dependencies.
• Advanced computational methods such as BDDs, junction tree algorithms, and unified algebraic frameworks enhance the practical analysis of complex systems using these models.

Fault trees and influence diagrams are foundational graphical modeling paradigms in systems engineering, risk analysis, and decision-making under uncertainty. Fault trees provide a deductive, logic-based structure for representing system failure propagation, while influence diagrams encode decision-theoretic problems by integrating uncertainties, choices, and objective functions within a unified graphical form. Both frameworks have evolved with extensive methodological innovations to accommodate realistic systems, diverse uncertainty forms, and complex interactions between decision, logic, and stochasticity.

1. Fundamental Principles and Structures

Fault trees (FTs) are rooted, hierarchical representations where the top event (usually a system-level failure) is recursively decomposed into combinations of constituent failures (basic events) using logic gates, chiefly AND, OR, k-out-of-n (VOT), and their generalizations. Each gate encapsulates a specific logical composition of failures—for example, an AND gate fails if all its inputs fail, while an OR gate fails if any input fails. The graph structure is a directed acyclic graph, with basic events as leaves and internal nodes as intermediate events or logical gates. Advanced fault tree extensions incorporate temporal and sequential relationships between events using gates such as PAND (priority AND) and POR (priority OR), as in Pandora temporal fault trees, to capture cases where the order or timing of failures is crucial (Khungla et al., 14 Nov 2024).

Influence diagrams (IDs), in contrast, are directed acyclic graphs in which nodes correspond to random variables (chance nodes), decisions (decision nodes), and utilities (value nodes). Arcs represent informational or probabilistic dependencies (for chance nodes), the available information at each decision (for decisions), and the flow of utility contributions. Influence diagrams are designed to structure and solve decision problems under uncertainty, capturing both observational and policy constraints. The semantics of the model are governed by principles of conditional independence, expected utility computation, and admissibility of decision rules (Shachter, 2013).

Comparative context: While both are graphical and encode system dependencies, FTs are primarily used for reliability analysis by capturing logical propagation of failure, and IDs for optimizing decision-making under uncertainty, explicitly modeling choices and their effect on outcomes (Jimenez-Roa et al., 2023).

2. Methodological Extensions and Generalizations

Unified algebraic frameworks: The Plausibility-Feasibility-Utility (PFU) framework introduces an encompassing algebraic graphical model that subsumes fault trees, influence diagrams, Bayesian networks, constraint satisfaction problems, and Markov decision processes. In the PFU formalism, a problem is encoded as a network {variables, plausibility functions, feasibility functions, utility functions, and a typed DAG} along with an ordered query (variable elimination sequence) that mirrors both the structural and sequential properties of decision-making or reliability analysis tasks (Pralet et al., 2011). The equivalence between decision-tree semantics (Sem-Ans(Q)) and variable elimination (Op-Ans(Q)) unifies analytical approaches for both FTs and IDs.

Information/Relevance Influence Diagrams (IRIDs): Standard IDs are extended to allow "relevance arrows" into decision nodes, meaning nodes can both observe and constrain the set of permissible decisions. The constraint function for a decision variable A, with parents X₁, ..., Xₖ, is

$$C_A: \mathcal{X}_1 \times \mathcal{X}_2 \times ... \times \mathcal{X}_k \to \mathcal{P}(\operatorname{dom}(A)),$$

where the constraint dictates valid decisions for each context. The IRID framework allows direct modeling of asymmetric and feasibility-constrained decision scenarios, and supports Gibbs sampling and stochastic dynamic programming for inference when classic methods become infeasible (Jenzarli, 2013).

Generalized Fault Diagrams: Generalized fault diagrams (also called fault influence diagrams) relax standard FT independence assumptions, allowing dependent basic events and replicated logical elements. Logical and probabilistic elements can intermix efficiently, supporting both deterministic logic propagation and local probabilistic inference. Modules are processed with hybrid techniques, partitioning the graph to minimize instantiations and combine deterministic reduction with probabilistic expectation computations (Shachter et al., 2013).

Logic-based and probabilistic querying frameworks: Domain-specific logics such as Boolean Fault tree Logic (BFL) and Probabilistic Fault tree Logic (PFL) enable formal queries about system structure, minimal cut sets, probability thresholds, and "what-if" scenarios. Model checking algorithms based on binary decision diagrams (BDDs) provide efficient evaluation of such specifications, supporting systematic analysis for both safety (FT) and security (attack tree) models (Nicoletti et al., 2022, Nicoletti et al., 2023, Nicoletti et al., 29 Jan 2024).

3. Computational Approaches and Complexity

Variable elimination and tree decompositions: IDs and generalizations solve for optimal strategies via recursive variable elimination that respects partial orderings of observation and decision. When treewidth ($w$) and maximum variable cardinality ($k$) are bounded, fully polynomial-time approximation schemes (FPTAS) exist for maximizing expected utility, exploiting localized computations and culling strategy sets through a-coverings and cluster marginals. The guarantee is that the result $E$ satisfies $\text{MEU} \le (1 + \varepsilon) E$ for desired approximation $\varepsilon > 0$ (Maua et al., 2012).

Junction tree algorithms: Transformation of IDs into strong junction trees supports local message passing for computing expected utilities and optimal policies. The method involves moralizing the DAG, triangulating with an elimination order that respects informational precedence, organizing into a running intersection property, and applying generalized marginalization (sum for chance nodes, max for decision nodes). Message passing (or "absorption") aggregates local potentials to the root, enabling localized extraction of optimal actions (Jensen et al., 2013).

BDD-based evaluation: For static FTs, BDDs represent the system failure Boolean function, enabling efficient extraction of minimal cut sets and direct probabilistic evaluation by recursively combining or marginalizing probabilities at each node (using Shannon expansion). For dynamic FTs, modularization isolates dynamic submodules, which are analyzed as Markov models; their time-dependent probabilities replace the modules with basic events, allowing the flattened tree to be analyzed via BDDs (Basgöze et al., 2022).

Algebraic and fuzzy methods: Squarefree polynomial algebras avoid overcounting in FT evaluation when nodes have multiple parents, associating each node with a squarefree polynomial and using substitution based on dominator analysis. This method yields provable polynomial complexity when the number of multiparent nodes is bounded (Lopuhaä-Zwakenberg, 2023). Fuzzy Pandora temporal FTs address uncertainty in parameter values by representing failure rates as triangular fuzzy numbers and extending logic gates (AND, OR, PAND, POR) to propagate fuzzy probabilities using interval arithmetic—supporting dynamic analysis even under imprecise information (Khungla et al., 14 Nov 2024).

4. Interplay, Translation, and Integration

The expressive boundaries between FTs and IDs have led to hybrid formalisms and transformation strategies:

• Attack-Fault Trees (AFTs): Integration of attack trees with fault trees supports joint modeling of accidental and malicious failure mechanisms. Composite structures—AFTs—are generated by merging partial FTs and ATs via graph transformation rules over knowledge extracted from system models, including deployment and dataflow abstractions. Logical gates (e.g., AND, OR, PAND) appear both in probabilistic risk and adversarial modeling (Groner et al., 2023).
• Knowledge-graph-driven synthesis: Fault trees can be synthesized automatically from knowledge graphs by extracting the system’s functional and structural dependencies via semantic queries. Dependencies detected in the knowledge graph map to OR (or AND) gates in the FT, with redundancy identified by multiple suppliers leading to AND gates. This approach enables the direct construction of FTs from structured knowledge representations, facilitating system-level diagnostics (Ntagengerwa et al., 29 Aug 2025).
• Comparison and conversion: BDDs are functionally equivalent to binary decision trees but achieve greater compactness via sub-node sharing. FTs, DTs, and BDDs may be converted between each other by extracting logical cut sets or applying Shannon expansion, although optimality of the tree structure may suffer in translation. Influence diagrams, in turn, can encode FTs as special cases—with chance nodes for basic events and utility nodes for system failure—and can be extended with decision and value nodes to optimize risk mitigation strategies (Jimenez-Roa et al., 2023).

5. Risk Analysis, Uncertainty, and Decision Support

IDs provide native support for optimizing decision-making under probabilistic uncertainty by explicit modeling of available information, feasible actions, and utility structures. Modern extensions incorporate advanced risk measures such as conditional value-at-risk (CVaR) and chance constraints. These are integrated using MIP formulations over rooted junction trees with constraints on the joint distributions of outcome variables. Techniques (e.g., algorithms for single-value-node conversion and RJT targeting) provide computational tractability and preserve the relevant probability distributions for correct risk-averse optimization (Herrala et al., 8 Jan 2024).

FTs, particularly when extended with dynamic gates or generalized with dependence structures, provide a detailed view of failure propagation, minimal cut/path sets, and criticality analysis via importance measures or sensitivity indices. Probabilistic (PFL) or fuzzy logic enriches the analysis in cases where underlying probabilities are uncertain or imprecise, supporting what-if analysis, risk quantification, and criticality ranking (Khungla et al., 14 Nov 2024).

6. Limitations, Synergies, and Future Directions

Limitations: Standard FTs are limited in expressing dependencies (beyond monotonic Boolean logic), handling sequence or time, and incorporating decision/action elements. Classic IDs, while general, may involve computational complexity that grows exponentially in treewidth or variable domain size, and require careful handling to accommodate constraints or asymmetric choice sets.

Synergies: Combining FTs and IDs, as in hybrid models or within the PFU algebraic framework, supports enhanced reliability analysis with actionable decision guidance. Analytical frameworks (e.g., those using BFL/PFL and LangPFL or integrating attack/security metrics) now allow querying across safety and cyber-physical security, detailed simulation of attack/failure interactions, and use of model checking for both structure and probability (Nicoletti et al., 29 Jan 2024).

Research frontiers: Developments continue in unifying modeling languages (adopting knowledge graphs or domain-specific logics), advanced inference techniques (algebraic, BDD, Markovian, MIP-based), quantified safety-security analysis, formalization with higher-order logics, and integration of data-driven models (machine learning-derived DTs or probabilistic graphical models) into engineering workflows.

---

This comprehensive perspective situates fault trees and influence diagrams within a shared landscape of logic-based and probabilistic graphical modeling for complex systems, elucidating their foundations, technical progressions, integrations, and computational strategies—all supported by rigorous research and practical applications across critical domains.