When engineering safety-critical systems—whether a satellite orbiting Earth, an automated insulin pump, or a flight-control system—traditional regulatory compliance relies heavily on process checklists. Did you run the required tests? Did you follow the mandated development guidelines?
However, as modern systems transition into interconnected cyber-physical networks and non-deterministic, learning-enabled architectures, rigid process compliance begins to fail. A checklist cannot prove that a complex, dynamically changing system is safe.
To address this, a growing paradigm shifts the focus from processes to explicit logic through structured assurance cases. Rather than assuming a system is safe simply because it followed a standard, engineers construct an explicit, graphical argument that links high-level safety claims directly to concrete empirical evidence.
The Anatomy of a Structured Argument
How do you prove an abstract property like "safety" or "fairness"? You break it down until it terminates in something measurable. An assurance case formalizes this by structuring the justification as a hierarchical tree.
The root of the tree is a high-level claim (e.g., "The closed-loop infusion pump is safe to operate"). To prove this claim, engineers use visual frameworks like Goal Structuring Notation (GSN) to systematically decompose it into smaller, manageable sub-goals. As demonstrated by Feng et al., a top-level safety goal for a medical device might be split into sub-goals that address specific risk dimensions: mitigating risks inherited from standalone components, managing newly introduced closed-loop interactions, and ensuring overall clinical benefits outweigh residual risks.
[ High-Level Goal: System is Safe ]
│
▼
[ Strategy of Argument ]
│
┌───────┴───────┐
▼ ▼
[ Sub-Goal A ] [ Sub-Goal B ]
│ │
▼ ▼
[ Evidence 1 ] [ Evidence 2 ]
These sub-goals are connected by strategies—the explicit rationale explaining why a specific decomposition is sufficient to satisfy the parent goal. Finally, the leaves of the tree consist of evidence fragments: formal verification proofs, test logs, or simulation results.
This structured visual logic transforms assurance from a passive checklist exercise into an active, evidence-based argument (Witulski et al.). By explicitly mapping out the reasoning, developers and regulators can trace a clear, transparent line from a low-level technical metric up to a high-level regulatory requirement (Bueno Momcilovic et al.).
Taming Complexity via Hierarchical Decomposition
The primary reason structured assurance cases work is that they exploit hierarchical structural decomposition to combat the curse of dimensionality.
In a flat system architecture, verifying safety requires analyzing every possible interaction between every single component, leading to an exponential explosion of states. However, this complexity can be drastically reduced by treating hierarchy as a primary structural element. As early pioneering work by Barrow demonstrated in digital hardware design, breaking a system down into a nested tree of modules allows engineers to verify each unique component type exactly once. Once a module is proven correct, its behavior can be treated as a primitive in higher-level proofs, scaling verification complexity linearly with the number of component types rather than exponentially with the total number of parts.
Modern assurance cases apply this exact mathematical intuition to system-level safety. By isolating safety properties within localized, semi-autonomous clusters or abstraction layers, the top-level verification task only needs to validate the interactions between those layers, rather than re-verifying the internal mechanics of every sub-component (Wu et al.; Liu et al.). This compositional approach allows engineers to systematically link abstract, high-level analysis to concrete, low-level designs across distinct tasks and tools (Murugesan et al.).
Exposing Gaps and Quantifying Confidence
Beyond reducing complexity, the act of formalizing an argument forces engineers to confront hidden assumptions. In traditional text-heavy safety documents, logical leaps and missing justifications are easily masked by technical jargon.
When safety arguments are explicitly modeled using graphical notations, implicit rationales become visible. This visibility makes it far easier to spot gaps between evidence and high-level objectives (Guiochet et al.). Empirical studies of practitioners by Goodrum et al. confirm that the process of building an assurance case acts as a cognitive forcing function. It compels developers to deeply scrutinize their safety assumptions while serving as a common language that bridges communication gaps between developers, safety analysts, and certifiers.
Furthermore, once the logical structure of an argument is laid bare, it can be paired with mathematical frameworks—such as Bayesian Networks or Dempster-Shafer theory—to move from purely qualitative reasoning to quantitative confidence modeling (Witulski et al.; Guiochet et al.). If a piece of evidence is weak or uncertain, that uncertainty propagates predictably up the tree, allowing engineers to mathematically calculate total confidence in the top-level safety claim.
From Cyber-Physical Systems to Artificial Intelligence
The power of structured assurance is its adaptability to domains where deterministic guarantees are impossible.
Consider Medical Cyber-Physical Systems (MCPS) that dynamically assemble multi-vendor devices at a patient's bedside. Because the exact network configuration cannot be known during manufacturing, traditional static certification fails. Lee et al. argue for a shift toward evidence-based assurance cases to safely certify these dynamic environments. Similarly, for self-adaptive systems that modify their behavior at runtime to cope with environmental changes, modular assurance cases allow safety proofs to be composed and updated dynamically as individual components evolve (de Lemos et al.).
Recently, this framework has stepped into the non-deterministic world of artificial intelligence. When dealing with machine learning components in medical devices, Lamp et al. show that structured safety cases can bridge the gap between abstract physiological safety goals and empirical AI performance, catching critical failures that standard accuracy metrics miss.
The same hierarchical structure of goals, reasoning strategies, and empirical evidence is now being deployed to justify sociotechnical properties like AI fairness throughout a system's lifecycle (Sabuncuoglu et al.). Whether verifying a transistor, a satellite, or a large language model, structured assurance cases provide the logical scaffolding necessary to prove that complex systems do exactly what they are supposed to do.
Key Foundational Work
Proving the Correctness of Digital Hardware Designs (1983) — contributed 2 concept elements to this direction.
Challenges in the regulatory approval of medical cyber-physical systems (2011) — contributed 1 concept elements to this direction.