A Heuristic Methodology for Efficient Reduction of Large Multistate Event Trees

Abstract

This work proposes a new methodology for the management of event tree information used in the quantitative risk assessment of complex systems. The size of event trees increases exponentially with the number of system components and the number of states that each component can be found in. Their reduction to a manageable set of events can facilitate risk quantification and safety optimization tasks. The proposed method launches a deductive exploitation of the event space, to generate reduced event trees for large multistate systems. The approach consists in the simultaneous treatment of large subsets of the tree, rather than focusing on the given single components of the system and getting trapped into guesses on their structural arrangement.

1. Introduction

For a given system, the scope of quantitative risk assessment is to investigate the circumstances giving rise to different modes of system operation and to quantify the risk for each operation mode. A system can be comprised of hardware, software, humans, or organizational components [1]. Each component can be found in various states of operation, leading to multiple modes of failure and normal operation for the overall system. Once this mapping of component states to system outcomes is known, it is theoretically possible to quantify the risks for different operation modes to occur, given the occurrence probabilities for all the component states [2, 3].

The computational effort and the memory requirements for risk evaluations increase exponentially as the system components and the number of component states increases. Exact calculations for binary systems are achieved faster by employing binary decision diagrams to effectively organize the evaluation procedure [4]. Since the logic behind multistate systems is not Boolean, multistate behavior cannot be represented by binary models without introducing additional variables and constraints [5]. Rocco and Muselli [6] developed a methodology based on machine-learning and hamming clustering to address multistate systems and any success criterion. The required computational resources can be reduced using approximate risk estimations [7] or criticality analysis [8]. Event trees represent the combination of component states leading to each mode of system operation. Quantification of event trees enables faster exact risk evaluation [2] and is not limited to binary or two-terminal systems, it is, however, very computationally intensive. Clearly, implementation of event tree quantification to systems with many components in multiple states needs to be preceded by substantial reduction of the number of tree branches.

This work develops an algorithm that can efficiently exploit a large event space and generate a reduced event tree. It is assumed that every real system has an intrinsic logic behind the assignment of system outcomes to the system events. A simple and general methodology is suggested to robustly extract this knowledge, by exploiting the system outcome space information as this is stored in a table listing all the possible event combinations and their associated final system outcomes. The proposed algorithm is not biased by any prior information on the functionalities of the system in structural or algebraic form and seeks to acquire knowledge on the system logic and encapsulate it in the reduced tree. The algorithm can be generally applied to any given system and is not affected by the way that the supplied data may be organized or sorted. The procedure is deductive, starting from the entire event table and systematically organizing the system events in a set of clusters. The final set of clusters can be translated back to an event tree that is significantly reduced compared to original outcome space information supplied to the algorithm.

The paper is organized as follows: Section 2 presents some very basic system definitions used in the system representation and operations presented in Section 3. In Section 3 a suitable system representation is defined, using sets of events and based on the concepts of Cartesian products. Section 4 describes a set of clustering and declustering operations to be applied on the event sets. Section 5 discusses the implementation of the proposed developments into an algorithmic procedure. Section 6 presents an illustration example and a large case study to demonstrate the proposed methodology. Section 7 concludes the work.

2. Basic System Definitions

The system considered here is comprised of blocks. Each block can be found in various states, and the system response (or output) at every given instance of time, 𝑡, depends on the state that the blocks occupy at 𝑡. Each block relates to a component, a set of components or a part of a component of the system, regardless of physical conventions and according to the choices in the system modeling. The basic definitions are taken from Papazoglou [9, 10] where the blocks were interconnected to form functional block diagrams. In the present work, the blocks are stripped of their networking functionalities, and the definitions are simplified accordingly.

2.1. System Blocks and Their States

Consider a system of 𝐾-independent blocks. Each block 𝑏_𝑘, 𝑘∈{1,2,…,𝐾}, can be found in various internal states during the system operation period.

Let the state set of block 𝑏_𝑘, denoted as 𝐒_𝑘={𝑠¹_𝑘,𝑠²_𝑘,…,𝑠^𝐾𝑆𝑘_𝑘}, be a partition over the possible instances of 𝑏_𝑘, where 𝑠^𝑖𝑘_𝑘 denotes the 𝑖_𝑘th state of block 𝑏_𝑘, and 𝐾_𝑆𝑘 denotes the number of elements in 𝐒_𝑘, thus 𝐾_𝑆𝑘 is the cardinality of 𝑆_𝑘,|𝑆_𝑘|.

It is assumed that, at every given time instance within the period of system operation, 𝑏_𝑘 is found in exactly one state (e.g., at 94% of maximum production level), and this state relates to exactly one member of 𝐒_𝑘 (e.g., 𝑠²_𝑘 = “at least 90% of maximum production level”).

2.2. Event Definitions

A basic event is an instance of a single system block according to the state set partition of this block. A basic event for block 𝑏_𝑘 is denoted as {𝑠^𝑖𝑘_𝑘},𝑠^𝑖𝑘_𝑘∈𝐒_𝑘.

A joint event {𝑠^𝑖𝑘1_𝑘1,𝑠^𝑖𝑘2_𝑘2,…,𝑠^𝑖𝑘𝑚_𝑘𝑚} is the combination of more than one basic events taking place in 𝑚 different blocks of the system 𝑏_𝑘1,𝑏_𝑘2,…,𝑏_𝑘𝑚. Note that, the set {𝑠^𝑖𝑘1_𝑘1,𝑠^𝑖𝑘2_𝑘2,…,𝑠^𝑖𝑘𝑚_𝑘𝑚} is the result of the Cartesian product {𝑠^𝑖𝑘1_𝑘1}×{𝑠^𝑖𝑘2_𝑘2}×⋯×{𝑠^𝑖𝑘𝑚_𝑘𝑚}.

A complete joint event 𝑒̂ is defined here as a joint event over all the system blocks {𝑠^𝑖1₁,𝑠^𝑖2₂,…,𝑠^𝑖𝐾_𝐾}. For simplicity, the term event is used here instead of complete joint event.

Note that, the above event definitions are simplified compared to Papazoglou [10] where blocks had functionalities not considered here.

2.3. Event Space, Subspaces, and Event Partitions

Let the system event space 𝐄 be the set of all the possible complete joint events 𝑒̂. Then 𝐄={𝑒₁̂,𝑒₂̂,…,𝑒̂_𝐾𝐸}, where 𝐾_𝐸 denotes the number of elements 𝐄, thus 𝐾_𝐸=|𝐸|. Note that, 𝐄 is the result of the Cartesian product 𝐒₁×𝐒₂×⋯×𝐒_𝐾, therefore |𝐄|=∏^𝐾_𝑘=1|𝐒_𝑘|.

Consider a nonempty subspace 𝐀 of the system event space 𝐀⊆𝐄∶𝐀≠∅. Let 𝐐(𝐀) denote a partition applied over 𝐀, composed of 𝐾_𝐐(𝐀) disjoint subspaces of 𝐀 denoted by 𝐪^𝑄_𝑖(𝐀),𝑖∈{1,2,…,𝐾_𝐐(𝐀)}.

2.4. Event Table

Let 𝐑={𝑟₁,𝑟₂,…,𝑟_𝐾𝐑} denote the set of the all possible system outcomes and 𝐾_𝐑 is their number. Therefore, 𝐾_𝐑 is the cardinality, |𝐑|, of 𝐑.

Each event yields a unique system outcome, while different events may yield the same outcome. For instance, there might be more than one event that leads to system failure. In event trees, a complete joint event and its associated outcome are equivalent to a path [9, 10].

Let 𝑇∶𝑒̂↦𝑟=𝑇(𝑒)̂, where 𝑒̂∈𝐄and𝑟∈𝐑, denote the many-to-one mapping from the event space 𝐄 to the set of system outcomes 𝐑. The 𝑇 mapping is recorded in the system event table, as a complete list of all the system events and their outcome.

The 𝑇 defines a partition on 𝐄, which is herein called the outcome-based partition and denoted by 𝐐^𝑇(𝐄). The members of 𝐐^𝑇(𝐄) are denoted by 𝐪^𝐐𝑇_𝑟𝑖(𝐄),𝑟_𝑖∈𝐑.

Table 1 gives the event table of an example taken from Papazoglou [10]. In this case, there are 32 events and 4 possible outcomes, and 𝐐^𝑇(𝐄) is comprised of the 4 sets:(1)𝐪^𝐐𝑇_𝑟1(𝐄)={𝑒₁̂,𝑒₃̂,𝑒₄̂,𝑒̂₁₁,𝑒̂₁₂,𝑒̂₁₇,𝑒̂₁₈,𝑒̂₁₉,𝑒̂₂₀,𝑒̂₂₅,𝑒̂₂₆,𝑒̂₂₇,𝑒̂₂₈}, (2)𝐪^𝐐𝑇_𝑟2(𝐄)={𝑒₇̂,𝑒̂₁₅,𝑒̂₁₆,𝑒̂₂₁,𝑒̂₂₂,𝑒̂₂₃,𝑒̂₂₄,𝑒̂₂₉,𝑒̂₃₀,𝑒̂₃₁,𝑒̂₃₂}, (3)𝐪^𝐐𝑇_𝑟3(𝐄)={𝑒₅̂,𝑒₆̂,𝑒₈̂,𝑒̂₁₃,𝑒̂₁₄}, (4)𝐪^𝐐𝑇_𝑟4(𝐄)={𝑒₂̂,𝑒₉̂,𝑒̂₁₀}. Note that the 𝑇 mapping can be derived from the structural dependencies among the system blocks, as dictated by the rational and physical interconnections of components within the system and depicted in the form of a fault tree or a functional block diagram. However, such information may be unavailable or too difficult to attain or process. This work assumes that the only information available is the system event table.

Table 1 

Event table for the motor-operated valve [10].

3. System Representation

The system representation presented here aims to organize the information contained in the event table. The table data are partitioned and organized into vectors summarizing the contribution of block states in each subspace of the partition. These vectors will provide the framework to apply the manipulations described in Section 4.

3.1. Cartesian Subspaces and Partitions

Let 𝐒^𝐀_𝑘⊆𝐒_𝑘,𝐀⊆𝐄∧𝐀≠∅ denote the set of 𝑏_𝑘 block states, 𝑘∈{1,2,…,𝐾}, in the events comprising 𝐀. Note that, since 𝐀≠∅, then 𝐒^𝐀_𝑘≠∅, for  all 𝑘.

Let 𝐂(𝐀),𝐀⊆𝐄∧𝐀≠∅, denote the Cartesian product 𝐒^𝐀₁×𝐒^𝐀₂×⋯×𝐒^𝐀_𝐾. In general, 𝐂(𝐀) is a superset of 𝐀, since it always contains all the elements of 𝐀 and may contain events not included in 𝐀.

Consider the system of Table 1. For the subspace 𝐁={𝑒₁̂,𝑒₃̂,𝑒₄̂,𝑒̂₁₇,𝑒̂₁₈,𝑒̂₁₉,𝑒̂₂₀} we get 𝐒^𝐁₁={𝑠¹₁,𝑠²₁},𝐒^𝐁₂={𝑠¹₂},𝐒^𝐁₃={𝑠¹₃,𝑠²₃,𝑠³₃,𝑠⁴₃}, and 𝐂(𝐁)={𝑒₁̂,𝑒₂̂,𝑒₃̂,𝑒₄̂,𝑒̂₁₇,𝑒̂₁₈,𝑒̂₁₉,𝑒̂₂₀}. As expected, 𝐂(𝐁) is a superset of 𝐁.

A Cartesian subspace, denoted as 𝐀, is herein defined as a nonempty subspace of 𝐄, such that 𝐀=𝐂(𝐀). Note that, all the singleton subspaces are Cartesian.

A Cartesian partition over 𝐀,𝐀⊆𝐄∧𝐀≠∅, denoted as 𝐐(𝐀), is herein defined as a partition comprised only of Cartesian subspaces of 𝐀. The elements of 𝐐(𝐀) are denoted as 𝐪^𝐐_𝑖(𝐀),𝑖∈{1,2,…,𝐾_𝐐(𝐀)}. Note that, every subspace of 𝐄 has at least one Cartesian partition comprised of singleton subspaces.

For instance, the subspace 𝐁 defined above can be partitioned into the four subspaces 𝐪^𝐐₁(𝐁)={𝑒₁̂}, 𝐪^𝐐₂(𝐁)={𝑒₃̂}, 𝐪^𝐐₃(𝐁)={𝑒₄̂},  and  𝐪^𝐐₄(𝐁)={𝑒̂₁₇,𝑒̂₁₈,𝑒̂₁₉,𝑒̂₂₀}. These are all Cartesian, since 𝐪^𝐐₁(𝐁), 𝐪^𝐐₂(𝐁), 𝐪^𝐐₃(𝐁) are singleton, and 𝐪^𝐐₄(𝐁)=𝑠²₁×𝑠¹₂×𝐒₃.

3.2. Implicit Subspaces and Partitions

The state set 𝐒^𝐀_𝑘 is called a complete state set when it contains all the possible states of the 𝑏_𝑘 block, that is, 𝐒^𝐀_𝑘=𝐒_𝑘.

An implicit subspace, denoted as 𝐀_≈, is herein defined as a Cartesian subspace when all of its constituent block state subsets 𝐒^𝐀≈_𝑘 are either complete or singleton sets. Note that an implicit subspace corresponds to the implicant [11] containing only the block states in the singleton sets. The subspace 𝐪^𝐐₄(𝐁) defined above is implicit and corresponds to the implicant {𝑠²₁,𝑠¹₂}.

For example, the sets 𝐁₁=𝑠²₁×𝑠²₂×𝐒₃,  𝐁₂=𝑠²₁×{𝑠¹₂,𝑠²₂}×𝐒₃  and  𝐁₃=𝑠²₁×𝐒₂×𝐒₃ are all Cartesian (since they are Cartesian products) but 𝐁₂ is not implicit.

An implicit partition over 𝐀, denoted as 𝐐_≈(𝐀), is herein defined as a partition comprised only of implicit subspaces. The elements of 𝐐_≈(𝐀) are denoted as 𝐪_≈^𝐐_𝑖(𝐀). Every subspace 𝐀 has at least oneimplicit partition, the 𝐐_≈(𝐀)=𝐀, and the cardinalities of all possible partitions over 𝐀 lie between one (when 𝐀 is an implicit subspace) and |𝐀|.

For example, the partition over subspace 𝐁 into 𝐪^𝐐_𝑖(𝐁),  𝑖∈{1,2,3,4}, is implicit. Also, the partition of 𝐁₂=𝑠²₁×{𝑠¹₂,𝑠²₂}×𝐒₃ into 𝑠²₁×𝑠¹₂×𝐒₃ and 𝑠²₁×𝑠²₂×𝐒₃ is implicit.

An implicit partition conveys the same information as the set of its corresponding implicants. Therefore 𝐁₂ can be derived from the prime implicants {𝑠²₁,𝑠¹₂} and {𝑠²₁,𝑠²₂}.

3.3. Contribution Vectors

The contribution vector of subspace 𝐀, denoted by 𝐍(𝐀), is defined here as a vector of nonnegative integer entries 𝑛^𝑖𝑘_𝑘(𝐀)∈ℤ₊, reporting the sum of the contributions of each state 𝑠^𝑖𝑘_𝑘 of each block 𝑏_𝑘 in the events comprising 𝐀, namely, the number of times that each block state contributes in the development of 𝐀.

For the example of subspace 𝐁, the contribution vector is 𝐍(𝐁)=[3,4;7,0,0,0;2,1,2,2], where the semicolons are used as separators between the three block compartments.

Properties of contribution vectors include the following.(i)The vector length is 𝜆=∑^𝐾_𝑘=1|𝐒_𝑘|, therefore 𝐍(𝐀)∈ℕ^𝜆₊,  for  all  𝐀⊆𝐄.(ii)For each block 𝑏_𝑘, the sum of all the block entries in 𝐍(𝐀) equals |𝐀|.In general, vector 𝐍(𝐀) is an abstract (inductive) representation of the information stored in 𝐀. As the size of 𝐀 increases, retrieving it from 𝐍(𝐀) is not trivial, it might even be impossible.

3.4. Bicontribution Vectors

Let the bicontribution vector 𝐋(𝐀) of subspace 𝐀 be defined as a vector of Boolean entries 𝑙^𝑖𝑘_𝑘(𝐀)∈{O,I}, reporting the contribution or not of each state 𝑠^𝑖𝑘_𝑘 of each block 𝑏_𝑘 to the events of 𝐀, namely, whether a certain block state contributes (“true” or I) or not (“false” or O) in the development of set 𝐀.

Properties of bicontribution vectors include the following.(i)The vector length is 𝜆=∑^𝐾_𝑘=1|𝐒_𝑘|, so 𝐋(𝐀)∈{O,I}^𝜆,  for  all  𝐀⊆𝐄.(ii)The sum of all the entries corresponding to block 𝑏_𝑘 equals |𝐒^𝐀_𝑘|,  for  all  𝑘∈{1,2,…,𝐾}.For instance, the associated bicontribution vector of 𝐍(𝐁) is 𝐋(𝐁)=[I,I;I,O,O,I;I,I,I,I]. The sum of entries is 8 and equals the number of block state instances present in set 𝐁.

Let Λ[𝐍(𝐀)]∶{1,2,…,|𝐀|}→{I,O} denote the operation applied on the contribution vector 𝐍(𝐀) to derive its associated bicontribution vector 𝐋(𝐀). Based on the definitions of contribution and bicontribution vectors: 𝐋(𝐀)=Λ𝐍(𝐀)⟺𝑙^𝑖𝑘_𝑘(𝐀)=O,𝑛^𝑖𝑘_𝑘(𝐀)=0,I,𝑛^𝑖𝑘_𝑘(𝐀)>0,∀𝑘,𝑖_𝑘. (1) The reverse operation Λ⁻¹[𝐍(𝐀)] yields 𝐂(𝐀) as follows: Λ⁻¹𝐍(𝐀=̂𝑠)𝑒=^𝑖1₁,𝑠^𝑖2₂,…,𝑠^𝑖𝐾_𝐾∈𝐄∶𝑙^𝑖𝑘_𝑘(𝐀)=I,∀𝑘,𝑖_𝑘. (2) Therefore, from the definition of 𝐂(𝐀),Λ⁻¹[𝐋(𝐀)]=𝐂(𝐀). Clearly, 𝐋(𝐀) always carries less information than its associated vector 𝐍(𝐀), unless 𝐀 is Cartesian.

3.5. Cartesian Contribution Vectors

The Cartesian contribution vector of subspace 𝐀, denoted as 𝐍(𝐀), is defined here as the contribution vector of 𝐂(𝐀), thus 𝐍(𝐀)≡𝐍(𝐂(𝐀)). Let 𝑛^𝑖𝑘_𝑘(𝐀) denote the entries of 𝐍(𝐀).

For instance, starting from subspace 𝐁 we get 𝐍(𝐁)=[4,4;8,0,0,0;2,2,2,2].

Let Ξ[𝐋(𝐀)] denote the operation applied on the bicontribution vector 𝐋(𝐀) to derive the Cartesian contribution vector 𝐍(𝐀). Based on the above vector definitions: 𝐍(𝐀)=Ξ𝐋(𝐀)⟺𝑛^𝑖𝑘_𝑘(𝐀)=0,𝑙^𝑖𝑘_𝑘(𝐀)|𝐂(𝐀=O,)|𝐒^𝐀_𝑘,𝑙^𝑖𝑘_𝑘(𝐀)=I,∀𝑘,𝑖_𝑘. (3) For every subspace 𝐀, each entry of 𝐂(𝐀), 𝑛^𝑖𝑘_𝑘(𝐀), lays between zero and 𝑛^𝑖𝑘_∼𝑘(𝐀). Nonzero entries for which 𝑛^𝑖𝑘_𝑘(𝐀)=𝑛^𝑖𝑘_∼𝑘(𝐀) are herein called Cartesian entries.

The vector 𝐍(𝐀) satisfies the Cartesian property if and only if is 𝐀 a Cartesian subset. In this case 𝐍(𝐀)=𝐍(𝐀).

Going back to set 𝐁 and comparing 𝐍(𝐁) to 𝐍(𝐁):(i)the entries corresponding to the block states 𝑠⁴₁, 𝑠¹₄, 𝑠³₄, and 𝑠⁴₄ are Cartesian,(ii)the 𝐍(𝐁) vector does not satisfy the Cartesian property since 𝑛^𝑖𝑘_𝑘(𝐁)≠𝑛^𝑖𝑘_∼𝑘(𝐁) at {𝑘,𝑖_𝑘}={2,1} or {3,2}.The contribution vectors of implicit subspaces are herein called implicit contribution vectors. Since, implicit subspaces are always Cartesian, implicit contribution vectors always satisfy the Cartesian property.

3.6. Vector Partitions

Considering a partition 𝐐(𝐀), the contribution vector partition of 𝐐(𝐀), denoted as 𝐍(𝐐(𝐀)), is defined as the set of the contribution vectors 𝐍(𝐪^𝐐_𝑖(𝐀)).

Since ∑_𝑖𝑛^𝑖𝑘_𝑘(𝐪^𝑄_𝑖(𝐀))=𝑛^𝑖𝑘_𝑘(𝐀),  for  all  𝑘,𝑖_𝑘, the vector 𝐍(𝐀) is specified as the composite contribution vector of 𝐍(𝐐(𝐀)). In general, composite contribution vectors carry less information than their vector partitions.

Likewise to subspace partitions, vector partitions can be classified as Cartesian (when all their associated vectors are Cartesian) or implicit (when all their associated vectors are implicit). Cartesian and implicit partitions are denoted as 𝐍(•) and 𝐍_≈(•), respectively.

Considering subspace 𝐁 and its partition 𝐪^𝐐₁(𝐁)={𝑒₁̂},  𝐪^𝐐₂(𝐁)={𝑒₃̂},  𝐪^𝐐₃(𝐁)={𝑒₄̂}, and 𝐪^𝐐₄(𝐁)={𝑒̂₁₇,𝑒̂₁₈,𝑒̂₁₉,𝑒̂₂₀}, the respective contribution vector partition is: 𝐍(𝐐(𝐁))=𝐍𝐪^𝐐₁(𝐁)𝐍𝐪^𝐐₂(𝐁)𝐍𝐪^𝐐₃(𝐁)𝐍𝐪^𝐐₄(𝐁)=[][][][]1,0;1,0,0,0;1,0,0,01,0;1,0,0,0;0,0,1,01,0;1,0,0,0;0,0,0,10,4;4,0,0,0;1,1,1,1. (4) The 𝐪^𝐐_𝑖(𝐁) subsets are implicit, so 𝐍(𝐐(𝐁)) is an implicit contribution vector partition.

It should be highlighted that a Cartesian contribution vector partition is a disjoint-set data structure, as it contains all the information necessary to: (a) find which subspace includes a certain event and (b) reconstruct the event union set using the Λ⁻¹[𝐋(•)] operations.

4. Decomposition and Recomposition Operations

Stating from a given outcome-based partition 𝐐^𝑇(𝐄), the scope here is to derive an implicit partition featuring minimal cardinality for each of the 𝐪^𝐐𝑇_𝑟𝑖(𝐄),  𝑟_𝑖∈𝐑 subspaces. This would be equivalent to a set of prime implicants describing the event table. The scope is accomplished through the application of specific operations on the system vectors defined above. These operations extract knowledge from the information carried in the composition vectors and store this knowledge in the minimal possible schemes. The naming of these operations is after Shannon’s decomposition [11].

4.1. Decomposition of Contribution Vectors

This section presents an operation for the systematic manipulation of a contribution vector to yield a contribution vector partition. The operation is called decomposition, since it is a case of multistate Shannon’s decomposition applied on the contribution vectors. This operation decreases the abstraction of the information stored in the vector, since contribution vector partitions carry more information than their composite vectors. Starting from a contribution vector, subsequent decomposition actions generate a low cardinality implicit partition of this vector.

Consider a subspace 𝐀≠∅∶∃𝑘∶|𝐒^𝐀_𝑘|≥2 and a nonempty subset 𝝈_𝑘⊂𝐒^𝐀_𝑘. The decomposition operation of 𝐀 according to 𝝈_𝑘 is a partition rule applied on 𝐀 to generate the sets {𝐀^𝝈𝑘,𝐀−𝐀^𝝈𝑘} such that: 𝐀^𝝈𝑘=𝑒̂∈𝐀∩Δ^𝝈𝑘_𝐀,𝐀−𝐀^𝝈𝑘=𝑒̂∈𝐀∩𝐂(𝐀)−Δ^𝝈𝑘_𝐀,whereΔ^𝝈𝑘_𝐀=𝐒^𝐀₁×𝐒^𝐀₂×⋯×𝝈_𝑘×⋯×𝐒^𝐀_𝐾. (5) Since 𝝈_𝑘≠∅ then 𝐀^𝝈𝑘, 𝐀−𝐀^𝝈𝑘≠∅.

The simplest way of applying the decomposition operation is to go through each one of the events in 𝐀, as described in the operation definition. This procedure requires computational effort to decide whether a certain event belongs in 𝐀^𝝈𝑘 or 𝐀−𝐀^𝝈𝑘. If, on the other hand, 𝐍(𝐀) contains Cartesian entries, the operation can be applied directly on 𝐍(𝐀). Section 6 shows that decomposing 𝐍(𝐀) rather than 𝐀 reduces the computational effort by several orders of magnitude.

Consider a contribution vector 𝐍(𝐀)∶∃𝑘∶|𝐒^𝐀_𝑘|≥2∧|𝐒^𝐀_𝑘|≠0 and a nonempty set 𝝈_𝑘⊆𝐒^𝐀_𝑘. The vector decomposition operation according to 𝝈_𝑘 is a partition rule applied on 𝐍(𝐀) to yield the contribution vector partition {𝐍(𝐀^𝝈𝑘),𝐍(𝐀^𝜎𝑘)} such that 𝐍𝐀^𝝈𝑘=𝐍𝐒^𝐍₁×𝐒^𝐍₂×⋯×𝝈_𝑘×⋯×𝐒^𝐍_𝐾,𝐍𝐀^𝜎𝑘=𝐍(𝐀)−𝐍𝐀^𝝈𝑘. (6) The development of 𝐍(𝐀^𝝈𝑘) ensures that this vector has the Cartesian property. Instead of the Cartesian product 𝐒^𝐍₁×𝐒^𝐍₂×⋯×𝝈_𝑘×⋯×𝐒^𝐍_𝐾 we can use the bicontribution vector: 𝐋𝐀^𝝈𝑘∶𝑙^𝑖𝑚_{𝑚𝐋(𝐀𝝈𝑘)}=𝑙^𝑖𝑚_{𝑚𝐋(𝐀)},𝑘≠𝑚,I,𝑘=𝑚∧𝑠^𝑖𝑚_𝑚∈𝝈_𝑘,O,𝑘=𝑚∧𝑠^{𝑖𝑚,𝑛}_𝑚∉𝝈_𝑘. (7) The decomposition operation can be applied iteratively. To simplify the notation, let 𝐍₀ be an initial contribution vector, decomposed into {𝐍^𝝈0₁,𝐍₁}, where 𝐍^𝝈0₁ has the Cartesian property. Then, 𝐍₁ is decomposed into {𝐍^𝝈1₂,𝐍₂}, where 𝐍^𝝈1₂ has the Cartesian property and so forth. Application of the decomposition operation over 𝑖 iterations replaces 𝐍₀ with the contribution vector partition 𝐍_𝑖={𝐍^𝝈0₁,𝐍^𝝈1₂,𝐍^𝝈2₃,…,𝐍^𝝈𝑖−1_𝑖,𝐍_𝑖}. The iterations terminate when 𝐍_𝑖 has the Cartesian property, therefore 𝐍_𝑖 is a Cartesian partition. Note that, the 𝐍^𝝈𝑖−1_𝑖 vectors can be derived as 𝐍^𝝈𝑖−1_𝑖=Ξ[𝐋^𝝈𝑖−1_𝑖], using (7) and 𝐋_𝑖−1=Λ[𝐍_𝑖−1].

4.1.1. Decomposition Example

To illustrate the decomposition operation consider the set 𝐪^𝑇_𝑟1(𝐄) of Table 1 and its contribution vector 𝐍₀=[5,8;7,0,6,0;3,2,4,4].

Starting from 𝐍₀, the bicontribution vector is 𝐋₀=[I,I;I,O,I,O;I,I,I,I] and the Cartesian contribution vector is 𝐍_∼0=[8,8;8,0,8,0;4,4,4,4]. Clearly, 𝐍_∼0 has three Cartesian entries at 𝑠²₁, 𝑠³₃ and  𝑠⁴₃. Let 𝝈₀={𝑠³₃}:(i)𝐋^𝝈0₁=[I,I;I,O,I,O;O,O,𝐈,O] ⇒𝐍^𝝈0₁=[2,2;2,0,2,0;0,0,𝟒,0], (ii)𝐍₁=𝐍₀−𝐍^𝝈0₁=[3,6;5,0,4,0;3,2,𝟎,4], 𝐋₁=[I,I;I,O,I,O;I,I,𝐎,I]. Alternatively, the decomposition could be applied simultaneously at 𝝈^∗₀={𝑠³₃,𝑠⁴₃} as follows:(i)𝐋^𝝈∗0₁=[I,I;I,O,I,O;O,O,𝐈,𝐈] ⇒𝐍^𝝈∗0₁=[4,4;4,0,4,0;0,0,𝟒,𝟒], (ii)𝐍^∗₁=𝐍₀−𝐍^𝝈∗0₁=[1,4;3,0,2,0;3,2,𝟎,𝟎], 𝐋^∗₁=[I,I;I,O,I,O;I,I,𝐎,𝐎]. In both cases, the vectors 𝐍₁ and 𝐍^∗₁ do not satisfy the Cartesian property, but they contain Cartesian entries. For instance, 𝐍^∗₁ can be decomposed at 𝝈^∗₁={𝑠²₁} as follows:(i)𝐋^𝝈∗1₂=[0,𝟏;1,0,1,0;1,1,0,0] ⇒𝐍^𝝈∗1₂=[0,𝟒;2,0,2,0;2,2,0,0], (ii)𝐍^∗₂=𝐍^∗₁−𝐍^𝝈∗1₂=[1,𝟎;1,0,0,0;1,0,0,0]. Both 𝐍^∗₂ and 𝐍^𝝈∗1₂ satisfy the Cartesian property and no further decomposition is necessary. So, the decomposition of 𝐍₀ yields the Cartesian contribution vector partition {𝐍^𝝈0₁,𝐍^∗₂,𝐍^𝝈∗1₂}.

The set vectors may contain complete blocks, like the first block in 𝐍^𝝈0₁. The vectors 𝐍^𝝈0₁ and 𝐍^𝝈1₂ can be further decomposed until they give implicit contribution vector partitions:

(i) 𝐍^𝝈0₁=[]∼[]4,4;4,0,4,0;0,0,4,42,2;4,0,0,0;0,0,2,2[]∼2,2;0,0,4,0;0,0,2,2_{[][]1,1;2,0,0,0;0,0,2,01,1;2,0,0,0;0,0,0,2[][]1,1;0,0,2,0;0,0,2,01,1;0,0,2,0;0,0,0,2}, (8)

(ii) 𝐍^𝝈1₂=[]∼[]0,4;2,0,2,0;2,2,0,00,2;0,0,2,0;1,1,0,0[]∼0,2;2,0,0,0;1,1,0,0_{[][]0,1;0,0,1,0;0,1,0,00,1;0,0,1,0;1,0,0,0[][]0,1;1,0,0,0;0,1,0,00,1;1,0,0,0;1,0,0,0}. (9) In the previous example, the cardinality of 𝐪^𝑇_𝑟1(𝐄) was 13, while the cardinality of the implicit partition is equal to 4+4+1=9. The latter cardinality could be even smaller if a more intelligent decomposition strategy were applied. For instance, 𝐍₀ has two complete blocks (first and third block) and three Cartesian entries (one in the first block and two in the third). The choice of decomposition order, that is, the sequence of 𝝈_𝑖’s is crucial, as discussed in the algorithm implementation section.

4.2. Recomposition of Contribution Vectors

The outcome of the decomposition operation is an implicit contribution vector partition. Given this, we can seek merging opportunities to create unions that have complete blocks, thus reduce the partition cardinality. Since the contribution vectors are all implicit, the recomposition operation is hereby discussed in terms of bicontribution vectors.

Consider a block 𝑏_𝑚 and its set of states 𝐒_𝑚. Let 𝐋 be a set of |𝐒_𝑚| bicontribution vectors, 𝐋_𝑖=[𝑙^𝑖𝑘_{𝑖𝑚,𝑘}],  𝑖_𝑚∈{1,2,…,|𝐒_𝑚|},  𝑖_𝑘∈{1,2,…,|𝐒_𝑘|},  𝑘∈{1,2,…,𝐾}, such that 𝑙^𝑖𝑘_{𝑖𝑚,𝑘}=𝜆^𝑖𝑘_𝑘∈{O,I},  for  all  𝑘≠𝑚,𝑖_𝑚,𝑖_𝑘. Then, the set 𝐋 can be replaced by the single bicontribution vector 𝐋=[𝜆^𝑖𝑘_𝑘], where 𝜆^𝑖𝑚_𝑚=𝐼,  for  all  𝑖_𝑚. Note that, 𝐋=𝐋(𝐒^𝐋1₁×𝐒^𝐋1₂×⋯×𝐒_𝑚×⋯×𝐒^𝐋1_𝐾).

4.2.1. Recomposition Example

Consider the set 𝐋=^{[I,O;I,O,O,O;I,O,O,O]}_{[O,I;I,O,O,O;I,O,O,O]}.

From the decomposition example discussed earlier. The two bicomposition vectors have exactly the same entries in the second and third block but different entries in the first block. In addition, the first block has exactly two state instances. The two vectors can be recomposed into a single equivalent vector [I,I;I,O,O,O;I,O,O,O].

5. Algorithm Implementation

Given the table associated with an event tree, the proposed algorithm launches an iterative process of decomposition and recomposition operations until we obtain an implicit partition of minimal cardinality for each one of the tree outcomes. Working with the vectors defined above rather than sets of events decreases significantly the amount of information being stored and the computational effort for manipulating this information.

The algorithm applies the vector decomposition and recomposition operations using a set of heuristic rules. These rules help in the identification of more promising entries to apply the operations. Sections 5\tmspace +\thinmuskip {.1667em}5.1 and 5\tmspace +\thinmuskip {.1667em}5.2 describe the heuristic rules, and Section 5\tmspace +\thinmuskip {.1667em}5.3 discusses how these procedures work together within the proposed algorithm.

5.1. Heuristic Rules for Decomposition Order

The decomposition operations proceed iteratively, replacing the original |𝐑| vectors of the outcome partition with |𝐑| contribution vector sets. Decompositions are applied locally, based on the features (e.g., the Cartesian entries) of each contribution vector.

Given a composition vector, the choice of decomposition order is crucial in preserving the maximum possible of the initial complete blocks. The set 𝐪^𝑇_𝑟1(𝐄) of Table 1 has a complete block of 2 states and a complete block of 4 states. If the decomposition order is different the final implicit partition could be different. In effect, applying the decomposition on entries {𝑠³₃,𝑠⁴₃} of 𝐍₀ results in a reduction by 4=13−9 on the cardinality of the final implicit partition of 𝐪^𝑇_𝑟1(𝐄). Applying the decomposition on {𝑠²₁}—followed by {𝑠³₃,𝑠⁴₃}, {𝑠¹₃}, {𝑠³₄,𝑠⁴₄}, and so forth, in any order—preserves the third block, and the final reduction is by 13−7=6: 𝐍₀=[]∼[]5,8;7,0,6,0;3,2,4,40,8;4,0,4,0;2,2,2,2[]∼5,0;3,0,2,0;1,0,2,2_{[][]0,4;4,0,0,0;1,1,1,10,4;0,0,4,0;1,1,1,1[][]4,0;2,0,2,0;0,0,2,21,0;1,0,0,0;1,0,0,0}∼^{[][]0,4;4,0,0,0;1,1,1,10,4;0,0,4,0;1,1,1,1}[][][][][].1,0;1,0,0,0;1,0,0,01,0;1,0,0,0;0,0,1,01,0;1,0,0,0;0,0,0,11,0;0,0,1,0;0,0,1,01,0;0,0,1,0;0,0,0,1 (10) The following decomposition rules support the generation of the smallest possible implicit partitions at the minimum possible execution time, and they are applied on each contribution vector that is not Cartesian.(a)If there are Cartesian entries in the current contribution vector:(i)it is prefered to decompose at Cartesian entries in incomplete blocks, to avoid breaking the complete blocks. Note that, in this case, the decomposition order makes no difference to the final partitions,(ii)if the only Cartesian entries are within complete blocks, start decomposing the complete blocks with the largest span between their contribution values, relatively to their number of states, that is, sort blocks according to (max_𝑘{𝑛^𝑖𝑘_𝑘}−min_𝑘{𝑛^𝑖𝑘_𝑘})/|𝐒_𝑘|.(b)If there are no Cartesian entries in the current contribution vector, then:(i)if no complete blocks are present, prefer incomplete blocks with more states being present, and decompose them into as many vectors as the number of states present,(ii)if only complete blocks are present, decompose the block featuring the entry with the maximum departure from its Cartesian value, that is, max_𝑘{𝑛^𝑖𝑘_𝑘−𝑛^𝑖𝑘_𝑘}.Before the application of these rules it is essential to recognize which of the complete blocks make sense, according to the values of the contribution vector entries. For instance, the vector [5,8;7,0,6,0;3,2,4,4] could lead to a partition that includes a bicontribution vector of 2 complete blocks, but this not possible for the vector [3,8;5,0,6,0;2,2,4,3], since the first entry in the compartment of the first block is lower than the number of states in the third block. Similarly, in the vector [0,4;2,0,2,0;1,1,1,1] the third block cannot remain complete under any decomposition order since there is no single entry in the second block compartment greater or equal to |𝐒₃|=4.

The final Cartesian partition includes vectors and may need to be further decomposed to derive implicit partitions. In this case, the vectors are decomposed in all their incomplete block entries (which are all Cartesian), and the decomposition order makes no difference.

5.2. Heuristic Rules for Recomposition Order

Once the decomposition stage is completed, the final implicit partitions may have vectors that can be merged. This reduces the partition cardinalities. The choice of recomposition order is crucial, since the application of decomposition operations on large event tables can produce numerous vectors as candidates for recomposition.

Let 𝐐₀(𝐪^𝑇_𝑟𝑖(𝐄)), 𝑟_𝑖∈𝐑, denote the implicit partitions output from the decomposition stage. The recomposition algorithm proceeds according to the following steps applied on each vector partition 𝐍₀=𝐍(𝐐₀(𝐪^𝑇_𝑟𝑖(𝐄))) (or the associated bicontribution vectors).(i)Partition 𝐍 into sets having the same complete blocks. Let 𝐍_𝑎 be such a subset of 𝐍.(ii)The set 𝐍_𝑎 is a candidate for creating an additional complete block 𝑏_𝑚, if there is at least one subset 𝐍^𝑚𝑖_𝑎⊆𝐍_𝑎 of cardinality |𝐒_𝑚|, where 𝑖∈𝐼_𝑚 is the index of the particular subset for 𝑏_𝑚, such that: (i) its overall contribution vector features 𝑏_𝑚 as a complete block and (ii) the remaining blocks have the same state sets 𝐒^𝑚𝑖_𝑘,forall𝑘≠𝑚.(iii)If 𝐍^𝑚𝑖_𝑎 is replaced by its composite contribution vector, the resulting vector partition 𝐍₁=𝐍(𝐐₁(𝐪^𝑇_𝑟𝑖(𝐄))) is implicit.(iv)The process is repeated on the new set 𝐍₁ to reduce it to 𝐍₂ and so forth and terminates when there are no more recomposition candidates left.The set 𝐍_𝑎 may have several subsets 𝐍^𝑚𝑖_𝑎 that relate to the creation of different complete blocks and/or to different ways of creating a particular complete block. The recomposition procedure is supported by intelligent selection biases to ensure that the merging opportunities are properly exploited. During the iterative recomposition process, the following recomposition rules are applied on every set 𝐍_𝑎 of Cartesian contribution vectors featuring the same complete blocks.(i)Find all the candidate sets 𝐍^𝑚𝑖_𝑎⊆𝐍_𝑎, 𝑖∈𝐼_𝑚, for creating each new complete block at 𝑏_𝑚,  for  all  𝑚∈{1,2,…,𝐾}.(ii)Associate each candidate to a score 𝑤^𝑚𝑖_𝑎 proportional to |𝐒_𝑚| and 𝐼_𝑚 and incorporate the potential to create two complete blocks in one go.(iii)Select among conflicting sets according to their 𝑤^𝑚𝑖_𝑎.(iv)Apply the recomposition operation on the selected sets.Note that, in the new partition, the composite vectors should be removed form the subset 𝐍_𝑎 and possibly included in other subsets including the complete blocks of 𝐍_𝑎 and complete blocks created during the recomposition. The reason why the value of 𝐼_𝑚 is taken into account is that larger 𝐼_𝑚’s increase the probability of finding “recomposable” sets in the next iteration of the recomposition process.

Consider, for example, the vectors of Table 2 representing the implicit partition for the fifth outcome of the BWR example solved in Section 6\tmspace +\thinmuskip {.1667em}6.1. As explained above, recomposition operations are applied on bicontribution vectors. The vectors are sorted and divided into different sets according to their complete blocks. The procedure starts from the subset with the fewer complete blocks. This includes the vectors 𝐋₂₄ and 𝐋₂₆, which are merged to give 𝐋₂₄₊₂₆. Table 3 shows the Cartesian set updated with 𝐋₂₄₊₂₆, which can now be merged with 𝐋₂₈ and so forth. The recomposition choices are not always so few and they can be conflicting. The subset of Table 4 appears after a few iterations. A crude analysis indicates the potential of creating new complete blocks at:(i)block 𝑏₄ by merging 𝐋_i & 𝐋_iii and/or 𝐋_iv & 𝐋_viii,(ii)block 𝑏₅ by merging 𝐋_ii & 𝐋_iii,𝐋_v & 𝐋_vii and/or 𝐋_vi & 𝐋_viii,(iii)block 𝑏₁₀ by merging 𝐋_v & 𝐋_vi and/or 𝐋_vii & 𝐋_viii.The above seven merging actions involve binary state blocks, so their initial scores are equal to 2. This score is multiplied by the number of candidate merges per block (𝐼_𝑚), giving a score of 4 for the 4 merges in blocks 𝑏₄ and 𝑏₁₀ and 6 for the 3 merges in block 𝑏₅. The possible merging actions are sorted according to their score and an action can take place if it does not conflict with any of the higher score actions. In this sense the proposed actions are 𝐋_ii & 𝐋_iii,𝐋_v & 𝐋_vii and 𝐋_vi & 𝐋_viii.

Table 2 

Recomposition example: initial set of bicontribution vectors (Step 1).

Table 3 

Recomposition example: set of bicontribution vectors.

Table 4 

Recomposition example: subset of bicontribution vectors including only 𝑏₆, 𝑏₇, 𝑏₈, and 𝑏₉ as complete blocks.

This involvement of 𝐼_𝑚 in the score calculation stems from the observation that the resulting vectors have many common entries so the possibility of these vectors being treated as candidates for subsequent merges is very high. In effect, amongst the merged vectors of Table 5, vectors 𝐋_v+vii and 𝐋_vi+viii are candidates to be merged. However, this potential should be examined along with other vectors featuring the same complete blocks.

Table 5 

Recomposition example: subset of bicontribution vectors including only the vectors appearing in Table 4.

5.3. Algorithm Implementation

The decomposition and recomposition operations discussed above are each implemented into an iterative procedure. Following is a step-by-step description of the algorithm, using the motor-operated valve (MOV) example of Table 1 to illustrate the different procedures.

Step 1. Acquire event outcome data. This step returns a table of 𝐾 columns for the 𝐾 component blocks and 1 column for the outcomes. Following is the data array for the MOV example:

Step 2. Get the contribution vectors referring to the outcome partition. The 32 events in columns 1 to 3 of the above array can be divided into 13, 11, 5, and 3 events according to the outcome they yield. The following arrays can be derived for the 4 outcomes:

Using composition vectors, each of these arrays gives a row of the following array: 𝑁^𝑅=58706032441380506224325003022201330102012004. (11) The 𝑁^𝑅 array now stores the contribution vector partition according to the system outcome. The superscript 𝑅 is used to indicate that the last column of 𝑁^𝑅 also stores the number of the outcome associated with each contribution vector.

Step 3. Check data consistency. This step exposes any irregularities present in the original data, by checking that all the possible complete events are present in the event table, only these events are present, and the table has no duplicate entries.
A fist check involves the columns of the contribution vector array. Based on the number of block states, we estimate the exact number of occurrences for each one of them and see if the sums of entries in the array satisfy this constraint. The MOV example has 3 blocks of 2, 4, and 4 states each. Therefore, each one of the 2 states of block 1 should occur 16 times; each one of the 4 states of blocks 2 and 3 should occur 8 times each. In effect, 16=5+3+5+3=8+8+0+0; 8=7+0+0+1=0+5+3+0=⋯=4+3+1+0.
The second check involves the rows of the contribution vector array. Each entry refers to a specific state of a specific block. In each row, the total number of occurrences of the block 1 states should be equal to the number of occurrences of blocks 2 and 3. Looking at the first row of the contribution vector array 5+8=7+0+6+0=3+2+4+4.
Step 3 is repeated for the other rows of 𝑁^𝑅.

Step 4. Contribution vector decomposition. This step applies the decomposition operation (Section 4\tmspace +\thinmuskip {.1667em}4.1) and the decomposition rules (Section 5\tmspace +\thinmuskip {.1667em}5.1) to the first row of array 𝑁^𝑅. Let, for instance, the contribution vector be  [5870603244]. The vector exhibits complete state blocks in block 1 (2nd state) and block 3 (3rd, 4th states). The rules indicate that the decomposition is first applied to block 1 and later to block 3. According to Section 5\tmspace +\thinmuskip {.1667em}5.1, the vector [5870603244] is decomposed into the Cartesian contribution vector [0840402222] and the remaining contribution vector [5030201022].

Step 5. Update system arrays. There are 1+𝑅 working arrays where contribution vectors (and their outcome) are stored. The first one is 𝑁^𝑅. The others are denoted by 𝑁_𝑖 and store the Cartesian vectors generated during Step 4 for each response 𝑚, starting from 𝑖=1. Each row of 𝑁^𝑅 treated during Step 4 is replaced by the remaining contribution vector. In our example, during the first iteration 𝑁^𝑅 and 𝑁₁ become 𝑁^𝑅=,50302010221380506224325003022201330102012004𝑁₁=[0840402222]. (12) Note that, there is no need to store outcome information in the arrays 𝑁_𝑖.
Steps 4 and 5 are repeated until a decomposition operation leads to two Cartesian vectors. Then, both vectors are added to 𝑁_𝑖, the first row of 𝑁^𝑅 is removed, and 𝑖 is replaced by 𝑖+1.

Step 6. Decompose 𝑁_𝑖. The array 𝑁_𝑖 is further decomposed to get an array 𝑁_≈𝑖 of implicit contribution vectors. Since the vectors have only Cartesian entries, the operations can be easily applied on the bicontribution vectors of 𝑁_𝑖 and 𝑁_≈𝑖, denoted by 𝐿_𝑖 and 𝐿_≈𝑖, respectively. The arrays referring to the contribution vector [5870603244] are 𝐿₁=011010111111010100011010001000 (13) and, after further decomposition, 𝐿_≈1=0100011111010010111110100000101000100010101000000110001000011010001000. (14) Step 6 supports the following recomposition actions.

Step 7. Apply recomposition actions. This step applies the recomposition operation (Section 4\tmspace +\thinmuskip {.1667em}4.2) and the recomposition rules (Section 5\tmspace +\thinmuskip {.1667em}5.2) to the parts of 𝐿_≈𝑖 sharing the same outcome. Note that, the example considered here is too small and simple to offer potential for recomposition.
Steps 4–7 are repeated until the array 𝑁^𝑅 is empty.

Step 8. Algorithm termination. The final output of the procedures described here is the arrays 𝐿_≈𝑚, which represent implicit partitions of significantly reduced cardinality compared to the size of the system event table. Note that, the decomposition and the recomposition operations developed here ensure that the consistency of the data is preserved throughout the vector processing.

The Matlab environment is chosen as suitable for the fast manipulation of matrices using the built-in matrix operations. For instance, the decomposition when there are no Cartesian entries requires knowledge of the exact event subspace that corresponds to the processed contribution vector. The algorithm can either keep track of the events contributing in each vector or go through the original event table to isolate the subspace relating to each vector. The former, though it is more sophisticated, takes up a lot of memory even for relatively small problems. Matlab takes advantage of its built-in matrix operations for sort and find, to reduce significantly the execution time.

6. Case Studies

6.1. Case Study 1

The first case study is taken from Papazoglou [10] and concerns the development of an event tree for a boiling water nuclear reactor. The system involves 10 state blocks with 2 to 4 block states each. The event space consists of 3072 complete events and the system has 5 outcomes. Papazoglou [10] provided a set of Boolean equations and developed functional block diagrams that embedded information on the dependencies between the blocks. He finally presented a reduced event tree of 41 branches. Note that, if the reactor system is treated in BowTieBuilder [12, 13] without providing dependency information, the resulting event tree has 110 branches. This confirms that the efficiency of functional block diagram applications in reducing the size of event trees depends on the structure of the Boolean model, that dictates the dependencies between the blocks.

The methodology proposed here takes as input the original 3072×11 event table and produces the results reported in Table 6. Note that(i)the states {1,2,3,4} of block I correspond to {L,M,N,T}, and(ii)the outcomes {1,2,3,4,5} correspond to {CI, CII, CIII, CIV, Success}of Papazoglou [10]. Each row of Table 6 gives a Cartesian vector (or an implicant) corresponding to a branch of the event tree. In this sense, the reduced tree described here has only 38 branches. The proposed algorithm identifies an inconsistency in the partition of block C of the original data. Resolving it leads to different results for outcome CIV, and this explains the three branches difference between 41 and 38. The rest of the branches/implicants are notably the same, with a single exception, involving the choice to expand block U rather than block Q (see bold cells of Table 6, lines 12–15). While both choices yield four branches/implicants, this differentiation shows that the procedure proposed here is not biased by the order of the blocks in the event table data.

Table 6 

Final reduced event table for case study 1.

6.2. Case Study 2

The proposed methodology is tested against a large problem involving 16 blocks, including one block having four state instances, four blocks with three states and eleven binary. The original event table has 663552×17 cells. The system has 5 possible outcomes. The initial event table is constructed via recursive partitions of the event subspace.

The resulting implicit partition has totally 273 vectors; in particular 86, 115, 34, 28, and 71 for the five outcomes. The recomposition stage requires 1.08 CPU seconds. Then, the final implicit partitions have totally 178 vectors; in particular 31, 54, 16, 20, and 57 for the respective partitions of the five outcomes.

CPU times can give an idea of the relative effort invested in the different activities taking place during a run. In this relatively large problem, the preparatory Steps 1–3 of Section 5\tmspace +\thinmuskip {.1667em}5.3 require 1.27 CPU seconds. The decomposition steps require only 0.0469 CPU seconds for a total of 86 decompositions using rule (a) and 124 CPU seconds for a total of 52 decompositions using rule (b) of Section 5\tmspace +\thinmuskip {.1667em}5.1. Therefore, the application of decompositions on the basis of Cartesian entries reduces the computational effort by almost 4 orders of magnitude. Clearly, an intelligent reduction of the frequency of visiting the event table would bring significant benefits in the computational times. Note that, CPU times refer to an Intel Core Quad 2.50 GHz processor with 1.95 GB RAM.

Finally, the proposed procedure manages to reduce the expanded event tree to just 0.0268% of its original size. The final partitions are easily translated into a set of implicants. There is no proof that this is a prime set, since there is lack of theoretical background on sufficient and necessary minimality conditions. In any case, the proposed methodology is a fast, effective, and intelligent way to reduce substantially a large event tree and facilitate the quantification of risk.

7. Conclusions

This work presents a new methodology for the reduction of event trees without the use of structural or functional information on the system. The work applies a holistic approach based on the concept of contribution vectors, to generate a minimal set of implicants representative of the system behavior. The method inherits the advantages and limitations of event tree representation. In this sense, the method is not hindered by component interdependences and noncoherent behavior in the considered systems. The proposed representation framework stems from Cartesian products to define partitions using composition vectors. The representation provides the basis for the application of decomposition and recomposition operations on single composition vectors and composition vector partitions. Implementation issues for the efficient use of these operations within an iterative algorithmic framework are discussed thoroughly.

The proposed method is tested against two case studies, one found in the literature and a fictitious large scale problem. In the former, the method provides a set of prime implicants very similar to the one reported in the literature. The latter illustrates the efficiency of the method in handling large-scale problems and proves the computational advantages from the proposed representation and operations.

Future work considers the use of the theoretical background presented here to develop necessary and sufficient conditions for the minimality of the final set of implicants. These conditions could then be incorporated in the recomposition stage to guide an optimal search algorithm towards the set of prime implicants.

Nomenclature

𝐾:	Number of system blocks
𝑏𝑘:	System block, 𝑘∈{1,2,…,𝐾}
𝐒𝑘:	Set of internal states of block 𝑏𝑘,  𝐒𝑘={𝑠1𝑘,𝑠2𝑘,…,𝑠𝐾S𝑘𝑘}
𝑠𝑖𝑘𝑘:	𝑖𝑘th internal state of block 𝑏𝑘,  𝑖𝑘∈{1,2,…,𝐾𝑠𝑖𝑘𝑘}
𝐄:	System event space
𝑒̂:	Complete joint event, 𝑒̂∈𝐄
𝐑:	Set of the all possible system outcomes
𝑟𝑗:	System outcome, 𝑗∈{1,2,…,|𝐑|}
𝑇:	Event table mapping 𝑇∶𝑒̂↦𝑟=𝑇(𝑒)̂, where 𝑒̂∈𝐄  and  𝑟∈𝐑
𝐀,𝐁:	Nonempty subspaces of 𝐄
|𝐗|,𝐾𝐗:	Number of elements (cardinality) of set 𝐗
𝐐(𝐀):	Partition applied over 𝐀
𝐪𝑄𝑖(𝐀):	𝑖th subset of 𝐀 according to 𝐐(𝐀),  𝑖∈{1,2,…,𝐊𝐐(𝐀)}
𝐐𝑇(𝐀):	Outcome-based partition of 𝐀 (according to mapping 𝐓)
𝐒𝐀𝑘:	Set of 𝑏𝑘-block states, 𝑘∈{1,2,…,𝐾}, in the events comprising 𝐀
𝐂(𝐀):	Cartesian product 𝐒𝐀1×𝐒𝐀2×⋯×𝐒𝐀𝐾
𝐀:	Cartesian subspace
𝐀≈:	Implicit subspace
𝐐(𝐀):	Cartesian partition over subspace 𝐀
𝐪𝐐𝑖(𝐀):	𝑖th subset of 𝐐(𝐀),  𝑖∈{1,2,…,𝐾𝐐(𝐀)}
𝐐≈(𝐀):	Implicit partition over 𝐀
𝐪≈𝐐𝑖(𝐀):	𝑖th subset of 𝐐≈(𝐀),  𝑖∈{1,2,…,𝐾𝐐≈(𝐀)}
𝐍(𝐀):	Contribution vector of 𝐀
𝑛𝑖𝑘𝑘(𝐀):	Entry of 𝐍(𝐀),  𝑛𝑖𝑘𝑘(𝐀)∈ℤ+  and  𝑘∈{1,2,…,𝐾},  𝑖𝑘∈{1,2,…,𝐾𝑠𝑖𝑘𝑘}
𝐋(𝐀):	Bicontribution vector of subspace 𝐀
𝑙𝑖𝑘𝑘(𝐀):	Entry of 𝐋(𝐀),  𝑙𝑖𝑘𝑘(𝐀)∈{O,I}  and  𝑘∈{1,2,…,𝐾},  𝑖𝑘∈{1,2,…,𝐾𝑠𝑖𝑘𝑘}
𝐍(𝐀):	Cartesian contribution vector of 𝐀
𝑛𝑖𝑘𝑘(𝐀):	Entry of 𝐍(𝐀),  𝑛≈𝑖𝑘𝑘(𝐀)∈ℤ+  and  𝑘∈{1,2,…,𝐾},  𝑖𝑘∈{1,2,…,𝐾𝑠𝑖𝑘𝑘}
𝐍(𝐐(𝐀)):	Contribution vector partition of 𝐐(𝐀)
𝐍(𝐪𝐐𝑖(𝐀)):	𝑖th member of 𝐍(𝐐(𝐀)),  𝑖∈{1,2,…,𝐾𝐐(𝐀)}
𝜆:	Vector length
𝑌:	Vector
𝑌:	Vector partition (i.e., set of vectors)
𝑌:	Entity obeying the Cartesian property
𝑌≈:	Entity obeying the property of implicitness
Λ[𝐍(𝐀)]:	Operation applied on 𝐍(𝐀) to obtain 𝐋(𝐀)
Ξ[𝐋(𝐀)]:	Operation applied on 𝐋(𝐀) to obtain 𝐍(𝐀)
𝝈𝑘:	Subset of 𝐒𝑘
𝐀𝝈𝑘:	Subset of 𝐀 such that 𝐀𝝈𝑘={𝑒̂∈𝐀∩Δ𝝈𝑘}
Δ𝝈𝑘𝐀:	Event subspace such that Δ𝝈𝑘𝐀={𝐒𝐀1×𝐒𝐀2×⋯×𝝈𝑘×⋯×𝐒𝐀𝐾}.

Glossary

Complete set of block states:	Set of all the possible states of a certain system block
Complete joint event:	Joint event containing an instance of each one of the system blocks
Cartesian property:	Event subspaces and contribution vectors that can be generated by a Cartesian product. Also, subspaces partitions and partition contribution vectors that can be generated by a set of Cartesian products
Property of implicitness:	Cartesian entities (i.e., subspaces, vectors, partitions) whose associated Cartesian products contain only complete or singleton sets of block states
Cartesian entries:	Nonzero entries of a contribution vector equal to their relative Cartesian contribution vector entries.