A Method for the Design of Fault Detection Experiments
GÜNEY GÖNENÇ, MEMBER, IEEE
Abstract- A methodical procedure for organization of fault detection experiments for synchronous sequential
machines possessing distinguishing sequences (DS) is given. The organization is based on the transition checking
approach. The checking experiment is considered in three concatenative parts: 1) the initial sequence which brings
the machine under test into a specific state, 2) the -sequence to recognize all the states and to establish the
information about the next states under the input DS, and 3) the -sequence to check all the individual transitions in
the state table.
Because of the algorithmic nature of the procedure, it can be computer programmed. It is shown that besides
being algorithmic, the described method yields upper bounds on the length of experiment smaller than those given in
previous works. The actual length of the experiments are, in general, well under the bound. A trial and error
procedure to further reduce the length of the experiment is described.
Index Terms - Checking experiments, distinguishing sequence, fault detection, sequential machines, transition
checking.
--------------------------------------------------------------------------------------------Reprinted from IEEE TRANSACTIONS ON COMPUTERS, Volume C-19, Number 6, June 1970, pp. 551-558.
Manuscript received June 9, 1969; revised December I, 1969. This research was supported by the U. S. Air Force Office of
Scientific Research, Office of Aerospace Research, under Contract AF-49-638-1402, and by the Technical and Scientific Research
Council of Turkey.
The author was with the Department of Electrical Engineering, Polytechnic Institute of Brooklyn, Brooklyn, N. Y. He is now a
Visiting Scientist in the Department of Electrical Engineering, University of Windsor, Windsor, Ontario, Canada, on leave of absence
from the Middle East Technical University, Ankara, Turkey.
---------------------------------------------------------------------------------------------
I. INTRODUCTION
The testing problem for a sequential switching circuit is the problem of determining whether or not the circuit is
operating correctly (i.e., in accordance with a given state table). For circuits built in integrated or module form, the
internal wiring is not accessible. The only accessible points are the terminals of a circuit; the only means of testing
the circuit is by performing an experiment on it, that is, applying an input signal and observing the output. Hence the
testing problem may be stated as follows. Given a sequential switching circuit and a state table, find an input-output
sequence pair (X, Z) such that the response of the circuit to X will be Z if and only if the circuit is operating
correctly. The application of this input sequence X and observation of the response, to see if it is Z, is called a
checking experiment. Needless to say, such a pair is not unique. In order to be able to find checking experiments of
reasonable length, some restrictions should be imposed on the state table (i.e., the correctly operating circuit) and on
the types of possible malfunctions. The class of state tables considered here consists of circuits which 1) are
strongly connected, 2) contain no equivalent states, and 3) have a distinguishing sequence (DS) [5]. The allowable
failures are characterized by the following. 1) Any failure which occurs is assumed to occur throughout the test, and
2) a failure which increases the number of states in the circuit does not occur.
The earliest work on failure detection problem was done by Moore [9]. His method not only determines whether
or not a malfunction has occurred, but also determines which malfunction has occurred. But this method has the disadvantage of requiring an extraordinary amount of work and of yielding unpractically long experiments. Hennie [5]
proposed a new approach, which can be called the transition checking method. Kime [6] proposed modifications on
Hennie's procedure, yielding reduced upper bounds on the length of the experiment. The procedure proposed in this
note is an algorithmic method based on the transition checking approach. Because of the algorithmic character of the
procedure, it can be computer programmed. Moreover, it yields upper bounds considerably smaller than the abovementioned methods.
II. NOTATION AND BASIC DEFINITIONS
The sequential machines considered in this note are assumed to be finite-state, synchronous, deterministic, and
completely specified. Furthermore, they are assumed to be in the class defined previously, i.e., strongly connected,
reduced, and possessing a DS. The checking experiment consists of the application of two concatenative input sequences: 1) the initial sequence which brings the machine into a specified state (called the starting state) regardless
of the initial state of the machine at the beginning of the experiment, and 2) the checking sequence organized for the
given state table and the specific starting state. The terms preset, adaptive, distinguishing sequence (DS),
synchronizing sequence (SS), and homing sequence (HS) are used in the usual way [2], [6]. The state set for the
circuit is denoted by1 S = {S1, S2, . . . , Sn}; the set of input symbols is denoted by I={x1, x2, .., xq}. Hence there are n
states and q inputs. In general x and z denote single input and output symbols; X and Z denote input and output
strings of length 1 or more. The DS which is being used in the checking sequence is denoted by Xd. (S, X) is the
terminal state function and (S, X) is the output sequence function [2]. The state and the output string resulting from
the application of Xd to the machine in state Sj is denoted by Qj and Zj, respectively, i.e., Qj= (Sj, Xd) and Zj=(Sj,
Xd). The output to the single input xi with the machine initially in state Sj is denoted by zij, i.e., zij = (Sj, xi).
X(i) denotes the ith digit of the sequence X and l(X) denotes the length of the sequence X. L is used for l(Xd). The
shortest (or one of the shortest) transitional (input) sequences from state Si to state Sj is denoted by T(Si, Sj). The
notation
Si X/Z Sj
is used as a shorthand2 for the functional relation pair
{(Si, X) = Sj, (Si, X) = Z}.
Definition 1: An (X)-table is a table giving values of the functions (Si, X) and (Si, X) for i = 1, 2, . . . , n for the
specific input string X. An (X)-diagram is the transition diagram obtained from the (X)-table.
Definition 2: A source for X is a state which is not a next-state of any state under input X; in other words, it is a
state which does not receive any transition under input X.
Definition 3: A state Si through which the circuit passes in the course of the experiment, is said to be recognized
if, from the knowledge of the output, Si can be identified with a state in the given state table.
Definition 4: A state can be recognized in one of the following ways.
1) A state can be recognized by the application of a DS and observing the output. If the response to Xd is Zi, then
the state of the machine prior to the application of the Xd is identified as Si Such a state is said to be d-recognized
and is shown with a superscript d.
2) A state can be recognized by the application of an HS and observing the output. Since every DS is also an HS
and the DS will be used throughout the experiment, the definition, for convenience, will make use of the DS as an
HS. If the response to Xd is Zi, the state of the machine after the application of Xd is identified as Qi. Such a state is
said to be q-recognized and shown with a superscript q.
3) A state can be recognized from the knowledge about a transition (observed elsewhere). Suppose, in the course
of the experiment, the following input is applied and the output is observed:
input:
X d X Xd
output: Zi Z
Zj
From this portion of the experiment, it is deduced that before the application of the specific sequence X, the
machine is in the q-recognized state Sk = Qi, and after the application of X, the machine is in the d-recognized state
Sj. Hence, the relationship Sj = (Sk, X) is established. Thus, whenever the machine is in the state Sk and the
specific input sequence X is applied, the state in which the machine falls can be readily identified as Sj. Such a state
is said to be t-recognized and shown with a superscript t.
III. PARTS OF THE CHECKING EXPERIMENT
A. The Initial Sequence
Since the checking sequence is designed to be applied to the machine in a particular state (the starting state), the
machine should be in that particular state when the checking sequence is to be applied. The initial sequence brings
the machine under test to the starting state. The initial sequence is a preset sequence if the state-table under
consideration has an SS. In fact, in this case it is the SS itself corresponding to the particular starting state into which
the machine is to be brought. On the other hand, the initial sequence has to be found adaptively if the state table does
not have an SS [2].
B. The Checking Sequence
The checking sequence, as organized according to the procedure given in this note consists of two parts. The first
part will be called the  - sequence and the second, the - sequence.
The -sequence is organized for the following two purposes: I) to recognize all states, and 2) to determine all Q's.
The - sequence is organized to check each transition in the state table. This sequence includes subsequences
which will be called cells. Each cell checks one particular transition. Each transition is checked by applying the
particular input in question, then applying Xd to recognize the state to which the transition leads. The important point
here is that the end state of each cell is readily (q-) recognized from the knowledge about the Q's obtained from the
 - sequence. Hence, the end state of a cell being so recognized, may well be the beginning state of the next cell.
This causes considerable reduction in the length of the overall sequence.
IV. THE  - SEQUENCE
A. Conditions on the  - Sequence
To meet the two requirements stated above, these two conditions are to be satisfied.
1) In order that every state can be recognized at least once, the  - sequence should be such that Xd is
applied to every state at least once. If Xd is applied to every state at least once and the machine is operating correctly, then there will be n distinct output substrings among the responses to Xd. These output substrings can be
associated with n different states.
2) In order that all Q's be determined, the  - sequence should be such that the input sequence XdXd is
applied to every state at least once. To show this, a possible portion of  is given below, where XdXd is applied to
the machine in state Si :
Xd
input:
state:
output:
Si
Xd
Sj = Q i
Zi
Sk = Qj
Zj
From this, it can easily be seen that if the response to XdXd is ZiZj, then Qi = Sj. Hence, by application of XdXd to
every state, all Q's will be determined.
B. Organization of the  - Sequence
Since condition 2 above covers condition 1, the aim is to apply XdXd to every state. If when doing this, one
reaches a state to which XdXd is already applied, one should jump into another state, using a T-sequence. Since each
source for Xd will need such a T-sequence to jump into it, a source should be chosen as the starting state. This will
save one T-sequence. If there is no source in the (Xd)-diagram, any state can be chosen as the starting state. Then
successive Xd's are applied, as long as the machine does not return to a previously recognized state. If the machine
returns to a recognized state, a T-sequence is applied to carry the machine into a not yet recognized state. There are
two considerations which govern the application of a T-sequence.
1) The beginning state of a T-sequence must have been recognized without the requirement that Xd be
applied again, i.e., it must be a q-recognized state. This is possible by applying one more Xd (step 5 in the algorithm
below) after the machine falls into an already recognized state.
2) The end state of a T-sequence should be
a) a source which is not yet recognized, if there is such a state;
b) a state which is not yet recognized, otherwise.3
The organization of the  - sequence terminates when all states are recognized.
Now an algorithm for the organization of  - sequence is given.
Step 1: If the given state table has more than one DS, choose one of the shortest as Xd. Draw the (Xd )diagram. Identify sources (if any).
Step 2: Choose one of the sources as starting state. If there is no source present, choose any state as starting
state.
Step 3: Apply Xd.
Step 4: If the state in which the state table goes with the application of Xd is a state not yet recognized, go to
Step 3. Otherwise go to Step 5.
Step 5: Apply Xd.
Step 6: If there is a source not yet recognized go to Step 7. Otherwise go to Step 8.
Step 7: Apply a T-sequence from the present state to (one of) the source(s) not yet recognized, then go to
Step 3.
Step 8: If there is any state which is not yet recognized go to Step 9. Otherwise stop; the design of the
 - sequence is terminated.
Step 9: Apply a T-sequence from the present state to the state not yet recognized. Then go to Step 3.
.
Example: The state table for machine A is given in Table 1. 001 is the shortest DS for this machine. (Xd)table and (Xd)-diagram is shown in Fig. 1.
TABLE 1
STATE TABLE FOR MACHINE
PS
1
2
3
4
5
6
x=0
2,0
3,0
4,1
5,0
6,0
2,1
A
NS,z
x=1
6,0
5,1
2,0
1,0
4,1
5,1
001/000
i
1
2
3
4
5
6
Qi
2
1
4
5
5
2
Zi
000
010
101
001
011
100
Fig. 1. (Xd)-table and (Xd)-diagram for machine A.
States 3 and 6 are sources. Either of them can be chosen as starting state. Choosing state 3 as starting state
will result with a slightly (one digit less) shorter SS and  - sequence. The initial sequence is preset, since this
machine has an SS. The SS for state 3 is 11011100. Hence the initial sequence is 11011100. The  - sequence,
organized according to the above algorithm, is
step number: 3
3
3
5
7
3
3
3
5 8
input:
001 001 001 001 0 001 001 001 001
state:
3
4d
5d
5d
5q 6d
2d
1d
2d
1q
output:
101 001 0ll 011 0 100 010 000 010
One T - sequence is used, which is T(5, 6) = 0. By first applying the initial sequence 11011100, and then the
above  - sequence to the machine under test, and if the response to the  - sequence is as given above, all of the six
states can be recognized somewhere in the course of this portion of the experiment; the knowledge about Q's of all
the six states is also established. For example, from a portion of the above  - sequence, it is seen that the response
to XdXd = 001001 is 100010 = Z6Z2; hence it is deduced that Q6 = 2.
The - sequence leaves the machine in a recognized state (state 1 in the example), and the  - sequence will be
designed to be applied with the machine in this known state.
V. THE  - SEQUENCE
A. General Considerations
The  - sequence is to be organized to check all the transitions, and it is composed of cells and T-sequences.
Definition 5: A cell to check the transition from state Sj under the input Xi, Xi  I, is the input sequence xiXd,
applied to the machine in state Sj.
One cell will be used for each transition to be checked, hence there are qn cells4. A cell should be applied to an
already recognized state. The general scheme for the cell to check the transition from Sj with input xi is given
below5:
input:
xi
state:
Skd = (Sj,xi)
Sj
output:
Xd
zij
Sm q = Qk
Zk
Since the experiment will be so designed that Sj is recognized beforehand, and Sk will be recognized from its response Zk to Xd, the transition
Sj  Sk under input xi
will be checked by the above cell. Furthermore, from the knowledge of Q's obtained previously from the sequence, the end state of the cell is also a recognized state. If the last L output symbols for the cell constitutes the
string Zk, then the end state of the cell is Qk. Hence, the end state of a cell is always a q-recognized state. Then it
follows that the end state of a cell may well be the beginning state of another cell.
B. Organization of  - Sequence
From the above discussion, it can be seen that to organize the  - sequence one should apply cells successively
unless the end state of the last cell is a state from which all transitions are checked. In this case, one has to apply a
T-sequence to transfer the machine into a state not yet checked for at least one input symbol.
The  - sequence is based on applying successive Xd’s, whereas the  - sequence is based on applying successive
cells of the form xiXd. Extending the idea of (Xd)-diagram, one can consider a " - diagram" for the organization of
the  - sequence. The  - diagram is the diagram obtained by considering inputs xiXd for all xiI, in other words, it is
the
(x 
i

xiXd) - diagram.
The  - diagram for machine A is given in Fig. 2. We treat the  - diagram as a directed graph, having n vertices
(states) and nq arcs (xiXd transitions). We define a path as a sequence of arcs such that the terminal state of each arc
coincides with the initial state of the succeeding are. A path corresponds to successive application of cells to the
machine. A path is simple if it does not use the same arc twice. A covering is a partitioning of all the arcs of a
graph into simple paths which are disjoint (i.e., not having any common arc). di+ is the number of arcs leaving state
Si and di is the number of arcs entering the state Si. Obviously, for the - diagram di+ = q for all i.
Fig.2. - diagram for machine A.
The subsets R, F, and P of S, which constitute a partitioning of S, are defined by
R = {Si S | di+ = di}
F = {Si S | di+ > di}
P = {Si S | di+ < di}
If di+ = di for all i the graph is called Eulerian. For a Eulerian graph R = S and sets F and P are empty. For a
connected Eulerian graph the set of all arcs is a circuit6 and hence constitutes the unique minimal covering; in other
words, starting from any state and going through arcs only once one can return to the initial state. If a Eulerian graph
is not connected the above is true for each component. For minimal coverings of connected non-Eulerian graphs we
have the following theorem [3].
Theorem 1: If a directed graph D is connected but not Eulerian, then every minimal covering of D consists of k
paths, each of which joins a vertex in F to one in P, where
k =
(di+
S i F
 di) = (di  di+).
(1)
S i P
This theorem obviously holds for non-Eulerian components of a nonconnected graph, where F and P are taken as
the subsets of the given property of the set of states of the component under consideration, and k is found accordingly.
The problem of - sequence organization is equivalent to finding a minimal covering of the - diagram. An
algorithm7 to find a minimal covering of a graph is given below. it is for connected graphs, or for individual
components of a nonconnected graph. It is clear that for a nonconnected graph, a minimal covering is the union of
the minimal coverings of its components, and the overall number of paths is equal to the sum of k's of the individual
components.
Algoritlım to find a minimal covering:
Step1: Start from any state in F.
Step 2: Each time an arc is followed, erase it.
Step 3: Do not use an arc which is an isthmus at that particular moment, if there exists any other arc which can be
followed. An isthmus is an arc, deletion of which divides the graph into two components.
Sep 4: When it is not possible to go further, start again from a state in F in such a way that eventually from each
state in F exactly j starts will be made, where j = dj+ dj
To reach Sj F for a restart, a "jump," i.e., a T-sequence of the form T(Si, Sj) is used, where SiP. Since there are
k paths, there are k  1 such T-sequences.
One should consider the following aspects.
1) Since the starting state of the - sequence should be the same as the end state of the  - sequence, this starting
state may not be a state in F. It can be shown that in this case, the minimal covering consists of k + 1 paths and that
the number of jumps is k. The above algorithm is valid, with the obvious change in Step 1.
2) In Step 4 there is the problem of choosing the state from which a restart is to be made. Let us define set V as the
set of states from which, at a particular moment, at least one (unerased) arc emanates. When one reaches a state Si
and it is not possible to go further, one must jump into the nearest state Sj (F  V). Nearest state is the one which
requires the shortest T-sequence. This choice ensures that the T-sequence T(Si, Sj) does not pass through a state
Sk(F  V), since in this case, Sk would have been chosen as the restarting state, i.e., the end state of the Tsequence.8
As an example, consider the  - diagram of machine A (Fig. 2). We have F={3, 4, 6}, P={1, 2, 5},
k=3+4+6=5. Hence the minimal covering consists of five paths and four jumps if the  - sequence starts from
states 3, 4, or 6, and six paths and five jumps for any other starting state. In the  -sequence, two (6) paths start
from state 3, one (4) path from state 4, and two (6) paths from state 6. An additional path starts from the starting
state of , if it is 1, 2, or 5. .
Three of the possible minimal coverings are
45525 - 65 - 611242 - 31 - 35
311255242 - 35 - 45 - 65 - 61
11255242 - 35 - 45 - 65 - 61 - 31
where digits correspond to states visited, hyphens correspond to jumps (T-sequences), and state sequences separated
by hyphens correspond to paths. First, two coverings start with a state in F; hence they have five paths, whereas the
last covering, starting with a state in P has six paths. The  - sequence which corresponds to a covering is very easy
to determine; for example, the input string of the  - sequence based on the third covering above is
0Xd1Xd1Xd1Xd0Xd0Xd1Xd00Xd10Xd01Xd00Xd001Xd
where Xd = 001. The - sequences found from the above three coverings have lengths of 53, 52, and 53,
respectively. The output sequence corresponding to the above input sequence can be found easily, from the state
table of the machine. The  given above, together with the  given in Section IV-B constitutes a checking sequence
for machine A in state 3.
C. Reduction of the Length of the  - Sequence
There is no need to include a cell for every transition in the state table. The fact that some transitions can be
checked without using a cell can be explained in the following way.
Suppose X is an-input sequence of length u, then
(S1, X(1)) = S2
(S2, X(2)) = S3

.
.
(Su-1, X(u-1)) = Su






implies





and
(S1, X) = Si
and
(S1, X(1)) = Z(1)
(S2, X(2)) = Z(2)
.
.
(Su-1, X(u-1)) = Z(u-1)
and
(S1, X) = Z
(Su, X(u)) = Si

(Su, X(u)) = Z(u)



These implications result from the fact that (S, X) and (S, X) are unique for a given pair (S, X). Two kinds of
input sequences can be used to deduce information: the T - sequences used in , and Xd. One notes that (Si, Xd) =
Qi and (Si, Xd) = Zj for all i are found from . Also, (Si, Tj) = Sk, and the corresponding output sequences are
known where Tj are T - sequences used in . This is so because the beginning and the end states of every T sequence in  are recognized states. Now, it is clear that if the left-hand side of the implication given above is
known for Xd and/or a specific T - sequence, then there is no need for a cell to check the transition on the righthand side. To foresee such possible deductions, one considers the application of Xd to each state, and the
application of the T - sequences used in  to their respective beginning states. As an example, consider machine A.
In Table II the application of Xd (001) to each state is considered. The first row shows that if 001 is applied to the
machine in state 1, it goes into state 2, passing through states 2 and 3. Hence, if the transitions 10 and 20 are checked,
then there will be no need for a cell for the transition 3 1. The transitions which may be checked in this way are the
ones from those states in the column one before the last, with the last digit of Xd. As for the T - sequences used in
 in this example there is one: T(5, 6) = 0, and this means there is no need to check the transition 5 0.
TABLE II
Xd = 001 APPLIED TO EACH STATE OF MACHINE A
0
1
2
3
4
5
6
0
2
3
4
5
6
2
1
3
4
5
6
2
3
2
1
4
5
5
2
Fig. 3. Modified  – diagram for machine A
One considers a modified  - diagram which is obtained by deleting the arcs corresponding to the transitions that
may be checked without using cells. The modified  - diagram for the machine A is shown in Fig. 3. Using this
modified diagram, starting from state 1, and using the minimal covering algorithm given in Section V-D, one finds a
possible minimal covering as
11245 - 61 – 35
which corresponds to the following  - sequence:
input:
output:
0001 1001 0001 0001 O 0001 00 0001
0010 0100 0101 0011 O 1010 00 1001.
It can be shown that the  given in Section IV-B and the above  constitute a checking sequence for machine A
in state 3. This  has a length 27 which is much smaller than the one found before.
Not every minimal covering of the modified  - diagram corresponds to a  - sequence. To see this, consider a
portion of  given below:
input:
T(Si, Sj)
xk
Xd
q
state: Si
Sj
Sm
Qm
This subsequence is applied to the machine in Siq, and the cell xkXd is intended to check (Sj, xk) = Sm. Now,
suppose T(Si, Sj) includes a transition (Sw, xy)= Su which is deleted from the  - diagram because it is one of the
transitions that may be checked without a cell. Hence there will be no cell to check (Sw, xy) = Su. Also suppose that
the implication from which one expects to obtain (Sw, xy) = Su is of the following form:
.
.
(Sj, xk) = Sm
.
.





implies (Sw, xy) = Su.
Clearly, this leads to an impossibility since Sj cannot be recognized. Hence, to find a  - sequence from the modified
 -diagram, one proceeds by trial and error. It may even be necessary to add one or more arcs to the modified  - diagram.
VI. BOUNDS ON EXPERIMENT LENGTH
A. Bound on the Length of  - Sequence
Let Ci be the components of the (Xd)-diagram. Let  and  be the set of components, which are Eulerian and nonEulerian, respectively. Let  = || and  = ||. Let ni and ei be the number of states and number of sources in Ci,
respectively. Let E be the total number of sources in the (Xd) - diagram.
From the organization of the  - sequence, it can be seen that the number of Xd’s required for a Eulerian
component Ci is ni+1; and for a non-Eulerian component Cj is nj+kj, where kj is the k for Cj as given by (1). Note
that since there is exactly one arc emanating from every state, kj = ej. The total number of Xd’s is given by


Ci
(ni + 1) +

Cj
(nj + kj) =

Ci
ni +

Cj
nj + +
 ej
Cj
= n++E.
The number of T -sequences is found as follows. In a Eulerian component no jump is required; in a non- Eulerian
component Cj there are kj  jumps. There are 1 additional jumps joining distinct components. Hence the
total number of jumps is


Cj
(ki  1) + (1) = E +  1.
Since the state diagram is strongly connected, the upper bound for length of T - sequences is n 1, hence
l()  (n +  + E)L + (E + ) (n  1)
or
l(a) (E + ) (L + n ) + nL  n + 1.
One notes that
n,
if E  0
E +  

n – 1, if E  0
En,  n,




Hence E +  attains its maximum value n when E = 0. Thus
l()  n (L + n 1) + nL  (n  1)
or
l() 2nL + (n  1)2.
B. Bound on the Length of the- Sequence
Let Ci be the components of the  - diagram. Let the number of components be w, and ki denote the k for Ci as
given by (1).
Let the starting state for  belong to C1. In C1 there are k1 jumps (or k1  1 jumps if the starting state is in F). For
each component Ci, i = 2, 3, . . . ,w; there are ki  1 jumps. For component Ci ,
ki =

SjFi
(dj+  dj) =

SjFi
(q  dj) = fi q 

SjFi
dj
where
Fi ={Sj | Sj is a state in Ci, dj+ > dj}
fi = |Fi|
it is clear that fi  ni – 1 and


SjFi
dj  0 .
Therefore,
ki (ni  1) q .
Hence the total number of jumps for  is smaller than
(n1  1) q +
wi=2
[(ni  1) q – 1] + (w  1) = q (n  w)
where the term (w  1) represents the jumps among distinct components. But since w  l, the number of jumps is
smaller than q(n1). Since each jump has a maximum length of n 1, and there are a total of qn cells, each of
which has a length of L+ 1, a bound on the length of  can be given as9
l()  q(n - 1)2 + qn(L + 1).
C. Bound on the Length of the Checking Sequence
From the bounds for l() and l(), one gets a bound on the checking sequence:10
l() = l() + l()  b
where
b = 2nL + (n – 1)2 + q(n – 1)2 + qn(L + 1)
or
b = (1 + q)(n  1)2 + 2nL + qn(L + 1) .
As an example, for machine A, n = 6, L = 3, and q = 2, hence b = 159.
It was found that l() = 25 and l() = 27 which gives a checking sequence of length 52. This is well under the
bound. It is clear that not all T - sequences can have a length n1; therefore the length of the checking sequence is
normally well under the bound.
The upper bounds on the length of the checking sequence as reported by Hennie [5] and Kime [6] are,
respectively,
bH = qn(2L + 2n  1) + n(n  1) + (n + 1)L
bK = (2L + n  1)(qn + 1) + [q n (n + 1)]/2 .
it can be shown that, for q  2 and n  2,
bHb  2n2 + n(L + 1) + L  3
bK  b  4n + 2L  4.
Considering the ratios,it is seen that b/bB is approximately 0.5 and b/bK is approximately in the range of 0.5 to 0.9.
VII. FURTHER CONSIDERATIONS
It seems that distinguishing sequences of the form Xd = X1 X2 X1 will yield shorter checking experiments, the
reduction in length being at least n[l(X1)]. This point will be described in a later study. Kohavi and Lavallee [7]
showed that distinguishing sequences consisting of repeated symbols (11, 000, etc.) yield considerably shorter
checking experiments. . Kohavi and Kohavi [8] showed that variable length distinguishing sequences (VLDS) can
be used, and this yields shorter checking experiments. But not all machines have VLDS's (for example, machine A
given in Fig. 1 does not have a VLDS). It seems that the possibility of having VLDS for a machine increases rapidly
with an increasing number of output symbols (machine M in [8] has 4 output symbols).
The method described in this note is an improvement over the algorithmic technique reported earlier [4]. Although the upper bounds on the length are the same, the actual length of experiments organized according to this
note are found to be shorter. A computer program is being written to organize the checking sequence (from the state
table of the machine) to demonstrate the algorithmic character of the method.
ACKNOWLEDGMENT
The author wishes to express his gratitude to his thesis advisor, Prof. E. J. Smith of the Polytechnic Institute of
Brooklyn, Brooklyn, N. Y, for his invaluable advice, iIluminating suggestions, and encouragement. Thanks are also
due to Ö. Yüksel, Dr. E. Gelenbe, and Prof. L. D. Meeker for their comments.
FOOTNOTES
1 In many occasions the states are represented by integers, i.e., i for Si
2 For example, [(3, 1) = 4, (3, 1) = 0] is shown as 3 1/0 4; or when the output symbol and the next state is not important for the
discussion, this transition is shown as 31.
3 Note that case b occurs when the (Xd)-diagram is not strongly connected.
4 If the technique which will be discussed in Section V-C is used, the number of cells decreases.
5 State Si in this scheme is either Sjq or Sjt,
6 A circuit is a finite path in which the initial vertex coincides with the terminal vertex.
7 This algorithm is based on a similar algorithm for undirected Eulerian graphs given by Fleury (Berge [1]). The proof is not given; it
is based on theorem 1.
8 This procedure prevents possible deadlocks in the organization. It also shortens the  - sequence. The proof of this statement is too
lengthy to be included here.
9 The technique described in Section V-C has a decreasing effect on the bound. However, it can be shown that in the worst case there
will be only one cell that may be excluded. Hence the bound will decrease by (L + n). This decrease is small and not taken
into account.
10 Note that if (Xd)-diagram has n components, then (Si, Xd) = Sj . This means that (Si, xjXd) = (Si,xj), i.e., the  - diagram is the
same as the state diagram, hence connected. Therefore the bounds found above for l() and l() are compatible, and they
can be added.
REFERENCES
[I] C. Berge, The Theory of Graphs. London: Methuen, 1962.
[2] T. L. Booth, Sequential Machines and Automata Theory, New York:Wiley, 1967.
[3] G. Busacker and T. Saaty, Finite Graphs and Networks. New York: McGraw-Hill, 1965.
[4] G. Gönenç, "An algorithmic method for organizing checking experiments," Polytechnic Institute of Brooklyn, Brooklyn, N. Y., Res. Rept.
PIBEE680006, June 1968.
[5] F. C. Hennie, "Fault detecting experiments for sequential circuits," Proc. 5th Ann. Symp. on Switching Theory and Logical Design,
Prince ton University, Princeton, N. J., November 1964, pp. 95-110.
[6] C. R. Kime, "A failure detection method for sequential circuits," Dept. of Elec. Engrg., University of Iowa, Iowa City, Tech. Rept.
66-13, January 1966.
[7] Z. Kohavi and P. Lavallee, "Design of sequential machines with fault detectian capabilities," IEEE Trans. Electronic Computers, vol. EC-16,
pp. 473-484, August 1967.
[8] I. Kohavi and Z. Kohavi, "Variable-Iength distinguishing sequences and their application to the design of fault-detection experiments," IEEE
Trans. Computers (Short Notes), vol. C-17, pp. 792-795, August 1968.
[9] E. F. Moore, "Gedanken experiments on sequential machines," in Automata Studies. Princeton, N. J.: Princeton University Press, 1956.
---------------