{'fraction_non_alphanumeric': 0.03921342881484722, 'fraction_numerical': 0.010499896382601487, 'mean_word_length': 4.372340425531915, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Automatic inference of fault tree models via multi-objective evolutionary algorithms

Fault tree analysis is a well-known technique in reliability engineering and risk assessment, which supports decision-making processes and the management of complex systems. Traditionally, fault tree (FT) models are built manually together with domain experts, considered a time-consuming process prone to human errors. With Industry 4.0, there is an increasing availability of inspection and monitoring data, making techniques that enable knowledge extraction from large data sets relevant. Thus, our goal with this work is to propose a data-driven approach to infer efficient FT structures that achieve a complete representation of the failure mechanisms contained in the failure data set without human intervention. Our algorithm, the FT-MOEA, based on multi-objective evolutionary algorithms, enables the simultaneous optimization of different relevant metrics such as the FT size, the error computed based on the failure data set and the Minimal Cut Sets. Our results show that, for six case studies from the literature, our approach successfully achieved automatic, efficient, and consistent inference of the associated FT models. We also present the results of a parametric analysis that tests our algorithm for different relevant conditions that influence its performance, as well as an overview of the data-driven methods used to automatically infer FT models.

carried out in conjunction with domain expertise and in a hand-crafted manner, resulting in a tedious and time-consuming task. In the case of complex industrial systems, manual development of these models can lead to incompleteness, inconsistencies, and even errors [2].
The above challenge has been discussed since the 1970s, and it is referred to in the literature as construction [3], synthesis [4], or induction [5] of FTs. In this work, we refer to this as automatic inference of FT models. The latter is a process, where a given observational failure data set, automatically outputs the FT structure that best encodes the logic that describes the failure propagation in the system. Different ways of inferring FTs have been discussed in the past. We identify three main groups namely knowledge-based, model-based, and data-driven. The main differences between these categories are that knowledge-based approaches employ different heuristics for knowledge representation, using information about the basic components and their interconnections in the system under analysis [6]; model-based approaches translate existing system and/or graph models into FTs, and data-driven approaches have structured databases as the primary source of information.
Carpignano & Poucet [7] thoroughly review several knowledge-based approaches. An example of a model-based approach can be found in Mhenni et al. [8] where the authors used SysML System Models as a base to obtain FT models. However, a major drawback of model-based approaches is the need for a pre-existing model [9].
We focus our attention on data-driven approaches, where the applications of machine learning techniques and data analytics fall into this category. In Appendix E, Table 5 (divided into two parts) we summarise and compare relevant literature in data-driven methods for the automatic inference of FT models. Below we briefly discuss these methods.
To the best of our knowledge, the very first attempt to tackle the challenge in a data-driven manner was made by Madden & Nolan [5] with their IFT algorithm, which is based on Quinlan's ID3 algorithm to induce Decision Trees (DTs) [10]. The authors also continued with this work in the subsequent years [11], [12]. Mukherjee & Chakraborty [13] addressed this challenge via linguistic analysis and domain knowledge to identify the nature of the failure from short plain text descriptions of equipment faults, and from this generate an FT model. Roth et al. [14] propose a method that follows the Structural Complexity Management (StCM) methodology, where their main goal is to deduce dependencies that are later on are used to infer the Boolean logic operators of the FT models. Inspired by Causal Decision Trees [15], in Nauta et al. [16] they proposed an approach based on the Mantel-Haenszel statistical test.
Based on Knowledge Discovery in Data set, Waghen & Ouali [17] propose a method for hierarchical causality analysis called Interpretable Logic Tree Analysis (ILTA), that looks for patterns in a data set which are translated into Interpretable Logic Trees. Linard et al. [18] proposed a method that consists of learning a Bayesian Network graph, which is later translated into an FT model. Lazarova-Molnaretal [19] presents an approach based on time series of failure data, binarization techniques, MCSs, and Boolean algebra. This algorithm also manages to infer FT models with VoT gates. In Waghen & Ouali [20] the authors further extended their work to the Multi-level Interpretable Logic Tree Analysis (MILTA), which tackles the problem of multiple cause-and-effect sequences (the latter a limitation of their previous version, the ILTA algorithm) by incorporating Bayesian probability rules.
The first attempt based on evolutionary algorithms was carried out by Linard et al. [21], here the authors created an algorithm to generate FT models from a labeled binary failure data set using a uni-dimensional cost function based on the accuracy, which is the proportion of correctly predicted top events by a given FT.
A drawback of the above approach is that it focuses solely on achieving high accuracy without considering the FT structure. The latter has negative implications such as: running the algorithm twice for the same failure data set may yield considerably different FT structures; it is prone to complexity explosion, leading to massive FTs that are difficult to handle; long computational time, and bad convergence of the algorithm.
Thus, the main contributions of this paper are that (i) we show it is possible to achieve more consistent and efficient FT structures via multi-objective evolutionary algorithms (MOEAs), which simultaneously optimize various criteria in a multi-dimensional space [22], (ii) we propose a metric to compare FT structures via Minimal Cut Sets using the RV-coefficient, (iii) we carry out a parametric analysis that explains the performance of the algorithm under different assumptions.
The remaining part of this paper is organized as follows. Section 1 formally defines FTA and provides the technical background of MOEAs. Section 2 explains our methodology. Section 3 presents how we apply the NSGA-II (an MOEA) to infer FTs. Section 4 presents the results of a thorough parametric analysis. Section 5 discusses our findings and presents our conclusions.

Fault Tree Analysis
Fault Tree Analysis (FTA) is one of the most famous methods in reliability engineering that supports decisions in the design and maintenance of complex systems. FTA enables qualitative and quantitative analyses. Qualitative analysis is based on the FT structure and aims at finding the critical system components.
Here, an important concept refers to the Minimal Cut Sets (MCSs), which are minimal combinations of component failures that lead to a system failure. Small minimal cut sets point to system vulnerabilities.
The quantitative analysis aims at computing various dependability metrics, such as system Reliability; Availability; and the Mean-Time-to-Failure. Estimation of these metrics requires that the FT leaves are equipped with failure probabilities.
A Fault Tree (FT) helps in understanding why a system fails by modeling how low-level failures propagate through the system and lead to the system-level failure. As similarly done by Ruijters and Stoelinga [23], to formally define an FT, we first define GateType = {And, Or} ∪ {VoT(k/N) | k, N ∈ N ≥1 , k ≤ N}. Then, an FT is a 5-tuple F = BE, G, T, I, TE where • BE is a set of basic events, which may be annotated with a probability of occurrence p i .
• G is a set of logic gates, with BE ∩ G = ∅.
• E = BE ∪ G for the set of elements.
• T : G → GateTypes is a function that describes the type of each gate.
• I : G → P(E) describes the inputs of each gate. We require I(g) = ∅ and that |I(g)| = N if T(g) = VoT(k/N).
• And gate is a tuple And, I, O where O outputs true, if every i ∈ I occurs.
• Or gate is a tuple OR, I, O where O outputs true, if at least one i ∈ I occurs.
• VoT(k/N) gate is a tuple VoT, k, I, O where O outputs true, if at least k of i ∈ I occur.
• TE ∈ E is a unique root called the top event, and it is reachable from all other nodes.
Importantly, the graph formed by (E, I) should be a directed acyclic graph. Fig. 1.(a) and 1.(b) depict respectively the event and gate symbols used to construct the FT model.   (c) provides an example of an FT. This is the FT of a Container Seal Design adapted from [24]. In this FT, the top event, the sealing function fails, either occurs if a common cause seal failure occurs or if the seals fail independently. For the former, it is necessary that the contamination tape fails, and a basic cause seal failure occurs. For the latter, it is necessary for the metal-tometal seal, the fused plug, and at least two of the three compression seals to fail.

Multi-Objective Evolutionary algorithms
Evolutionary algorithms (EAs) are population-based search strategies that use the fundamental principle of natural selection, where the best individuals are more likely to reproduce and, therefore, to pass on to the next generations [25]. When the EA deals with several conflicting objective functions to be simultaneously optimized in a multi-dimensional space [26], we call these Multi-Objective Evolutionary Algorithms (MOEAs). The result of MOEAs is a set of solutions with trade-offs, better known as Pareto-optimal solutions, from which a user can then, based on higherlevel qualitative considerations, make a choice [22].
As a first step to tackle the challenge of automatically inferring FTs from a failure data set by simultaneously optimizing different metrics, we decided to use one of the most popular algorithms in multiobjective optimization called the Elitist Non-dominated Sorting Genetic Algorithm (NSGA-II) (Section 1.2.1) and the Crowding-Distance (Section 1.2.2).

Elitist Non-dominated Sorting Genetic Algorithms (NSGA-II)
The Elitist Non-dominated Sorting Genetic Algorithm (NSGA-II) [27] aims at finding multiple Paretooptimal solutions. NSGA-II uses the elitist principle which is a diversity preserving mechanism that emphasizes the non-dominated solutions [22]. Moreover, the elitist principle guarantees that the quality of the solution does not decrease, by letting the best individual(s) of the current generation pass to the next one.
Non-dominated MOEAs use the concept of dominance, where two solutions are compared to evaluate whether one dominates the other or not. Nondominated sorting is a crucial step to uncover elitist efficient solutions in MOEAs, but it is computationally expensive since it involves numerous comparisons [28]. A set of solutions that do not dominate each other is known as a non-dominated front. In Appendix A.1 we provide a detailed explanation of these concepts and exemplify how the NSGA-II is applied in the automatic inference of FTs.

Crowding-Distance
Since it may be the case that the last non-dominated front obtained through the NSGA-II does not fully accommodate the available slots to complete the new population, the Crowding-Distance is used to decide which individuals of the last front can pass to the next generation, acting as a mechanism that promotes diversity [29]. In Appendix A.2 we provide details on how the Crowding-Distance is applied in the automatic inference of FTs. Fig. 2 depicts the general methodology we followed in this paper. First, we selected some case studies of existing FTs (Section 4.2), these FTs act as ground truth. Then, we selected some parameters of interest (Section 4.4) to be evaluated in the parametric analysis. We used the Monte Carlo method (Section 4.1) to generate failure data sets (Section 2.1) based on the selected case studies. Then we used our FT-MOEA algorithm (Section 3) to infer the FT based on the provided failure data set. Finally, we compared the ground truth with the inferred FTs and evaluate the experiment (Section 4.4.1 to 4.4.5).

The failure data set
Our methodology needs the following assumptions for the input failure data set: • Labeled: Our data set consists of combinations of BE and their corresponding TE.
• Binary: Both BE and TE are binary. This poses an advantage because we can make use of Boolean operations which makes the algorithm faster. In our case, 0 and 1 are used as nonfaulty and faulty states, respectively.
• Monotonic/consistent: For a given set of BE, if a single BE changes from state 0 to 1, it is possible that TE changes from state 0 to 1, but it will never change from state 1 to 0.
• Complete: The total number of unique combinations of BE in the failure data set equals the space complexity O(2 w ), where w corresponds to the number of unique BE for a given FT.
• Noise-free: There is no corrupted information contained in the failure data set. In other words, the relation BE → TE is always true for a given FT. Table 1 presents an example of the data set associated with the FT in Fig. 1. To generate this data set, we used the Monte Carlo method described in Section 4.1 for N = 250, 000 data points and using a failure rate for the BE of p i = 0.5. Ob. refers to the observation associated with a unique combination of values of BE, and the associated TE. The columns BE1, BE2, ..., BE7 show the states of the set of BE. TE corresponds to the top event. Finally, the last column refers to the count of each of the observations in the failure data set.

INFERRING FAULT TREES VIA MULTI-OBJECTIVE EVOLUTIONARY ALGORITHMS (FT-MOEA)
The input of the algorithm is composed of the failure data set, described in Section 2.1, and the initial parameters of the MOEA, described in Section 3.1. The output of the algorithm is a string that describes the structure of the inferred FT (based solely on And and Or gates), and metrics of interest that tell about the error between the inferred FT and the failure data set. These metrics are explained in detail in Section 3.5.1. Fig. 3 provides an overview of our approach, consisting of the following five steps: 1) Step 1: Initialize the algorithm by loading the failure data set (Section 2.1) as well as the initial parameters (Section 3.1). An optional step is the extraction of the MCSs from the failure data set (Section 3.2), which is executed only when the objective function considers metrics based on MCSs. 2) Step 2: Initialize the population with the parent fault tree(s) (Section 3.3) on which the genetic operators are applied until the desired population size is reached.

3)
Step 3: Apply the genetic operators (Section 3.4) to randomly modify the structure of the FTs. These genetic operators are recursively applied to a population of FTs until reaching at least the desired population size. 4) Step 4: For each FT in the offspring population, compute the metrics to be optimized (Section 3.5.1). Then, using the concept of Pareto efficiency through the Elitist Non-Dominated Sorting Algorithm (NSGA-II) and Crowding-Distance (Section 1.2), determine the population of FTs for the next generation. 5) Step 5: Check whether any of the convergence criteria (Section 3.6) are met. If not, the genetic operators ( Step 3) are applied to the new population, and Steps 4 and 5 are applied recursively until at least one of the convergence criteria is met, outputting a Pareto set of inferred FTs where we chose the best individual i.e., the FT with the smallest size, and smallest error(s) within the first Pareto set.

Convergence criteria
Inferred FT

Parent fault trees
Step 2 Step

Step 1 -Initialization
We have the following initial parameters.
• Population size (ps): Corresponds to the number of FTs within a generation. Only the best ps FTs can pass to the next generation.
• Selection strategy: For the NSGA-II algorithm we only use the elitist selection strategy.
• Max. generations with unchanged best candidate (uc): if after uc number of generations the best individual (i.e., the FT with the smallest size, and smallest error(s) within the best Pareto set) remains unchanged, then we assume the process has converged and is therefore terminated.
• Max. number of generations (ng): Terminates the optimization process if the number of generations exceeds ng and none of the other convergence criteria is met.

Step 1.2 -Extraction of MCSs from the failure data set (optional step)
As mentioned before, MCSs are a minimal combinations of component failures that lead to a system failure. This information is extremely valuable because it encodes the failure modes of the system. By considering this information in our optimization process we are adding additional criteria that can help our algorithm to find better solutions in a shorter amount of time. However, the user can decide whether to consider MCSs within the optimization process.
One should consider MCSs only if it is guaranteed that the failure data set is noise-free, and if the expected FT is not too complex (see Section 4.4.3 where we address the topic of complexity in FTs). The former because otherwise one cannot be sure whether MCSs are correct, and the latter because computing MCSs is computationally expensive (we will discuss this in Section 3.5.1) and for complex FTs, this could increase the convergence time.
The process of extracting MCSs from a failure data set is done as described by Lazarova-Molnar et al. [19] with the following four steps.
Step 1: identify all the combinations of BE that output class 1 (i.e., TE = 1).
Step 2: from this sub-set, identify the one with the minimal order (where the order is defined as the number of true BE in an observation) and save this observation as part of the MCSs matrix computed from the failure data set (M D ).
Step 3: look in the subset for other observations that include the previously identified MCS. If any, delete them from the sub-set.
Step 4: repeat Steps 2 and 3 until the sub-set is empty. Now, the obtained M D can be used as an input argument to compute the accuracy based on the MCSs (φ c ) (see Eq. 3). Table 2 provides an example of M D for the failure data set described in Table 1 for the example in Figure 1

Step 2 -parent fault tree(s)
The parent fault tree(s) can be seen as that one (or those ones) from which the offspring population is generated when applying the genetic operators (Section  Table 1 associated with the example in Figure 1. Defining the parent FT(s) is important because it determines how far away, from the global optimum, one starts the optimization process. In Linard et al. [21] two parent FTs are used to generate the offspring population, one in which the set of BE are connected to a single Or gate, and the other to a single And gate. We consider this aspect in our parametric analysis, the results are in Section 4.4.5.

Step 3 -Genetic operators
The genetic operators are mathematical operations that seek to modify the structure of an FT. We use the seven genetic operators proposed by Linard et al. [21], which also gives the formal definitions of these operators. For completeness, we here provide a short description.
(i) G-create: randomly creates an And or Or gate under an existing gate in the set G for a given FT.
(ii) G-mutate: randomly selects a gate in the set G and changes its type (i.e., Or → And, or And → Or). (iii) G-delete: from a given FT takes a gate in the set G and deletes it, including its children. (iv) BE-disconnect: from a given FT takes a basic event in the set BE and disconnects it. (v) BE-connect: from a given FT takes a disconnected basic event and randomly places it under a gate in the set G. (vi) BE-swap: from a given FT takes a basic event in the set BE and randomly moves it under a different parent gate in the set G. (vii) Crossover: randomly chooses two FTs in the offspring population, then an element in the set E of each FT is randomly selected and exchanged.

Step 4 -Multi-objective function
In Section 3.5.1 we define the metrics to be minimized, and in Section 3.5.2 we describe the different setups of our multi-objective optimization function.

Computation of metrics
In this multi-objective function, we consider three metrics, namely the fault tree size (φ s ), the error based on the failure data set (φ d ), and the error based on the MCSs (φ c ).
Here note that φ s ≥ 2, as each FT has at least one BE and one G (i.e., the TE).
• Error based on the failure data set (φ d ): First we need to compute a one-dimensional vector P with N values, where N is the number of data points. P contains the value of the TE of an FT for a given set BE. For the same set BE, we count with the value of the ground truth top event (TE * ), which is in the failure data set (Section 2.1). Thus, φ d is computed as follows Here φ d varies in the closed interval [0, 1], where 0 means that an FT manages to perfectly map the given set BE in the failure data set into the corresponding TE in the failure data set.
• Error based on the MCSs (φ c ): we propose to compute the error of an FT based on MCSs by means of the RV-coefficient [30]. The RVcoefficient is a generalization of the squared Pearson correlation coefficient and measures the similarity between the MCS matrix computed from the failure data set (M D ) (see Section 3.2) and the MCS matrix of a given FT (M F ). M F is computed based on the disjunctive normal form (DNF), which in Boolean logic is also known as an Or of Ands. Thus, we transform a given FT into its DNF and identify from it the MCSs to construct M F . However, this transformation showed to be computationally expensive for large FT sizes. In our context, M D is a p × w matrix, M F is a q × w matrix, w corresponds to the number of unique BEs considered in the problem and p and q are the number of MCSs in the failure data set and an FT, respectively. The computation of φ c is defined as follows Here tr(.) is the trace, and φ c varies in the closed interval [0, 1], where 0 indicates perfect correlation or similarity between M D and M F . We choose to use the RV-coefficient as a means to compute the error based on MCSs because, for a given problem, the number of unique BEs always remains the same, but the FTs within a population for a given generation often have different number of MCSs with respect the ones found in the failure data set (i.e., p = q).

Setups of the multi-objective functions
Since our multi-objective function (m.o.f.) has three arguments, we can play with different setups and assess their influence (see Section 4.4.2 for the results of the parametric analysis). For example, if we want to minimize only the error based on the MCSs (φ c ), we can "turn off" φ s and φ d by assigning constant values (i.e., φ s = φ d = 1). To differentiate between the different configurations in the m.o.f., we propose the nomenclature presented in Table 3.
Here 'x' refers to whether a metric is being considered (or active) in the m.o.f.

Step 5 -Convergence criterion
Our convergence criterion is based on two initial parameters namely the max. number of generations (ng), and the max. generations with unchanged best candidate (see Section 3.1). Additionally, we terminate the convergence process if φ c = 0 or φ d = 0 when the minimization of the FT size is "turned off", i.e. for the m.o.f.'s cd, c, or d.

EXPERIMENTAL EVALUATION
For our experimental evaluation, we first selected six case studies from the literature (Section 4.2), then we made the implementation of our FT-MOEA algorithm in Python 1 . We evaluate our algorithm using synthetic failure data sets (Section 4.1). Some key findings and our parametric analysis are presented respectively in Sections 4.3 and 4.4.

The Monte Carlo method
We use the Monte Carlo method to generate synthetic failure data sets using the case studies presented in Section 4.2 and keeping the same properties of the input data set described in Section 2.1. To generate the synthetic dataset (i) we randomly generate (N) data points, by drawing the BE independently from a binomial distribution with a probability of success equal to p i , where i corresponds to a basic event, and (ii) computing the corresponding TE by following the logical rules of the given FT. As one of the main

Case studies
In order to establish a sensible ground truth, we used existing FTs in the literature with different applications. Our selection criteria were the number of elements in the FT as well as the number of MCSs and their orders. Table 4 presents the case studies we selected together information on their number of BE, the total number of And, Or, and VoT gates, the number of MCSs, their orders, and the space complexity which is measured as O(2 w ). We make a distinction between the number of unique BE (w) and the total number of BE (W ) because some FTs have shared BE.

Key findings of the FT-MOEA algorithm
To illustrate our findings and main contributions, we will use the case study Mono-propellant propulsion system (MPPS) from Table 4. We first generate the failure data set as described in Section 4.1, with N = 250.000 data points. Then, we used this failure data set as part of the input data of the FT-MOEA algorithm, together with the following initial parameters: ps = 400, ng = 100, and uc = 20.
We first compare the evolutionary process between generations for two m.o.f.'s d and sdc. In this way we can respectively compare the approach by Linard et al. [21] (only minimizing φ d ) and our multi-objective optimization process (minimizing φ s , φ d , and φ c ).   first generations there is a rapid decrease in φ d but from the 10th generation onwards, there is a rapid growth in the size of the FTs (φ s ) (up to φ s = 100) without decreasing φ d , whereas the ground truth FT is φ s = 23. On the other hand, by using the FT-MOEA algorithm ( Fig. 4.(b)) we observe a smoother decrease in all directions. Additionally, we observe that the FT-MOEA found the global optimum (i.e., φ d = φ c = 0.0) in the 20th generation with φ s = 14 i.e., a compressed version of the ground truth. In Fig. 5 we compare both m.o.f.'s across generations using only the metrics of the best FT per generation (i.e., that one in the first Pareto front that has the smallest error φ d and φ c ). In Fig. 5.

Parametric analysis
We consider five aspects to evaluate within our parametric analysis namely the population size, the multiobjective functions, the FT complexity, the influence of superfluous variables, and the initial parent FTs. We decided to explore these parameters because we believe they have an important impact on the computational time, convergence, and the chances of reaching the global optimum.
For this parametric analysis, we generate the failure data set as described in Section 4.1. Since the evolutionary algorithm is a stochastic process, we run our algorithm five times per combination of parameters, and by using box charts in Matlab (e.g., Fig. 6) we depict the groups of numerical data through their quartiles.  (Table 4).

Multi-objective functions
We evaluate all Setups of our m.o.f. (Table 3), for this, we use the case studies in Table 4, and keep fixed the input parameters ps = 400, ng = 100, uc = 20.  ing φ s . When accounted, φ s for most of the cases is equal or less than the ground truth, indicated with the horizontal lines for the different case studies (see Appendix B for examples and details). When not accounted for, in some cases, φ s may be significantly larger than the ground truth.  Table 4). For example, the case study ddFT has six MCSs and with orders between 3 and 6, the FT-MOEA generally took the longest time to converge. In contrast, the SMS case study has 13 MCSs but all have order 1, here the FT-MOEA converged almost immediately. Thus, the greater the number of MCSs and their orders, the longer will take the algorithm to retrieve the global optimum. We believe that further research is needed to better quantify this type of complexity.

Influence of superfluous variables
Real-world data sets may consider a different number of BEs where possibly not all of them contribute to the failure of the system. In other words, regardless of the state of superfluous BEs, they will not have any effect on the TE. We call these superfluous variables (ρ). We assess ρ ranging from 0 to 6 using the MPPS case study with ps = 400, ng = 100, and uc

Varying the parent fault trees
We defined in Section 3.3 what a parent FT is, and here we evaluate the effects of varying this parameter. We use the case study MPPS, the m.o.f. sdc with the following parameters ps = 400, ng = 100, uc = 20, ρ = 6. We consider three setups. Setup A is our reference, we have been using it throughout this paper (see Section 3.3). Setup B consists of a single parent FT based on the DNF. Setup C takes an inferred suboptimal FT model with φ s = 98 previously obtained using the m.o.f. d in Fig. 8.(a).
We already discussed in detail the results of Setup A in Fig. 5, Section 4.3. Fig. 9.(a) and (b) shows that Setup B has an error of zero since the onset (i.e., φ d = φ d = 0.0). This is expected because Setup B considers as parent FT the DNF. However, this does not mean the parent FT has the optimal structure, this is what we observe in Fig. 9.(c) where around the 30th generation the FT-MOEA found a smaller structure with the same performance. The latter structure is the same as the one where Setup A converged. Setup C started with a sub-optimal parent FT of φ s = 98 but in Fig. 9.(c) we observe that right from the first generation, the FT-MOEA algorithm found a better solution of φ s = 47, and it converged in φ s = 21. Fig. 9.(d) shows that it took about 3 days to get through the first three generations, the reason being that computing the MCSs of many large FTs was expensive, but as soon as the FTs of the population reached a smaller size, the process became faster.
From the above results, we can conclude that Setup A is faster than Setups B and C, although it took more generations to find the global optimum. On the contrary, Setup C found the global optimum with fewer generations, but both, Setup B and C are slower, the reason most likely is because obtaining MCSs from large FTs is computationally expensive.

DISCUSSION AND CONCLUSIONS
In this paper we demonstrate that it is possible to infer efficient and interpretable FT structures by implementing multi-objective evolutionary algorithms. However, there are several aspects that still need to be addressed before thinking about real-world applications.
Even though our algorithm fares better than alternative approaches, its scalability will become an issue for FTs with many BEs. A way to overcome this drawback is by means of "guided" multi-objective evolutionary algorithms. This concept consists of helping the optimization process by injecting additional knowledge. One way to address this is by searching out for patterns (e.g., Waghen & Ouali [20]) in the failure data set that enables identifying parts of the FT and then assemble them.
Another way is by guiding the application of the genetic operators. In our current procedure these are randomly applied, whereas one may be able to increase the chances of finding the global optimum by targeting at parts of the FT that most likely need to be modified. The latter might be possible to achieve by implementing Bayesian optimization. A more challenging path is exploring deep learning-based approaches like the one by Cranmer et al. [33] to derive symbolic rules from a Graph Neural Networks.
We found that the inclusion of MCSs in the multiobjective optimization function greatly improves the optimization process. However, the FT-MOEA computes the MCSs based on the disjunctive normal form, which is computationally expensive for large FTs. Moreover, MCSs cannot be computed in noisy data. Thus, alternatives to overcome these issues are worth exploring. Finally, some spare but equally interesting challenges are enlisted next.
• Having complete failure data sets for complex engineering systems is virtually impossible. Thus, a more thorough evaluation of the performance of our algorithm under incomplete failure data sets is necessary.
• Real-world problems often contain symmetries, e.g., when two basic events are known to be fully exchangeable. This property could be used as an advantage, because we expect to reduce the solution space, leading to faster convergence. Thus, research in this direction is needed.
• In order to obtain more compact and efficient FT structures, exploring alternatives that enable the inference of more sophisticated gates (e.g., VoT gates) is necessary.
• We believe that a methodology similar to the one used in this paper could be applied for the inference of other reliability models, such as reliability block diagrams, as well as Boolean circuits.
Our novel algorithm, FT-MOEA, has in general a better performance than its predecessor, the FT-GA, by converging faster, inferring more compact FT structures, achieving lower error levels, better removing superfluous variables, and being consistent.
Lisandro A. Jimenez-Roa is a doctorate candidate in computer science at the University of Twente, The Netherlands. His background is in civil engineering and have worked in a variety of projects on the fields of structural health monitoring, finite element modelling, and damage detection via data analytics and machine learning. Currently, he is conducting research on system-level prognostics of complex engineering systems within the PrimaVera project (https://primavera-project.com), with particular interest on hybrid integration of domain expertise, physics-informed and data-driven approaches.
Tom Heskes is full professor of Artificial Intelligence. After receiving his PhD on neural networks, he worked as a postdoc at the Beckman Institute in Champaign-Urbana, Illinois. Back in the Netherlands, he joined SNN, the Foundation for Neural Networks and later the Institute for Computing and Information Sciences at Radboud University. Tom Heskes is former Editor-in-Chief of Neurocomputing and has been (co-)leading various national and European projects. Heskes' research concerns the development, understanding, and application of machine learning methods, currently in particular deep learning and causal inference. He works on applications in other scientific disciplines, as well as in industry, among others through his spin-off company Machine2Learn.
Tiedo Tinga is a full professor in dynamics based maintenance at the University of Twente since 2012 and full professor Life Cycle Management at the Netherlands Defence Academy since 2016. He received his PhD degree in mechanics of materials from Eindhoven University in 2009. He is chairing the smart maintenance knowledge center and leads a number of research projects on developing predictive maintenance concepts, mainly based on physics of failure models, but also following datadriven approaches.
Marielle Stoelinga is a full professor of risk analysis for high-tech systems, both at the University of Twente and Radboud University, the Netherlands. She holds a Master's degree in Mathematics & Computer Science, and a PhD in Computer Science. After her PhD, she has been a postdoctoral researcher at the University of California at Santa Cruz, USA.
Prof. Stoelinga leads the executive Master on Risk Management at the University of Twente, a part time programme for risk professionals. She also leads various research projects, including a large national consortium on Predictive Maintenance and an ERC consolidator grant on safety and security interactions.

APPENDIX A APPLYING
NSGA-II AND

A.1 Applying NSGA-II to infer FTs
We provide a conceptual visualisation in Fig. 10 that explains our implementation of the NSGA-II and Crowding-Distance in the context of the automatic inference of FTs. To ease the visualisation, we consider the bi-dimensional case where the multi-objective function is sd (see Table 3). After computing the metrics for a population of FTs within a given generation, one can depict the FTs with circles as in Fig. 10.(a). The output of the NSGA-II algorithm is a set of Pareto fronts, represented in Fig. 10.(b) with different colours (red, blue, green and purple). Fig. 10.(c) shows some details related to the FTs in the first front (red). Note that these FTs have different structures. Here the top FT has a higher error based on the failure data set (φ d ) compared to the others, but it is the smallest FT in the first front. On the contrary, the bottom FT has a smaller error in φ d , but with the trade-off of having a larger size. Fig. 10.(d) shows the effect of the Crowding-Distance. Suppose that only four of the five FTs of the third front can pass to the next generation. Therefore, it is necessary to "break" the front. To do so, we compute the Crowding-Distance metric (d i ) (Section A.2). Those solutions in the front with a large d i value have priority to pass to the next generation. Conversely, those with a small d i value have a lower priority because it means that they are similar to other solutions in the front. Therefore, in Fig. 10.(d) the FT marked with the arrow "Delete" must have similar features in φ s and φ d compared to its neighbours, thus becoming the candidate to be deleted from the third front. Figure 10.(e) represents the process to select the FTs that pass to the next generation, where first the FTs within each front are ordered from the minimum to the maximum error (or errors when considering the minimisation of both φ c and φ d , here we sum them up and sort them up), then only the first ps FTs pass to the next generation. Here we can observe that one FT from the third front and the only FT from the fourth front did not manage to pass to the next generation.

A.2 Crowding-Distance
This process is based on the Crowding-Distance metric (d i ) which makes that individuals with a large d i wins, the latter to avoid solutions to be similar (i.e., to maintain diversity). This metric estimates the density of a particular solution in the non-dominated front based on the neighbour solutions. We provide below a summary of the steps necessary to compute d i . For details, we suggest the reader to consult Deb et al. [22].

•
Step 1: For each solution in the non-dominated set (F ) assign d i = 0.
Here I j denotes the solution index of the j-th member sorted in the vector.

•
Step 4: Pass the solution with the largest d i , then the solution with the second largest d i , until the maximum population size is met.

APPENDIX B EXAMPLE OF INFERRED FAULT TREES
Here we provide as an example a pair of FTs obtained with the FT-MOEA. Fig. 11 Fig. 13 depicts the convergence of the metrics φ s , φ d , and φ c , over the generations for the same example discussed in Fig. 5 in Section 4.3. But now also the distribution inside the population of each generation is visualised. The aim is to provide the reader a better understanding of what is happening between the generations with respect to the convergence of the metrics. The common elements in these figures are grey shades associated to the percentiles 25% (darkest shade), 50%, 75% and 100% (lightest shade), a horizontal blue line that indicates the size of the ground truth FT, red dots that indicate the extreme values in that generation for a given metric, and a white dashed line that indicates the mean value of the metric. that some FTs are Pareto optimal in other aspects, e.g. FTs with a small size, and often these FTs have higher error. In contrast, Fig. 13.(b) shows less variance, which tells that FTs within a generation have a similar error based on the failure data set (φ d ). Fig. 13.(c) and 13.(d) depict the convergence of φ c . We observe a similar pattern, where our approach keeps more "variety" of FTs structures between generations where each of those is to be Pareto efficient in at least one metric. In Fig 13.(d) we observe that variance decreases with the generations, which tells that FTs tend to be more similar in their MCS matrices in latter generations. Fig. 13.(e) and 13.(f) depict the convergence of φ s . Here we can see the most significant differences between both approaches. We observe in Fig. 13.(e) that the FTs tend to be small. It is important to notice that right before finding the global optimum, the FTs within a generation tend to increase in size. Once the global optimum is found (i.e., φ d = φ c = 0), the remaining part of the process, naturally (since the error of the best FT candidate(s) cannot be minimised anymore) is related to minimise the FT size, which yields a compressed version of the found global optimum. On the other hand, Fig. 13.(f) shows that not controlling the size of the FT results in structural explosion, yielding massive structures that are not beneficial for the inference process.  Table 4, using ps = 400, ng = 100, uc = 20.  Table 5 (divided in two parts) contain references associated to data-driven algorithms to infer FTs, the name of the algorithm (if any), whether it is publicly available (if 'yes' the table provides a hyperlink redirecting to the respective online repository), the key aspects of the methodology, the input data, the benefits, and drawbacks.  [5], (1998) [11], (1999) [12] IFT No Based on the ID3 algorithm [10] to induce DTs.

TS
Purely data-driven approach. Provides insights to carry out rules-based diagnostics.
It is unclear whether the IFT algorithm guarantees the encoding of cause-effect relationships, which is a requirement for FT models. Berikov (2004) [34] -No They build FT models based on DTs.

TS
They build the FT model in layers from the DT, this is an interesting way to exploit DTs capabilities.
It is difficult to determine automatically the non-terminal nodes of the FT without expert advice. Mukherjee & Chakraborty (2007) [13] -No Based on text mining and natural language processing.

Text
Makes use of data such as maintenance reports.
It requires a manually built (partial) FT, which is then refined through their method. Roth et al. (2015) [14] -No Based on various matrix analysis methods commonly used to model dependencies.

SDR
The approach helps to identify critical failures or elements from a structural point of view. Also enables handling alternative input data.

TS
It does not require human expertise in the construction stage. It generates intuitive logic trees structures that encode hidden system's causal relations.
The ILTA algorithm is insufficient when several subsystems and characteristic variables may have interdependent relationships with each other.

FT-BN Yes
First learn the parameters of a Bayesian Network (BN) and then translates the BN into a FT.

BD
Their results show that the method is particularly robust handling noisy data.
It requires prior assumptions based on whiteand black-listing, which define arcs that are respectively missing or present in the BN. Lazarova-Molnaretal (2020) [19] DDFTA No It makes use of binarization techniques, MCSs, and Boolean algebra TS It is efficient in terms of computational time. Moreover, the algorithm infers VoT logic gates.