Reliability Engineering and System Safety 36 (1992) 59-62

Finding minimal cut sets in a fault tree

Jsrn Vatn
SINTEF, Safety and Reliability, N-7034 Trondheim, Norway

This paper presents a new method for identification of minimal cut sets in a
fault tree. The (non-minimal) cut sets are found by a modification of the
well-known MOCUS algorithm. These cut sets are stored in a virtual tree
structure which requires far less core space than the MOCUS cut set matrix.
The minimal cut sets are found by traversing this virtual tree a number of
times. In the first cycle, all cut sets of order one are identified. In the next
cycle, all cut sets of order two are identified and compared with the cut sets of
order one to exclude non-minimal sets. This procedure is continued until all
minimal cut sets are identified. The procedure is very fast. Compared to the
standard MOCUS program the computer time is reduced by at least a factor of
ten.

INTRODUCTION
When developing c o m p u t e r programs for Fault T r e e
Analysis (VI'A), one of the main challenges is to find
an effective algorithm for minimal cut set identifica-
tion. For the fault tree module of C A R A 1 a new
method has been developed. This new method is
based on the same basic idea as the well-known
M O C U S algorithm. 2 T h r e e m a j o r problems arise
when trying to implement M O C U S on a personal
computer:
(i) We may run out of m e m o r y . W h e n dimension-
ing the cut set matrix, we must define the
n u m b e r of columns to be large enough to hold
the cut set with the highest n u m b e r of basic
events. The n u m b e r of rows must be large
enough to hold all (non-minimal) cut sets.
(ii) For each gate in the fault tree, M O C U S
updates the cut set matrix. In most cases the
updated matrix will hold a n u m b e r of rows
which are identical with the previous matrix. A
lot of unnecessary work has thus to be carried
out, since M O C U S does not take advantage of
these duplications.
(iii) The final cut set matrix which we get from the
M O C U S approach is hard to reduce to obtain
the minimal cut sets.
THE NEW ALGORITHM
The new C A R A algorithm for identification
minimal cut sets is p e r f o r m e d in two main steps:
Reliability Engineering and System Safety 0951-8320/92/$05.00
1992 Elsevier Science Publishers Ltd, England.
(I) Instead of building the cut set matrix (as done
by M O C U S ) , a virtual cut set tree structure is
developed. This virtual tree should not be
confused with the original fault tree.
(II) To obtain the cut sets, we traverse the cut set
tree several times in a systematic manner. As
cut sets are obtained, they are immediately
checked as to whether they are minimal or not.
! Building the cut set tree structure
The virtual cut set tree contains a n u m b e r of nodes.
The nodes are either gates or basic events. Each node
has two pointers (written in cursive below) which are
pointing to other nodes:
h --horizontal pointer, h points to the next element
in a cut set (a row in the cut set matrix),
v --vertical pointer, v points to the next row in the
minimal cut set matrix.
Further notation:
p = pointer to a node
P 1' = node pointed to by p,
p 1' . I D = the node identifier of the node pointed to
by p,
p 1' . h = the horizontal pointer of the node pointed
to by p,
p 1' . v -- the vertical pointer of the node pointed to
by p,
of N I L = null pointer.
The function create_new(node_id, h, v) returns a
pointer to a new node with the node identifier equal
to node_id, and with pointers h and v. The function
59
60
next_descendent(g) returns the next descendent of the
gate g (as they appear in the original fault tree).
The algorithm for building the tree is given below:
1. Initiating.
p = create_new(TOP, NIL, NIL):
2. process p 1' (the node pointed to by p).
p 1' . ID = 1. st descendent o f p 1' . ID;
h-trap = p ~ . h;
v-trap = p ~ . v;
next = p;
3. the rest of the descendents of p 1`. ID are
inserted in the tree depending on whether
p 1' . ID is an A N D gate or an O R gate:
IF (p I' . ID is an A N D gate):
n e x t t h = create_new(next_
descendants(p 1' . ID), h-trap, NIL);
n e x t = n e x t 1` . h;
E L S E I F (p 1' . ID is an O R gate):
n e x t 1` . v = create_new(next_
descendents(p 1' . ID), h-trap, v - t m p ) ;
n e x t = n e x t 1` . v;
ENDIF
IF p 1' . ID has more descendents, G O T O 3:
4. IF all gates have been processed, STOP;
ELSE
p = pointer to next unprocessed gate in the
tree;
G O T O 2;
ENDIF
II Identifying the minimal cut sets
Let
X, Y = cut sets
K = family of cut sets
In order to obtain the cut sets, a tree traversal must be
performed. A buffer B is used to store a cut set before
it is included in the family, K, of cut sets. A pointer,
b, is used to control the position up to which the
members of the buffer B are applicable. When a cut
set X is found, we check X against K in order to
identify non-minimal cut sets. There are three
different situations:
1. X is identical to an existing cut set in K. X is not
included in K, no further checking is necessary.
2. There exists a cut set Y in K, such that Y c X. X
is therefore not minimal, no further checking is
necessary.
3. There exists a cut set Y in K, such that X c Y. Y
is therefore not minimal, and should be removed
from K. K is replaced by K U X , and X is
checked against K t 0 X to obtain further
occurrences of such Ys.
The algorithm, which is given below, is recursive, but
JCrn Vatn
is written non-recursively by using a stack to store
values as the tree is traversed.
The procedure push_stack(p, b) saves the values of
p and the buffer pointer b to a stack. The values can
be retrieved by calling the procedure pop_stack(p, b).
The function stack_underflow0 returns T R U E when
there are no more values to pop from the stack, and
we are done.
1. p = pointer to the root node of the tree;
b =0;
2. I F ( p T . h ~ N I L ) :
IF (p 1' . v =~NIL):
push_stack(p 1' . v, b);
ENDIF
IF(p1' .ID~B):
B=BUpl' .ID;
b=b+l;
ENDIF
E L S E I F (p 1' . h = NIL):
Update K, i.e. check whether X should be
included in K, or existing cut sets in K should
be removed when X is included. (X is now the
first b elements of the buffer B)
If (p 1' . v :/=NIL):
p=p~ .v;
E L S E I F (p 1' . v = NIL):
pop_stack(p, b);
IF stack_underflow0 STOP:
ENDIF
ENDIF
3. G O T O 2:
The algorithm finds all minimal cut sets. Step 2 may
be modified so that only minimal cut sets up to a
certain order are identified. This is done by not
allowing proceeding in the horizontal direction, when
the buffer pointer b exceeds the limit specified by the
maximum cut size.
To illustrate the method, consider the fault tree in
Fig. 1.
When constructing the virtual tree structure, we
start with the T O P event, GO, as illustrated in Fig. 2.
The next step is to resolve the GO gate. GO is replaced
with its first descendent (basic event no 1). Since GO is
an O R gate, the tree is developed in the vertical
direction. Hence the rest of the descendents of GO are
inserted as shown in Fig. 3(a). In Fig. 3(b), G1 has
been resolved by G2 and G3. We notice that G2 is an
A N D gate, and the tree is developed in the horizontal
direction. Thus G2 is resolved by G4 and G5 in Fig. 4.
When resolving G4, we notice that G 4 . h :~NIL
(the horizontal pointer of the G4 node is pointing to
G5), hence both basic event 4 and basic event 5 are
pointing at G5 (Fig. 5). Proceeding in this manner,
gives the complete resolved structure (Fig. 6).
To find the cut sets, the tree is traversed. We start
with node 1. The horizontal pointer = NIL, (h = NIL)
 Finding minimal cut sets in a fault tree 61

Topevent J

l
I I I I <g> I
OD

I
I I

]
I I
I I I Q II I

1 I I I
I (D
II II ] I I[ I
Pig. 1. Example fault tree.

C~ 1

(a) (b)
Pig. 2. Initial structure. Fig. 3. Developing vertically.

C~ (

d
- - n

Fig. 4. Developing horizontally. Fig. 5. Double pointer to G5. Fig. 6. Final structure.
62 JOrn Vatn

and {1} is therefore a cut set. We now proceed to To illustrate the improvement in computer time, the
node 4. The vertical pointer is 4: NIL (v 4: NIL), and algorithm is compared with the commercially available
must push v (pointer to node 5), and the (empty) cut MOCUS program. The figures are given in seconds,
set is pushed to the STACK. Before we proceed to and the programs were run on an 20 MHz PC.
node 6 we let B = {4} and b = 1. Now h = N I L , and
( B = ) {4, 6} is therefore a (non-minimal) cut set. Since
Fault tree 1 ( # gates = 84, # basic events = 81):
v 4: NIL, we proceed to node 7. h = NIL, and {4, 7} is
a (minimal) cut set. v = NIL, and we pop the node
Maximum MOCUS C A R A algorithm
pointer and the empty cut set from the STACK. Now
cut size
we proceed from node 5 similar to what we did with
1 10 0-1
node 4 (remembering to push a pointer to node 3 to
2 25 0.2
the STACK), giving the cut sets {5, 6} and {5, 7}.
3 170 0.4
From the STACK we now pop the pointer to node
4 350 1.2
3. h---NIL, hence {3} is a minimal cut set. We
5 -- 4.3
proceed to node 6, and {6} is also a minimal cut set.
We detect that the cut set {4, 6} which is a member of Fault tree 2 ( # gates = 35, # of basic events = 34):
the family of cut sets K, is no longer minimal, and we
Maximum MOCUS C A R A algorithm
remove {4, 6} from K. Also {5, 6} is not minimal.
cut size
When the procedure is completed, the minimal cut
5 23 0-1
sets are:
6 30 0.3
{1}, {4,7}, {5,7}, {3}, {6} and {2} 7 30 0-8
8 30 1-4
Application of this algorithm on practical fault trees
9 36 2-3
has shown that the time necessary for a tree traversal
is short compared with the time used for checking for
minimal cut sets. We can, therefore, afford traversing
the tree several times. In the first pass, we are looking REFERENCES
for minimal cut sets with only one basic event in each
cut. In the second pass we are looking for cut sets with 1. CARA---Computer Aided Reliability analysis. User's
manual. SINTEF Safety and Reliability N-7034 Trond-
only two basic events in each cut set and so on. We heim, Norway.
then know that all cut sets in K are minimal, and a 2. Fussell, J. B. et al., MOCUS---A COMPUTER
new cut set needs only to be tested against cut sets PROGRAM TO OBTAIN MINIMAL SETS FROM
which we know are minimal. FAULT TREES. Aerojet Nuclear Company, 1974.