Ontology-Grounded Capability Interaction Graphs: From Knowledge Graphs to Fault Trees

Abstract: The development of Cyber-Physical Systems (CPSs) is inherently multidisciplinary, involving expertise from domains such as software engineering, electrical engineering, and mechatronics. throughout the lifecycle of the system, from design to deployment. Ensuring system reliability in Cyber-Physical Systems (CPSs) requires the identification and analysis of potential failures and their cascading effects. However, reliability modeling remains a challenging and error-prone activity, as it often depends on tacit expert knowledge, incomplete documentation of failure modes, and limited consideration of interactions between subsystems. To address these challenges, this paper introduce the Capability Interaction Graph (CIG), an ontology-driven representation of CPS architectures grounded in the Unified Foundational Ontology (UFO). Due to its graph-based structure, a CIG is naturally represented as a knowledge graph (KG), enabling the explicit capture of functional dependencies and system semantics. Building upon this representation, we propose an automated synthesis algorithm for generating Fault Trees (FTs) directly from CIGs encoded as knowledge graphs. Fault Tree Analysis provides an effective mechanism for evaluating critical failure properties, including failure propagation paths and minimal cut set sets. Our approach reduces this complexity by leveraging CIGs and knowledge graphs. We provide a common semantic representation across engineering domains and support the automated generation of reliability models.

• The paper introduces FDGs to bridge architectural knowledge and formal reliability assessment in CPS design.
• It leverages a formal ontology based on UFO and OntoUML, ensuring precise semantic mapping between components, capabilities, and faults.
• The approach enables automated, traceable fault tree generation, reducing manual modeling and improving early design reliability analysis.

Formal Foundations and Automated Synthesis of Fault Trees from Ontology-Grounded Capability Interaction Graphs

Motivation and Conceptual Framework

The modeling and analysis of failures in cyber-physical systems (CPSs) is a highly multidisciplinary endeavor spanning software, electrical, and mechanical engineering. Manual construction of reliability models such as fault trees (FTs) is fraught with challenges stemming from incomplete failure documentation, tacit expert knowledge, and the lack of a principled mechanism for bridging architectural description and error propagation semantics. Current fault tree analysis (FTA) techniques are mature, but integration with Model-Based Systems Engineering (MBSE) and knowledge graphs (KGs) has historically lacked a precise intermediate representation to connect architectural knowledge and formal reliability assessment.

This paper introduces the Ontology-Grounded Capability Interaction Graph (FDG), a formal construct for capturing components, capabilities, channels, interfaces, faults, and errors in CPS architectures. FDGs are grounded in the Unified Foundational Ontology (UFO), ensuring precise semantics for notions such as capability manifestation, participation, error propagation, and causality, while remaining lightweight for early-stage system modeling. Importantly, FDGs provide the basis for automated synthesis of fault trees directly from KG-based architectural representations, reducing reliance on labor-intensive manual fault modeling.

Figure 1: Proposed pipeline for the automatic synthesis of fault trees from a knowledge graph.

Ontological Formalization and Capability Interaction

At the core of this approach is a novel ontology specifying components, channels, resource types, capabilities, functions, output/input interfaces, faults, and expectations—each formally specified within the UFO and OntoUML paradigm.

• Components and Channels: Represented as objects (endurants) with atomic identity in accordance with atomistic mereology, allowing abstraction across varying system boundaries.
• Capabilities: Dispositions inhering in objects, manifested as events (functions), and associated with consumed/produced resource types.
• Interfaces: Relators mediating interactions, ensuring channel-resource and component-capability compatibilities.
• Faults/Errors: Intrinsic moments preventing manifestation of expected capabilities; faults created spontaneously, activated under expectation, and errors triggered as events when expectations are unmet.

The formal ontological diagram details these constructs and their relations, providing the blueprint for semantic translation to KGs.

Figure 2: Our proposed ontology of CPS architecture, introducing the notions of components, capabilities, functions, channels, etc.

FDGs as Knowledge Graphs and Dynamic Evolution

FDGs are instantiated in KGs (e.g. RDF triple stores such as GraphDB) with fully machine-readable semantics, supporting SPARQL queries for extracting architectural structure and functional dependencies. The semantics are extended to error propagation by explicitly modeling temporally and causally ordered events: fault creation, activation, and error propagation. Events are modeled as perdurants, transforming situations (system states) and establishing causal chains.

The dynamic evolution of FDGs is formalized through UFO-B's notion of events, with strict temporal ordering, direct and indirect causality, and existential dependency relations.

Functional Dependency and Error Propagation

Functional dependency describes the prerequisite relationships that must be satisfied for capability manifestation. The model distinguishes three scenarios:

• Component capability dependencies: Access to resource types must be provided by channel output capabilities.
• Channel output dependencies: Output capability depends on prior manifestation of input capability.
• Channel input dependencies: Input capability requires production by upstream component capabilities.

Minimal configuration fragments, derived through KG queries, specify atomic sets fulfilling capability prerequisites. Through cascading expectation, errors propagate along functional dependency chains. The diagnostic structure function is recursively defined, enabling symbolic evaluation of failure modes.

Figure 3: An example of error propagation.

Automated Synthesis of Fault Trees

The model enables transformation of KG-based FDGs into classical static fault trees:

• Semantic Mapping: Capabilities of interest are mapped to top-level events; fault activation and error propagation to basic and intermediate events, respectively; minimal configuration fragments dictate AND/OR gate logic.
• Transformation Algorithm: Recursively traverses FDG structure, synthesizing FTs with gates and basic events aligned with underlying functional dependencies and error semantics.
• Soundness and Completeness: The transformation is mathematically proven to be both sound and complete with respect to the recursive structure function, ensuring all and only the valid failure modes are captured.

  Figure 4: An illustration of the general case of the transformation.

Strong Results and Claims

• Automated FT Generation: The approach produces semantically precise fault trees from structured architectural knowledge with minimal additional modeling, without manual annotation of failure modes.
• Traceability and Consistency: FDGs preserve explicit links between architectural elements and failure propagation, improving traceability and reducing ambiguity relative to traditional FT formalisms.
• Formal Guarantees: The transformation is shown to preserve error semantics exactly; i.e., failure modes and minimal cut sets in the synthesized FT correspond precisely to the causal structure encoded in the FDG.
• Applicability to Early Design: The ontological framework remains lightweight, supporting application at early design stages where detailed behavioral models are unavailable.

  Figure 5: An example of a system with redundancy.

Practical and Theoretical Implications

Practically, synthesis of semantically rich fault trees from minimally structured architectural KGs enables earlier, more scalable reliability analysis in CPS design, mitigating the prohibitive costs of post hoc reliability assessment. The approach supports integration of heterogeneous models, abstraction over subsystem boundaries, and systematic reuse of architectural information across domains.

Theoretically, the paper establishes a rigorous bridge between architectural ontologies, knowledge-graph reasoning, and formal reliability modeling. Explicit distinctions in the ontology (e.g., between faults, errors, fault activation) resolve several semantic ambiguities inherent in classical FTA and facilitate future integration of behavioral, quantitative, and temporal failure semantics. The model can be extended to probabilistic analysis, dynamic FTs, and modular compositional reasoning.

The FDG formalism also advances ontological engineering for complex systems, providing a template for the application of foundational ontologies (UFO, COVER) to operational risk assessment and reliability analysis. The formal alignment ensures semantic interoperability, supports automated reasoning, and offers a scalable pathway for integrating MBSE with safety certification workflows.

Future Directions

Potential research directions include:

• Quantitative Extensions: Incorporation of failure rates, probabilities, and uncertainty for probabilistic FTA.
• Temporal and Behavioral Semantics: Integration of dynamic fault trees, repairable models, and event sequencing constraints.
• Toolchain Integration: Automated extraction from MBSE artifacts, natural language documentation, and heterogeneous engineering models.
• Industrial Validation: Application to large-scale CPSs, validation of scalability, and integration with certification processes.

Conclusion

The FDG approach introduced in this paper provides a formally grounded, ontologically precise mechanism for synthesizing fault trees from knowledge graphs, enabling more rigorous, scalable, and traceable reliability analysis in the development of cyber-physical systems. The strong formal guarantees, explicit semantic distinctions, and practical applicability mark a significant advance in the integration of MBSE, ontological engineering, and automated reliability modeling. Future extensions toward richer behavioral, quantitative, and epistemic semantics are both technically feasible and theoretically motivated.