Eﬃcient SMT-Based Analysis of Failure Propagation

. The process of developing civil aircraft and their related systems includes multiple phases of Preliminary Safety Assessment (PSA). An objective of PSA is to link the classiﬁcation of failure conditions and eﬀects (produced in the functional hazard analysis phases) to appropriate safety requirements for elements in the aircraft architecture. A complete and correct preliminary safety assessment phase avoids potentially costly revisions to the design late in the design process. Hence, automated ways to support PSA are an important challenge in modern aircraft design. A modern approach to conducting PSAs is via the use of abstract propagation models, that are basically hyper-graphs where arcs model the dependency among components, e.g. how the degradation of one component may lead to the degraded or failed operation of another. Such models are used for computing failure propagations : the fault of a component may have multiple ramiﬁcations within the system, causing the malfunction of several interconnected components. A central aspect of this problem is that of identifying the minimal fault combinations, also referred to as minimal cut sets , that cause overall failures. In this paper we propose an expressive framework to model failure propagation, catering for multiple levels of degradation as well as cyclic and nondeterministic dependencies. We deﬁne a formal sequential semantics, and present an eﬃcient SMT-based method for the analysis of failure propagation, able to enumerate cut sets that are minimal with respect to the order between levels of degradation. In contrast with the state of the art, the proposed approach is provably more expressive, and dramatically outperforms other systems when a comparison is possible.


Introduction
The process of developing civil aircraft and their related systems is guided by documents ARP4754A [17] and ARP4761 [16] produced by the engineering and standards organization SAE International. These documents describe a structured process for the safety assessment of these classes of platforms. An important stage is that of the Preliminary Aircraft Safety Assessment (PASA) and Preliminary System Safety Assessment (PSSA). The PASA is followed by multiple PSSA, carried out at the level of the systems composing the aircraft. One important goal of these process stages is to link the classification of failure conditions and effects (produced in the aircraft functional hazard analysis phase) to appropriate safety requirements for elements in the aircraft architecture. These safety requirements drive, among other things, assignment of target Development Assurance Levels (DAL) for items within the architecture. A complete and correct preliminary safety assessment phase avoids potentially costly revisions to the design late in the design process. Hence, automated ways to support PSA are an important challenge in modern aircraft design [18].
An important goal of PSAs is to fully understand how faults of simple functions (e.g. providing electrical power, on-ground braking) interact and propagate to affect the overall behaviours (e.g. landing, take-off, taxiing). A modern approach to conducting such safety assessments is via propagation models [1,14,19], that model the dependency among components, e.g. how the degradation of one component may lead to the degraded or failed operation of another. Such models are used for computing failure propagations: the fault of a component may have multiple ramifications within the system, causing the malfunction of several interconnected components. A central problem is identifying the minimal fault combinations, also referred to as minimal cut sets, that cause overall failures [12].
Given that PSAs occur in the early stages of the development process when limited information regarding the design is available, reasoning is carried out at a very high level of abstraction. Therefore, instead of using behavioural models (e.g., infinite-state transition systems) adopted in formal verification, the system is more naturally modeled by a simpler formalism of propagation graphs. This does not make PSA any easier. There are in fact several aspects that must be taken into account. The first problem is the sheer size of propagation graphs, both in terms of nodes and hyper-paths to be explored, which make enumerative techniques completely inadequate. Second, the propagation is non-Boolean [19]. That is, the degradation levels of the system functions are not binary (working vs not working) but the functions may be subject to different levels of degradation (e.g. fully operational, partly failed, completely failed), and fail in different ways (e.g. detected vs undetected, stuck open vs stuck closed), and different failures may be associated to different probabilities [19]. For example, the state of a component can be abstractly modeled into working (w), failed safe (fs), failed detected (fd), or failed undetected (fu), with degrees of degradation partially ordered as shown in Fig. 1.
In this setting, the notion of minimality needs to take into account the order among the levels of degradation, and can not be simply considered in terms of minimality with respect to set-inclusion. Third, various forms of failure propagation may be possible, e.g., nondeterministic, temporally-constrained, cyclic. For example, the failure of a power generator may lead, within a certain amount of time, to a depleted battery and then to the loss of an engine. In turn, the loss of an engine may compromise the ability to generate power, which clearly requires the ability to deal with cyclic propagation graphs. Additionally, a failure of the control system might cause a pressure valve to become either stuck open or stuck closed; this requires the ability to deal with nondeterministic propagations.
In this paper we tackle the problem of analyzing failure propagation in the full generality required by real-world applications. We start from Finite Degradation Structures (fds) [14], a recently-proposed modeling framework, which unifies various combinational models traditionally used in safety analysis (such as fault trees and minimal cut sets) and generalizes them to deal with different levels of degradation. We propose a framework, referred to as pgfds (Propagation Graphs over fds), that allows to model non-deterministic and cyclic propagation graphs. The framework is general and can be used in other safety-critical domains.
In order to deal with cyclic behaviours, pgfds require a sequential semantics, expressed via symbolic transition systems. The computation of minimal cut sets over pgfds can be carried out by means of techniques based on model checking, developed for the general case of behavioural models [6].
Then, we prove that it is possible to carry out the same analysis within a combinational setting, leveraging two widely adopted assumptions: that faults are persistent and that the fault propagation is monotone. These assumptions allow us to devise an efficient algorithm that can analyze fault propagations of realistic industrial benchmarks that are currently out of reach of state-of-the-art methods. The analysis of pgfds is reduced to model enumeration for an SMT formula that does not require the explicit unrolling of the transition system. We tackle two key difficulties. The first one is to ensure causality and rule out self-supporting fault configurations in the combinational encoding. This is done by imposing cycle-breaking constraints requiring the existence of a partial order that is then constructed by the SMT solver during the analysis. The second one is to devise efficient enumeration techniques of models that are fds-minimal, i.e., minimal with respect to the severity of the degradation given by the fds. To this end, we propose an SMT-based enumerator of fds-minimal models.
We have experimentally evaluated our approach on a comprehensive set of realistic benchmarks, also generating random systems that have a similar structure as our proprietary systems 1 . The results demonstrate substantial advances with respect to the state of the art. Our approach is clearly superior to the approach proposed in [14], that is limited to the case of acyclic deterministic pgfds. For the cyclic pgfdss, we contrast our approach against the sequential approach based on model-checking and show that our approach is able to scale to large pgfds, dramatically outperforming the sequential approach.
This paper is structured as follows. In Sect. 2 we present the mathematical notation and background on fds. In Sect. 3 we describe Propagation Graphs over fds (pgfds). In Sect. 4 we present the combinational encoding of pgfds into SMT. In Sect. 5 we describe how to use the SMT encoding for the enumeration of fds-minimal cut sets. In Sect. 6 we discuss some related work, and in Sect. 7 we present the experimental evaluation. In Sect. 8 we draw some conclusions and outline directions for future work.

Preliminaries
In the section, we explain the basic mathematical conventions that are used in the paper. We assume that the reader is familiar with the basic ideas of Satisfiability Modulo Theories (SMT) and in particular with the theory of linear integer arithmetic and the DPLL(T) procedure, as presented, e.g., in [2].
If convenient, we define unary functions with small domains in-place extensionally, e.g., {1 → 2, 2 → 3} is a function with domain {1, 2} that maps 1 to 2 and 2 to 3. We say that the n-ary function f (x 1 , x 2 , . . . , x n ) depends on its formal argument Given sets A and B, we denote as B A the set of all functions from A to B. Given a partially ordered set (A, ≤), its subset B ⊆ A is called an upper (resp. lower ) set if for A Finite Degradation Structure (fds) [14] is a triple (FM , ≤, ⊥), where FM is a finite set of failure modes and ≤ is a partial order on FM with the least element ⊥. For any set A and an fds B We assume that each fds contains at least two elements. We say that an fds is Boolean if it is isomorphic to the structure ({⊥, }, ⊥ ≤ , ⊥). In the following, for an fds D = (FM , ≤, ⊥), we denote elements of the set FM with f, f and call them failure modes.
Given a first-order formula ϕ over the language of the theory of linear integer arithmetic, an assignment μ that assigns a value μ(b) ∈ {false, true} to each free Boolean variable b of ϕ and a value μ(n) ∈ Z to each free integer variable n of ϕ is called a model of ϕ (denoted μ |= ϕ) if μ makes ϕ true. If B is a subset of free Boolean variables of ϕ, the model μ |= ϕ is called subset-minimal with A transition system T S is a tuple (X, I, T ) where X is a set of (state) variables, I(X) is a formula representing the initial states, and T (X, X ) is a formula representing the transitions. A state of T S is an assignment to the variables X. A trace of M is a (possibly infinite) sequence s 0 , s 1 , . . . of states such that s 0 |= I and, for all i ≥ 0, s i , s i+1 |= T .

Propagation Graphs over FDSs
In this section, we introduce our model for fault propagation, which we call Propagation Graphs over fdss (pgfds), and provide a sequential semantics for it which can be used to encode pgfdss into transition systems.
Intuitively, a Propagation Graph over fds (pgfds) consists of a set of components of the system and of the next function. In each step of the failure propagation, each component is in some failure mode from the underlying fds.
In the next step of the failure propagation, each component can either 1) stay in its previous failure mode or 2) switch to an arbitrary failure mode from the set of possible next failure modes. The set of possible next failure modes for each component is given by the function next, based on the current failure modes of all components in the system. Note that next(c)(s) = ∅ means that if the system is in the state s, the component c cannot change its current failure mode. The structure is intuitively associated with the hypergraph depicted in Fig. 2. The dashed rectangles represent the fact that each component can fail on its own (locally); the hyper-arc from e and h to g is conjunctive, while the arcs incoming into a node are disjunctive.
The important assumption of our approach is that we consider only faultpersistent propagations, i.e., fault propagations where each component can fail only once and after it does, it stays in the same failure mode forever. Note that this is a realistic assumption that is also used in other techniques for reliability analysis [5]. It is also implicitly used in other modeling techniques that are purely combinational (e.g., [19]) because they model the system only in a single time step, without considering any change in time whatsoever. Single propagation step of such computations can be described by a fault-persistent transition relation; the whole such computation as fault-persistent failure propagation.

Definition 3 (Fault-persistent failure propagation).
Given a pgfds S = (C, next), its fault-persistent transition relation R s , and k ∈ N, the sequence Because we deal only with fault-persistent failure propagations in this paper, we from now on refer to the fault-persistent transition relation and the faultpersistent failure propagation only as transition relation and failure propagation, respectively. To analyze reliability of the modeled system, it is important to identify the failures of its components (i.e., assignment of failure modes to the components) which cause the system to reach a given set of dangerous states, usually called top level event (TLE). Such assignments are called cut sets. Since the number of all cut sets can be prohibitively large, it is often enough to identify the least severe failures in terms of the underlying fds that are sufficient to cause the TLE. Such cut sets are called fds-minimal, or minimal for short. These concepts are formalized in the following definitions.

Definition 6 ((FDS-Minimal) Cut Set).
Given a pgfds S = (C, next), and a top level event TLE , a cut set is any state s for which there is a fault-persistent failure propagation that starts in s and ends in some s k ∈ TLE . A cut set is called fds-minimal (or minimal for short) if it is minimal with respect to the pointwise ordering ≤ of the underlying fds.
Given a system S and a top level event TLE , we denote the set of all corresponding cut sets as CS (S, TLE ) and the set of all minimal cut sets as MCS (S, TLE ). As a convention, when talking about cut sets, we will explicitly mention only the components to which the cut set assigns a failure mode different from ⊥.
Note that besides these three minimal cut sets, there are other cut sets that are not minimal, such as {e → , h → }.
Fault-persistent computations of a pgfds can be easily represented as traces of a (symbolic) transition system. Definition 7 (Fault-persistent transition system). Given a pgfds S = (C, next) and an fds D = (FM , ≤, ⊥), the corresponding fault-persistent (symbolic) transition system is given by TS S = (X, true, T ), where: is a symbolic encoding of the fault-persistent transition relation of S as given in Definition 2. That is, for each assignment μ :

and similarly for s ).
By definition, every fault-persistent computation of S has a corresponding trace (of the same length) in TS S . Therefore, encoding pgfdss as transition systems allows leveraging off-the-shelf algorithms for subset-minimal cut set enumeration, such as those given in [6]. However, this might be inefficient, particularly for TLEs that are triggered by long failure propagations (corresponding to equally-long traces of the induced transition system). Moreover, as we show later, enumerating fds-minimal cut sets is more involved.
Fault propagation systems used in practice often have the property that no transition can be disabled by additional faults, i.e., by switching a failure mode of a component from ⊥ to f = ⊥. This is also the case for the pgfds from Example 1. Such systems are called subset-monotone or monotone for short. This is formalized by the following definition.

From Sequential to Combinational
In this section, we describe a combinational encoding of fault-persistent computations of a pgfds, which is guaranteed to be exact for subset-monotone pgfdss and provides a useful overapproximation for general pgfdss. In the rest of the section, let S = (C, next) be a pgfds over the fds D = (FM , ≤, ⊥), and TLE be a top level event. We show how to construct a first-order formula ϕ cs over the theory of linear integer arithmetic whose models correspond to cut sets of S with respect to TLE . In the next section, we then use this formula to enumerate all fds-minimal cut sets of S.
To encode the propagations of S, for each component c ∈ C and each failure mode f ∈ FM we introduce two Boolean variables: I c,f and F c,f . The variable I c,f encodes whether c was in the failure mode f in the initial state of the propagation. The variable F c,f encodes whether c has been in the failure mode f at any time during the propagation. We can then encode TLE as a formula ϕ TLE over variables F c,f . 2 Considering now a possible propagation, a component c can be in failure mode f = ⊥ at some time during the propagation for two reasons: either it was already in f in the initial state of the propagation, or it transitions to f because of its next function. The first case is represented by I c,f being true. The second case can be encoded as follows (for each c ∈ C and f ∈ FM \ {⊥}): stating that there must exist a row in the truth table of next(c), whose result includes f and which agrees with the current state on the failure modes of failed dependencies. 3 The above, however, would not work in the presence of cycles. This can already be seen on the simple cyclic pgfds from Example 1.   ∨ F e, )).
Although this encoding has a model μ such that μ |= ¬I g, ∧ ¬I e, ∧ ¬I h, ∧ F g, ∧ F e, ∧ F h, , there is no propagation path of S in which both components e and h are initially in the state ⊥ and switch to state during the propagation. The problem is that the encoding allows models where a failure of e was caused by a failure of h, which was in turn caused by the same failure of e.
In order to solve the problem, we introduce constraints imposing a causal ordering among the components, stating that the failure of a component can be caused only by other components that precede it in the causal order. We encode this by introducing one additional integer variable o c for each component c, which intuitively corresponds to the time when the component c switched to a failure mode different from ⊥, and modifying the formula (1) to take the causal ordering into account: 4 Putting it all together, the encoding for the failure mode changes is given by the formula ϕ next below: Example 5. For the pgfds S from Example 1, the correct encoding of the propagations of S is thus the following formula ϕ next : Note that the constraints for causal ordering now rule out the spurious selfsupporting propagation in which e fails because of h and h fails because of e.
This would require that o h < o e and o e < o h are both true, which is clearly impossible in the theory of linear integer arithmetic (or, more generally, in any theory in which < is interpreted as a strict ordering relation).
The propagations of S mentioned in Example 3 correspond to the following assignments: Finally, we encode the fault-persistence constraint by stating that no component can be in two failure modes either in the initial state of the propagation or at any time during the propagation: The final formula is then given by ϕ cs : As the following theorem shows, the formula ϕ cs for general systems encodes an overapproximation of the set CS (S, TLE ). The reason for this is that the encoding does not enforce failure mode of dependencies that are working, i.e., are in the failure mode ⊥. Note that even an overapproximation of CS (S, TLE ) is useful for safety analysis; it can be used, for example, for computing an upper bound on the probability of failure of the system. Moreover, if the system S is subset-monotone, which is often the case in practice, the formula ϕ cs is guaranteed to encode the set CS (S, TLE ) exactly.
To formulate the relationship precisely, we define the function that provides the correspondence between the models of μ and the cut sets of S. Observe that thanks to ϕ once , each model μ of ϕ cs corresponds to a unique initial state modelToState(μ) of S as defined below: add-preferred-var(solver, I c,f , false) 6. while check-sat(solver):

Theorem 1. For an arbitrary pgfds S and a top level event TLE ,
Moreover, if S is subset-monotone, these sets are equal.

Enumeration of FDS-Minimal Cut Sets
In this section, we show how to efficiently enumerate fds-minimal cut sets of subset-monotone systems using the formula ϕ cs and an SMT solver. We first consider a simplified case, in which the underlying fds D is Boolean. We then show how to generalize our solution to arbitrary fdss.

Algorithm for Boolean FDSs
The pseudo-code of our procedure for the case when the underlying fds is Boolean is shown in Fig. 3. Intuitively, the algorithm enumerates all the subsetminimal models of ϕ cs with respect to the set of variables of form I c,f . These models are enumerated one by one and each enumerated model is, together with all its supermodels, blocked by the assertion on line 13, until the formula becomes unsatisfiable. Each model of the formula is converted to a cut set by the function modelToState.
The algorithm makes use of a DPLL(T)-based SMT solver that provides the following functionalities: 1. An assert-formula method that allows to add constraints incrementally; 2. A check-sat method to determine the satisfiability of the current set of constraints; 3. A get-model method that returns a model for the current asserted set of constraints, in case they are satisfiable; 4. An add-preferred-var method that allows to control the branching heuristics of the internal SAT engine of the solver, such that whenever a SAT decision needs to be performed, variables in the preferred set are always considered before the other variables for branching, and are assigned the value specified in the add-preferred-var call. 5 The correctness for our algorithm is formalized by the theorem below.

Theorem 2 (MCS enumeration over Boolean FDS). For a subsetmonotone pgfds S over the Boolean fds, the result of MCS− enumeration(ϕ cs , modelToState) is the set of all fds-minimal cut sets of S.
Proof. Let S = (C, next) be a subset-monotone pgfds. It was proven by Di Rosa et al. [15] that if branching heuristics of a CDCL-based SAT solver are modified to assign false to a subset V of variables before branching on other variables (lines 4-5 of our pseudocode), the produced model is subset-minimal with respect to the set of variables V . This claim straightforwardly extends to DPLL(T)-based SMT solvers. In every iteration, the algorithm thus finds one subset-minimal model μ of ϕ cs with respect to the set of variables I c,f and adds a constraint that prevents enumerating any model μ such that {I c,f ∈ vars(ϕ cs ) | μ(I c,f ) = true} ⊆ {I c,f ∈ vars(ϕ cs ) | μ (I c,f ) = true} in the following iterations. Therefore, the described algorithm enumerates, for each model μ of the formula ∃{F c,f | c ∈ C, f ∈ FM } ∃{o c | c ∈ C} (ϕ cs ) that is subset-minimal with respect to the set of variables I c,f , exactly one model μ of ϕ cs that agrees with μ on all variables I c,f . Note that vars(ϕ cs ) does not contain the variable I c,⊥ for any c ∈ C. For a Boolean fds and models μ, μ |= ϕ cs , we thus have {I c,f ∈ vars(ϕ cs ) | μ(I c,f ) = true} ⊆ {I c,f ∈ vars(ϕ cs ) | μ (I c,f ) = true} if and only if modelToState(μ) ≤ modelToState(μ ). Therefore, Theorem 1 implies that for subset-monotone S, subset-minimal models of ϕ cs with respect to the set of variables of form I c,f precisely correspond to fds-minimal cut sets of S and the correspondence is given by the function modelToState.

Extension to Arbitrary FDSs
The algorithm of Fig. 3 does not work in general for arbitrary fdss, but only for the fdss in which all the failure modes different from ⊥ are incomparable. The problem is that the assumption that a cut set is fds-minimal iff the corresponding model of ϕ cs is subset-minimal with respect to the set of variables I c,f with f = ⊥ does not hold in general with the encoding of Sect. 4, as can be seen on the following simple example. Both {c → } and {c → m} are cut sets, but only the latter is fds-minimal. However, the algorithm of Fig. 3 will return both, since they both correspond to subset-minimal models with respect to the set of variables I c,f .
We can adapt the procedure of Fig. 3 to arbitrary fdss by using an encoding in which the ordering of assignments to the I c,f variables corresponds to the severity ordering ≤ of the underlying fds D. In order to do this, we exploit the isomorphism between D = (FM , ≤, ⊥) and the poset D ↓ of its lower subsets generated by single elements defined as D ↓= {{f ∈ FM | f ≤ f } | f ∈ FM } with partial order ⊆ and the least element {⊥}. For example, the poset (W 3F ↓, ⊆) for the fds W 3F of Fig. 1 is shown in Fig. 4, together with an encoding of the elements as formulas.
With this isomorphism in mind, we define for each c ∈ C and f ∈ FM the formula ψ c=f that represents the failure mode f of component c by assigning the subset of variables {I c,f |f ≤ f } to true: The important property of this definition is that for all c ∈ C, f, f ∈ FM and assignments μ |= ψ c=f and μ |= ψ c=f , we have f ≤ f if and only if We then modify the encoding ϕ cs of Sect. 4 as follows: 1. First, we modify ϕ next to encode the initial state by using ψ c=f instead of I c,f . This ensures that the ordering of assignments to the initial variables reflects the ordering given by the underlying fds. We also remove the mutual exclusion constraints on the variables I c,f from ϕ once , because the mutual exclusion of initial failure modes is now guaranteed by the definition of ψ c=f : 2. Then, we add domain constraints that ensure that the resulting formula represents only models with assignments to I c,f that correspond to elements of D ↓: The new encoding is then given by ϕ FM cs : The modified encoding ϕ FM cs represents the cut sets in a different way: instead of representing the failure modes directly by I c,f as in ϕ cs , they are now represented by the subformulas ψ c=f . Therefore, to prove correctness of the modified encoding, the function modelToState that maps models to cut sets also has to be changed. We define the initial state modelToState FM (μ) corresponding to the model μ by modelToState FM (μ)(c) = max{f ∈ FM | μ(I c,f ) = true}. Note that the maximum is guaranteed to exist because of the ϕ D↓ constraint.

Theorem 3. For an arbitrary pgfds S and a top level event TLE ,
Moreover, if S is subset-monotone, these sets are equal.
Therefore, the algorithm MCS-enumeration from Fig. 3 can be used to enumerate fds-minimal cut sets of a subset-monotone pgfds, given as the inputs the modified encoding ϕ FM cs and the modified function modelToState FM . This is formalized by the following theorem:

Theorem 4 (MCS enumeration for general FDS). For a subset-monotone pgfds S over an fds D, the result of MCS-enumeration(ϕ FM cs , modelToState FM ) is the set of all fds-minimal cut sets of S.
Note that our encoding of fds-minimality is general and does not depend on the algorithm for enumeration of subset-minimal models. Indeed, thanks to our encoding, any off-the-shelf minimal-model enumerator can be used to enumerate fds-minimal models. Therefore, any improvements to minimal model enumeration directly translate to improved performance of our method for fds-minimal cut set enumeration. From the opposite point of view, our encoding can in principle be employed by other tools to reduce fds-minimal cut set enumeration to subset-minimal cut set enumeration.

Related Work
Finite Degradation Models (fdms) [14] are an algebraic framework accommodating the concept of fault degradation, where faults may have different values organized into a semi-lattice. Using fdms (probabilistic) safety analysis (fault trees and minimal cut sets) can be generalized from Boolean models to multistate systems. Compared to fdms, fault-persistent pgfdss differ in two significant aspects: first, since the function next returns a set of possible next failure modes, pgfdss allow non-determinism in the failure propagation, i.e., the failure of a component is not uniquely determined by the failure modes of its dependencies. Second, and more importantly, pgfdss allow cyclic dependencies and give them well-defined and expected semantics. Since the work on fdms is the closest to ours, we shall discuss it in detail below.
In [8] the authors present a framework for failure propagation which enables modeling sets of failure modes using a domain specific language. It is less expressive than fdms, in that sets of failure modes cannot be related by degradation orders, which significantly simplifies the enumeration of MCSs. Finally, classical formalisms for failure propagation, but less expressive than fds, include fptn [9] and Hip-HOps [11].
tfpgs (Timed Failure Propagation Graphs) [1] extend fault propagation model by enabling the specification of time bounds and mode constraints on the propagation links. However, tfpgs do not consider degradation, and they do not support cyclic dependencies. Conversely, the pgfds formalism can be easily extended to support time bounds, failure probabilities, mode constraints, and constraints on propagation delays similar to those available in tfpgs (e.g., following [5]). Moreover, once the minimal cut sets of a pgfds are computed, the existing approach to computing probability of overall failure [5] can be used almost unchanged.
Finally, xSAP [3] is a safety analysis platform that supports library-based fault models and the generation of safety artifacts for fully general behavioral models, e.g., it can generate fault trees and minimal cut sets for arbitrary transition systems [6]. Currently, xSAP does not support fds and degradation models.

Detailed Comparison with Finite Degradation Models
As outlined above, the formalism Finite Degradation Models (fdms), introduced in [14], is closely related to our pgfds. Here, we describe fdm in further detail and show that pgfds are a strict generalization of fds, obtained by (i) considering non-determinism in the propagation of failures, and (ii) by allowing cyclic dependencies among the components.
Each fdm has state variables, which correspond to the sources of failures in the system, and flow variables, which correspond to the propagated consequences of these failures. Each flow variable has an associated equation, which prescribes the failure mode of the corresponding flow variable based on the failure modes of state variables and other flow variables. We assume that the failure modes of all state and flow variables are modeled by the fds D = (FM , ≤, ⊥). 6 [14]  We say that a flow variable W m+i depends on a variable v if the function φ m+i depends on v. An fdm is called acyclic if there are no cyclic dependencies among its flow variables, i.e., no flow variable transitively depends on itself. We stress out that in contrast to our definitions of pgfds, the original paper [14] only deals with acyclic fdms and does not provide semantics and necessary definitions for cyclic fdms. We thus assume in the rest of the section that all fdms are acyclic.

Definition 9 (Finite Degradation Model
An assignment σ : V → FM is called admissible if the failure modes assigned to the flow variables satisfy all the corresponding equations, i.e., σ(W m+i ) = φ m+i (σ) for each 1 ≤ i ≤ n. The assumption of acyclicity of fdms, together with the fact that all equations are deterministic functions and not general relations, guarantees that in each admissible assignment, failure modes of the flow variables are uniquely determined by the failure modes of the state variables. This defines a function [[M ]](σ) = σ M , which maps each state variable assignment σ to its unique admissible extension σ M that assigns values to all variables. This is a stark contrast to pgfds, where a single initial state can give rise to multiple different propagation paths.
A corresponding notion to our notion of top level event for fdm is the notion of observer. An observer is a pair (R, U ), where R is a flow variable and U ⊆ FM is a set of failure modes. Intuitively, the observer represents a set of dangerous failure modes of the given flow variable. A cut set is any assignment σ : S → FM of failure modes to state variables such that σ(R) ∈ U .
A notion related to our notion of monotonicity for fdm is coherence. The observer is coherent if for all assignments σ, σ : S → FM such that σ is a cut set and σ ≤ σ , the assignment σ is also a cut set.
Each fdm M can be translated to a pgfds S M such that the cut sets of M correspond to the cut sets of S M . Moreover, if the fdm M is coherent, the resulting pgfds S M is guaranteed to be subset-monotone. This enables efficient analysis of coherent fdms by our SMT-based technique. Intuitively, the pgfds S M has one component for each state variable of M and an additional component R for the observer flow variable R. The next function is defined in a way that the failure modes of all the components that correspond to state variables cannot

Experimental Evaluation
To evaluate the performance and scalability of our approach, we have implemented the proposed algorithm MCS-enumeration in a simple Python tool that uses the solver MathSAT [7], which supports all the required functionalities that are described in Sect. 5.1. In this section, we refer to the tool as SMT-PGFPS. As a comparison, we have used Emmy [13], a tool based on decision diagrams for the enumeration of fds-minimal cut sets of fdms, and xSAP [3], a tool for safety assessment for arbitrary transition systems. Each of these tools only supports a subset of the capabilities of our approach, as summarized in Table 1.
Emmy supports minimal cut set enumeration with respect to an arbitrary ordering of failure modes given by an fds, but only for acyclic and deterministic fdms; xSAP supports analysis of arbitrary transition systems with cycles, given that it internally relies on the nuXmv model checker. However, it cannot enumerate fds-minimal cut sets, but only subset-minimal ones. Note that for computation of subset-minimal cut sets, xSAP is more general than our approach, as it supports general transition systems and arbitrary temporal properties. However, we use xSAP as a baseline to compare performance and scalability of our approach for cyclic pgfds because it is a subcase of general transition systems that is important in practice. In the evaluation, we use the IC3-based engine described in [6] (denoted as xSAP-IC3). Note that this algorithm assumes that the verified property is monotone and leverages this assumption for efficiency.
For the comparison, we have created three sets of benchmarks: Scalable acyclic benchmarks consisting of linear structures extended by a triple modular redundancy scheme. The basic architecture of these structures is parameterized by its size n and the system contains 6n components: 3n modules and 3n voters. These benchmarks use the fds W2F, which is a restriction of the fds W3F of Fig. 1 to failure modes {w, fd , fu}, with the ordering w < fd < fu. Note that fds-minimal cut sets of these benchmarks cannot be enumerated by xSAP, as the benchmarks use a non-Boolean fds. Randomly generated systems with cycles over Boolean FDS which share some structural properties with real-world systems. In particular, we generated random systems that have a similar distribution of in-degrees and out-degrees of the components as our proprietary systems, which we cannot disclose. We have generated 950 such systems of sizes ranging between 50 and 1000 components. We have used the Boolean fds for these benchmarks, so that they can be precisely analyzed also by xSAP. Note that these benchmarks cannot be solved by Emmy, as they contain cyclic dependencies among the components. Randomly generated systems over W2F which are created from the abovementioned randomly generated systems by using the fds W2F instead of the Boolean one. Although this does not change the overall structure of the system, it makes the transition relation more complicated and significantly increases number of minimal cut sets.
In the evaluation, we only used systems of size at most 400, as both the compared approaches timed out on the vast majority of larger systems. Note that these benchmarks cannot be solved by Emmy, as they contain cyclic dependencies among the components. They can be solved by xSAP, but the generated cut sets are only subset-minimal with respect to fault variables, and not (in general) fds-minimal.
For the scalable benchmarks, we have generated encodings in the SMT format described in this paper and in the fds-ml format used by Emmy. For the randomly generated cyclic benchmarks, we have generated encodings in the SMT format and in the SMV format used by xSAP. The SMV encodings also include the assumption of fault-persistence. All the used benchmarks are subsetmonotone, and therefore our SMT-based approach can be used to compute the set of minimal cut sets correctly.
We have used wall time limit of 30 min for each solver-benchmark pair. All experiments were performed on a Linux laptop with Intel Core i7-8665U cpu and 32 GiB of ram.
A comparison of SMT-PGFPS and Emmy on the scalable acyclic benchmarks can be seen in Table 2. It shows that Emmy times out already on systems of size 5, i.e., on systems with 30 components. On the other hand, our approach is able to scale to systems with three thousand components.
A comparison against the sequential approach of xSAP on cyclic benchmarks can be seen in Fig. 5. Figures 5a and 5b show that on random systems over Boolean fdss, our approach significantly outperforms the sequential approach of xSAP. As the size of the system grows, the difference can be up to several orders of magnitude. Both xSAP and SMT-PGFPS compute exactly the same minimal cut sets. Hence, the dramatic difference in performance can be justified by the reduction to the combinational case, which prevents the unrolling of the transition relation by implicitly encoding the propagations in the total ordering(s) found by the SMT solver. The performance difference on the systems over the fds W2F, shown in Figures 5c and 5d, is even more pronounced. This can be caused by two additional factors. First, the systems over the fds W2F have more complicated transition relation, more minimal cut sets, and are in general harder. Thus, the unrolling performed by xSAP is even more costly. Second, xSAP has to enumerate more cut sets, because it is enumerating all subset-minimal cut sets and not only fds-minimal cut sets. However, this cannot be the main source of the observed performance gap: on 35 from the 113 benchmarks on which both xSAP and SMT-PGFPS finished before timeout, the number of cut sets are the same; on the remaining 78 benchmarks, xSAP enumerates on average 6% more cut sets and at most 62% more cut sets. In order to obtain fds-minimal cut sets from xSAP, the produced subset-minimal cut sets would have to be filtered or explicitly minimized, which would add yet another performance penalty for xSAP.
Overall, the SMT-based techniques presented in this paper yield a fundamental advancement with respect to the state of the art, both in terms of expressiveness as well as in terms of performance.

Conclusions and Further Work
We tackled the problem of supporting the Preliminary Safety Assessment phase of aircraft design. Specifically, we defined an expressive framework for modeling failure propagation over components with multiple levels of degradation, with nondeterminism and cyclic dependencies. We presented a sequential semantics and proved that the problem can be tackled by means of minimal models enumeration in SMT. The framework is more expressive than the state of the art, and the proposed method outperforms the BDD-based techniques from [14] on acyclic benchmarks over generic fdss, and the model checking techniques of [6] on cyclic benchmarks. In the future, we are going to introduce timing constraints and analyze redundancy architectures. We also investigate ways to relax the monotonicity and fault-persistence assumptions to explore recovery mechanisms and to further extend the reach of our approach. We are also working on encoding the causality constraints in the frameworks of SAT modulo acyclicity [10] and ASP modulo acyclicity [4], which could improve the performance of our approach even further.