
Citation 
 Permanent Link:
 https://ufdc.ufl.edu/UFE0006553/00001
Material Information
 Title:
 On the Control of Asynchronous Machines with Infinite Cycles
 Creator:
 VENKATRAMAN, NIRANJAN ( Author, Primary )
 Copyright Date:
 2008
Subjects
 Subjects / Keywords:
 Alphabets ( jstor )
Automata ( jstor ) Closed loop systems ( jstor ) Feedback control ( jstor ) Hammers ( jstor ) Integers ( jstor ) Machinery ( jstor ) Matrices ( jstor ) Recursive functions ( jstor ) Skeleton ( jstor )
Record Information
 Source Institution:
 University of Florida
 Holding Location:
 University of Florida
 Rights Management:
 Copyright Niranjan Venkatraman. Permission granted to University of Florida to digitize and display this item for nonprofit research and educational purposes. Any reuse of this item in excess of fair use or other copyright exemptions requires permission of the copyright holder.
 Embargo Date:
 8/7/2004
 Resource Identifier:
 56799473 ( OCLC )

Downloads 
This item has the following downloads:

Full Text 
ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES
By
NIRANJAN VENKATRAMAN
A DISSERTATION PRESENTED TO THE GRADUATE SCHOOL
OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT
OF THE REQUIREMENTS FOR THE DEGREE OF
DOCTOR OF PHILOSOPHY
UNIVERSITY OF FLORIDA
2004
Copyright 2004
by
Niranj an Venkatraman
To my parents, who always stood by me.
ACKNOWLEDGMENTS
First and foremost, I would like to acknowledge the unflagging support and
excellent supervision of my advisor, Dr. Jacob Hammer, during my four years at the
University of Florida. I thank Dr. Haniph Latchman, Dr. Tan Wong, and Dr. John
Schueller for all their efforts and their advice, and for serving on my Ph.D. supervisory
committee.
I would like to especially thank Xiaojun Geng (my officemate for three years) for
our animated and interesting discussions. I also extend special thanks to my current
officemates (Jun Peng and Debraj Chakraborty) for making the last year interesting and
full of fun. Special thanks are also due to my roommates (Raj, Nand and Arun) for
putting up with my eccentric behavior for four years. I would also like to thank all my
friends; their unceasing friendship and care has made this work possible.
Last but not the least, I would like to thank my parents, my grandmother, my sister,
her husband and my other relatives for their unfailing love and support during all the
years that I have been away from them.
TABLE OF CONTENTS
A C K N O W L E D G M E N T S ................................................................................................. iv
L IST O F T A B L E S ........ ................................................................................. vi
L IST O F FIG U R E S .... ....... ...................... ........................ .... ...... .. ............. vii
A B S T R A C T ......... .................................. ................................................... v iii
CHAPTER
1 IN T R O D U C T IO N ............................................................................... .............. ..
2 TERMINOLOGY AND BACKGROUND ...........................................................10
2.1 Asynchronous Machines and States ....................................... ............... 10
2.2 M odes of O operation ........................................................... ............... 14
3 IN F IN IT E C Y C L E S .......................................................................... ....................20
3 .1 In tro d u ctio n .................................................................................................. 2 0
3.2 D election of Cycles................. ............ ....................................... .. ... ....22
3.3 Stable State Representations for Machines with Cycles.................................29
3.4 Stable R eachability .............................................. .... .......... .............. .. 32
3.5 Matrix of Stable Transitions and the Skeleton Matrix..................................34
3 .6 C orrectiv e C controllers ........................................ .........................................39
4 THE MODEL MATCHING PROBLEM ........................................................46
5 E X A M P L E ............................................................................................................ 5 9
6 SUMMARY AND FUTURE WORK ................................................... ...............65
L IST O F R E F E R E N C E S ..................................... .................................... ....................68
B IO G R A PH IC A L SK E TCH ...................................................................... ..................76
v
LIST OF TABLES
Table page
51. Transition table for the m machine ........................................ ....................... 59
52. Stable transition table for the generalized stable state machine ls ........................60
53. Matrix of onestep generalized stable transitions R(ls) ...........................................60
54. Stable transition function of the given model '. .............................................61
LIST OF FIGURES
Figure
11. Control configuration for the asynchronous sequential machine ...........................3
page
Abstract of Dissertation Presented to the Graduate School
of the University of Florida in Partial Fulfillment of the
Requirements for the Degree of Doctor of Philosophy
ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES
By
Niranj an Venkatraman
August 2004
Chair: Jacob Hammer
Major Department: Electrical and Computer Engineering
My study deals with the problem of eliminating the effects of infinite cycles on
asynchronous sequential machines by using state feedback controllers. In addition to
eliminating the effects of infinite cycles, the controllers also transform the machine to
match the behavior of a prescribed model.
My study addresses machines in which the state is provided as the output of the
machine (input/state machines). Algorithms are provided for detecting infinite cycles in a
given machine, for verifying the existence of controllers that eliminate the effects of
infinite cycles, and for constructing the controllers whenever they exist.
The feedback controllers developed in my study resolve the model matching
problem for machines that are afflicted by infinite cycles. They transform the given
machine into a machine whose input/output behavior is deterministic and conforms with
the behavior of a prescribed model. Thus, the feedback control strategy overcomes the
effects of infinite cycles as well as any other undesirable aspects of the machine's
behavior.
Results include necessary and sufficient conditions for the existence of controllers,
as well as algorithms for their construction whenever they exist. These conditions are
presented in terms of a matrix inequality.
The occurrence of infinite cycles produces undesirable behavior of afflicted
asynchronous sequential machines. The occurrence of hazards has been a major problem
since the early development of asynchronous sequential machines. There are many
methods to design cyclefree machines; but the literature does not seem to contain any
technique for eliminating the negative effects of infinite cycles in case it occurs in
existing asynchronous sequential machines.
CHAPTER 1
INTRODUCTION
Asynchronous sequential machines are digital logic circuits that function without a
governing clock. They are also described variously as clockless logic circuits, selftiming
logic circuits, and asynchronous finite state machines (AFSMs). Asynchronous operation
has long been an active area of research (e.g., Huffman 1954a, 1954b, 1957), because of
its inherent advantages over commonly used synchronous machines. One of the more
obvious advantages is the complete elimination of clock skew problems, because of the
absence of clocks. This implies that skew in synchronization signals can be tolerated.
The various components of the machine can also be constructed in a modular fashion,
and reused, as there are no difficulties that are associated with synchronizing clocks.
Further, the speed of the circuit is allowed to change dynamically to the maximal respond
speed of the components. This leads to improved performance of the machine.
Asynchronous machines are by nature adaptive to all variations, and only speed up or
slow down as necessary (Cole and Zajicek (1990), Lavagno et al. (1991), Moon et al.
(1991), Yu and Subrahmanyam (1992), Fisher and Wu (1993), Furber (1993), Nowick
(1993), Nowick and Coates (1994), Hauck (1995)). Asynchronous machines also require
lower power, because of the absence of clock buffers and clock drivers that are normally
required to reduce clock skew. The switching activity within the machine is
uncorrelated, leading to a distributed electromagnetic noise spectrum and a lower average
peak value. Moreover, asynchronous operation is inherent in parallel computation
systems (Nishimura (1990), Plateau and Atif (1991), Bruschi et al. (1994)).
Asynchronous design is essential to ensure maximum efficiency in parallel computation
(Cole and Zajicek (1990), Higham and Schenk (1992), Nishimura (1995)).
Asynchronous machines are driven by changes of the input character, and are self
timed. In this context, it is vital to address design issues, especially those that can lead to
potential inconsistencies in the pulses that propagate through the machine. These
difficulties are referred to as "hazards" (Kohavi (1970), Unger (1995)). A cycle is one
such potential hazard in the operation of asynchronous machines. It causes the machine
to "hang," as is demonstrated in software applications with coding defects that can cause
the program to hang in an infinite loop. A "critical race" is another hazard that causes the
machine to exhibit unpredictable behavior. These hazards can occur because of
malfunctions, design flaws, or implementation flaws. The common procedure followed
when a hazard occurs is to replace the machine with a new one, built with no defects. In
our study, we propose to employ control techniques to devise methods that take a
machine out of an infinite cycle and endow it with desirable behavior. Thus, we
concentrate on the design of controllers that resolve infinite cycles and control the
machine so as to achieve specified performance.
To explain the mode of action of our controllers, a basic description of the structure
of an asynchronous machine needs to be reviewed. An asynchronous machine has two
types of states: stable states and unstable states. A stable state is one in which the
machine may linger indefinitely, while an unstable state is just transitory, and the
machine cannot linger at it. A cycle is a situation where the machine moves indefinitely
from one unstable state to another, without encountering a stable state. Cycles can occur
often in applications, brought about by errors in design, by errors in implementation, or
by malfunctions of components, for example, errors in programming that lead to infinite
cycles. The solution currently recommended in the literature for correcting an infinite
cycle is to replace the affected machine by a new machine. The solution proposed in our
study is, in many cases, more efficient. Moreover, it is the only practical solution in
cases where the affected system is out of reach.
The controllers we design are feedback controllers connected to the afflicted
machine, as depicted in Figure 11. The controller is activated during a cycle. Whenever
possible, the controller drives the machine out of the cycle, and leads it to a desirable
state. We characterize all cycles from which there is an escape, and present an algorithm
for the design of a controller that takes the machine out of any escapable cycle.
u C V
I
Figure 11. Control configuration for the asynchronous sequential machine X
Here, X is the asynchronous machine being controlled, and C is another
asynchronous machine that serves as a controller. We denote by Yc the closed loop
system represented by Figure 11. The controller C eliminates the effects of the cycles
of X so that the closed loop system Yc matches a prescribed model X' (i.e., Yc = Y').
The goal is to provide necessary and sufficient conditions for the existence of such a
controller C as well as an algorithm for its design. An important property of the
controller C is that the closed loop system will function properly whether or not the
cycle actually occurs. As a result, the controller C can be used to prevent the effects of
cycles before they occur, improving the reliability of the system.
It is important to note that during a cycle, the machine moves among unstable states
in quick succession, without lingering in any of the cycle states. Consequently, it cannot
be arranged for an input change to occur at a specific state of the cycle. Thus, the input
changes enforced by the controller occur at random during the cycle, and it is not possible
to predetermine the state of the cycle at which the controller acts. As a result, the
outcome of the controller action is unpredictable in most cases. This could lead to a
critical race condition being generated by the controller, which can then be rectified by
known procedures (Murphy (1996); Murphy, Geng and Hammer (2002, 2003); Geng
2003; Geng and Hammer (2003, 2004a, 2004b)).
When machine Y is an input state machine, i.e., the output of Y is the state of Y,
the controller C is called a state feedback controller. The existence of such a controller
C that takes the system out of a cycle depends on certain reachability properties of the
system. These reachability properties can be characterized in terms of a numerical matrix
called the "skeleton matrix" of the system. The skeleton matrix is calculated from the
various transitions of the machine. This skeleton matrix gives a methodology to derive
the necessary and sufficient conditions for the existence of a corrective controller C.
The function of the controller is twofold: it eliminates the effects of the cycle on
the machine and assigns to the closed loop a specified behavior. The controller C
functions by forcing an input character change while the machine is in a cycle; this may
induce a critical race. The outcome of this unpredictable behavior is then used by the
controller to assign a proper transition, as required to match the operation of the model.
In this way, the cycles of the machine are stopped, and the machine exhibits the desired
external behavior.
The modelmatching problem described here is basically a continuation of the work
of Hammer (1994, 1995, 1996a, 1996b); Murphy (1996); Murphy, Geng and Hammer
(2002, 2003); Geng (2003); and Geng and Hammer (2003, 2004a, 2004b). There are a
number of papers that relate to the modelmatching problem for synchronous sequential
machines (Dibinedetto et al. (1994, 1995a, 1995b, 2001), Barrett and Lafortune (1998)).
The studies relating to synchronous machines do not take into consideration the
differences between stable and unstable states, fundamental and semifundamental mode
of operation (Chapter 2), and other issues that are vital to the operation of asynchronous
machines. Our study seems to be the first one to explore control theoretic tools to
eliminate the effects of infinite cycles on asynchronous machines.
Eliminating the effects of infinite cycles is not the only situation in which model
matching is beneficial (Dibenedetto et al. (2001)). For example, most large digital
system are designed in a modular fashion, with a number of subsystems. An error in the
behavior of the machine detected late in the design phase may make it more economical
to use a controller instead of redesigning, or rebuilding, the entire machine. In other
words, model matching offers a lowcost option to remedy design and construction errors
(Fujita (1993)). Moreover, the controller can also be used to improve the reliability and
performance of the system, by deploying it before a fault develops in the system. In this
way, the controller can guard against potential malfunctions, while being "transparent"
before a malfunction occurs. Thus, in machines where high reliability is vital, our study
provides a new design option.
The early work on automata theory was carried out by Turing (1936). Huffman
(1954a, 1954b, 1957) investigated various aspects of the synthesis of asynchronous relay
circuits. There is a well established technical literature relating to the subject of design of
hazardfree machines (e.g., Liu (1963), Tracey (1966), Kohavi (1970), Maki and Tracey
(1971)). This is achieved by appropriate state assignment techniques. Classical methods
for hazard free state assignments (Huffman (1954a, 1954b)) are reviewed in most
textbooks on digital circuit design (e.g., Kohavi (1970)). More recently, studies on the
subject were done by Masuyama and Yoshida (1977), Sen (1985), Datta et al. (1988),
Nowick and Dill (1991), Fisher and Wu (1993), Chu (1994), Lavagno et al. (1994),
Nowick and Coates (1994), and Lin and Devadas (1995). Evading hazards using a
locally generated clock pulse was introduced by Unger (1977), Nowick and Dill (1991),
and Moore et al. (2000). A graph theoretic approach for state assignment of
asynchronous machines was introduced by Datta, Bandopadhyay and Choudhury (1988).
Of course, all the above studies discuss the hazard free design of asynchronous machines,
and can be applied only before the machine is constructed; only Murphy (1986); Murphy,
Geng and Hammer (2002, 2003); Geng 2003; and Geng and Hammer (2003, 2004a,
2004b) detail methods to overcome hazards in an existing asynchronous machine.
Other early works on the synthesis of asynchronous machines were by Mealy
(1955) and Moore (1956). These works investigated state and circuit equivalence, and
provided methods for synthesizing asynchronous and synchronous sequential machines.
Their models of sequential machines are most commonly used today. In the work done
by Liu (1963), all internal transitions of a machine go directly from unstable states to
terminal states; with no sequencing permitted though stable states. This method of
hazard free assignment (called single transition time state variable assignment) uses
assignments similar to an equidistant errorcorrecting code. This kind of assignment,
which can be accomplished by mapping the rows of a flow table onto the vertices of a
unit ndimensional cube, is not guaranteed minimal, but it works effectively with
incompletely specified flow tables. Tracey (1966) extended this work to techniques that
maximize the speed of the machine. A method for sequencing (though unstable states are
allowed before a stable state is reached when an input character is applied) was presented
by Maki and Tracey (1971), using a technique called the shared row state assignment
method. This method generally required fewer state variables than single transition time
assignments. Other work on hazardfree state assignment techniques can be found in
Hazeltine (1965); McCluskey (1965); Armstrong, Friedman and Menon (1968); Hlavicka
(1970); Mago (1971); Chiang and Radhakrishnan (1990); Lavagno, Keutzer and
SangiovanniVincentelli (1991); Piguet (1991); Oikonomou (1992); Chu, Mani and
Leung (1993); and Fisher and Wu (1993).
Some other techniques for avoiding hazards were proposed by Yoeli and Rinon
(1964) and Eichelberger (1965). They proposed ternary logic models to analyze certain
aspects of the machines. Ternary algebra seems to provide an efficient method for
detection and analysis of hazards in sequential circuits. These models were further
worked on by Brzozowski and Seger (1987, 1989) and Brzozowski and Yoeli (1987).
Another method of avoiding hazards was by generating a clock pulse from other signals
in the machine (Bredeson and Hulina (1971), Whitaker and Maki (1992)).
Most applications of asynchronous machines assume that the environment of
operation is the fundamental mode (Unger (1969)); that is, an input change is applied
only after the machine has reached stability. No input change is allowed when the
machine transits through unstable states. Our study specifies conditions where
fundamental mode is not applicable, leading to what is called semifundamental mode of
operation (Chapter 2). Recent work in asynchronous sequential machines allows the
simultaneous change of several input variables. This mode of operation is referred to as
burstmode (Davis et al. (1993a), Nowick (1993), Yun (1994), and Oliviera et al. (2000)).
Deterministic behavior of the machine in this approach needs special restrictions to be
imposed on the machine.
Plenty of literature is available on the application of control theory to automata and
asynchronous machines under discrete event systems. One such example that can be
readily quoted is supervisory control (Ramadge and Wonham (1987, 1989)). This is
based on formal language theory, and assumes that certain events in the system can be
enabled or disabled. The control of the system is achieved by choosing control inputs
such that the events are enabled or disabled. Literature on discrete event systems is
extensive (Ozveren et al. (1991), Lin (1993), Koutsoukos et al. (2000), Alpan and Jafari
(2002), Hubbard and Caines (2002), Park and Lim (2002)). Our study employs finite
state machines models, which are more suitable to the investigation of engineering
implementations than formal language theory (Dibenedetto et al. (2001)).
Asynchronous machines are widely used in industry, as they result in economical
digital systems. Some examples of industrial applications are the adaptive routing chip
(Davis et al. (1993b)), a cache controller (Nowick et al. (1993)) and the infrared
communications chip (Marshall et al. 1994).
The organization of this dissertation is as follows. Terminology and background is
provided in Chapter 2. A detailed analysis of infinite cycles, detection algorithms, and
the existence conditions are detailed in Chapter 3. This chapter also introduced the
concepts of generalized state machines, and the use of transition matrices and skeleton
matrices in determining the existence of the controller. Chapter 4 gives a detailed
solution to the model matching problem for asynchronous sequential machines with
cycles, and an algorithm for the construction of the controller. Chapters 3 and 4 contain
the necessary and sufficient conditions for the existence of a controller. An example is
solved in Chapter 5, detailing the transition and output functions of the controller states,
and finally, a conclusion and possible directions of further research are provided in
Chapter 6.
CHAPTER 2
TERMINOLOGY AND BACKGROUND
2.1 Asynchronous Machines and States
Here, the background and notation is introduced and the basic theory of
asynchronous sequential machines is described. An asynchronous machine is activated
by a change of its input character; it generates a sequence of characters in response. To
explain the mathematical theory, we introduce the notation and terminology involved in
describing sequence of characters.
An alphabet is a finite nonempty set A; the elements of this set are called
characters. A word w over an alphabet A is a finite and ordered (possibly empty)
string of characters from A. Let A be a finite nonempty alphabet, let A* denote the
set of all strings of characters of A, including the empty string, and let A+ be the set of
all nonempty strings in A*. The length wl of a string w e A* is the number of
characters of w. For two strings wi, w2 e A*, the concatenation is the string w:=
wiW2, obtained by appending w2 to the end of wi. A non empty word wi in A* is a
prefix of the word w2 if w2 = wiw; and wi is a suffix of the word w2 if w2 = w'wl,
where w, w' e A*. A partial function f: S1>S2 is a function whose domain is a
subset of S1 (Eilenberg (1974)).
We now introduce the concept of a sequential machine. A sequential machine
provides a working mathematical model for a computing device with finite memory. It
has the following characteristic properties:
* A finite set of inputs can be applied to the machine in a sequential order.
* There is a finite set of internal configuration that the machine can be in. These
configuration are called states, and physically, these states correspond to the setting
on the flip flop or the bit combinations in memory devices.
* The current internal configuration or state and the applied input character determine
the next internal configuration or state that the machine achieves. For
deterministic systems, the next state is unique.
* There is a finite set of input characters.
There are two broad classes of sequential machines: asynchronous machines and
synchronous machines. An asynchronous sequential machine responds to input changes
instantaneously as they occur. On the other hand, a synchronous sequential machine is
driven by a clock, and the values of input variables affect the machine only at clock
"ticks". The current work concentrates on asynchronous sequential machines. These
machine describe the structure of the fastest computing systems.
An asynchronous machine is defined by the sextuple Y := (A,Y,X,xo,f,h), where
A, Y, and X are nonempty sets, x0 is the initial state, and f: XxA > X and h : XxA
> Y are partial functions. The set A is the set of input values, Y is the set of output
values, and X is the set of states. The partial function f is the recursionfunction and h
is the output function. The operation of the machine is described by the recursion
xk+l = f(Xk, Uk),
yk = h(xk, Uk), k = 0, 1, 2,... (21)
A valid pair (x,u) e XxA is a point at which the partial functions f and h are
defined. We assume that the initial state xo is provided with Y. An input sequence is
permissible when all pairs (xk, Uk), k = 0, 1, 2, ... are valid pairs. The integer k acts
as the step counter. An increment in the step counter takes place with every change of
the input value or with a state transition. For consistency, we assume that the functions
f and h have the same domain. It is clear from the above description that the recursion
(21) represents a causal system. When the output function h only depends on the state
and does not depend on the input, the machine induces a strictly causal system.
If the functions f and h are functions rather than partial functions, the machine is
said to be complete. A deterministic finite state machine is often referred to as the Mealy
machine (Mealy (1955)). If the output function does not depend on the input variable,
then the machine is referred to as the Moore machine (Moore (1956)). An asynchronous
Mealy machine can be transformed into an equivalent Moore machine, and vice versa.
A nondeterministic finite state machine X = (A,Y,X,xo,f,h) has the following
objects:
* A finite, nonempty set A of permissible input characters, termed as the input
alphabet;
* A finite, nonempty set Y of permissible output characters, termed as the output
alphabet;
* A finite, nonempty set X of states of the machine. Any number of the states can
be designates as initial or terminal states;
* A nondeterministic partial transition function f: 3(X)xA > 3(X), where 3(X)
denotes the set of all the subsets of X (i.e., the power set of X);
* A partial function h : XxA > Y, called the output function; and
* The initial state of the machine xo e X.
The transition function f can generate sets of states as its values, i.e., f(x,a) = {xi,
.., xk}, rather than just single values; here xl, .., k E X and a e A. In contrast, the
output function h takes only single values, i.e., there can be only one output character
associated with each state. The class of deterministic finite state machines is a subclass
of nondeterministic finite state machines.
The operation of the machine Y can be described as follows. The machine Y
starts from the initial state xo and accepts input sequences of the form u := uo ul ...
where uo, ui, ... e A. In response to this set of applied input characters, it generates a
sequence of states xo, xl, x2, ... e X and a sequence of output values yo, y1, y2, ... E
Y, according to the recursion in Equation 21.
Finally, the machine Y is an input/state machine when Y = X and the output is
equal to the state at each step, that is,
Yk = Xk, k = 0, 1, 2, ... (22)
An input/state machine Y can be represented by the quadruple (A,X,xo,f), since the
output is the state.
Using the notion of the transition function f, we can define the partial function f*:
XxA+ > X by setting f*(x,u) := f(...f(f(f(x,uo),ul),u2)...,Uk) for some state x E X and
an input string u = uoulu2...uk e A+. Thus, f* provides the value of the last state in the
path generated by the input string u. For simplicity of notation, we will use f for f*.
Some basic terminology important to the study of asynchronous machines is now
described. A valid pair (x,u) e XxA of the machine Y is called a stable combination if
f(x,u)= x, i.e., if the state x is a fixed point of the function f An asynchronous
machine will linger at a stable combination until an input change occurs. A pair (x,v)
that is not a stable combination is called a transient combination. A potentially stable
state x is one for which there is a stable combination. Of course, states that are not
potentially stable serve only as transition states; the machine cannot stop or linger in
them, and they are not usable in applications. Due to this, it is common practice to
ignore states that are not potentially stable; will adhere to this practice and not include
such state in our state set.
Consider the sequential machine Y of Equation 22. Let x be the state of the
machine and u the input value. When a stateinput pair (x,u) is not a stable
combination, the machine Y will go through a chain of input/state transitions, starting
from (x,u), which may or may not terminate. If the machine reaches a stable
combination (x',u) with the same input value, then the chain of transitions terminates.
It must be noted that the input value must remain constant throughout the entire
transition; and the transition will end if and only if such a stable combination as (x',u)
exists. In such a case, x' is called the next stable state of x with input value u. When
the next stable state is not uniquely determined, that is, the transition at some point has
more than one value, we have a critical race. In case there is no next stable state for x
with input value u, we obtain an infinite cycle. Critical races and infinite cycles are the
types of hazards that can occur in an asynchronous machine.
2.2 Modes of Operation
When the value of an input variable is changed while the asynchronous machine
undergoes a chain of transitions, the response of the machine may become unpredictable,
since the state of the machine at which the input change occurs in unpredictable. To
avoid this potential uncertainty, asynchronous machines are usually operated in
fundamental mode, where only one variable of the machine is allowed to change each
time. In particular, in fundamental mode operation, a change in the input variable is
allowed only while the machine is in a stable combination.
One of the main topics of our present discussion relates to the control of an
asynchronous machine in an infinite cycle. When a machine is in an infinite cycle,
fundamental mode operation becomes impossible, since the machine will not reach a
stable combination without a change of the input variable. Nevertheless, we will show
later that, when taking the machine out of its infinite cycle, it is not necessary to forego
fundamental mode operation for more than one step. When an asynchronous machine
operates in fundamental mode in all but a finite number of steps, we say that it operates in
semifundamental mode. The conditions and procedures for operation in semi
fundamental mode is described in Chapter 3.
Consider a defectfree asynchronous machine Y = (A,X,xo,Y,f,h) operating in
fundamental mode. Let the machine start at the state xo, and be driven by the input
string w = vovi...vm1. The machine now has transitions through the states xo,..., xm,
where xi+l = f(xi,vi); i = 0,1,2,...,ml, where the last pair (xm,Vml) is a stable
combination. Fundamental mode operation implies that vi = vi+l whenever (xi,vi) is
not a stable pair, i = 0,...,m1.
Thepath is defined as the set of pairs
P(,xo,w) = {(xo,v0), (x1,v1),...,(xml,vm1), (Xm,vm1)}. (23)
When a cycle occurs, there is no final stable pair, and the path becomes infinite
P(E,xo,w) = {...,(xi,vj), (xi+l,vj),...,(xi+t,vj), (xi,vj),... }.
As mentioned earlier, the step counter k advances one step during each state transition
or input change. Of course, for fundamental mode operation, the input character remains
constant during all transition chains.
Consider the case where the input value of the machine is kept constant at the
character v, while the machine goes through a string of state transitions. At each state
transition, the step counter of the system advances by one. This results in the input value
being represented as a repetitive string vvv... v, where each repetition corresponds to an
advance of the step counter. It is convenient to represent all such repetitions of the input
character by a single character, so that, for example, a string of the form w =
vovoviviviv2V2 is represented by w = voviv2. Here, it is understood that each input
value is repeated as many times as necessary. In the case of an infinite cycle, the input
value is repeated indefinitely.
Next, let Y be an asynchronous machine without hazards. Then, the notion of the
next stable state leads to the notion of the stable transition function, which plays an
important role in our discussion. As the machine Y has no hazards, every valid pair
(x,u) of Y has a next stable state x'. Define a partial function s : XxA > X by setting
s(x,u) := x' for every valid pair (x,u), where x' is the next stable state of x with the
input character u. The function s is called the stable transition function of the machine
Y. Note that the stable transition function describes the operation of the machine in the
fundamental mode, i.e., under the requirement that the input value be changed only after
the machine reaches a stable combination. This is a standard restriction in the operation
of asynchronous machines, and it guarantees that the machine produces a deterministic
response.
The stable transition function can be used to describe the operation of an
asynchronous machine Y in the following way. We know that the machine always
starts from a stable combination (xo,u1), at which the machine has been lingering for
some time. Suppose now that an input string u := uoul...Uk e A+ is applied to the
machine. Then, the machine moves through the a list of states xl, ..., xk+l of next
stable states, where xi+1 = s(xi,ui), which implies that (xi+l,ui) is a stable combination
for i = 0, 1, ..., k. The input list u ispermissible if (xi,ui) is a valid combination for i
= 0, 1, ..., k. Since the machine operates in the fundamental mode, the input character
changes from ui to ui+l only after the stable combination (xi+1,ui) has been reached.
This guarantees that the state of the machine is well determined at the time when the
input value changes.
In general, when a machine does not have infinite cycles, the intermediate
transitory states are ignored, as they occur very speedily and are not noticeable by a user.
Thus, the operation of an asynchronous machine without infinite cycles, as observed by a
user, is best described by the stable transition function s. However, when the machine
has infinite cycles, it is not possible to ignore the transitory states involved in the cycle,
as the machine lingers among these transitions indefinitely. In Chapter 3, we will
introduce a generalized notion of the stable transition function which accommodates
infinite cycles by considering them as another form of persistent states.
Using the stable transition function s, we define the asynchronous sequential
machine XIs := (A,X,Y,xo,s,h), which is called the stable state machine induced by X.
For an input/state machine, the stable state machine is given by the quadruple (A,X,xo,s).
To deal with input strings, we can define a partial function s* : XxA+ > X by
setting s*(x,u)= s(... s(s(s(x,uo),ul),u2)...,Uk), for some state x E X and a permissible
input string u = uouI...Uk e A+. The partial function s* provides the last state in the
path generated by the input string u. As before, we shall abuse the notation somewhat
by using s for s*.
In the case where we do not have a Moore machine, we can define the partial
function h* : XxA+ Y in a similar fashion by setting h*(x,u) :=
h(... s(s(s(x,uo),ul),u2)...,Uk) for a state x e X and a permissible input string u=
uoui...Uk e A+, as was done for the stable transition function s defined earlier. The
partial function h* gives the last output value generated by the input list u.
It is necessary in some cases to compare different states of a sequential machine.
Two states x and x' of a machine Y are distinguishable if the following condition is
valid: there is at least one finite input string which yields different output sequences when
applied to Y starting from the initial states x or x'. Two states x and x' of the
machine Y are equivalent when, for every possible input sequence, the same output
sequence is produced regardless of whether the initial state is x or x'. Qualitatively,
two states are equivalent if we cannot distinguish them by the input/output behavior of
the machine. If two states are equivalent, then so are all corresponding states included in
any paths started from x and x'. If a machine Y contains two equivalent distinct
states, then one of the states is redundant, and it can be omitted from the mathematical
model of the machine. A machine Y is minimal or reduced if it has no distinct states
that are equivalent to each other.
Consider two machines Y = (A,Y,X,f,h) and 2' = (A',Y',X',f,h'). Let x be a
state of Y and let x' be a state of Y'. The states x and x' are equivalent if both have
the same permissible input sequences, and if, for every permissible input sequence, the
output sequence generated by Y from the initial state x is the same as the output
19
sequence generated by 2' from the initial state x'. The two machines Y and 2' are
equivalent whenever there exists an equivalent state in Y for every state in 2', and
similarly, an equivalent state in Y for every state in Y'. A number of texts dwell on the
various aspects of the theory of sequential machines and automata, including McCluskey
(1965); Arbib (1969); Kalman, Falb and Arbib (1969); Kohavi (1970); Eilenberg (1974);
and Evans (1988).
CHAPTER 3
INFINITE CYCLES
3.1 Introduction
An infinite cycle is caused when there is no next stable state for a valid pair (x,u)
of a finite state asynchronous machine Y = (A,X,xo,Y,f,h). In such case, the machine
will keep moving indefinitely from one transient combination to another. Only a finite
number of states can be involved in these transitions, since Y is a finite state machine.
An infinite cycle can then be characterized by listing these states and the corresponding
input which causes the infinite cycle. Specifically, let the state set of Y be X = {x1, x2,
...,xn. Consider a infinite cycle p of Y that involves p states, say the states xkl, xk2
..., xk e X, and let a e A be the input character causing the infinite cycle. The infinite
cycle then functions according to the recursion
xkj+1 = f(xkj, a), j = 1,..., , and
xkl = f(xk, a). (31)
As a shorthand notation, we will use p = a;xkl, xk2, ..., xke}, where a is the input
character of the infinite cycle, and xk xk2, ..., xk are its states. A stateinput pair (xkj
,a), for some j = 1, ..., is then said to be apair of the cycle p. The length of the
infinite cycle p is defined as the number of distinct states it contains. It follows that a
cycle of length has distinct inputstate pairs. A brief examination of Equation 31
leads to the following conclusion: Let (x,a) be any pair of the infinite cycle p. Then, x'
is a state of p if and only if there is an integer j such that x' = fJ(x,a). Then, the
recursion can be followed for the entire length of the cycle. It is convenient to denote by
{fi(x,a)}j=o the set of all distinct states included in the set {x, f(x,a), f2(x,a), ...}. This
leads us to the following lemma.
Lemma 31 Let (x,a) be any pair of the infinite cycle p. Then, the state set of p
is {fi(x,a)}jo.
Lemma 31 gives a way of finding the states of a cycle. A machine can have
several infinite cycles, and we demonstrate below an algorithm that finds all infinite
cycles of a given machine. It is relevant to see that an infinite cycle of length 1 is
nothing but a stable combination. To distinguish between infinite cycles and stable
combinations, the length of an infinite cycle must at least be 2. According to the next
statement, infinite cycles associated with the same input character must have disjoint
state sets.
Lemma 32 A valid input/state pair (x,a) of an asynchronous machine Y can be a
member of at most one infinite cycle.
Proof 32. Let pl and p2 be two infinite cycles of the machine Y associated
with the same input character a. If pi and p2 contain the same pair (x,a), then, using
Lemma 31, we conclude that pi and p2 have the same state set. In other words, p1 =
p2, and our proof concludes. *
The above Lemma 31 gives us an insight into the structure of the cycle. Since no
state can be a member of more than one cycle, we can say that a pair of a cycle is unique
to that cycle. We can now find a bound on the maximal number of infinite cycles a
machine can have. Indeed, consider the set of all infinite cycles involving the input
character a. In view of Lemma 32, all such infinite cycles have disjoint state sets. But
then, the fact that a infinite cycle must contain at least 2 states, implies that there cannot
be more than n/2 such infinite cycles, where n is the number of states of the machine.
Finally, recalling that the machine has m input characters, we obtain the following.
(Denote by [a] the largest integer not exceeding a.)
Proposition 33 Let Y be a sequential machine with n states and an alphabet A
consisting of m characters. Then, Y cannot have more than m[n/2] infinite cycles. *
For the sake of brevity, "infinite cycles" will be referred to as just "cycles" in the
rest of the document.
3.2 Detection of Cycles
In this section, a procedure to detect the cycles associated with a machine will be
outlined. Consider an asynchronous machine Y = (A,X,xo,Y,f,h) with n states and an
alphabet A of m input characters. Next all the cycles of the machine Y will be
determined. To this end, an nxn matrix M(f) is recursively constructed as follows.
The (i,j) entry of M(f) is the set of all characters u e A for which xi= f(xj,u). If
there is no input character u e A for which xi = f(xj,u), then the (ij) entry of M is
denoted F, where F is a character not included in the alphabet set A. Thus, the matrix
becomes
u E A:xi = f(xj,u),
Mi,j(f) := (32)
F otherwise,
i, j = 1, ..., n. Multiple entries in a cell are separated using a comma. We refer to M(f)
as the onestep transition matrix of the machine E.
We now define two matrix operations for onestep transition matrices. First, the
sum of two nxn onestep transition matrices A and B is defined element wise by
(A U B)j := Aij U Bij, i, j = 1, ..., n. (33)
The sum operation is reminiscent of the numerical addition of matrices. The
following operations on members of the set A U F is now defined.
uFF:= F
uui := F
Ful := uF
Uu2 := r
FU := (34)
ui U := ui
ui Uui := F
ui U u2 :=
Also, for any two sets, the operation of multiplication is defined by
{al, a2, ..., aq}.{bi, b2, ..., br = {aibj}i= ,...,q,j=I ...,r
This is similar to the classical definition of the scalar product of two vectors. Using these
operations of multiplication, the definition of matrix combination is defined as follows.
(AB)ij := Uk=l,...,nAikBkj for all i, j = 1, ..., n. (35)
Consider two functions g, h : XxA > X. The composition of g and h is defined
by gh(x,u) := g(h(x,u),u). The composition of function is closely related to the
combination of the corresponding onestep transition matrices, as indicated by the
following. The next statement shows that the multiplication of two onestep transition
matrices on two recursion functions is the transition matrix on the composition of the two
functions.
Lemma 34 Let g, h : XxA > X be two recursion functions with one step
transition matrices M(g) and M(h), respectively. Then, M(g)M(h) = M(gh).
Proof 34. Using Definition 34, we have
M(g)M(h) = Uk=l..n Mi,k(g)Mk,j(h). (36)
Now, each entry of M(g)M(h) is either a character of A or F; the definition of matrix
composition implies that the following two statements are equivalent:
(i) The (ij) element of M(g)M(h) is u.
(ii) There is a k e {1, ..., n} for which Mi,k(g)= u and Mkj(h) = u.
When (ii) holds, we have xi = g(xk,u) and xk = h(xj,u), so that xi = g(h(xj,u),u) =
gh(xj,u). Then, the (i,j) entry of M(gh) is u. Conversely, if the (ij) entry of M(gh)
is u, then xi = gh(xj,u), so that xi = g(h(xj,u),u). Now, the value h(xj,u) is, by
definition, an element of X, say the element xk, k e {1, ..., n}. Then, xk = h(xj,u) and
xi = g(xk,u), which implies that (ii) is valid for this k. Thus, we have shown that (ii) is
equivalent to
(iii) Mij(gh) = u.
Using the fact that (ii) is equivalent to (i), the Lemma follows. *
Thus, the product of two transition matrices with two different transition functions
is the transition matrix of the composition of the two functions in the order of
multiplication. Consider now the a machine Y with recursion function f. Let M(f) be
its onestep transition matrix. Then, by Lemma 34, M(f)M(f) = M(f2), M(f2)M(f) =
M(f3), and so on. This leads to the following corollary.
Corollary 35 Let Y = (A,X,xo,Y,f,h) be an asynchronous machine. Then, for
every integer p > 0, the onestep transition matrix satisfies MP(f) = M(fP). *
Consider a machine Z = (A,X,xo,Y,f,h). As mentioned earlier, a stable
combination (x,u) of Y can be considered as a cycle of length 1. This observation
helps simplify the following statement, which forms an important tool in our process of
finding all cycles of the machine Y.
Lemma 36 Let Y be an asynchronous machine with the recursion function f and
the state set X = {x1, ..., xn}. Let xi e X be a state and let u be an input character of
Y. Then, the following three statements are equivalent.
(i) There is an integer c > 1 such that xi = f(xi,u)
(ii) u appears on the (i,i) diagonal entry of the matrix Mt(f).
(iii) (xi,u) is a pair of a cycle whose length X is an integer divisor of c.
Proof 36. First, we show that (i) implies (ii). Assume that (i) is valid, so that xi =
ft(xi,u) for some integer c > 1. Then, by Equation 32, the character u appears on the
diagonal entry (i,i) of the matrix M(ft). By Corollary 35, M(f) = MZ(f); this implies
that u appears on the diagonal entry (i,i) of the transition matrix MZ(f).
Next, we show that (ii) implies (iii). Let k > 1 be the smallest integer satisfying
xi = f(xi,u). Then, < Tc. Now, if k = 1, then (xi,u) is a stable combination of Y, and
hence forms a cycle of length 1. Otherwise, (xi,u) is a pair of the cycle {xi, f(xi,u), ..,
fl1(xi,u); u} of length k.
Now, using the integer division algorithm, we can write c = qX + p, where q and
p are integers and 0 < p < k. If p > 0, then, using the equality xi = f(xi,u), we can
write xi = f(xi,u) = fP(fq(xi,u),u) = fP(xi,u), so that xi = fP(xi,u). The latter contradicts
the fact that X was the smallest integer satisfying xi = f(xi,u), since 0 < p < k. Thus,
we must have p = 0, and X must be an integer divisor of c.
Finally, we show that (iii) implies (i). Assume that (iii) is valid, i.e., that (xi,u) is a
pair of a cycle whose length k is a divisor of c. Then, there is an integer q such that c
= qk. But then, ft(xi,u) = fq(xi,u) = xi, and (i) is valid. This concludes the proof.
Thus, by taking the powers of the onestep transition matrix M(f) and observing
the diagonal matrix at each step, the states of the machine involved in cycles can be
isolated. The next lemma indicates a method of identifying the elements of each cycle.
Lemma 37 Let Y be an asynchronous machine with state set X = {x, ..., xn}
and recursion function f. Assume that Y has a cycle of length k > 1 that includes the
pair (xJo,u). Then, the other states xJi, ..., xJi1 of the cycle can be found from the matrix
M(f) in the following way: for every integer i = 0, ..., k2, the index ji+l is given by the
position of the entry u in the column ji of the matrix M(f).
Proof 37. Consider a cycle of length > 1. Let {xJo, xi1, ..., xJ 1} be the states
involved in the cycle, and let u be the input character. We know f(xio,u) = xJ. This
implies that the input character u appears exactly in the position (jo, j ) of the matrix
M(f). Thus, the value of ji is given by the position of the character u in the row jo.
Continuing recursively, assume that, for some 0 < k < X, the indices jo,, ..., jk of the
states xJo, xJi, ..., xJk of the cycle have been found. Then, since xJk+1 = f(xJk,u), the
character u will appear exactly in position jk+l of the row jk of the matrix M(f). This
concludes our proof.
Thus, the knowledge of the states involved in cycles of a particular length can be
used to find the cycles specifically by applying Lemma 37. An algorithm that finds all
the cycles of an asynchronous machine Y whose recursion function is f will now be
outlined. Let #A denote the number of elements in the set A.
Algorithm 38 Let Y = (A,X,xo,Y,f,h) be an asynchronous machine, and let M(f)
be its transition matrix.
Step 1: All entries on the main diagonal of M(f) represent stable combinations
(i.e., cycles of length 1). For each input character u e A, let Ai(u) be the set of all
states for which u is included in a diagonal entry of the matrix M(f); set 41(u) := A(u).
Step 2: For i > 2, let Ai(u) be the set of all states for which u is included in a
diagonal entry of the matrix Mi(f). Define the difference set
si(u) := Ai(u) \ UI <
Stop the algorithm for the character u when i+1 > n 1 #aj(u). *
The significance of Algorithm 38 is pointed out by the following statement.
Proposition 39 Let i > 1 be an integer. Then, in the notation of Algorithm 38,
the following are true.
(i) The set 4i(u) consists of all states of the machine Y that are members of cycles
of length i with the input character u.
(ii) The machine Y has exactly #,i(u)/i cycles of length i.
Suppose there are 2X states in 4j(u). This means there are 2 cycles of length k
in the machine. Pick one state from 4j(u); use Lemma 37 to find the other k1
members of that cycle. Now, pick another state from the k remaining states in 4j(u),
and using Lemma 37, the second cycle can be determined. This procedure is extended
to any number of cycles of a certain length.
Proof 39. Let X = {x1, ..., xn} be the state set of Y, and let u e A be a character
of the input set. By Lemma 36, the following two statements are equivalent:
(a) The matrix Mi(f) has an entry including u on its main diagonal, in a column
that corresponds to the state xr of y.
(b) The state xr is a member of a cycle whose length is i or an integer divisor of
i.
The case i = 1 is simple, since the elements on the main diagonal of M(f)
represent the stable combinations of the system, and whence the cycles of length 1. For i
> 1, assume that the algorithm has not stopped before i, i.e., that i < n Y' #8j(u).
Then, a slight reflection shows that the construction Equation 37 of ,i(u) removes all
states that are included in cycles of length less than i. Combining this with the
equivalence of (a) and (b), it follows that xr E 4i(u) if and only if xr is a member of a
cycle of length i.
Finally, consider the case where i+1 > n '1 #aj(u), and u(u) be the number of
states of Y that are members of cycles of length k < i with the character u. From the
definition of 4j(u), it follows that u(u) = '1 #aj(u). Thus, when i + 1 > n u(u), there
are not enough states left to form a cycle of length i + 1 with the character u; whence
the machine Y has no cycles of length greater than i with the character u. This
completes the proof of part (i) of the Proposition.
Regarding part (ii) of the Proposition, note that the set ,i(u) consists of all states
that form cycles of length i with the input character u. By Lemma 32, no two cycles
can have common states. Consequently, the number of elements of ,i(u) is a multiple
of i, and the number of cycles in 4i(u) is given by #,i(u)/i. This concludes our proof.
3.3 Stable State Representations for Machines with Cycles
In this section, a form of representation of only the next stable states and the
extension of the definitions to the case of a machine with cycles will be explained. For
an asynchronous machine Y = (A,X,Y,xo,f,h) without cycles, a valid pair (x,u) always
has a next stable state x'. Consequently, for such a machine, one can define a partial
function s : XxA X by setting s(x,u) = x' for every valid pair (x,u). The function s
is then called the stable recursionfunction of the machine Y. When s is used as a
recursion function, it induces the stablestate machine Is = (A,X,Y,xo,s,h). The stable
state machine describes only persistent states of the machine, and ignores unstable
transitions. This function describes the behavior of Y as experienced by a user, i.e., the
transition of the machine to its next stable state is described. A reformulation of the finite
state machine with cycles will now be explained, so that an equivalent stable state
machine can be described from this reformulated machine.
As mentioned earlier in Chapter 2, asynchronous machines are normally operated
in fundamental mode. In specific terms, fundamental mode operation is as follows. Let
Y be an asynchronous machine without cycles, resting in a stable combination (x,uo).
Consider a string of input values u = ui...Uk e A' applied to the machine. When the
input of X switches to ui, the machine may engage in a string of transitions culminating
in the next stable state s(x,ul). In fundamental mode operation, the input character ui is
kept fixed until the machine has reached its next stable state, to guaranty deterministic
behavior. Then, once the machine reaches the stable combination (s(x,ul),ul), the input
character is switched to u2, and the machine eventually settles on its next stable state
s(s(x,ul),U2). This process continues until we reach the final input value uk. The last
stable state reached in this process is given by x" := s(... (s(s(s(x,uo),ul),2)...,Uk). To
simplify our notation, we shall write in brief x" := s(x,u).
As mentioned earlier, the stable state machine describes persistent states of an
asynchronous machine. For machines with cycles, a cycle describes a persistent state of
the machine (i.e., the "state" of being in a cycle). Hence, when cycles are present, they
must be represented in the stable state machine. Our next objective is to generalize the
definition of the stable state machine, so it gives due representation to cycles, whenever
they are present.
Consider an asynchronous machine X = (A,Y,X,xo,f,h) having t > 0 cycles pi,
..., pt. To define a stable state machine XIs that represents the persistent behavior of X,
we first augment the state set X of X by t new elements xn+1, ..., xn+t to obtain the
augmented state set
XP := X U {xn+l, ..., xn+t}. (38)
Each one of the new states, called the cycle states, corresponds to one of the cycles
of X, i.e., xn+i corresponds to the cycle pi, i = 1, ..., t.
Define the function s' : XxA XP by setting
{s(x,u) if x e X and (x,u) is a stable combination,
sl(xu = (39)
xn+ if (x,u) e pi.
For a cycle p = {xkl, xk2, ..., xkp;a}, ki e [1,...,n], denote
sl[p,u] := {s(xk,u), sl(xk2,u), ..., sl(xkp,u)}. (310)
Now, the function s2 : XPxA XP is defined by setting
s(xu) if x e X,
s2(x,u) := i x (311)
s [pi,u] if x = xn+
The generalized stable state machine EIs of Y is then the input/state machine
defined by quintuple (A,XP,xo,s2). For the sake of notational convenience, we will omit
the primes from s2 in the future, and write YIs = (A,XP,xo,s). The function s is called
the generalized stable recursion function of E.
A cycle p associated with a cycle state x is said to be stoppable if there exists an
input character u e A such that at least one of the outcomes of s(x,u) e X. In the
present work, we assume that all the cycles are stoppable. It is necessary to make this
assumption; if not, there will be no controller that can stop the cycle.
Note that when there are no cycles, the generalized stable recursion function of X
is identical to the stable recursion function of Y. Let cs, be the generalized stable state
machine induced by the closed loop system Ec shown in Figure 11. The present work
concentrates on finding the solution to the next statement; consequently, this statement is
the main topic of our discussion.
The Model Matching Problem 310 Let X be a machine and let X' be a stable
state machine with the same input and output alphabets as E. Find necessary and
sufficient conditions for the existence of a controller C such that the generalized stable
state machine Ecs = E'. When C exists, provide a method for its design. *
The controller C of Problem 310 assigns to closed loop system the stable state
behavior of the specified machine X'. Of particular interest to us here is the case where
the machine X has infinite cycles. In such case, the controller C of 310 eliminates the
effect of infinite cycles on the closed loop system. The model matching problem for
asynchronous machines with critical races, but not infinite cycles, was discussed in
Murphy 1996, Murphy, Geng and Hammer 2002, 2003, Geng 2003 In the following
section, a solution for the model matching problem for the case where the controlled
system X has infinite cycles is derived, and in Chapter 5 the design of an appropriate
controller is demonstrated by means of an example.
3.4 Stable Reachability
The extension of the stable state machine to machines with cycles will now be
described. This requires a reformulation of the machine. Consider an asynchronous
machine X represented by the sextuple (A,Y,X,xo,f,h), and assume that X has t > 0
cycles pi, ..., pt. Let Xis = (A,XP,xo,s), where XP X U {xn+l, ..., xn+t}, and xn+i is the
generalized state corresponding to the cycle pi. We aim to define the notion of stable
reachability for the machine X so as to characterize the "stable" states X can reach from
a given initial condition, in response to various input strings. To this end, we need to
define several notions. A generalized stable combination of the machine X is either a
stable combination of X or a pair of the form (xn+i,u), where u is the input character of
the cycle pi. A state of XIs is potentially stable if it is part of a generalized stable
combination of X.
When applying a control input to a machine that is in an cycle, it is not possible to
operate in the fundamental mode. The input character must be changed while the cycle is
in progress in order to attempt to interrupt the cycle. In other words, the input character
is changed while the machine is not in a stable combination. Of course, if this change in
input leads the machine to a stable combination, then fundamental mode operation can be
resumed from there on. We arrive at the following notion, which describes the mode of
operation that is closest to fundamental mode operation.
Definition 311 A machine X is said to operate in semifundamental mode if the
machine operates in fundamental mode when it is not in an cycle. *
Recall that the states of the generalize stablestate machine XIs are either
potentially stable states of X or cycle state that represent cycles. Thus, semi
fundamental mode operation of X becomes fundamental mode operation of XIs.
Definition 312 Let X be an asynchronous machine with generalized state set XP
and generalized stable recursion function s. A state x' e XP is stably reachable from a
state x e XP if there is a input string u =uoui...uk of X for which x'= s(x,u). *
The following assumption is essential in determining the controller operation. If an
input character forms a valid combination with one outcome of a critical race, then it
forms a valid combination with all other outcomes of the same race. This assumption can
always be satisfied by extending the definition of the recursion function of the machine.
It is necessary to assume this statement because we need the controller to be operational
will all outcomes of the critical race that follows the cycle.
3.5 Matrix of Stable Transitions and the Skeleton Matrix
Consider an asynchronous machine Y = (A,Y,X,xo,f,h) with the state set { x1, ...,
xn}, and assume that Y has t > 0 cycles pi, ..., pt. Let is = (A,XP,xo,s), where XP=
X U {xn+l, ..., xn+t} and xn+i is the generalized state corresponding to the cycle pi. Let
sx(xJ,xi) be the set of all characters u e A such that x1i s(xi,u). The matrix of onestep
generalized stable transitions gives all the possible stable onestep transitions of the
machine is; it is an (n+t)x(n+t) matrix R(is), whose (i,j) entry is given by
rsx(xJ,xi) if sx(xJ,xi) # 0,
Rij(s) (312)
SN otherwise,
i, j = 1, ..., n+t. Recall that, if xJ is a generalized state, then a critical race may occur
when an input character u is applied at xJ. This race is represented in the matrix R(Yis)
by the appearance of the character u in more than one row of column j. Note that
Equation 312 is similar to Equation 32, except for the fact that R(Yis) has some
augmented states instead of cycles. We turn now to a description of some operations on
the matrix R(Yis).
Let A* be the set of all words over the alphabet A. The operation of unison / is
defined over the set A* U N as follows. Let wi, w2 be either subsets of the set A* or
the character N; then, set
wI U w2 if w1 c A* and w2 c A*,
w1 if w1 c A* and w2 =N,
wi W w2 := (313)
w2 if w = N and w2 c A*,
N if w = w2 = N.
Extending this definition to matrices, the unison C := A 1 B of two nxn matrices
A and B is defined by Cij := Aij J Bij, i, j = 1, ..., n, i.e., an elementwise operation as
defined in Equation 313
As usual, the concatenation of two words wi, w2 e A* is given by wiw2, i.e., wl
followed by w2. For elements wi, w2 are elements of A* or the character N, the
concatenation is defined as follows.
WiW2 if Wl, W2 e A*,
conc(wi,w2) := N if N o 2 N. (314)
N if w, =N or w2 =N.
More generally, let W = {wi, w2, ..., Wq} and V = {vI, v2, ..., Vr} be two
subsets, whose elements are either words of A* or the character N. Define
conc(W,V):= Ui=l,...,q conc(wi,vj). (315)
j=l,...,r
Note that the concatenation is either a subset of A*, or it is the character N. The
concatenation is noncommutative, and N takes the place of a "zero".
Let C and D to be two nxn matrices whose entries are subsets of A* or the
character N. Let Ci and Dij be the (i,j) entries of the corresponding matrices. Then, the
product Z := CD is an nxn matrix, whose (i,j) entry Zj is given by
Zij := L lconc(Cik,Dkj), ij = 1, ..., n. (316)
Using this notation, we can define powers of the onestep transition matrix
recursively, by setting
RW(ls) := RW (Els)R(ils), t = 2, 3, ... (317)
The matrix R"(EXs) has the following physical significance. The (ij) element of
R"(Yls) is the set of all input strings that take xJ to xi in exactly [t steps. Thus, R"(Yls)
is called the matrix ofu step stable transitions. This follows from Corollary 35, which
states that the powers of the onestep transition matrix is equal to the transition matrix of
the powers of the recursion function, i.e., the steps of the transition matrix.
Define the matrix
R(")(EIs) := Uk=l... Rk(ls), v=2,3,...,(n+t1). (318)
By construction, the (i,j) entry of R( )(Ys) consists of all strings that can take the
machine Yls from the state xJ to the state x1 in [t or fewer steps. The following
statement is important to our discussion; the proof is similar to that of Murphy, Geng and
Hammer, 2003, Lemma 39.
Lemma 313 The following two statements are equivalent:
(i) There is an input string that can take the machine Yls from the state xi to the
state x1.
(n+t1)
(ii) The ij entry Rij (Ys) N. *
Now, R(n+t1)(Yls) contains not only the stable transitions, but also the critical races
that are cause when an input character is applied to a cycle state. To satisfy the model
matching problem, we need a matrix for which the same input string does not lead to
multiple outcomes. This is achieved by modifying the above matrix. This modified
matrix is at the center of our discussion.
Definition 314 Let Y be an asynchronous machine. The matrix of stable
transitions T(Is) is constructed by performing the following operation on each column
of the matrix R(n+t1)(Yis): remove all occurrences of strings that appear in more than one
entry of the column; if empty entries result, replace them by the character N. *
To understand the significance of the matrix T(Is), it is instructive to compare it to
the matrix R(n+t1)(lsi). A string u in the (ij) entry of the matrix R(n+t1)(lis)
indicates, of course, that u takes Is from xJ to xi. However, if the string u appears
in another entry in column j of R(n+t1)(YIs), say in entry k, then the same string may
also take YIs from xi to xk; this indicates a critical race. The construction of the matrix
T(ls) removes then all transitions that involve critical races. As a result, an input string
u that is included in the (i,j) entry of T(Is) takes the machine YIs from the state xJ to
the state xi, and to no other state.
Definition 315 Let Y be an asynchronous machine with the generalized state set
{x1, ... xn+t}. A generalized stable transition from a generalized state xi to a generalized
state xi is a uniform transition when one of the following is true: (i) xi can be reached
from xJ without passing through a critical race, or (ii) there is a succession of critical
races through which xi can be reached from xJ for all possible race outcomes. *
Note that in case (ii) of Definition 315, the input string applied to the machine may
depend on the outcomes of the critical races encountered by the machine along its way
from the state xJ to the state xi. Specifically, let x(k,p) be outcome k of race p along
the way from xJ to x1. The input string applied to the machine will then be a function of
the outcomes u(x(kl,,l1), ..., x(ki,,,pl)) The set Ua= 1...,ru(x(kr,l,1), ..., x(kr,,pr,)) is
(i,j) transition set, where r is the number of possible input strings taking into account all
the critical races encountered in the path from xJ to xi. This means that pr races are
encountered in the path followed by the rth string, and x(kr,,pr,) is the outcome kr,p of
the race pr. Further, By construction, the elements of T(Is) will contain sets of strings
that satisfy the following proposition.
Proposition 316 The (i,j) entry of T(Is) is different from N if and only if there
is a uniform transition from xJ to xi. Furthermore, if the (i,j) entry of T(Is) is not N,
then it includes an (i,j) transition set. *
Thus, depending on the sequence of critical races that occur, the entries of T(Is)
gives a set of strings that can be used for the control process. The skeleton matrix is now
defined as follows matrix:
Definition 317 Let T(Is) be the matrix of stable transitions of the generalized
stable state machine Is. The skeleton matrix K(X) of Y is a matrix of zeros and ones,
whose (ij) entry is given by
ri if Tij(s) N,
Kij() = I (319)
0 otherwise
i= 1,...,n,j = 1,...,n+t. *
The skeleton matrix K(X) has a simple interpretation. In view of Lemma 313, the
following is true
Proposition 318 Let K(X) be the skeleton matrix of a given machine Y. Then,
the (ij) entry of K(X) is 1 if and only if there exists a string that takes the machine XIs
from the generalized state xJ to the state xi and to no other state. *
The skeleton matrix plays a critical role in our discussion, reminiscent of the role it
played in Murphy, Geng and Hammer 2002, 2003
3.6 Corrective Controllers
The basic considerations in the construction of a corrective controller and its
limitations for asynchronous input/state machines will now be outlined. Let X be an
asynchronous machine, being controlled in the configuration Figure 11 with the
controller C. Recall that Yc denotes the closed loop machine of Figure 11; let Xcs be
the stable state machine induced by Yc. Now, let X' = (A,X,xo,s') be a stable state
input/state machine, with the same input set and the same state set as the machine Y.
Referring to the configuration Figure 11 and the Model Matching Problem 310, we are
investigating the existence of a controller C for which cs, = X'.
Consider the input/state machine X = (A,X,X,f,h) and the controller C =
(AxX,A,E,4,r). Let the generalized stable state machine associated with X be X1s. As
shown below, the controller C will operate in the semifundamental mode: when the
controlled machine X moves toward a stable combination, the controller C will operate
in fundamental mode it will keep its output value constant until X has reached its next
stable combination; however, if X moves into an infinite cycle, the controller has no
choice but to change its output value while X is cycling otherwise, X will remain in the
cycle forever. In this case, the controller operates in the semifundamental mode.
Recalling that Y has the state set X and that C has the state set E, it follows that
the composite machine Yc of Figure 11 has the state set XxE. We can then represent
Ec by the quintuple (A,X,XxE,fc,hc), where fc is the recursion function of Yc and he
is its output function. Being an input/state system, the machine Y has the output
function h(x,u) = x. As the output of Yc is the same as the output of Y, it follows that
hc(x,,,v) = x. Formally, let 7tx: XxEX : 7Tx(x,) > x be the standard projection.
Then, we have he = 7tx.
Now, let y be the recursion function of cIs. We know that the output of cs, is
the state of Y. So, if cIs = Y', then, for every valid pair (x,v) of Y', there is a state e
E for which (x,i,v) is a valid pair of c,s. This leads to the conclusion
hcy(x,,,v)= s'(x,v), (320)
and, using the equality he = 7x, we obtain 7Txy(x,,,v) = s'(x,v). Note that, if s' is not
constant over one of the cycles, then the response of the closed loop machine will depend
on the state of the cycle at which the input character is applied, creating a critical race. In
other words, in order for the response of the closed loop system to be deterministic, the
stable recursion function of the model must be constant over each cycle of the controlled
machine Y. To state this fact formally, consider a cycle p = {xkl, xk2, ..., xkp;a}, ki E
[1,...,n], of the machine Y. Let s'{p) := {s'(xk,a), ..., s'(xkp,a)}, i.e., the set of values of
s' over the cycle. We say that s' is constant over the cycle p if all members of the set
s'{p} are identical.
Proposition 319 Let Y and 2' be two machines, where 2' is a stable state
machine. Assume that there is a controller C such that c Is = Y'. If the closed loop
machine cs, has a race free response, then the recursion function s' of the model 2' is
constant over every cycle of Y. *
We are now ready to state one of the main results of our discussion. The following
theorem deals with the fundamental conditions for the existence of a model matching
controller (compare to Murphy, Geng and Hammer 2002, 2003, Theorem 4.3). Before
stating the theorem, we need some notation. For a cycle state z e XP, let p(z) = {a; xk,
xk2, ..., xkp}, ki e [1,...,n], be the corresponding cycle, and let 7Txp(z) := {xkl, xk2, ..., xkp
} be the states of the cycle. Define
i z if z is a regular state,
P(z)= (321)
t=xp(z) if z is a cycle state.
Note that (p(z) is always a set of regular states, not cycle states.
Theorem 320 (Existence of Controller) Let Eis = (A,XP,xo,s) be the generalized
stable state machine induced by an input/state machine Y = (A,X,xo,f). Let z1, ..., zk be
generalized states of Eis and let U1, ..., Uk be sets of input characters such that zlxU1,
z2xU2, ..., zkxUk are distinct sets of valid pairs of is. For each i = 1, ..., k, let z'i be a
state of Y that is stably reachable from the generalized state z1. Then, there exists a
controller C for which cs, is equivalent to a stable state machine 2' = (A,X,xo,s'),
whose recursion function s' satisfies
(i) s'[p(zi),Ui] = z'i for all i = 1,...,k, and
(ii) s'(x,t) = s(x,t) for all (x,t) e XxA / Ui=1 ...,k ZixUi.
Moreover, the closed loop system Yc is well posed, and it operates in the semi
fundamental mode.
Proof 320. By Proposition 319, the recursion function of the model is constant
over all cycles of the machine Y. Thus, since z'i is stably reachable from the
generalized state zi, there exists a string wi e A+ such that s(zi,wi) = z'i, where s is the
stable recursion function of Y. Let m(i) be the length of wi; write wi = v ...vm(i)1
where vo, v., ..., vm(i) are individual characters of the input alphabet A and i = 1,...,
k. With this input string wi, the recursion function s generates a string of generalized
states, which we denote by
xi, := s(zi,vi),
xi,2 := s(x l,v ), ...,
xi,m(i) := s(xi,m(i)2vm(i)2),
:= s(xim(il,vm(il), i = 1, ..., k. (322)
Let U(zi) c A be the set of all input characters that form stable combinations with
the generalized state zi, i = 1, ..., k. Define the following sets:
S := Ui=1, ..., k ziU(zi),
V := Ui=l, ..., k zixUi, (323)
where Ui are the input character sets given in the statement of the Theorem. Then, a
controller C = (AxX,A,E,4,r) that satisfies the requirements of Theorem 320 can be
constructed as follows.
(i) The state set E of C has 2 + lm(i) states given by
= 1, El im(1) 1 m(2) m(k)} (324)
^ 05 0, 1. 5' 2'!$ ' ^2! , '*' ^' **' k (324)
The significance of these states is explained below.
(ii) The initial state of the controller C is o0. The controller moves to the state
j1 upon the detection of a stable combination with one of the generalized states zl,..., zk
e XP. Note that, for cycle states, this transition occurs during the cycle, and is therefore a
semifundamental mode transition. For states that are not cycle states, this transition is in
fundamental mode. To implement these transitions, the recursion function 4 of C is
defined by
(ko,(z,t)):= o for all (z,t) E XxA \ S,
(,o,(x,u)) := 1 for all (x,u) e S. (325)
The state o indicates that the machine X is not in a state in which its response
must be changed, and hence, when in the state o, the controller does not interfere with
the operation of X; it simply applies to X its own external input. To this end, the output
function r of C at the state o is defined by
r(o,(z,t)) := t for all (z,t) e XxA. (326)
The output function at the state ,1 is defined as follows. Choose a character ui e U(zi);
set
r(li,(zi,t)) := ui for all t e A, i = 1, ..., k. (327)
Then, the machine X continues to rest at the generalized state z1.
(iii) Next, assume that X is in a stable combination with the generalized state zi, i
= 1, ..., k, and an input value u e Ui is applied. Then, the controller C will begin to
apply the string wi to Y, to take Y to the state z,. To this end, the recursion function of
C is defined as follows.
(l,(zi,u)) := i for all u e Ui, i = 1, ..., k;
4(1,(z,t)) := o for all pairs (z,t) e XxA\V. (328)
Upon reaching the state i, the controller generates the first character of the input string
wi of Y, to start taking Y to the desired state z'i. Accordingly, the controllers output
function value at this point is
r(G,(z,t))= v0 for all (z,t) e XxA, i = 1, ..., k. (329)
Upon application of this input character, the machine Y will move to its next generalized
stable state xi,1, where (xi, vi) is the next generalized stable combination.
(iv) In order for the controller to continue to generate the string wi as input for Y,
we define its recursion function as follows.
(,,(xid,u)) := ,1 for all u e Ui, (330)
j = 1,...,m(i)l, i = 1, ..., k. Now, the controller feeds to Y the next character in the
string wi, i.e., the character vi. So the output function must satisfy
r(i ,(z,u)) := v for all (z,u) e XxA, (331)
i = 1,...,k,j = 1, 2, ..., m(i)l.
(v) At the step j = m(i)l, the controller completes generating the string wi. It
assumes then a stable combination, and continues to feed the input character vm(i) 1 until
its external input character is changed. To implement these requirements, the transition
and output functions of the controller are defined by
(((i),(z'iu)) := m(i) for all u e Ui
(i),(z,t)) := o for all (z,t) e XxA\ z'ixUi,
m(i) m(i) 1
r(i(i),(z,u)) := v(i). (332)
k
i = 1,...,k. Note that, since the stateinput sets {zixUili=l are all disjoint, there is no
ambiguity in the definition of the recursion function 4.
From the above construction, the stable recursion function y of the closed loop
system Ec can be deduced. On analysis, this recursion function satisfies, for all i =
1,...,k:
y(zi,o,u) = (s(zi,u),S1) for all u e U(zl),
y(z,o,t) = (s(z,t),o) for all (z,t) e XxA\(SUV),
y(zi,l4,ui)= (z'i, m(i)) for all ui e Ui,
y(zi,l,u) = (zi,1) for all u e U(zi),
y(zi,,l,t) = (zi,,o) for all t e A\(U(zi) U Ui),
y(z'i,m(i),u) = (z'i,gm(i)) for all u e Ui,
y(z,im(i),t)= (s(z,t),o) for all (z,t) e XxA\z'ixUi, (333)
i = 1,...,k. Thus, the equivalence of 7xY and s' as defined in the beginning of this
section holds true. Also, the closed loop system operates in the semifundamental mode
as the definitions of 4 and r specify. We know E is an inputstate system, hence it is
strictly causal; consequently the closed loop system ,c is well posed (Hammer 1996).
This concludes the proof. *
Chapter 4 deals with the specific solution to the model matching problem for this
problem. The necessary and sufficient conditions for the existence of the controller,
using the skeleton matrices are put forward, and if the controller exists, an algorithm to
construct the states is also given.
CHAPTER 4
THE MODEL MATCHING PROBLEM
In this section we present a solution to the model matching problems for machines
with infinite cycles. The solution to the model matching problem for deterministic
systems and for machines with races was presented in Murphy, Geng and Hammer,
(2002, 2003). Let Y be an asynchronous machine with all cycles stoppable, and let 2'
be the stablestate model to be matched. The skeleton matrix Ko(') of the model 2' is
given as in Definition 317. For the solution to the model matching problem, a form of
the skeleton matrix with columns augmented to include the solution to cycles is
introduced; this is the augmented skeleton matrix K(2').
The matrix K(2') is an nx(n+t) matrix of zeros and ones. It is obtained by
augmenting the matrix Ko(') with t columns corresponding to the cycle states, as
follows. Let z be a cycle state, and let 7Txp(z) be the states of the cycle. Then,
K (E'), i,j = 1,...,n,
Kij(Y')= 1 if K (Y')= 1 for all xk e 7xp(x), i = 1,...,n, j = n+l,...,n+t, (41)
0 otherwise.
In view of Proposition 319, the model 2' can be matched only if its stable
transition function is constant over the states of each cycle of Y. Assume then that 2'
satisfies this requirement. In such case, it follows by Equation 41 that the entries of the
column corresponding to xk, k = n+l,...,n+t in K(X') are all 1. The solution to the
model matching problem for a machine with infinite cycles can now be stated as follows.
Theorem 41 Let Y be an asynchronous machine all of whose cycles are
stoppable, and let is = (A,XP,xo,s) be the generalized stable state machine induced by
Y. Let 2' = (A,X,xo,s') be a stablestate input/state machine with the same state set X
and the same input set A as those of Y. Let K(X) be the skeleton matrix of Y, and let
K(X') be the skeleton matrix of Y'. Then, the two following statements are equivalent.
(i) There is a controller C for which the closed loop system cs, is equivalent to
2', where cIs operates in the semifundamental mode and is well posed.
(ii) The skeleton matrices satisfy K(X) > K(E').
Theorem 41 provides a simple necessary and sufficient condition for the existence
of a solution to the model matching problem for systems with infinite cycles. The proof
of the Theorem, which is provided later in this section, includes an algorithm for the
construction of an appropriate controller C. When the model matching problem is
solvable, the controller C operates by transforming into unstable combinations all
generalized stable combinations of Y that do not correspond to stable combinations of
the model Y'. In this way, the stable state machine cs, induced by the closed loop
system becomes stably equivalent to Y'.
The skeleton matrix of the given machine K(X) is never fully zeros, since each
state is potentially stable. Thus, there always exists a stable state machine Y" with
skeleton matrix equal to K(X). When considered as a model, the machine Y" satisfies
condition (ii) of Theorem 41. Consequently, there is a controller C for which cIs = ",
and this controller eliminates the effects of the infinite cycles of Y. Thus, feedback
controller can turn every machine with stoppable cycles into a deterministic stable state
machine.
We turn now to a preliminary technical discussion that will lead us to the proof of
Theorem 41. Let s be the stable recursion function of the generalized stable state
machine EIs of E, and let s' be the stable recursion function of the model E', with the
codomain of s' extended to XP. Build the discrepancy set of E as
D(E,E') := {(x,u) e XxA : (x,u) is a valid pair of E'
and s(x,u) s'(x,u)}. (42)
In intuitive terms, D(E,E') is the set of all valid pairs of E' for which the next stable
state of E' is different from the next generalized state of EIs.
Now, since K(E) > K(E'), for each (x,u) e D(E,E'), there exists an input string w
e A+ for which s(x,w) = s'(x,u); let
S(x,u) c A+ (43)
be the set of all input strings w satisfying s(x,w) = s'(x,u). Next, consider a pair (x,u)
e D(E,E') and an input string w e S(x,u). Let P(E,x,w) be the corresponding path of
E, and let
p(E) := {(z,r) : (z,r) e XxA, (z,r) e pi, i = 1,...,t) (44)
be the set of all stateinput pairs involved in cycles. Define the set
DN(E,E') := {(x,u) e D(E,E') : there is a string w e S(x,u) such that
P(X,x,w)n p(X) = 0}. (45)
For elements (x,u) e DN(E,E'), the machine E can reach the value s'(x,u)
without passing through a cycle. Here, the controller will simply feed to E the string w,
so that the next stable state of the combination Yc will match the next stable state of the
model Y'.
Finally, on the difference set
Dc((,Y') := D( ,:')\DN(=,X'), (46)
the machine Y cannot match the response of 2' without passing through a cycle. In this
case, the controller will have to generate an input string for Y that will initially drive the
machine into a cycle, and then take it out of the cycle. When Y comes out of the cycle,
its next state may be one of several possible states, as exit from a cycle may give rise to a
critical race. The controller will then have to resolve the indeterminancy of the race and
drive the machine to the next stable state determined by the model 2'. The exact process
by which this is accomplished is described in the following proof.
Proof 41. Assume first that condition (i) of Theorem 41 is valid, i.e., that there
exists a controller C such that cs, = Y'. Let Sc be the stable recursion function of Yc,
and recall that s' is the stable recursion function of the model 2'. The last equality
implies that c,(x,u) = s'(x,u) for all pairs (x,u) e XxA. Now, since the controller C
accesses Y only through its input, there is a string w(x,u) e A+ such that Sc(x,u) =
s(x,w(x,u)) where s is the stable recursion function of Y. Consequently, s(x,w(x,u))=
s'(x,u), and the state s'(x,u) is stably reachable from the state x in the machine Y.
Thus, any state that is stably reachable from the state x in the machine 2' must also be
stably reachable from the state x in the machine Y. In other words, K(X) > K(2'), and
we conclude that part (i) implies part (ii).
Conversely, assume that (ii) is true, i.e., that K(X) > K(X'). We construct below a
controller C that satisfies statement (i) of Theorem 41. Recalling the set D(X,2') of
Equation 42, note that if D(X,2') = 0, then the stable transition function of Y matches
that of Y', and no controller is needed. Next, consider the case D( 0,2') 0. Define the
set D by replacing in D(X,2') all the pairs included in cycles by the corresponding
generalized pairs, that is,
Dc := {Dc(X,') \ p(X)} U {(xn+i,u) : pi D(n,X') 0} (47)
The set of all input characters that pair with a state x in D is given by
D(x) := {u e A: (x,u) e D}. (48)
Let rx : XPxA > XP: (x,u) > x be the standard projection. Then, r7xD is the set
of all generalized states x e XP for which there is an input character u E A such that
(x,u) e D. Also, let U(x) be the set of all input characters that form a stable
combination with the generalized state x e XP. The set
V := x x U(x): x e ctxD} (49)
is then the set of all generalized stable combinations with states in rxD.
Suppose that DN(X,X') 0. Then, for each (x,u) e DN(X,X'), there exists an input
string w0(x,u) such that s(x,w0(x,u)) = s'(x,u) and the path P(X,x,w) does not contain
any cycle states. Let m(0;x,u) = Iw0(x,u)l be the length of this string, write it in terms of
0 0 0
its characters as w0(x,u) = wo(x,u)wl(x,u) ... wm(x,u)l(x,u). Then, w0(x,u) takes the
machine through a succession of stable states, which we denote as follows.
0
xoI(x,u) := s(x,wo(x,u)),
0
x0'2(x,u) := s(x,1(x,u),wl(x,u)), ...,
xO,mn(x,u)(x,u) := s(xOn(x,u)2(X,U),Wm(x,u)2(X,U)),
and, by selection of the string w0(x,u),
s(xm(x,u)l(x,u),Wn(x,u)1(x,u)) = s'(x,u). (410)
Thus, to guarantee fundamental mode operation, we see that the controller must
have m(0;x,u) states associated with the pair (x,u). Now, let (zl,ul), ..., (zn(N),un(N)) be
the elements of DN(X,'). Then, for each pair (zi,ui) e DN(X,'), the controller needs
m(0;zi,ui) states to facilitate fundamental mode operation, say the states il(zi,ui), ..
m(o;zi,ui)(zi,ui). This leads to the set of controller states
EN:= R{l(zl,ul), ..., mn(o;z,ul)(zl,ul), ..., (zn(N),un(N)), ...,
m(o0;zn(N),un(N))(zn(N),un(N))}. (411)
In case DN(X,') = 0, set EN := 0.
We turn now to the set DC of Equation 47, assuming that it is not empty. Let
n(C) be the number of elements of DC. Recall that, for each pair of DC, the machine
must pass through at least one cycle in the process of matching the response of the model
Y'; one of these cycles may be the initial step.
Consider a pair (x,u) e DC, let T(1s) be the matrix of stable transitions of X.
Recall that the state set of Y is X = {xl, ..., xn} and the generalized state set of Y is XP
= {x1, ..., xn+t}. In the case x is a cycle state, say x = xY, where y e {n+1, ..., n+t}, let
p(xY) := {xv(1), ...,x(P)} c X. Setting xP := s'(xa(1),u) e X, it follows by Proposition 3
19 that s'(xa(i),u) = xP for all i = 1, ..., p. The fact that x := s'(xa(i),u) implies that
Kpa(i)(X') = 1, i = 1, ..., p. By Equation 41, we then have that Kpy(X') = 1. The
inequality K(X) > K(X') implies then that the entry Tpy(ls) is not empty. Furthermore,
letting w(x,u) be an element of Tpy(ls), it follows by Proposition 318 that s'(x,u) =
s(x,w(x,u)). Consider now the path P(ls,x,w(x,u)). Recalling that (x,u) e DC, the
following hold. If x is not a cycle state, then the path P(ls,x,w(x,u)) must include a
cycle. If x is a cycle state, then P(ls,x,w(x,u)) may or may not include an additional
cycle.
The string w(x,u) takes the machine through one possible outcome of each cycle
encountered along the path P(ls,x,w(x,u)). Depending on the outcome of the critical
races that occur as the machine Y passes through the cycles along the path
P(ls,x,w(x,u)), different strings may need to be used to take the machine to the state
s'(x,u). Let wo(x,u) be the initial segment of the string w(x,u) that takes the machine Y
to the state following the first cycle state along the path P(Xls,x,v(x,u)). By construction,
the shortest length of wO(x,u) is one character, and it is obtained when the state x is
itself a cycle state. The controller C initially feeds this string to the machine Y
character by character, to achieve semifundamental mode operation. The last character
of w(x,u) leads Y into a critical race, as it exits from the corresponding cycle. The
inequality K()) > K(X') implies that there is an input string that leads Y from each
outcome of this race to the next cycle along its way to the state s'(x,u). This string will
then similarly be generated by the controller and applied to the machine Y. This process
continues through each cycle encountered along the way, and is formally described next.
0
Writing the initial substring in terms of its individual characters, set w(x,u) = wo
0 0
(x,u)wl(x,u) ... wm(o;x,u)l(x,u); here, m(O;x,u) = w(x,u)l is the length of the string.
This string take the machine Y through the following sequence of generalized stable
states.
0
xo,(x,u) := s(x,wo(x,u)),
0
x0,2(,) := S(X0,1(X,U),Wl(x,u)), ...,
xO,m(0;x,ul(xu) := S(xO0,m(;x,u)2(X,U),Wm(0;x,u)2(X,U)),
X(1)(x,u) := s(xOm(O;xu)l(x,u),Wm(o;x,u)1(x,u)), (412)
where X(1)(x,u)= {x(1,1), ..., x(1,ri)} c X is the set of all states of Y that form
possible outcomes of the critical race. Since the string w0(x,u) takes Y up to one step
past a cycle state to the outcome of the corresponding critical race, it follows that
xo,m(o;x,u)l(x,u) is a cycle state. Note that if the initial state x is a cycle state, then
m(0;x,u) = 1, namely, the substring wO(x,u) has just a single character.
The next substring of characters in w(x,u) takes the machine from the present
outcome of the cycle to the outcome of the next cycle (or to the final destination, if no
other cycle is encountered). Denote this substring by wi(x,u,x(1,ii)). It takes the
machine from the state x(1,ii) to the outcome of the next cycle; the process is similar to
the process described in Equation 412, and wl(x,u,x(1,ii)) has at least one character. If
a cycle leading to a critical race is reached at the end of the substring wl(x,u,x(1,ii)),
then, letting r2(ii) be the number of its outcomes, we denote the set of outcomes by
X(2,ii)(x,u) and let its members be {x(2,il,1), ..., x(2,i1,r2(i1))} c X. Let
1 1
m(1;x,u,x(1,il)) = wl(x,u,x(1,il))l be the length of the string, and let wo(x,u,x(1,ii)), wi
(x,u,x(1,il)), ..., Wm(1;x,u,x(1,i))l(x,u,x(l,il)) be its characters.
The next such substring depends on the outcome of both the races encountered, and
is given by w2(,ux(2,il,i)). The number of cycles encountered may vary, depending on
the outcome of the critical races through which the machine has passed. Let q be the
number of cycles encountered along our path to the target s'(x,u). The outcomes of the
q critical races caused by the cycles are then denoted by x(1,il), x(2,ii2), ..., x(q,il, iq). In
order to simplify the notation, define x(k,i(
input characters that takes the machine from (x,u) to s'(x,u) consists then of the
following segments
w(x,u) := w(x,u) w1(x,u,x(1,i(
where each one of the segments takes the machine from the outcome of one cycle to the
outcome of the next cycle along the path. The length of the segment wJ(x,u,x(j,i(
m(j;x,u,x(j,i(j))) > 1. Each segment can then be written in terms of its individual
characters in the form
J J
wJ(x,u,x(j,i(
wm(j;x,u,x(ji( ))1(x,u,x(j,i(
where the possible values for each variable are il = 1, ..., r, i2 = 1, ..., r2(i), ..., ij = 1,
..., rj(il,...,ij_i), and j = 1, ..., q. Using the same notation introduced earlier, let rj(i(
1)) = rj(i,...,ij_i) for some j.
q1
Each of the substrings {wJ(x,u,x(j,i(gj)))}j=1 drives the machine through a string of
the stable transitions similar to Equation 412. The last segment wq(x,u,x(q,i(
the machine to the destination s'(x,u), i.e.,
s(i1 !!'( I. 11 (q,i( q)))l(x,u,x(qx,u,x(q,i(q))(x,u,x(q,i(<)))) = '(x,u).
We are now ready to introduce the operation of the controller C. The controller
generates each segment of the string w(x,u) in turn. To guaranty semifundamental
mode operation, the controller must generate the string segments wo(x,u), ...,
wq(x,u,x(q,i(
its next generalized state. For this purpose, the controller operation is defined as follows.
Let 4 be the transition function of the controller and let r be its output function.
Assume that the controller is in the initial state o and that the machine Y is in a
generalized stable combination (x,v), when the input character changes to u. Upon
detecting the combination (x,u) e V, the controller changes to the state 1. This entails
the following values of the transition function.
(o,(z,t)) := o for all (z,t) e XxA\V,
(o,(x,u)) := 51 for all (x,u) e V. (415)
Referring to (al 1), note that, while in the state o, the controller is transparent; it
applies to the machine Y it's own external input character. This entails the following
value of the output function.
r(o,(z,t)) := t for all (z,t) e XpxA. (416)
For semifundamental mode operation, the machine Y cannot change its
generalized state during a state change of the controller C. To this end, recall that U(x)
is the set of all characters that form generalized stable combinations with the state x.
Select a character v' e U(x) and set
r( 1,(x,t)) := v' for all (x,t) e XpxA. (417)
The controller starts now to generate the substring w0(x,u), feeding it to the
machine Y in order to make its response match the response of the model 2'. The
substring w0(x,u) is generated one character at a time, waiting after each character for
the machine Y to reach its next generalized stable combination. This process requires
0 0
the controller states o(x,u), ..., m(o;x,u)(x,u), and the controller's recursion function is
defined as follows.
0
(1,,(x,u)) := o(x,u), for (x,u) e D,
(Sl,(x,t)) := 1, for all t e U(x)\D(x),
0. 0
(j (x,u),(xOJ(x,,u)u)) := ij+I(x,u),
O 0
K(j (x,u),(z,t)) := j (x,u), for all (z,t) e XpxA, (418)
where 0 j < m(0;x,u)2. We can now generate the first m(0;x,u)l characters of the
substring wO(x,u) by defining the controller output function as follows.
0 0
r(j (x,u),(z,t)) := wj (x,u), for all (z,t) e XpxA, (419)
where 0
Y is in the cycle state xo,m(o;x,u)l(x,u), and creates a critical race with the outcome
x(1,ii), as discussed earlier.
Recall that w(x,u) passes through q cycles. The controller continues to generate
all the substrings wJ(x,u,x(j,i(j))), j = 1, ..., q consecutively. Let the controller states
associated with the substring wJ(x,u,x(j,i(
transition function is then given by
$(h(x,u),(xj,h(x,u),u)) = h+1(Xu),
$(h(x,u),(z,t)) := Wh(x,u), for all (z,t) f (xj,h(x,u),u), (420)
where h = 0, ..., m(j;x,u,x(j,i(
are generated by the controller's output function as follows.
ri(h(x,u),(z,t)) := wh(x,u,x(j,i(
where h = 0, ..., m(j;x,u,x(j,i(,j)))1, and j = 1, ..., q.
The transition from the end of one substring to the first character of the next
substring of w(x,u) is accomplished by defining the controller's transition function as
follows.
j j+l 1
(m(j;mx,u,xj,i(,j)))l(X,U),(xh(x,u),u)) = 0 (x,u), (422)
j = 0, ..., q1.
At the end of the string w(x,u), the machine Y reaches the state s'(x,u), required
for matching the model 2'. The last character of w(x,u) is, of course, the last character
of wq(x,u,x(q,i(
stable combination with the state s'(x,u) until the external input changes. To implement
this requirement, the transition function of the controller is defined by
q
$( m(q;x,u,x(q,i(
This completes the operation of the controller for the transition from x to s'(x,u).
Summarizing, the set of all controller states associated with the generation of the string
w(x,u) is given by
0 0 q
Ec(w(x,u))= ((x,u), ,m(o, x,u), ..., o(x,u), ...,
q
m(q;x,u,x(q,i(
Note when (x,u) E DN((,'), then q is taken as zero in the above construction, and
w(x,u) consists of only one substring which completes the required transition.
To complete the implementation of the controller C, the above construction has to
be applied to each input pair (x,u) e DC. To describe the state set of the controller, let
the elements of Dc be given by {(zi,ul), ..., (zn(C),un(C))} and let w(zk,uk) be the
string that takes from (xk,uk) to the state s'(xk,uk) required to match the model for a
specific sequence of cycle outcomes. Then, in analogy with Equation 424, the controller
states associated with the generation of w(xk,uk), for a specific combination of the
outcome of the cycles encountered, are
Ec(w(xk,uk)) = {0(xk uk)' ... k k(Xk uk), k),...
m(qux k _,l)(Xk Uk) } (425)
The set of all states for all combinations of outcomes of cycles are then given by
EC(xk,uk) = Uall possible w(xk,uk) EC(W(Xk,uk)). (426)
Thus, the set of controller states for all the elements of DC are
Ec = Uk = 1,..., n(C) E(xk,uk) (427)
Of course, if DC = 0, then EC(xk,uk) = 0 and Ec = 0. Then the complete state
set of the controller is given by
E = {R0, l} U ENU Ec. (428)
By construction, the closed loop system operates in semifundamental mode and is well
posed. This completes the construction of the controller C. *
Note that the states of the controller are not optimized. This can be done by the
various state reduction techniques, e.g., KOHAVI [1970]. Further state reductions can be
done by careful choice of the corrective string.
CHAPTER 5
EXAMPLE
This chapter demonstrates the construction of a controller C that fulfills the
requirements of Theorem 41. Consider the input/state machine Y having the input set
A = {a, b, c, d} and the state set X = {xl, x2, x3, x4}. Consider the recursion function of
the machine f to be defined by Table 51 of transitions.
Table 51. Transition table for the machine X.
a b c d
x1 x1 x3 x1 x1
x2 x3 x2 x4 x3
X3 x4 x4 x4 x3
X4 x2 x4 x3 x4
Applying Algorithm 38 to the above machine, the cycles in the machine can be
found. We see that the cycles are pi = {a;x2, x3, x4} and p2 = {c;x3, x4}. Now, the
cycle states corresponding to the cycles pi and p2 are x5 and x6. The generalized
stable state machine Is now has the state set XP = {x1, x2, x3, x4, x5, x6}, as defined in
Equation 38, and the same input set A. The stable recursion function s of the
generalized stable state machine Is is defined in the Table 52 of transitions. The
generalized stable recursion function for the generalized stable state machine is defined in
Equation 311. Note that when an input character is applied to a cycle state, it can result
in unpredictable outcomes. This is represented as the set of all possible output states.
60
Table 52. Stable transition table for the generalized stable state machine XIs
a b c d
x3
x2
x4
x4
{x2,x4}
x4
xl
x6
x6
x6
{x4,x6
x6
1
xl
x3
x3
3
x4
{x3,x4}
{x3,x4}
The machine Is is now an asynchronous machine with multiple race outcomes.
We will now follow the procedure in Chapter 4 to calculate the skeleton matrix of this
machine. As defined in Equation 312, the matrix of onestep generalized stable
transitions R(Xls) is shown in Table 53.
Table 53. Matrix of onestep generalized stable transitions R(YIs)
x1 X2 x3 x4 x5 x6
a,c,d
N
N
b
N
N
Using Equation 317 and Equation 318, we construct the matrices R2(Xis), R3( ls),
R4( s), and R5(Els), and then the matrix R(5)(EIs). Then, applying Definition 314, the
matrix of stable transitions T(Is) is constructed. Finally, using Definition 317, the
skeleton matrix is derived. The skeleton matrix K(E) calculated from R(5)(E) is given
by
01 0000 0
K() 0 1 1 0 0 1 (51)
10 1 1 0 0 1
Now to solve the model matching problem, we need the given stable state machine
Y' as our model. The stable recursion function for X' is given in Table 54 of
transitions.
Table 54. Stable transition function of the given model X'.
a b c d
generalized stable state machine, except for the absence of the cycle states. This results
in a square matrix, given by
F10001
Ko(X') 0 1 0 0 (52)
1 1 1 1
I I I I
_2 i i
Following Equation 41, the augmented skeleton matrix K(E') is then constructed
as follows.
K(')= 0 1 0 0 0 (53)
011 000
111111
The next step in the construction of the controller is to see if the necessary and
sufficient conditions are satisfied. We find that K(X) > K(2'), thus satisfying Theorem 4
1. To construct the controller, we need the following matrices, as explained in the proof
of Theorem 41.
D(,') := {(x2,a),(x3,a),(x4,a),(x2,c),(x3,c),(x4,c)},
D := {(x5,a),(x6,c),(x2,c)},
7rxD := x2,x3,4},
D(x) := {a,c},
U(x2) := {b},
U(x5):= {a},
U(x6):= {c},
DN(X,X') := 0,
Dc := {(x2,c),(x5,a),(x6,c)}. (54)
For (x2,c) e Dc(E,E'), wo(x2,c) = d, wi(x2,c,x3) = b. There are two possible
strings, d and db; r(x2,c) = 2. The state transitions are:
4(,o,(z,t)) := o for all (z,t) e XxA\V,
4(,o,(x2,c)) := for all (x2,c) e V,
(Sl,(x2,c)) := So(x2,c), for (x2,c) e D,
4(l1,(x2,t)) := 1, for all t e U(x2)\D(x2),
(i1,,(z,t)) := o, for all pairs (z,t) e XpxA\(VUD),
(S((x2,c),(x0,1(x2,c),d)) := l (x2,c),
(,(x2,c),(z,t)) := (,(x2,c), for all (z,t) / (xo,l(x2,c),d),
K(o(x2,c),(z,t)) := 1, (z,t) f (s'(x2,c),u). (55)
The output functions are
r(o,(z,t)) := t for all (z,t) e XpxA,
r(I,(x2,t)) := b for all (x2,t) e XpxA,
o o
ri(o(x2,c),(z,t)) := wo(x2,c) = d, for all (z,t) e XpxA,
ri(Co(x2c),(z,t)) = w(x2,c,x3) = b, (z,t) e XpxA. (56)
Now, consider the next element (x5,a) e Dc(X,2'). For this cycle state, wo(x5,a)
d, Wl(x5,a,x3) = b; as before, r(x5,a) = 2. The state transitions and output functions are
given by
4(o,(z,t)) := o for all (z,t) e XxA\V,
(o,(x5,a)) := for all (x5,a) e V,
#(l,(x5,a)) := So(x5,a), for (x5,a) e D,
4(1,(x5,t)) := 1, for all t E U(x5)\D(x5),
4(l1,(z,t)) := 5o, for all pairs (z,t) e XpxA\(VUD),
o 1
W(So(x5,a),(xO,l(x5,a),d)) := o(x5,a),
o o
W(So(x5,a),(z,t)) := o(x5,a), for all (z,t) (xO,l(x5,a),d),
1
O(So(x5,a),(z,t)) := 1, (z,t) / (s'(x5,a),b),
rj(o,(z,t)) := t for all (z,t) e XpxA,
r(1i,(x5,t)) := a for all (x5,t) e XpxA,
o o
ri(o(x5,a),(z,t)) := wo(x5,a) = d, for all (z,t) e XpxA,
1 1
r(So(x5,a),(z,t)) := wo(x5,a,x3) = b, (z,t) e XpxA. (57)
Similarly, the transition and output functions for the third element (x6,a) e
Dc(Y,2') are defined below. Here, wo(x6,c) = b; r(x6,a) =
4(o,(z,t)) := o for all (z,t) e XxA\V,
(o,(x6,c)) := l for all (x6,c) e V,
(l,(x6,C)) := o(x6,c), for (x6,c) e D,
4(l1,(x6,t)) := for all t E U(x6)\D(x6),
W(4l,(z,t)) := o, for all pairs (z,t) e XpxA\(VUD),
0
W(So(x6,c),(z,t)) := (i, (z,t) / (s'(x6,c),b),
rj(o,(z,t)):= t for all (z,t) e XpxA,
r(1,(x6,t)) = c for all (x6,t) e XpxA,
64
0 0
ri((x6,c),(z,t)) := w0(x6,c) = b, for all (z,t) e XpxA. (58)
This concludes the construction of the feedback controller C such that the closed
loop machine cs = Y'. The equations (56), (57) and (58) give the state and transition
functions of the controller C.
CHAPTER 6
SUMMARY AND FUTURE WORK
The present work shows the use of feedback controllers to correct one of the
common hazards in the behavior of asynchronous sequential machines. Specifically, the
designed controller not only eliminates the effects of infinite cycles in such a machine,
but it can also drive the defective machine to match the behavior of a desired model.
This approach opens an interesting arena where many open problems remain to be
analyzed.
In Chapter 5 of this dissertation, solutions have been presented to the model
matching problem of inputstate machines involved in infinite cycles. The necessary and
sufficient conditions for the existence of a controller have been stated, and an algorithm
for its construction has been included, whenever a controller exists.
The control of asynchronous machines is an area of research that is still ripe with
possibilities. A straight forward extension of this dissertation is to the construction of a
comprehensive state feedback controller that solves the the model matching problem for a
machine with multiple hazards, including both races and cycles. The comprehensive
controller has elements of both the race problem investigated by Murphy 1996, Murphy,
Geng, and Hammer 2002, and Murphy, Geng, and Hammer 2003, as well as the
controller for remedying cycles in an asynchronous machine, described in this
dissertation.
My future research plans include work on extending the results obtained in this
dissertation to the comprehensive state feedback controller. The next logical step lies in
formulating a more compact representation of the controller. A close examination of the
controller structure described in Chapter 3 and Chapter 4 shows that it consists of a
number of interconnected similar units. This observation leads us to believe that the
controller can be assembled in a modular fashion from a collection of standard units.
Formalizing this observation will lead to a simple methodology of controller design,
whereby the controller is constructed simply by interconnecting a few standard blocks.
Further, investigating the possibility of a comprehensive output feedback controller
for a machine with multiple races and cycles is also a future research interest. The
present proposal develops a controller that eliminates the negative effects of infinite
cycles in asynchronous machines under the assumption that the state of the machine is
available for feedback purposes. The problem of overcoming the effects of infinite
cycles becomes substantially more complex if the state of the machine is not available,
and only an output signal is available. The solution of this problem requires the
development of concepts related to the observability of asynchronous machines, to find
conditions under which an infinite cycle in state space can be detected from an
observation of the output signal.
The application of the obtained results to parallel and distributed systems is also an
area of interest. Asynchronous sequential systems can be used to model parallel and
distributed systems due to their event driven nature. It has been shown by Plateau and
Atif 1991 that complex parallel networks can be modeled using stochastic automata
networks. Recent work has succeeded in showing that a distributed system can be
represented by cellular automata (Zambonelli et al 2003). Feedback control holds
67
promise for improving the performance and reliability of such parallel and distributed
systems, and it is possible to apply the principles developed in this work.
LIST OF REFERENCES
Alpan, G., and Jafari, M.A., 2002, "Synthesis of a closedloop combined plant and
controller model," IEEE Transactions on Systems, Man and Cybernetics, Vol. 32,
No. 2, pp.163175.
Arbib, M., 1969, "Theories of abstract automata," Prentice Hall Inc., Englewood Cliffs,
NJ.
Armstrong, D., Friedman A., and Menon P., 1968, "Realization of asynchronous
sequential circuits without inserted delay elements," IEEE Transactions on
Computers, C17, No. 2.
Bredeson, J., and Hulina, P., 1971, "Generation of a clock pulse for asynchronous
sequential machines to eliminate critical races," IEEE Transactions on Computers,
C20, pp. 225226.
Bruschi, D., Pighizzini, G., and Sabadini, N., 1994, "On the existence of minimum
asynchronous automata and on the equivalence problem for unambiguous regular
trace languages," Information and Computation, Vol. 108, No. 2, pp. 262285.
Brzozowski, J.A., and Seger, C., 1987, "A characterization of ternary simulation of gate
networks," IEEE Transactions on Computers, C36, No. 11, pp. 13181327.
Brzozowski, J.A., and Seger, CJ., 1989, "A unified framework for race analysis of
asynchronous networks," Journal of the Association for Computing Machinery,
Vol. 36, No. 1, pp. 2045.
Brzozowski, J.A., and Yeoli, M., 1979, "On a ternary model of gate networks," IEEE
Transactions on Computers, C28, pp.178183.
Chiang, J., and Radhakrishnan, D., 1990, "Hazardfree design of mixed operating mode
asynchronous sequential circuits," International Journal of Electronics, Vol. 68, No.
1, pp. 2337.
Chu, T., 1994, "Synthesis of hazardfree control circuits from asynchronous finite state
machine specifications," Journal of VLSI Signal Processing, Vol. 7, No. 12, pp.
6184.
Chu, T., Mani, N., and Leung, C., 1993, An efficient critical racefree state assignment
technique for asynchronous finite state machines," Proceedings of the 30th
ACM/IEEE Design Automation Conference, Dallas, TX, pp. 25.
Cole, R., and Zajicek, 0., 1990, "The expected advantage of asynchrony," Proceedings of
the Second Annual ACM Symposium on Parallel Algorithms and Architectures,
pp. 8594.
Datta, P.K., Bandyopadhyay, S.K., and Choudhury, A.K., 1988, "A graph theoretic
approach for state assignment of asynchronous sequential machines," International
Jounal of Electronics, Vol. 65, No. 6, pp. 10671075.
Davis, A., Coates, B., and Stevens, K., 1993a, "Automatic synthesis of fast compact
asynchronous control circuits," S. Furber and M. Edwards, editors, Asynchronous
Design Methodologies, Volume A28 of IFIP Transactions, Elsevier Science
Publishers, pp. 193207.
Davis, A., Coates, B., and Stevens, K., 1993b, "The post office experience: designing a
large asynchronous chip," Proceeding of the 26th Hawaii International Conference
on System Sciences, Vol. 1, pp. 409418.
Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1994, "Model
matching for finite state machines," Proceedings of the IEEE Conference on
Decision and Control, Vol. 3, pp. 31173124.
Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995a, "Strong model
matching for finite state machines with nondeterministic reference model,"
Proceedings of the IEEE conference on Decision and Control, Vol. 1, pp. 422426.
Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995b, "Strong model
matching for finite state machines," Proceedings of European Control Conference,
Vol. 3, pp. 20272034.
Dibenedetto, M.D., SangiovanniVincentelli, A., and Villa, T., 2001, "Model matching
for finitestate machines," IEEE Transactions on Automatic Control, Vol. 26, No.
11, pp. 17261743.
Eichelberger, E.B., 1965, "Hazard detection in combinational and sequential switching
circuits," IBM Journal of Research and Development, Vol. 9, No. 2, pp. 9099.
Eilenberg, S., 1974, "Automata, Languages and Machines," Volume A, Academic Press,
New York.
Evans, J.B., 1988, "Structures of discrete event simulation," Halsted Press, New York.
Fisher, P., and Wu, S., September 1993, "Racefree state assignments for synthesizing
largescale asynchronous sequential logic circuits," IEEE Transactions of
Computers, Vol. 42, No. 9, pp.10251034.
Fujita, M., 1993, "Methods for automatic design error correction in sequential circuits,"
Proceedings of the European Conference on Design Automation with the European
Event in ASIC Design, pp. 7680.
70
Furber, S.B., 1993, "Breaking step The return of asynchronous logic," IEEE Review,
pp. 159162.
Geng, X. J., 2003, "Model matching for asynchronous sequential machines," Ph.D.
dissertation, Department of Electrical and Computer Engineering, University of
Florida, Gainesville, Florida.
Geng, X. J., and Hammer, J., 2003, "Input/output control of asynchronous sequential
machines", submitted for publication.
Geng, X. J., and Hammer, J., 2004a, "Asynchronous sequential machines: input/output
control", Proceedings of the 12th Mediterranean Conference on Control and
Automation, Kusadasi, Turkey, June 2004.
Geng, X. J., and Hammer, J., 2004b, "Output Feedback Control Asynchronous Sequential
Machines", Proceedings of the 8th World Multiconference on Systemics,
Cybernetics and Informatics (SCI 2004) to be held in Orlando, Florida.(to appear).
Hammer, J., 1994, "On some control problems in molecular biology," Proceedings of the
IEEE Conference on Decision and Control, Vol. 4, pp. 40984103.
Hammer, J., 1995, "On the modeling and control of biological signaling chains,"
Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 3747
3752.
Hammer J., 1996a, "On the control of incompletely described sequential machines,"
International Journal of Control, Vol. 63, No. 6, pp. 10051028.
Hammer J., 1996b, "On the corrective control of sequential machines," International
Journal of Control, Vol. 65, No. 6, pp. 249276.
Hauck, S., 1995, "Asynchronous design methodologies: an overview," Proceedings of the
IEEE, Vol. 83, No. 1, pp. 6993.
Hazeltine, B., 1965, "Encoding of asynchronous sequential circuits," IEEE Transactions
on Electronic Computers, EX14, pp.727729.
Higham, L., and Schenk, E., 1992, "The parallel asynchronous recursion model,"
Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp.
310316.
Hlavicka, J., 1970, "Essential hazard correction without the use of delay elements," IEEE
Transactions on Computers, C19, No. 3, pp. 232238.
Holcombe, W.M.L., 1982, "Algebraic automata theory," Cambridge University Press,
New York.
Hubbard, P., and Caines, P.E., 2002, "Dynamical consistency in hierarchical supervisory
control," IEEE Transactions on Automatic Control, Vol. 47, No. 1, pp. 3752.
Huffmann D.A., 1954a, "The synthesis of sequential switching circuits," J. Franklin Inst.,
Vol. 257, pp. 161190.
Huffmann D.A., 1954b, "The synthesis of sequential switching circuits," J. Franklin Inst.,
Vol. 257, pp. 275303.
Huffmann, D.A., 1957, "The design and use of hazardfree switching networks," Journal
of the Association of Computing Machinery, Vol. 4, No. 1, pp. 4762.
Ingerson, T.E., and Buvel, R.L., 1984, "Structure in Asynchronous Cellular Automata,"
Physica D, Vol. 10, pp. 5968.
Kailath, T., 1980, "Linear systems," Prentice Hall Inc., Englewood Cliffs, New Jersey,
1979, pp. 268272.
Kalman, R.E., Falb, P.L., and Arbib, M.A., 1969, "Topics in Mathematical Systems
Theory," McGrawHill Book Company, New York.
Kohavi, Z., 1970, "Switching and finite automata theory," McGrawHill Book Company,
New York, 1970.
Koutsoukos, X.D., Antsaklis, P.J., Stiver, J.A., and Lemmon, M.D., 2000, "Supervisory
control of hybrid systems," Proceedings of the IEEE, Vol. 88, No. 7, pp. 1026
1049.
Lavagno, L., Keutzer, K., and SangiovanniVincentelli, A., 1991, "Algorithms for
synthesis of hazardfree asynchronous circuits," Proceedings of the 28th
ACM/IEEE Design Automation Conference, San Francisco, CA, pp. 302308.
Lavagno, L., Moon, C.W., and SangiovanniVincentelli, A., 1994, "Efficient heuristic
procedure for solving the state assignment problem for eventbased specifications,"
IEEE Transactions on ComputerAided Design of Integrated Circuits and Systems,
Vol. 14, pp. 4560.
Lin, B., and Devadas, S., 1995, "Synthesis of hazardfree multilevel logic under multiple
input changes from binary decision diagrams," IEEE Transactions on Computer
Aided Design of Integrated Circuits and Systems, Vol. 14, No. 8, pp. 974985.
Lin, F., 1993, "Robust and adaptive supervisory control of discrete event systems," IEEE
Transactions on Automatic Control, Vol. 38, No. 12, pp. 18481852.
Lin, F., and Wonham, W.M., 1990, "Decentralized control and coordination of discrete
event systems with partial observation," IEEE Transactions on Automatic Control,
Vol. 35, No. 12, pp. 13301337.
Liu, C., 1963, "A state variable assignment procedure for asynchronous sequential
switching circuits," Journal of the Association of Computing Machinery, Vol. 10,
pp. 209216.
MacLane, S., and Birkhoff, G., 1967, "Algebra," The Macmillan Company, New York.
Mago, G., 1971, "Realization of methods for asynchronous sequential circuits," IEEE
Transactions on Computers, C20, pp. 290298.
Maki, G., and Tracey, J., 1971, "A state assignment procedure for asynchronous
sequential circuits," IEEE Transactions on Computers, C20, pp. 666668.
Marshall, A., Coates, B., and Siegel, F., 1994, "Designing an asynchronous
communications chip," IEEE Design & Test of Computers, Vol. 11, No. 2, pp. 8
21.
Masuyama, H., and Yoshida, N., 1977, "design of failsafe asynchronous sequential
machines," Transactions of the Institute of Electronics and Communication, Vol.
E60, No. 10, pp. 527532.
McCluskey, E.J., 1963, "Fundamental mode and pulse mode sequential circuits," Proc.
IFIP Congress 1962, International Conference on Information Processing, Munich,
August 27September 1, 1962, pp. 725730, Cicely M. Popplewell (ed.), North
Holland Publishing Company, Amsterdam.
McCluskey, E.J., 1965, "Introduction to the theory of switching circuits," McGrawHill
Book Company, New York.
Mealy, G.H., 1955, "A method for synthesizing sequential circuits," Bell Systems
Technical Journal, Vol. 34, pp. 10451079.
Moon, C.W., Stephan, P.R., and Brayton, R.K., 1991, "Synthesis of hazardfree
asynchronous circuits from graphical specifications," IEEE International
Conference on ComputerAided Design, pp. 322325.
Moore, E.F., 1956, "Gedankenexperiments on sequential machines," Automata Studies,
Annals of Mathematical Studies, No. 34, Princeton University Press, Princeton, NJ.
Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D., and Robinson, P., 2000,
"Self calibrating clocks for globally asynchronous locally synchronous systems,"
Proceedings of the International Conference on Computer Design, pp 7378.
Murphy, T.E., 1996, "On the control of asynchronous sequential machines with races,"
Ph.D. Dissertation, Department of Electrical and Computer Engineering, University
of Florida, Gainesville, Florida.
Murphy, T.E., Geng, X. J., and Hammer, J., 2002, "Controlling races in asynchronous
sequential machines," Proceedings of the IFAC World Congress, Barcelona, July
2002.
Murphy, T.E., Geng, X. J., and Hammer, J., 2003, "On the control of asynchronous
machines with races," IEEE Transactions on Automatic Control, Vol. 28, No. 6, pp.
10731081.
Nelson, R.J., 1968, "Introduction to automata," John Wiley and Sons, Inc., 1979.
Nishimura, N., 1990, "Asynchronous shared memory parallel computation," The 3rd
ACM Symposium on Parallel Algorithms and Architectures SPAA '90, pp. 7684.
Nishimura, N., 1995, "Efficient asynchronous simulation of a class of synchronous
parallel algorithms," Journal of Computer and System Sciences, Vol. 50, No. 1, pp.
98113.
Nowick, S.M., 1993, "Automatic synthesis of burstmode asynchronous controllers,"
Ph.D. Dissertation, Department of Computer Science, Stanford University,
Stanford, California.
Nowick, S.M., and Coates, B., 1994, "UCLOCK: Automated design of highperformance
unclocked state machines," Proceedings of the IEEE International Conference on
Computer Design (ICCD), pp. 434441.
Nowick, S.M., Dean, M.E., Dill, D.L., and Horowitz, M., 1993, "The design of a high
performance cache controller: A case study in asynchronous synthesis,"
Proceedings of the 26th Hawaii International Conference on System Sciences, pp.
419427.
Nowick, S.M., and Dill, D.L., 1991, "Synthesis of asynchronous state machines using a
local clock," IEEE International Conference on Computer Design, pp. 192197.
Oikonomou, K.N., 1992, "Abstractions of finitestate machines and immediately
detectable output faults," IEEE Transactions on Computers, Vol. 41, No. 3, pp.
325338.
Oliviera, D.L., Strum, M., Wang, J.C., and Cunha, W.C., 2000, "Synthesis of high
performance extended burst mode asynchronous state machines," Proceedings of
the 13th Symposium on Integrated Circuits and Systems Design, pp. 4146.
Ozveren, C.M., and Willsky, A.S., 1990, "Observability of discrete event dynamic
systems," IEEE Transactions on Automatic Control, Vol. 35, No. 7, pp. 797806.
Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., 1991, "Stability and stabilizability of
discrete event dynamics systems," Journal of the Association of Computing
Machinery, Vol. 38, No. 3, pp. 730752.
Park, SJ., and Lim, JT., 2002, "Robust and nonblocking supervisory control of
nondeterministic discrete event systems using trajectory models," IEEE
Transactions on Automatic Control, Vol. 47, No. 4, pp. 655658.
Patterson, W.W., and Metze, G., 1974, "Fail safe asynchronous sequential machine,"
IEEE Transactions on Computers, Vol. C23, No. 4, pp. 369374.
Piguet, C., 1991, "Logic synthesis of racefree asynchronous CMOS circuits," IEEE
Journal of SolidState Circuits, Vol. 26, No. 3, pp. 371380.
Plateau, B., and Atif, K., 1991, "Stochastic automata network of modeling parallel
systems," IEEE Transactions on Software Engineering, Vol. 17, No. 10, pp. 1093
1108.
Ramadge, P.J., and Wonham, W.M., 1987, "Modular feedback logic for discrete event
systems," SIAM Journal of Control and Optimization, Vol. 25, pp. 12021218.
Ramadge, P.J., and Wonham, W.M., 1989, "The control of discrete event systems,"
Proceedings of the IEEE, Vol. 77, No. 1, pp. 8199.
Ramadge, P.J.G., and Wonham, W.M., 1987, "Supervisory control of a class of discrete
event processes," SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp.
206230.
Sen, R.K., 1985, "On state assignment of asynchronous sequential machines,"
Proceedings COMPINT 85: Computer Aided Technologies, pp. 433440.
Schonfisch, B., and De Roos, A., 1999, "Synchronous and Asynchronous Updating in
Cellular Automata", BioSystems, 51(3), pp. 123143.
Shields, M.W., 1987, "An introduction to automata theory," Blackwell Scientific
Publications, Boston, Massachusetts.
Thistle, J.G., and Wonham, W.M., 1994, "Control of infinite behavior of finite
automata," SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206
230.
Tracey, J.H., 1966, "Internal state assignments for asynchronous sequential machines,"
IEEE Transactions on Electronic Computers, EC15, pp. 551560.
Turing, A., 19361937, "On computable numbers, with an application to the
entscheidungsproblem," Proceedings of the London Mathematical Society, Ser. 2
42, pp. 230265 with a correction, Ibid, Ser. 243, pp.544546, 19361937.
Unger, S.H., 1959, "Hazards and delays in asynchronous sequential switching circuits,"
IRE Transactions on Circuit Theory, Vol. CT6, No. 1, pp.1225.
75
Unger, S.H., 1969, "Asynchronous sequential switching circuits," Wiley Interscience,
New York, NY.
Unger, S.H., 1977, "Selfsynchronizing circuits and nonfundamental mode operation,"
IEEE Transactions on Computers, Vol. 26, No. 3, pp. 278281.
Unger, S.H., 1995, "Hazards, critical races and metastability," IEEE Transactions on
Computers, Vol. 44, No. 6, pp. 754768.
Watanable, Y. and Brayton, R., 1993, "Computing permissible behaviors ofFSM's,"
Proceedings of the International Conference on ComputerAided Design, pp. 316
320.
Whitaker, S., and Maki, G., 1992, "Self synchronized asynchronous sequential pass
transistor circuits," IEEE Transactions on Computers, Vol. 41, No. 10, pp. 1344
1348.
Wolfram, S., 1994, "Cellular automata and complexity," World Scientific Pub Co Inc.,
1986.
Wonham, W.M., and Ramadge, P.J.G., 1987, "On the supremal controllable sublanguage
of a given language," SIAM Journal of Control and Optimization, Vol. 25, pp. 637
659.
Yoeli, M., and Rinon, S., 1964, "Application of ternary algebra to the study of static
hazards," Journal of the Association of Computing Machinery, Vol. 11, No. 1, pp.
8497.
Yu, M.L., and Subrahmanyam, P.A., 1992, "A pathoriented approach for reducing
hazards in asynchronous design," Proceedings of the Design Automation
Conference, 29th ACM/IEE, pp. 239244.
Zambonelli, F., Roli, A., and Mamei, M., 2003, "Dissipative cellular automata as
minimalist distributed systems : A study on emergent behaviors," 11th IEEE
EUROMICRO Conference on Parallel, Distributed, and Network Processing,
Genova (I), IEEE CS Press, pp. 250257.
BIOGRAPHICAL SKETCH
Niranjan Venkatraman was born in Bangalore, India, and obtained his Bachelor of
Engineering (B.E.) degree in Electrical and Electronics Engineering in May 2000 from
the College of Engineering, Guindy, Chennai, a part of Anna University. Since August
2000, he has been a Ph.D. student in the Department of Electrical and Computer
Engineering at the University of Florida, Gainesville, FL. During the pursuit of his Ph.D.,
he obtained his M.S. in Electrical and Computer Engineering from the University of
Florida in December 2002. His research interests include control theory, control systems,
automata theory, and the application of control theory to asynchronous networks and
parallel computation.

Full Text 
PAGE 1
ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES By NIRANJAN VENKATRAMAN A DISSERTATION PRESENTED TO THE GRADUATE SCHOOL OF THE UNIVERSITY OF FLOR IDA IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY UNIVERSITY OF FLORIDA 2004
PAGE 2
Copyright 2004 by Niranjan Venkatraman
PAGE 3
To my parents, who always stood by me.
PAGE 4
ACKNOWLEDGMENTS First and foremost, I would like to acknowledge the unflagging support and excellent supervision of my advisor, Dr. Jacob Hammer, during my four years at the University of Florida. I thank Dr. Haniph Latchman, Dr. Tan Wong, and Dr. John Schueller for all their efforts and their advice, and for serving on my Ph.D. supervisory committee. I would like to especially thank Xiaojun Geng (my officemate for three years) for our animated and interesting discussions. I also extend special thanks to my current officemates (Jun Peng and Debraj Chakraborty) for making the last year interesting and full of fun. Special thanks are also due to my roommates (Raj, Nand and Arun) for putting up with my eccentric behavior for four years. I would also like to thank all my friends; their unceasing friendship and care has made this work possible. Last but not the least, I would like to thank my parents, my grandmother, my sister, her husband and my other relatives for their unfailing love and support during all the years that I have been away from them. iv
PAGE 5
TABLE OF CONTENTS page ACKNOWLEDGMENTS.................................................................................................iv LIST OF TABLES.............................................................................................................vi LIST OF FIGURES..........................................................................................................vii ABSTRACT.....................................................................................................................viii CHAPTER 1 INTRODUCTION........................................................................................................1 2 TERMINOLOGY AND BACKGROUND................................................................10 2.1 Asynchronous Machines and States.................................................................10 2.2 Modes of Operation..........................................................................................14 3 INFINITE CYCLES...................................................................................................20 3.1 Introduction.......................................................................................................20 3.2 Detection of Cycles...........................................................................................22 3.3 Stable State Representations for Machines with Cycles...................................29 3.4 Stable Reachability...........................................................................................32 3.5 Matrix of Stable Transitions and the Skeleton Matrix......................................34 3.6 Corrective Controllers......................................................................................39 4 THE MODEL MATCHING PROBLEM...................................................................46 5 EXAMPLE.................................................................................................................59 6 SUM MARY AND FUTURE WORK........................................................................65 LIST OF REFERENCES...................................................................................................68 BIOGRAPHICAL SKETCH.............................................................................................76 v
PAGE 6
LIST OF TABLES Table page 51. Transition table for the machine ...........................................................................59 52. Stable transition table for the generalized stable state machine s..........................60 53. Matrix of onestep generalized stable transitions R(s)...........................................60 54. Stable transition function of the given model .......................................................61 vi
PAGE 7
LIST OF FIGURES Figure page 11. Control configuration for the asynchronous sequential machine .............................3 vii
PAGE 8
Abstract of Dissertation Presented to the Graduate School of the University of Florida in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES By Niranjan Venkatraman August 2004 Chair: Jacob Hammer Major Department: Electrical and Computer Engineering My study deals with the problem of eliminating the effects of infinite cycles on asynchronous sequential machines by using state feedback controllers. In addition to eliminating the effects of infinite cycles, the controllers also transform the machine to match the behavior of a prescribed model. My study addresses machines in which the state is provided as the output of the machine (input/state machines). Algorithms are provided for detecting infinite cycles in a given machine, for verifying the existence of controllers that eliminate the effects of infinite cycles, and for constructing the controllers whenever they exist. The feedback controllers developed in my study resolve the model matching problem for machines that are afflicted by infinite cycles. They transform the given machine into a machine whose input/output behavior is deterministic and conforms with the behavior of a prescribed model. Thus, the feedback control strategy overcomes the viii
PAGE 9
effects of infinite cycles as well as any other undesirable aspects of the machines behavior. Results include necessary and sufficient conditions for the existence of controllers, as well as algorithms for their construction whenever they exist. These conditions are presented in terms of a matrix inequality. The occurrence of infinite cycles produces undesirable behavior of afflicted asynchronous sequential machines. The occurrence of hazards has been a major problem since the early development of asynchronous sequential machines. There are many methods to design cyclefree machines; but the literature does not seem to contain any technique for eliminating the negative effects of infinite cycles in case it occurs in existing asynchronous sequential machines. ix
PAGE 10
CHAPTER 1 INTRODUCTION Asynchronous sequential machines are digital logic circuits that function without a governing clock. They are also described variously as clockless logic circuits, selftiming logic circuits, and asynchronous finite state machines (AFSMs). Asynchronous operation has long been an active area of research (e.g., Huffman 1954a, 1954b, 1957), because of its inherent advantages over commonly used synchronous machines. One of the more obvious advantages is the complete elimination of clock skew problems, because of the absence of clocks. This implies that skew in synchronization signals can be tolerated. The various components of the machine can also be constructed in a modular fashion, and reused, as there are no difficulties that are associated with synchronizing clocks. Further, the speed of the circuit is allowed to change dynamically to the maximal respond speed of the components. This leads to improved performance of the machine. Asynchronous machines are by nature adaptive to all variations, and only speed up or slow down as necessary (Cole and Zajicek (1990), Lavagno et al. (1991), Moon et al. (1991), Yu and Subrahmanyam (1992), Fisher and Wu (1993), Furber (1993), Nowick (1993), Nowick and Coates (1994), Hauck (1995)). Asynchronous machines also require lower power, because of the absence of clock buffers and clock drivers that are normally required to reduce clock skew. The switching activity within the machine is uncorrelated, leading to a distributed electromagnetic noise spectrum and a lower average peak value. Moreover, asynchronous operation is inherent in parallel computation systems (Nishimura (1990), Plateau and Atif (1991), Bruschi et al. (1994)). 1
PAGE 11
2 Asynchronous design is essential to ensure maximum efficiency in parallel computation (Cole and Zajicek (1990), Higham and Schenk (1992), Nishimura (1995)). Asynchronous machines are driven by changes of the input character, and are selftimed. In this context, it is vital to address design issues, especially those that can lead to potential inconsistencies in the pulses that propagate through the machine. These difficulties are referred to as hazards (Kohavi (1970), Unger (1995)). A cycle is one such potential hazard in the operation of asynchronous machines. It causes the machine to hang, as is demonstrated in software applications with coding defects that can cause the program to hang in an infinite loop. A critical race is another hazard that causes the machine to exhibit unpredictable behavior. These hazards can occur because of malfunctions, design flaws, or implementation flaws. The common procedure followed when a hazard occurs is to replace the machine with a new one, built with no defects. In our study, we propose to employ control techniques to devise methods that take a machine out of an infinite cycle and endow it with desirable behavior. Thus, we concentrate on the design of controllers that resolve infinite cycles and control the machine so as to achieve specified performance. To explain the mode of action of our controllers, a basic description of the structure of an asynchronous machine needs to be reviewed. An asynchronous machine has two types of states: stable states and unstable states. A stable state is one in which the machine may linger indefinitely, while an unstable state is just transitory, and the machine cannot linger at it. A cycle is a situation where the machine moves indefinitely from one unstable state to another, without encountering a stable state. Cycles can occur often in applications, brought about by errors in design, by errors in implementation, or
PAGE 12
3 by malfunctions of components, for example, errors in programming that lead to infinite cycles. The solution currently recommended in the literature for correcting an infinite cycle is to replace the affected machine by a new machine. The solution proposed in our study is, in many cases, more efficient. Moreover, it is the only practical solution in cases where the affected system is out of reach. The controllers we design are feedback controllers connected to the afflicted machine, as depicted in Figure 11. The controller is activated during a cycle. Whenever possible, the controller drives the machine out of the cycle, and leads it to a desirable state. We characterize all cycles from which there is an escape, and present an algorithm for the design of a controller that takes the machine out of any escapable cycle. uvyC c Figure 11. Control configuration for the asynchronous sequential machine Here, is the asynchronous machine being controlled, and C is another asynchronous machine that serves as a controller. We denote by c the closed loop system represented by Figure 11. The controller C eliminates the effects of the cycles of so that the closed loop system c matches a prescribed model (i.e., c = ). The goal is to provide necessary and sufficient conditions for the existence of such a controller C as well as an algorithm for its design. An important property of the controller C is that the closed loop system will function properly whether or not the
PAGE 13
4 cycle actually occurs. As a result, the controller C can be used to prevent the effects of cycles before they occur, improving the reliability of the system. It is important to note that during a cycle, the machine moves among unstable states in quick succession, without lingering in any of the cycle states. Consequently, it cannot be arranged for an input change to occur at a specific state of the cycle. Thus, the input changes enforced by the controller occur at random during the cycle, and it is not possible to predetermine the state of the cycle at which the controller acts. As a result, the outcome of the controller action is unpredictable in most cases. This could lead to a critical race condition being generated by the controller, which can then be rectified by known procedures (Murphy (1996); Murphy, Geng and Hammer (2002, 2003); Geng 2003; Geng and Hammer (2003, 2004a, 2004b)). When machine is an input state machine, i.e., the output of is the state of the controller C is called a state feedback controller. The existence of such a controller C that takes the system out of a cycle depends on certain reachability properties of the system. These reachability properties can be characterized in terms of a numerical matrix called the skeleton matrix of the system. The skeleton matrix is calculated from the various transitions of the machine. This skeleton matrix gives a methodology to derive the necessary and sufficient conditions for the existence of a corrective controller C. The function of the controller is twofold: it eliminates the effects of the cycle on the machine and assigns to the closed loop a specified behavior. The controller C functions by forcing an input character change while the machine is in a cycle; this may induce a critical race. The outcome of this unpredictable behavior is then used by the controller to assign a proper transition, as required to match the operation of the model.
PAGE 14
5 In this way, the cycles of the machine are stopped, and the machine exhibits the desired external behavior. The modelmatching problem described here is basically a continuation of the work of Hammer (1994, 1995, 1996a, 1996b); Murphy (1996); Murphy, Geng and Hammer (2002, 2003); Geng (2003); and Geng and Hammer (2003, 2004a, 2004b). There are a number of papers that relate to the modelmatching problem for synchronous sequential machines (Dibinedetto et al. (1994, 1995a, 1995b, 2001), Barrett and Lafortune (1998)). The studies relating to synchronous machines do not take into consideration the differences between stable and unstable states, fundamental and semifundamental mode of operation (Chapter 2), and other issues that are vital to the operation of asynchronous machines. Our study seems to be the first one to explore control theoretic tools to eliminate the effects of infinite cycles on asynchronous machines. Eliminating the effects of infinite cycles is not the only situation in which model matching is beneficial (Dibenedetto et al. (2001)). For example, most large digital system are designed in a modular fashion, with a number of subsystems. An error in the behavior of the machine detected late in the design phase may make it more economical to use a controller instead of redesigning, or rebuilding, the entire machine. In other words, model matching offers a lowcost option to remedy design and construction errors (Fujita (1993)). Moreover, the controller can also be used to improve the reliability and performance of the system, by deploying it before a fault develops in the system. In this way, the controller can guard against potential malfunctions, while being "transparent" before a malfunction occurs. Thus, in machines where high reliability is vital, our study provides a new design option.
PAGE 15
6 The early work on automata theory was carried out by Turing (1936). Huffman (1954a, 1954b, 1957) investigated various aspects of the synthesis of asynchronous relay circuits. There is a well established technical literature relating to the subject of design of hazardfree machines (e.g., Liu (1963), Tracey (1966), Kohavi (1970), Maki and Tracey (1971)). This is achieved by appropriate state assignment techniques. Classical methods for hazard free state assignments (Huffman (1954a, 1954b)) are reviewed in most textbooks on digital circuit design (e.g., Kohavi (1970)). More recently, studies on the subject were done by Masuyama and Yoshida (1977), Sen (1985), Datta et al. (1988), Nowick and Dill (1991), Fisher and Wu (1993), Chu (1994), Lavagno et al. (1994), Nowick and Coates (1994), and Lin and Devadas (1995). Evading hazards using a locally generated clock pulse was introduced by Unger (1977), Nowick and Dill (1991), and Moore et al. (2000). A graph theoretic approach for state assignment of asynchronous machines was introduced by Datta, Bandopadhyay and Choudhury (1988). Of course, all the above studies discuss the hazard free design of asynchronous machines, and can be applied only before the machine is constructed; only Murphy (1986); Murphy, Geng and Hammer (2002, 2003); Geng 2003; and Geng and Hammer (2003, 2004a, 2004b) detail methods to overcome hazards in an existing asynchronous machine. Other early works on the synthesis of asynchronous machines were by Mealy (1955) and Moore (1956). These works investigated state and circuit equivalence, and provided methods for synthesizing asynchronous and synchronous sequential machines. Their models of sequential machines are most commonly used today. In the work done by Liu (1963), all internal transitions of a machine go directly from unstable states to terminal states; with no sequencing permitted though stable states. This method of
PAGE 16
7 hazard free assignment (called single transition time state variable assignment) uses assignments similar to an equidistant errorcorrecting code. This kind of assignment, which can be accomplished by mapping the rows of a flow table onto the vertices of a unit ndimensional cube, is not guaranteed minimal, but it works effectively with incompletely specified flow tables. Tracey (1966) extended this work to techniques that maximize the speed of the machine. A method for sequencing (though unstable states are allowed before a stable state is reached when an input character is applied) was presented by Maki and Tracey (1971), using a technique called the shared row state assignment method. This method generally required fewer state variables than single transition time assignments. Other work on hazardfree state assignment techniques can be found in Hazeltine (1965); McCluskey (1965); Armstrong, Friedman and Menon (1968); Hlavicka (1970); Mago (1971); Chiang and Radhakrishnan (1990); Lavagno, Keutzer and SangiovanniVincentelli (1991); Piguet (1991); Oikonomou (1992); Chu, Mani and Leung (1993); and Fisher and Wu (1993). Some other techniques for avoiding hazards were proposed by Yoeli and Rinon (1964) and Eichelberger (1965). They proposed ternary logic models to analyze certain aspects of the machines. Ternary algebra seems to provide an efficient method for detection and analysis of hazards in sequential circuits. These models were further worked on by Brzozowski and Seger (1987, 1989) and Brzozowski and Yoeli (1987). Another method of avoiding hazards was by generating a clock pulse from other signals in the machine (Bredeson and Hulina (1971), Whitaker and Maki (1992)). Most applications of asynchronous machines assume that the environment of operation is the fundamental mode (Unger (1969)); that is, an input change is applied
PAGE 17
8 only after the machine has reached stability. No input change is allowed when the machine transits through unstable states. Our study specifies conditions where fundamental mode is not applicable, leading to what is called semifundamental mode of operation (Chapter 2). Recent work in asynchronous sequential machines allows the simultaneous change of several input variables. This mode of operation is referred to as burstmode (Davis et al. (1993a), Nowick (1993), Yun (1994), and Oliviera et al. (2000)). Deterministic behavior of the machine in this approach needs special restrictions to be imposed on the machine. Plenty of literature is available on the application of control theory to automata and asynchronous machines under discrete event systems. One such example that can be readily quoted is supervisory control (Ramadge and Wonham (1987, 1989)). This is based on formal language theory, and assumes that certain events in the system can be enabled or disabled. The control of the system is achieved by choosing control inputs such that the events are enabled or disabled. Literature on discrete event systems is extensive (Ozveren et al. (1991), Lin (1993), Koutsoukos et al. (2000), Alpan and Jafari (2002), Hubbard and Caines (2002), Park and Lim (2002)). Our study employs finite state machines models, which are more suitable to the investigation of engineering implementations than formal language theory (Dibenedetto et al. (2001)). Asynchronous machines are widely used in industry, as they result in economical digital systems. Some examples of industrial applications are the adaptive routing chip (Davis et al. (1993b)), a cache controller (Nowick et al. (1993)) and the infrared communications chip (Marshall et al. 1994).
PAGE 18
9 The organization of this dissertation is as follows. Terminology and background is provided in Chapter 2. A detailed analysis of infinite cycles, detection algorithms, and the existence conditions are detailed in Chapter 3. This chapter also introduced the concepts of generalized state machines, and the use of transition matrices and skeleton matrices in determining the existence of the controller. Chapter 4 gives a detailed solution to the model matching problem for asynchronous sequential machines with cycles, and an algorithm for the construction of the controller. Chapters 3 and 4 contain the necessary and sufficient conditions for the existence of a controller. An example is solved in Chapter 5, detailing the transition and output functions of the controller states, and finally, a conclusion and possible directions of further research are provided in Chapter 6.
PAGE 19
CHAPTER 2 TERMINOLOGY AND BACKGROUND 2.1 Asynchronous Machines and States Here, the background and notation is introduced and the basic theory of asynchronous sequential machines is described. An asynchronous machine is activated by a change of its input character; it generates a sequence of characters in response. To explain the mathematical theory, we introduce the notation and terminology involved in describing sequence of characters. An alphabet is a finite nonempty set A; the elements of this set are called characters. A word w over an alphabet A is a finite and ordered (possibly empty) string of characters from A. Let A be a finite nonempty alphabet, let A* denote the set of all strings of characters of A, including the empty string, and let A+ be the set of all nonempty strings in A*. The length w of a string w A* is the number of characters of w. For two strings w1, w2 A*, the concatenation is the string w := w1w2, obtained by appending w2 to the end of w1. A non empty word w1 in A* is a prefix of the word w2 if w2 = w1w; and w1 is a suffix of the word w2 if w2 = ww1, where w, w A*. A partial function f : S1S2 is a function whose domain is a subset of S1 (Eilenberg (1974)). We now introduce the concept of a sequential machine. A sequential machine provides a working mathematical model for a computing device with finite memory. It has the following characteristic properties: 10
PAGE 20
11 A finite set of inputs can be applied to the machine in a sequential order. There is a finite set of internal configuration that the machine can be in. These configuration are called states, and physically, these states correspond to the setting on the flip flop or the bit combinations in memory devices. The current internal configuration or state and the applied input character determine the next internal configuration or state that the machine achieves. For deterministic systems, the next state is unique. There is a finite set of input characters. There are two broad classes of sequential machines: asynchronous machines and synchronous machines. An asynchronous sequential machine responds to input changes instantaneously as they occur. On the other hand, a synchronous sequential machine is driven by a clock, and the values of input variables affect the machine only at clock "ticks". The current work concentrates on asynchronous sequential machines. These machine describe the structure of the fastest computing systems. An asynchronous machine is defined by the sextuple := (A,Y,X,x0,f,h), where A, Y, and X are nonempty sets, x0 is the initial state, and f : XA X and h : XA Y are partial functions. The set A is the set of input values, Y is the set of output values, and X is the set of states. The partial function f is the recursion function and h is the output function. The operation of the machine is described by the recursion xk+1 = f(xk, uk), yk = h(xk, uk), k = 0, 1, 2, (21) A valid pair (x,u) XA is a point at which the partial functions f and h are defined. We assume that the initial state x0 is provided with An input sequence is permissible when all pairs (xk, uk), k = 0, 1, 2, ... are valid pairs. The integer k acts as the step counter. An increment in the step counter takes place with every change of
PAGE 21
12 the input value or with a state transition. For consistency, we assume that the functions f and h have the same domain. It is clear from the above description that the recursion (21) represents a causal system. When the output function h only depends on the state and does not depend on the input, the machine induces a strictly causal system. If the functions f and h are functions rather than partial functions, the machine is said to be complete. A deterministic finite state machine is often referred to as the Mealy machine (Mealy (1955)). If the output function does not depend on the input variable, then the machine is referred to as the Moore machine (Moore (1956)). An asynchronous Mealy machine can be transformed into an equivalent Moore machine, and vice versa. A nondeterministic finite state machine = (A,Y,X,x0,f,h) has the following objects: A finite, nonempty set A of permissible input characters, termed as the input alphabet; A finite, nonempty set Y of permissible output characters, termed as the output alphabet; A finite, nonempty set X of states of the machine. Any number of the states can be designates as initial or terminal states; A nondeterministic partial transition function f : (X)A (X), where (X) denotes the set of all the subsets of X (i.e., the power set of X); A partial function h : XA Y, called the output function; and The initial state of the machine x0 X. The transition function f can generate sets of states as its values, i.e., f(x,a) = {x1, xk}, rather than just single values; here x1, xk X and a A. In contrast, the output function h takes only single values, i.e., there can be only one output character
PAGE 22
13 associated with each state. The class of deterministic finite state machines is a subclass of nondeterministic finite state machines. The operation of the machine can be described as follows. The machine starts from the initial state x0 and accepts input sequences of the form u := u0 u1 ... where u0, u1, A. In response to this set of applied input characters, it generates a sequence of states x0, x1, x2, X and a sequence of output values y0, y1, y2, ... Y, according to the recursion in Equation 21. Finally, the machine is an input/state machine when Y = X and the output is equal to the state at each step, that is, yk = xk, k = 0, 1, 2, (22) An input/state machine can be represented by the quadruple (A,X,x0,f), since the output is the state. Using the notion of the transition function f, we can define the partial function f*: XA+ X by setting f*(x,u) := f(f(f(f(x,u0),u1),u2),uk) for some state x X and an input string u = u0u1u2uk A+. Thus, f* provides the value of the last state in the path generated by the input string u. For simplicity of notation, we will use f for f*. Some basic terminology important to the study of asynchronous machines is now described. A valid pair (x,u) XA of the machine is called a stable combination if f(x,u) = x, i.e., if the state x is a fixed point of the function f. An asynchronous machine will linger at a stable combination until an input change occurs. A pair (x,v) that is not a stable combination is called a transient combination. A potentially stable state x is one for which there is a stable combination. Of course, states that are not potentially stable serve only as transition states; the machine cannot stop or linger in
PAGE 23
14 them, and they are not usable in applications. Due to this, it is common practice to ignore states that are not potentially stable; will adhere to this practice and not include such state in our state set. Consider the sequential machine of Equation 22. Let x be the state of the machine and u the input value. When a stateinput pair (x,u) is not a stable combination, the machine will go through a chain of input/state transitions, starting from (x,u), which may or may not terminate. If the machine reaches a stable combination (x,u) with the same input value, then the chain of transitions terminates. It must be noted that the input value must remain constant throughout the entire transition; and the transition will end if and only if such a stable combination as (x,u) exists. In such a case, x is called the next stable state of x with input value u. When the next stable state is not uniquely determined, that is, the transition at some point has more than one value, we have a critical race. In case there is no next stable state for x with input value u, we obtain an infinite cycle. Critical races and infinite cycles are the types of hazards that can occur in an asynchronous machine. 2.2 Modes of Operation When the value of an input variable is changed while the asynchronous machine undergoes a chain of transitions, the response of the machine may become unpredictable, since the state of the machine at which the input change occurs in unpredictable. To avoid this potential uncertainty, asynchronous machines are usually operated in fundamental mode, where only one variable of the machine is allowed to change each time. In particular, in fundamental mode operation, a change in the input variable is allowed only while the machine is in a stable combination.
PAGE 24
15 One of the main topics of our present discussion relates to the control of an asynchronous machine in an infinite cycle. When a machine is in an infinite cycle, fundamental mode operation becomes impossible, since the machine will not reach a stable combination without a change of the input variable. Nevertheless, we will show later that, when taking the machine out of its infinite cycle, it is not necessary to forego fundamental mode operation for more than one step. When an asynchronous machine operates in fundamental mode in all but a finite number of steps, we say that it operates in semifundamental mode. The conditions and procedures for operation in semifundamental mode is described in Chapter 3. Consider a defectfree asynchronous machine = (A,X,x0,Y,f,h) operating in fundamental mode. Let the machine start at the state x0, and be driven by the input string w = v0v1vm. The machine now has transitions through the states x0,, xm, where xi+1 = f(xi,vi); i = 0,1,2,,m1, where the last pair (xm,vm) is a stable combination. Fundamental mode operation implies that vi = vi+1 whenever (xi,vi) is not a stable pair, i = 0,,m. The path is defined as the set of pairs P(,x0,w) = {(x0,v0), (x1,v1),,(xm,vm), (xm,vm)}. (23) When a cycle occurs, there is no final stable pair, and the path becomes infinite P(,x0,w) = {,(xi,vj), (xi+1,vj),,(xi+,vj), (xi,vj),}. As mentioned earlier, the step counter k advances one step during each state transition or input change. Of course, for fundamental mode operation, the input character remains constant during all transition chains.
PAGE 25
16 Consider the case where the input value of the machine is kept constant at the character v, while the machine goes through a string of state transitions. At each state transition, the step counter of the system advances by one. This results in the input value being represented as a repetitive string vvv... v, where each repetition corresponds to an advance of the step counter. It is convenient to represent all such repetitions of the input character by a single character, so that, for example, a string of the form w = v0v0v1v1v1v2v2 is represented by w = v0v1v2. Here, it is understood that each input value is repeated as many times as necessary. In the case of an infinite cycle, the input value is repeated indefinitely. Next, let be an asynchronous machine without hazards. Then, the notion of the next stable state leads to the notion of the stable transition function, which plays an important role in our discussion. As the machine has no hazards, every valid pair (x,u) of has a next stable state x. Define a partial function s : XA X by setting s(x,u) := x for every valid pair (x,u), where x is the next stable state of x with the input character u. The function s is called the stable transition function of the machine Note that the stable transition function describes the operation of the machine in the fundamental mode, i.e., under the requirement that the input value be changed only after the machine reaches a stable combination. This is a standard restriction in the operation of asynchronous machines, and it guarantees that the machine produces a deterministic response. The stable transition function can be used to describe the operation of an asynchronous machine in the following way. We know that the machine always starts from a stable combination (x0,u1), at which the machine has been lingering for
PAGE 26
17 some time. Suppose now that an input string u := u0u1uk A+ is applied to the machine. Then, the machine moves through the a list of states x1, xk+1 of next stable states, where xi+1 = s(xi,ui), which implies that (xi+1,ui) is a stable combination for i = 0, 1, k. The input list u is permissible if (xi,ui) is a valid combination for i = 0, 1, k. Since the machine operates in the fundamental mode, the input character changes from ui to ui+1 only after the stable combination (xi+1,ui) has been reached. This guarantees that the state of the machine is well determined at the time when the input value changes. In general, when a machine does not have infinite cycles, the intermediate transitory states are ignored, as they occur very speedily and are not noticeable by a user. Thus, the operation of an asynchronous machine without infinite cycles, as observed by a user, is best described by the stable transition function s. However, when the machine has infinite cycles, it is not possible to ignore the transitory states involved in the cycle, as the machine lingers among these transitions indefinitely. In Chapter 3, we will introduce a generalized notion of the stable transition function which accommodates infinite cycles by considering them as another form of persistent states. Using the stable transition function s, we define the asynchronous sequential machine s := (A,X,Y,x0,s,h), which is called the stable state machine induced by For an input/state machine, the stable state machine is given by the quadruple (A,X,x0,s). To deal with input strings, we can define a partial function s* : XA+ X by setting s*(x,u) = s(s(s(s(x,u0),u1),u2),uk), for some state x X and a permissible input string u = u0u1uk A+. The partial function s* provides the last state in the
PAGE 27
18 path generated by the input string u. As before, we shall abuse the notation somewhat by using s for s*. In the case where we do not have a Moore machine, we can define the partial function h* : XA+ Y in a similar fashion by setting h*(x,u) := h(s(s(s(x,u0),u1),u2),uk) for a state x X and a permissible input string u = u0u1uk A+, as was done for the stable transition function s defined earlier. The partial function h* gives the last output value generated by the input list u. It is necessary in some cases to compare different states of a sequential machine. Two states x and x of a machine are distinguishable if the following condition is valid: there is at least one finite input string which yields different output sequences when applied to starting from the initial states x or x. Two states x and x of the machine are equivalent when, for every possible input sequence, the same output sequence is produced regardless of whether the initial state is x or x. Qualitatively, two states are equivalent if we cannot distinguish them by the input/output behavior of the machine. If two states are equivalent, then so are all corresponding states included in any paths started from x and x. If a machine contains two equivalent distinct states, then one of the states is redundant, and it can be omitted from the mathematical model of the machine. A machine is minimal or reduced if it has no distinct states that are equivalent to each other. Consider two machines = (A,Y,X,f,h) and = (A,Y,X,f,h). Let x be a state of and let x be a state of The states x and x are equivalent if both have the same permissible input sequences, and if, for every permissible input sequence, the output sequence generated by from the initial state x is the same as the output
PAGE 28
19 sequence generated by from the initial state x. The two machines and are equivalent whenever there exists an equivalent state in for everystate in, and similarly, an equivalent state in for every state in A number of texts dwell on the various aspects of the theory of sequential machines and automata, including McCluskey (1965); Arbib (1969); Kalman, Falb and Arbib (1969); Kohavi (1970); Eilenberg (1974); and Evans (1988).
PAGE 29
CHAPTER 3 INFINITE CYCLES 3.1 Introduction An infinite cycle is caused when there is no next stable state for a valid pair (x,u) of a finite state asynchronous machine = (A,X,x0,Y,f,h). In such case, the machine will keep moving indefinitely from one transient combination to another. Only a finite number of states can be involved in these transitions, since is a finite state machine. An infinite cycle can then be characterized by listing these states and the corresponding input which causes the infinite cycle. Specifically, let the state set of be X = {x1, x2, ..., xn}. Consider a infinite cycle of that involves p states, say the states x k1 x k2 ..., x k X, and let a A be the input character causing the infinite cycle. The infinite cycle then functions according to the recursion x kj+1 = f(x kj a), j = 1, ..., and x k1 = f(x k a). (31) As a shorthand notation, we will use = {a;x k1 x k2 ..., x k }, where a is the input character of the infinite cycle, and x k1 x k2 ..., x k are its states. A stateinput pair (x kj ,a), for some j = 1, is then said to be a pair of the cycle The length of the infinite cycle is defined as the number of distinct states it contains. It follows that a cycle of length has distinct inputstate pairs. A brief examination of Equation 31 leads to the following conclusion: Let (x,a) be any pair of the infinite cycle Then, x 20
PAGE 30
21 is a state of if and only if there is an integer j such that x = fj(x,a). Then, the recursion can be followed for the entire length of the cycle. It is convenient to denote by {fj(x,a)}j=0 the set of all distinct states included in the set {x, f(x,a), f2(x,a), ...}. This leads us to the following lemma. Lemma 31 Let (x,a) be any pair of the infinite cycle Then, the state set of is {fj(x,a)}j=0. Lemma 31 gives a way of finding the states of a cycle. A machine can have several infinite cycles, and we demonstrate below an algorithm that finds all infinite cycles of a given machine. It is relevant to see that an infinite cycle of length 1 is nothing but a stable combination. To distinguish between infinite cycles and stable combinations, the length of an infinite cycle must at least be 2. According to the next statement, infinite cycles associated with the same input character must have disjoint state sets. Lemma 32 A valid input/state pair (x,a) of an asynchronous machine can be a member of at most one infinite cycle. Proof 32. Let 1 and 2 be two infinite cycles of the machine associated with the same input character a. If 1 and 2 contain the same pair (x,a), then, using Lemma 31, we conclude that 1 and 2 have the same state set. In other words, 1 = 2, and our proof concludes. The above Lemma 31 gives us an insight into the structure of the cycle. Since no state can be a member of more than one cycle, we can say that a pair of a cycle is unique to that cycle. We can now find a bound on the maximal number of infinite cycles a
PAGE 31
22 machine can have. Indeed, consider the set of all infinite cycles involving the input character a. In view of Lemma 32, all such infinite cycles have disjoint state sets. But then, the fact that a infinite cycle must contain at least 2 states, implies that there cannot be more than n/2 such infinite cycles, where n is the number of states of the machine. Finally, recalling that the machine has m input characters, we obtain the following. (Denote by [a] the largest integer not exceeding a.) Proposition 33 Let be a sequential machine with n states and an alphabet A consisting of m characters. Then, cannot have more than m[n/2] infinite cycles. For the sake of brevity, infinite cycles will be referred to as just cycles in the rest of the document. 3.2 Detection of Cycles In this section, a procedure to detect the cycles associated with a machine will be outlined. Consider an asynchronous machine = (A,X,x0,Y,f,h) with n states and an alphabet A of m input characters. Next all the cycles of the machine will be determined. To this end, an nn matrix M(f) is recursively constructed as follows. The (i,j) entry of M(f) is the set of all characters u A for which xi = f(xj,u). If there is no input character u A for which xi = f(xj,u), then the (i,j) entry of M is denoted where is a character not included in the alphabet set A. Thus, the matrix becomes Mi,j(f) := (32) i, j = 1, ..., n. Multiple entries in a cell are separated using a comma. We refer to M(f) as the onestep transition matrix of the machine iju A : x f(x,u), otherwise,
PAGE 32
23 We now define two matrix operations for onestep transition matrices. First, the sum of two nn onestep transition matrices A and B is defined element wise by (A B)ij := Aij Bij, i, j = 1, ..., n. (33) The sum operation is reminiscent of the numerical addition of matrices. The following operations on members of the set A is now defined. := u1 := u1 := u1u1 := u1u1u2 := := u1 := u1u1 u1 := u1 u2 := (34) Also, for any two sets, the operation of multiplication is defined by {a1, a2, ..., aq}.{b1, b2, ..., br} = {aibj}i=1, ...,q, j=1, ...,r This is similar to the classical definition of the scalar product of two vectors. Using these operations of multiplication, the definition of matrix combination is defined as follows. (AB)ij := k=1, ..., nAikBkj for all i, j = 1, ..., n. (35) Consider two functions g, h : XA X. The composition of g and h is defined by gh(x,u) := g(h(x,u),u). The composition of function is closely related to the combination of the corresponding onestep transition matrices, as indicated by the following. The next statement shows that the multiplication of two onestep transition
PAGE 33
24 matrices on two recursion functions is the transition matrix on the composition of the two functions. Lemma 34 Let g, h : XA X be two recursion functions with one step transition matrices M(g) and M(h), respectively. Then, M(g)M(h) = M(gh). Proof 34. Using Definition 34, we have M(g)M(h) = k=1..n Mi,k(g)Mk,j(h). (36) Now, each entry of M(g)M(h) is either a character of A or ; the definition of matrix composition implies that the following two statements are equivalent: (i) The (i,j) element of M(g)M(h) is u. (ii) There is a k {1, ..., n} for which Mi,k(g) = u and Mk,j(h) = u. When (ii) holds, we have xi = g(xk,u) and xk = h(xj,u), so that xi = g(h(xj,u),u) = gh(xj,u). Then, the (i,j) entry of M(gh) is u. Conversely, if the (i,j) entry of M(gh) is u, then xi = gh(xj,u), so that xi = g(h(xj,u),u). Now, the value h(xj,u) is, by definition, an element of X, say the element xk, k {1, ..., n}. Then, xk = h(xj,u) and xi = g(xk,u), which implies that (ii) is valid for this k. Thus, we have shown that (ii) is equivalent to (iii) Mi,j(gh) = u. Using the fact that (ii) is equivalent to (i), the Lemma follows. Thus, the product of two transition matrices with two different transition functions is the transition matrix of the composition of the two functions in the order of multiplication. Consider now the a machine with recursion function f. Let M(f) be
PAGE 34
25 its onestep transition matrix. Then, by Lemma 34, M(f)M(f) = M(f2), M(f2)M(f) = M(f3), and so on. This leads to the following corollary. Corollary 35 Let = (A,X,x0,Y,f,h) be an asynchronous machine. Then, for every integer p > 0, the onestep transition matrix satisfies Mp(f) = M(fp). Consider a machine = (A,X,x0,Y,f,h). As mentioned earlier, a stable combination (x,u) of can be considered as a cycle of length 1. This observation helps simplify the following statement, which forms an important tool in our process of finding all cycles of the machine Lemma 36 Let be an asynchronous machine with the recursion function f and the state set X = {x1, ..., xn}. Let xi X be a state and let u be an input character of Then, the following three statements are equivalent. (i) There is an integer 1 such that xi = f(xi,u) (ii) u appears on the (i,i) diagonal entry of the matrix M(f). (iii) (xi,u) is a pair of a cycle whose length is an integer divisor of Proof 36. First, we show that (i) implies (ii). Assume that (i) is valid, so that xi = f(xi,u) for some integer 1. Then, by Equation 32, the character u appears on the diagonal entry (i,i) of the matrix M(f). By Corollary 35, M(f) = M(f); this implies that u appears on the diagonal entry (i,i) of the transition matrix M(f). Next, we show that (ii) implies (iii). Let 1 be the smallest integer satisfying xi = f(xi,u). Then, Now, if = 1, then (xi,u) is a stable combination of and hence forms a cycle of length 1. Otherwise, (xi,u) is a pair of the cycle {xi, f(xi,u), ..., f(xi,u); u} of length
PAGE 35
26 Now, using the integer division algorithm, we can write = q + where q and are integers and 0 < If > 0, then, using the equality xi = f(xi,u), we can write xi = f(xi,u) = f(fq(xi,u),u) = f(xi,u), so that xi = f(xi,u). The latter contradicts the fact that was the smallest integer satisfying xi = f(xi,u), since 0 < < Thus, we must have = 0, and must be an integer divisor of Finally, we show that (iii) implies (i). Assume that (iii) is valid, i.e., that (xi,u) is a pair of a cycle whose length is a divisor of Then, there is an integer q such that = q. But then, f(xi,u) = fq(xi,u) = xi, and (i) is valid. This concludes the proof. Thus, by taking the powers of the onestep transition matrix M(f) and observing the diagonal matrix at each step, the states of the machine involved in cycles can be isolated. The next lemma indicates a method of identifying the elements of each cycle. Lemma 37 Let be an asynchronous machine with state set X = {x1, ..., xn} and recursion function f. Assume that has a cycle of length > 1 that includes the pair (xj0,u). Then, the other states xj 1 ..., xj of the cycle can be found from the matrix M(f) in the following way: for every integer i = 0, ..., the index ji+1 is given by the position of the entry u in the column ji of the matrix M(f). Proof 37. Consider a cycle of length > 1. Let {xj0, xj1, ..., xj} be the states involved in the cycle, and let u be the input character. We know f(xj0,u) = xj1. This implies that the input character u appears exactly in the position (j0, j1) of the matrix M(f). Thus, the value of j1 is given by the position of the character u in the row j0. Continuing recursively, assume that, for some 0 k < the indices j0, j1, ..., jk of the states xj0, xj1, ..., xjk of the cycle have been found. Then, since xjk+1 = f(xjk,u), the
PAGE 36
27 character u will appear exactly in position jk+1 of the row jk of the matrix M(f). This concludes our proof. Thus, the knowledge of the states involved in cycles of a particular length can be used to find the cycles specifically by applying Lemma 37. An algorithm that finds all the cycles of an asynchronous machine whose recursion function is f will now be outlined. Let #A denote the number of elements in the set A. Algorithm 38 Let = (A,X,x0,Y,f,h) be an asynchronous machine, and let M(f) be its transition matrix. Step 1: All entries on the main diagonal of M(f) represent stable combinations (i.e., cycles of length 1). For each input character u A, let 1(u) be the set of all states for which u is included in a diagonal entry of the matrix M(f); set 1(u) := 1(u). Step 2: For i 2, let i(u) be the set of all states for which u is included in a diagonal entry of the matrix Mi(f). Define the difference set i(u) := i(u) \ 1 j i1 j(u). (37) Stop the algorithm for the character u when i+1 > n ij=1 #j(u). The significance of Algorithm 38 is pointed out by the following statement. Proposition 39 Let i 1 be an integer. Then, in the notation of Algorithm 38, the following are true. (i) The set i(u) consists of all states of the machine that are members of cycles of length i with the input character u. (ii) The machine has exactly #i(u)/i cycles of length i.
PAGE 37
28 Suppose there are 2 states in (u). This means there are 2 cycles of length in the machine. Pick one state from (u); use Lemma 37 to find the other members of that cycle. Now, pick another state from the remaining states in (u), and using Lemma 37, the second cycle can be determined. This procedure is extended to any number of cycles of a certain length. Proof 39. Let X = {x1, ..., xn} be the state set of and let u A be a character of the input set. By Lemma 36, the following two statements are equivalent: (a) The matrix Mi(f) has an entry including u on its main diagonal, in a column that corresponds to the state xr of (b) The state xr is a member of a cycle whose length is i or an integer divisor of i. The case i = 1 is simple, since the elements on the main diagonal of M(f) represent the stable combinations of the system, and whence the cycles of length 1. For i > 1, assume that the algorithm has not stopped before i, i.e., that i n ij=1 #j(u). Then, a slight reflection shows that the construction Equation 37 of i(u) removes all states that are included in cycles of length less than i. Combining this with the equivalence of (a) and (b), it follows that xr i(u) if and only if xr is a member of a cycle of length i. Finally, consider the case where i+1 > n ij=1 #j(u), and (u) be the number of states of that are members of cycles of length i with the character u. From the definition of j(u), it follows that (u) = ij=1 #j(u). Thus, when i + 1 > n (u), there are not enough states left to form a cycle of length i + 1 with the character u; whence
PAGE 38
29 the machine has no cycles of length greater than i with the character u. This completes the proof of part (i) of the Proposition. Regarding part (ii) of the Proposition, note that the set i(u) consists of all states that form cycles of length i with the input character u. By Lemma 32, no two cycles can have common states. Consequently, the number of elements of i(u) is a multiple of i, and the number of cycles in i(u) is given by #i(u)/i. This concludes our proof. 3.3 Stable State Representations for Machines with Cycles In this section, a form of representation of only the next stable states and the extension of the definitions to the case of a machine with cycles will be explained. For an asynchronous machine = (A,X,Y,x0,f,h)without cycles, a valid pair (x,u) always has a next stable state x. Consequently, for such a machine, one can define a partial function s : XA X by setting s(x,u) = x for every valid pair (x,u). The function s is then called the stable recursion function of the machine When s is used as a recursion function, it induces the stablestate machine s = (A,X,Y,x0,s,h). The stable state machine describes only persistent states of the machine, and ignores unstable transitions. This function describes the behavior of as experienced by a user, i.e., the transition of the machine to its next stable state is described. A reformulation of the finite state machine with cycles will now be explained, so that an equivalent stable state machine can be described from this reformulated machine. As mentioned earlier in Chapter 2, asynchronous machines are normally operated in fundamental mode. In specific terms, fundamental mode operation is as follows. Let be an asynchronous machine without cycles, resting in a stable combination (x,u0).
PAGE 39
30 Consider a string of input values u = u1uk A+ applied to the machine. When the input of switches to u1, the machine may engage in a string of transitions culminating in the next stable state s(x,u1). In fundamental mode operation, the input character u1 is kept fixed until the machine has reached its next stable state, to guaranty deterministic behavior. Then, once the machine reaches the stable combination (s(x,u1),u1), the input character is switched to u2, and the machine eventually settles on its next stable state s(s(x,u1),u2). This process continues until we reach the final input value uk. The last stable state reached in this process is given by x" := s((s(s(s(x,u0),u1),u2),uk). To simplify our notation, we shall write in brief x" := s(x,u). As mentioned earlier, the stable state machine describes persistent states of an asynchronous machine. For machines with cycles, a cycle describes a persistent state of the machine (i.e., the "state" of being in a cycle). Hence, when cycles are present, they must be represented in the stable state machine. Our next objective is to generalize the definition of the stable state machine, so it gives due representation to cycles, whenever they are present. Consider an asynchronous machine = (A,Y,X,x0,f,h) having t > 0 cycles 1, ..., t. To define a stable state machine s that represents the persistent behavior of we first augment the state set X of by t new elements xn+1, ..., xn+t to obtain the augmented state set X := X {xn+1, ..., xn+t}. (38) Each one of the new states, called the cycle states, corresponds to one of the cycles of i.e., xn+i corresponds to the cycle i, i = 1, ..., t.
PAGE 40
31 Define the function s : XA X by setting s1(x,u) = (39) n+1is(x,u) if x X and (x,u) is a stable combination,x if (x,u) For a cycle = {x k1 x k2 ..., x kp ;a}, ki [1,,n], denote s1[,u] := {s1(x k1 ,u), s1(x k2 ,u), ..., s1(x kp ,u)}. (310) Now, the function s2 : XA X is defined by setting s2(x,u) := (311) 11is(x,u) if x X,s[,u] if x = x. n+i The generalized stable state machine s of is then the input/state machine defined by quintuple (A,X,x0,s2). For the sake of notational convenience, we will omit the primes from s2 in the future, and write s = (A,X,x0,s). The function s is called the generalized stable recursion function of A cycle associated with a cycle state x is said to be stoppable if there exists an input character u A such that at least one of the outcomes of s(x,u) X. In the present work, we assume that all the cycles are stoppable. It is necessary to make this assumption; if not, there will be no controller that can stop the cycle. Note that when there are no cycles, the generalized stable recursion function of is identical to the stable recursion function of Let cs be the generalized stable state machine induced by the closed loop system c shown in Figure 11. The present work concentrates on finding the solution to the next statement; consequently, this statement is the main topic of our discussion.
PAGE 41
32 The Model Matching Problem 310 Let be a machine and let be a stable state machine with the same input and output alphabets as Find necessary and sufficient conditions for the existence of a controller C such that the generalized stable state machine cs = When C exists, provide a method for its design. The controller C of Problem 310 assigns to closed loop system the stable state behavior of the specified machine Of particular interest to us here is the case where the machine has infinite cycles. In such case, the controller C of 310 eliminates the effect of infinite cycles on the closed loop system. The model matching problem for asynchronous machines with critical races, but not infinite cycles, was discussed in Murphy 1996, Murphy, Geng and Hammer 2002, 2003, Geng 2003In the following section, a solution for the model matching problem for the case where the controlled system has infinite cycles is derived, and in Chapter 5 the design of an appropriate controller is demonstrated by means of an example. 3.4 Stable Reachability The extension of the stable state machine to machines with cycles will now be described. This requires a reformulation of the machine. Consider an asynchronous machine represented by the sextuple (A,Y,X,x0,f,h), and assume that has t > 0 cycles 1, ..., t. Let s = (A,X,x0,s), where X = X {xn+1, ..., xn+t}, and xn+i is the generalized state corresponding to the cycle i. We aim to define the notion of stable reachability for the machine so as to characterize the "stable" states can reach from a given initial condition, in response to various input strings. To this end, we need to define several notions. A generalized stable combination of the machine is either a
PAGE 42
33 stable combination of or a pair of the form (xn+i,u), where u is the input character of the cycle i. A state of s is potentially stable if it is part of a generalized stable combination of When applying a control input to a machine that is in an cycle, it is not possible to operate in the fundamental mode. The input character must be changed while the cycle is in progress in order to attempt to interrupt the cycle. In other words, the input character is changed while the machine is not in a stable combination. Of course, if this change in input leads the machine to a stable combination, then fundamental mode operation can be resumed from there on. We arrive at the following notion, which describes the mode of operation that is closest to fundamental mode operation. Definition 311 A machine is said to operate in semifundamental mode if the machine operates in fundamental mode when it is not in an cycle. Recall that the states of the generalize stablestate machine s are either potentially stable states of or cycle state that represent cycles. Thus, semifundamental mode operation of becomes fundamental mode operation of s. Definition 312 Let be an asynchronous machine with generalized state set X and generalized stable recursion function s. A state x X is stably reachable from a state x X if there is a input string u = u0u1uk of for which x = s(x,u). The following assumption is essential in determining the controller operation. If an input character forms a valid combination with one outcome of a critical race, then it forms a valid combination with all other outcomes of the same race. This assumption can always be satisfied by extending the definition of the recursion function of the machine.
PAGE 43
34 It is necessary to assume this statement because we need the controller to be operational will all outcomes of the critical race that follows the cycle. 3.5 Matrix of Stable Transitions and the Skeleton Matrix Consider an asynchronous machine = (A,Y,X,x0,f,h) with the state set { x1, ..., xn}, and assume that has t > 0 cycles 1, ..., t. Let s = (A,X,x0,s), where X = X {xn+1, ..., xn+t} and xn+i is the generalized state corresponding to the cycle i. Let sx(xj,xi) be the set of all characters u A such that xi s(xj,u). The matrix of onestep generalized stable transitions gives all the possible stable onestep transitions of the machine s; it is an (n+t)(n+t) matrix R(s), whose (i,j) entry is given by Rij(s) = xjixjis(x,x) if s(x,x) ,N otherwise, (312) i, j = 1, ..., n+t. Recall that, if xj is a generalized state, then a critical race may occur when an input character u is applied at xj. This race is represented in the matrix R(s) by the appearance of the character u in more than one row of column j. Note that Equation 312 is similar to Equation 32, except for the fact that R(s) has some augmented states instead of cycles. We turn now to a description of some operations on the matrix R(s). Let A* be the set of all words over the alphabet A. The operation of unison / is defined over the set A* N as follows. Let w1, w2 be either subsets of the set A* or the character N; then, set
PAGE 44
35 w1 / w2 := (313) 121211221212w w if w A* and w A*,w if w A* and w = N,w if w = N and w A*,N if w = w = N. Extending this definition to matrices, the unison C := A / B of two nn matrices A and B is defined by Cij := Aij / Bij, i, j = 1, ..., n, i.e., an elementwise operation as defined in Equation 313As usual, the concatenation of two words w1, w2 A* is given by w1w2, i.e., w1 followed by w2. For elements w1, w2 are elements of A* or the character N, the concatenation is defined as follows. conc(w1,w2) := (314) 121212ww if w, w A*,N if w = N or w = N. More generally, let W = {w1, w2, wq} and V = {v1, v2, vr} be two subsets, whose elements are either words of A* or the character N. Define conc(W,V):= / conc(wi,vj). (315) i=1,...,qj=1,...,r Note that the concatenation is either a subset of A*, or it is the character N. The concatenation is noncommutative, and N takes the place of a "zero". Let C and D to be two nn matrices whose entries are subsets of A* or the character N. Let Cij and Dij be the (i,j) entries of the corresponding matrices. Then, the product Z := CD is an nn matrix, whose (i,j) entry Zij is given by Zij := /nk=1conc(Cik,Dkj), i,j = 1, n. (316)
PAGE 45
36 Using this notation, we can define powers of the onestep transition matrix recursively, by setting R(s) := R(s)R(s), = 2, 3, (317) The matrix R(s) has the following physical significance. The (i,j) element of R(s) is the set of all input strings that take xj to xi in exactly steps. Thus, R(s) is called the matrix of step stable transitions. This follows from Corollary 35, which states that the powers of the onestep transition matrix is equal to the transition matrix of the powers of the recursion function, i.e., the steps of the transition matrix. Define the matrix R()(s) := / k=1... Rk(s), v=2,3,...,(n+t). (318) By construction, the (i,j) entry of R()(s) consists of all strings that can take the machine s from the state xj to the state xi in or fewer steps. The following statement is important to our discussion; the proof is similar to that of Murphy, Geng and Hammer, 2003, Lemma 39. Lemma 313 The following two statements are equivalent: (i) There is an input string that can take the machine s from the state xj to the state xi. (ii) The i,j entry R(n+t)ij(s) N. Now, R(n+t)(s) contains not only the stable transitions, but also the critical races that are cause when an input character is applied to a cycle state. To satisfy the model matching problem, we need a matrix for which the same input string does not lead to
PAGE 46
37 multiple outcomes. This is achieved by modifying the above matrix. This modified matrix is at the center of our discussion. Definition 314 Let be an asynchronous machine. The matrix of stable transitions T(s) is constructed by performing the following operation on each column of the matrix R(n+t)(s): remove all occurrences of strings that appear in more than one entry of the column; if empty entries result, replace them by the character N. To understand the significance of the matrix T(s), it is instructive to compare it to the matrix R(n+t)(s). A string u in the (i,j) entry of the matrix R(n+t)(s) indicates, of course, that u takes s from xj to xi. However, if the string u appears in another entry in column j of R(n+t)(s), say in entry k, then the same string may also take s from xj to xk; this indicates a critical race. The construction of the matrix T(s) removes then all transitions that involve critical races. As a result, an input string u that is included in the (i,j) entry of T(s) takes the machine s from the state xj to the state xi, and to no other state. Definition 315 Let be an asynchronous machine with the generalized state set {x1, ... xn+t}. A generalized stable transition from a generalized state xj to a generalized state xi is a uniform transition when one of the following is true: (i) xi can be reached from xj without passing through a critical race, or (ii) there is a succession of critical races through which xi can be reached from xj for all possible race outcomes. Note that in case (ii) of Definition 315, the input string applied to the machine may depend on the outcomes of the critical races encountered by the machine along its way from the state xj to the state xi. Specifically, let x(k,p) be outcome k of race p along
PAGE 47
38 the way from xj to xi. The input string applied to the machine will then be a function of the outcomes u(x(k1,1,1), ..., x(k1,p1,p1)) The set a = 1,,ru(x(kr,1,1), ..., x(kr,pr,pr)) is (i,j) transition set, where r is the number of possible input strings taking into account all the critical races encountered in the path from xj to xi. This means that pr races are encountered in the path followed by the rth string, and x(kr,pr,pr) is the outcome kr,pr of the race pr. Further, By construction, the elements of T(s) will contain sets of strings that satisfy the following proposition. Proposition 316 The (i,j) entry of T(s) is different from N if and only if there is a uniform transition from xj to xi. Furthermore, if the (i,j) entry of T(s) is not N, then it includes an (i,j) transition set. Thus, depending on the sequence of critical races that occur, the entries of T(s) gives a set of strings that can be used for the control process. The skeleton matrix is now defined as follows matrix: Definition 317 Let T(s) be the matrix of stable transitions of the generalized stable state machine s. The skeleton matrix K() of is a matrix of zeros and ones, whose (i,j) entry is given by Kij() = (319) ijs1 if T() N,0 otherwise i = 1,,n, j = 1,,n+t. The skeleton matrix K() has a simple interpretation. In view of Lemma 313, the following is true
PAGE 48
39 Proposition 318 Let K() be the skeleton matrix of a given machine Then, the (i,j) entry of K() is 1 if and only if there exists a string that takes the machine s from the generalized state xj to the state xi and to no other state. The skeleton matrix plays a critical role in our discussion, reminiscent of the role it played in Murphy, Geng and Hammer 2002, 20033.6 Corrective Controllers The basic considerations in the construction of a corrective controller and its limitations for asynchronous input/state machines will now be outlined. Let be an asynchronous machine, being controlled in the configuration Figure 11 with the controller C. Recall that c denotes the closed loop machine of Figure 11; let cs be the stable state machine induced by c. Now, let = (A,X,x0,s) be a stable state input/state machine, with the same input set and the same state set as the machine Referring to the configuration Figure 11 and the Model Matching Problem 310, we are investigating the existence of a controller C for which cs = Consider the input/state machine = (A,X,X,f,h) and the controller C = (AX,A,,,). Let the generalized stable state machine associated with be s. As shown below, the controller C will operate in the semifundamental mode: when the controlled machine moves toward a stable combination, the controller C will operate in fundamental mode it will keep its output value constant until has reached its next stable combination; however, if moves into an infinite cycle, the controller has no choice but to change its output value while is cycling otherwise, will remain in the cycle forever. In this case, the controller operates in the semifundamental mode.
PAGE 49
40 Recalling that has the state set X and that C has the state set it follows that the composite machine c of Figure 11 has the state set X. We can then represent c by the quintuple (A,X,X,fc,hc), where fc is the recursion function of c and hc is its output function. Being an input/state system, the machine has the output function h(x,u) = x. As the output of c is the same as the output of it follows that hc(x,,v) = x. Formally, let x : XX : x(x,) x be the standard projection. Then, we have hc = x. Now, let be the recursion function of cs. We know that the output of cs is the state of So, if cs = then, for every valid pair (x,v) of there is a state for which (x,,v) is a valid pair of cs. This leads to the conclusion hc(x,,v) = s(x,v), (320) and, using the equality hc = x, we obtain x(x,,v) = s(x,v). Note that, if s is not constant over one of the cycles, then the response of the closed loop machine will depend on the state of the cycle at which the input character is applied, creating a critical race. In other words, in order for the response of the closed loop system to be deterministic, the stable recursion function of the model must be constant over each cycle of the controlled machine To state this fact formally, consider a cycle = {x k1 x k2 ..., x kp ;a}, ki [1,,n], of the machine Let s{} := {s(x k1 ,a), ..., s(x kp ,a)}, i.e., the set of values of s over the cycle. We say that s is constant over the cycle if all members of the set s{} are identical.
PAGE 50
41 Proposition 319 Let and be two machines, where is a stable state machine. Assume that there is a controller C such that cs = If the closed loop machine cs has a race free response, then the recursion function s of the model is constant over every cycle of We are now ready to state one of the main results of our discussion. The following theorem deals with the fundamental conditions for the existence of a model matching controller (compare to Murphy, Geng and Hammer 2002, 2003, Theorem 4.3). Before stating the theorem, we need some notation. For a cycle state z X, let (z) = {a; x k1 x k2 ..., x kp }, ki [1,,n], be the corresponding cycle, and let x(z) := {x k1 x k2 ..., x kp } be the states of the cycle. Define (z) = (321) xz if z is a regular state,(z) if z is a cycle state. Note that (z) is always a set of regular states, not cycle states. Theorem 320 (Existence of Controller) Let s = (A,X,x0,s) be the generalized stable state machine induced by an input/state machine = (A,X,x0,f). Let z1, ..., zk be generalized states of s and let U1, ..., Uk be sets of input characters such that z1U1, z2U2, zkUk are distinct sets of valid pairs of s. For each i = 1, ..., k,let zi be a state of that is stably reachable from the generalized state zi. Then, there exists a controller C for which cs is equivalent to a stable state machine = (A,X,x0,s), whose recursion function s satisfies (i) s[zi),Ui] = zi for all i = 1,,k, and (ii) s(x,t) = s(x,t) for all (x,t) XA / i=1,,k ziUi.
PAGE 51
42 Moreover, the closed loop system c is well posed, and it operates in the semifundamental mode. Proof 320. By Proposition 319, the recursion function of the model is constant over all cycles of the machine Thus, since zi is stably reachable from the generalized state zi, there exists a string wi A+ such that s(zi,wi) = zi, where s is the stable recursion function of Let m(i) be the length of wi; write wi = v0iv1ivm(i)i, where v0i, v1i, vm(i)i are individual characters of the input alphabet A and i = 1, k. With this input string wi, the recursion function s generates a string of generalized states, which we denote by xi,1 := s(zi,v0i), xi,2 := s(xi,1,v1i), xi,m(i) := s(xi,m(i),vm(i)i), zi := s(xi,m(i),vm(i)i), i = 1, k. (322) Let U(zi) A be the set of all input characters that form stable combinations with the generalized state zi, i = 1, k. Define the following sets: S := i=1, k ziU(zi), V := i=1, k ziUi, (323) where Ui are the input character sets given in the statement of the Theorem. Then, a controller C = (AX,A,,,) that satisfies the requirements of Theorem 320 can be constructed as follows. (i) The state set of C has 2 + ki=1m(i) states given by
PAGE 52
43 = {0, 1, 11,, m(1)1, 12,, m(2)2,, 1k, m(k)k}. (324) The significance of these states is explained below. (ii) The initial state of the controller C is 0. The controller moves to the state 1 upon the detection of a stable combination with one of the generalized states z1,, zk X. Note that, for cycle states, this transition occurs during the cycle, and is therefore a semifundamental mode transition. For states that are not cycle states, this transition is in fundamental mode. To implement these transitions, the recursion function of C is defined by (0,(z,t)) := 0 for all (z,t) XA \ S, (0,(x,u)) := 1 for all (x,u) S. (325) The state 0 indicates that the machine is not in a state in which its response must be changed, and hence, when in the state 0, the controller does not interfere with the operation of ; it simply applies to its own external input. To this end, the output function of C at the state 0 is defined by (0,(z,t)) := t for all (z,t) XA. (326) The output function at the state 1 is defined as follows. Choose a character ui U(zi); set (1,(zi,t)) := ui for all t A, i = 1, k. (327) Then, the machine continues to rest at the generalized state zi. (iii) Next, assume that is in a stable combination with the generalized state zi, i = 1, k, and an input value u Ui is applied. Then, the controller C will begin to
PAGE 53
44 apply the string wi to to take to the state zi. To this end, the recursion function of C is defined as follows. (1,(zi,u)) := 1i for all u Ui, i = 1, k; (1,(z,t)) := 0 for all pairs (z,t) XA\V. (328) Upon reaching the state 1i, the controller generates the first character of the input string wi of to start taking to the desired state zi. Accordingly, the controllers output function value at this point is (1i,(z,t)) = v0i for all (z,t) XA, i = 1, k. (329) Upon application of this input character, the machine will move to its next generalized stable state xi,1, where (xi,1, v0i) is the next generalized stable combination. (iv) In order for the controller to continue to generate the string wi as input for we define its recursion function as follows. (ji,(xi,j,u)) := j+1i for all u Ui, (330) j = 1,,m(i), i = 1, k. Now, the controller feeds to the next character in the string wi, i.e., the character vji. So the output function must satisfy (j+1i,(z,u)) := vji for all (z,u) XA, (331) i = 1,,k, j = 1, 2, m(i). (v) At the step j = m(i)1, the controller completes generating the string wi. It assumes then a stable combination, and continues to feed the input character vm(i)i until its external input character is changed. To implement these requirements, the transition and output functions of the controller are defined by
PAGE 54
45 (m(i)i,(zi,u)) := m(i)i for all u Ui (m(i)i,(z,t)) := 0 for all (z,t) XA\ ziUi, (m(i)i,(z,u)) := vm(i)i. (332) i = 1,,k. Note that, since the stateinput sets {ziUi}ki=1 are all disjoint, there is no ambiguity in the definition of the recursion function From the above construction, the stable recursion function of the closed loop system c can be deduced. On analysis, this recursion function satisfies, for all i = 1,,k: (zi,0,u) = (s(zi,u),1) for all u U(zi), (z,0,t) = (s(z,t),0) for all (z,t) XA\(SV), (zi,1,ui) = (zi,m(i)i) for all ui Ui, (zi,1,u) = (zi,1) for all u U(zi), (zi,1,t) = (zi,0) for all t A\(U(zi) Ui), (zi,m(i)i,u) = (zi,m(i)i) for all u Ui, (z,m(i)i,t) = (s(z,t),0) for all (z,t) XA\ziUi, (333) i = 1,,k. Thus, the equivalence of x and s as defined in the beginning of this section holds true. Also, the closed loop system operates in the semifundamental mode as the definitions of and specify. We know is an inputstate system, hence it is strictly causal; consequently the closed loop system c is well posed (Hammer 1996). This concludes the proof. Chapter 4 deals with the specific solution to the model matching problem for this problem. The necessary and sufficient conditions for the existence of the controller, using the skeleton matrices are put forward, and if the controller exists, an algorithm to construct the states is also given.
PAGE 55
46 CHAPTER 4 THE MODEL MATCHING PROBLEM In this section we present a solution to the model matching problems for machines with infinite cycles. The solution to the model matching problem for deterministic systems and for machines with races was presented in Murphy, Geng and Hammer, (2002, 2003). Let be an asynchronous machine with all cycles stoppable, and let be the stablestate model to be matched. The skeleton matrix K0() of the model is given as in Definition 317. For the solution to the model matching problem, a form of the skeleton matrix with columns augmented to include the solution to cycles is introduced; this is the augmented skeleton matrix K(). The matrix K() is an n(n+t) matrix of zeros and ones. It is obtained by augmenting the matrix K0() with t columns corresponding to the cycle states, as follows. Let z be a cycle state, and let x(z) be the states of the cycle. Then, Kij() = (41) 0ij0kjijxK(), i,j = 1,...,n,1 if K() = 1 for all x (x), i = 1,...,n, j = n+1,...,n+t,0 otherwise. In view of Proposition 319, the model can be matched only if its stable transition function is constant over the states of each cycle of Assume then that satisfies this requirement. In such case, it follows by Equation 41 that the entries of the column corresponding to xk, k = n+1,,n+t in K() are all 1. The solution to the model matching problem for a machine with infinite cycles can now be stated as follows.
PAGE 56
47 Theorem 41 Let be an asynchronous machine all of whose cycles are stoppable, and let s = (A,X,x0,s) be the generalized stable state machine induced by Let = (A,X,x0,s) be a stablestate input/state machine with the same state set X and the same input set A as those of Let K() be the skeleton matrix of and let K() be the skeleton matrix of Then, the two following statements are equivalent. (i) There is a controller C for which the closed loop system cs is equivalent to where cs operates in the semifundamental mode and is well posed. (ii) The skeleton matrices satisfy K() K(). Theorem 41 provides a simple necessary and sufficient condition for the existence of a solution to the model matching problem for systems with infinite cycles. The proof of the Theorem, which is provided later in this section, includes an algorithm for the construction of an appropriate controller C. When the model matching problem is solvable, the controller C operates by transforming into unstable combinations all generalized stable combinations of that do not correspond to stable combinations of the model In this way, the stable state machine cs induced by the closed loop system becomes stably equivalent to The skeleton matrix of the given machine K() is never fully zeros, since each state is potentially stable. Thus, there always exists a stable state machine with skeleton matrix equal to K(). When considered as a model, the machine satisfies condition (ii) of Theorem 41. Consequently, there is a controller C for which cs = and this controller eliminates the effects of the infinite cycles of Thus, feedback
PAGE 57
48 controller can turn every machine with stoppable cycles into a deterministic stable state machine. We turn now to a preliminary technical discussion that will lead us to the proof of Theorem 41. Let s be the stable recursion function of the generalized stable state machine s of and let s be the stable recursion function of the model with the codomain of s extended to X. Build the discrepancy set of as D(,) := {(x,u) XA : (x,u) is a valid pair of and s(x,u) s(x,u)}. (42) In intuitive terms, D(,) is the set of all valid pairs of for which the next stable state of is different from the next generalized state of s. Now, since K() K(), for each (x,u) D(,), there exists an input string w A+ for which s(x,w) = s(x,u); let S(x,u) A+ (43) be the set of all input strings w satisfying s(x,w) = s(x,u). Next, consider a pair (x,u) D(,) and an input string w S(x,u). Let P(,x,w) be the corresponding path of and let () := {(z,r) : (z,r) XA, (z,r) i, i = 1,,t} (44) be the set of all stateinput pairs involved in cycles. Define the set DN(,) := {(x,u) D(,) : there is a string w S(x,u) such that P(,x,w) () = }. (45) For elements (x,u) DN(,), the machine can reach the value s(x,u) without passing through a cycle. Here, the controller will simply feed to the string w,
PAGE 58
49 so that the next stable state of the combination c will match the next stable state of the model Finally, on the difference set DC(,) := D(,)\DN(,), (46) the machine cannot match the response of without passing through a cycle. In this case, the controller will have to generate an input string for that will initially drive the machine into a cycle, and then take it out of the cycle. When comes out of the cycle, its next state may be one of several possible states, as exit from a cycle may give rise to a critical race. The controller will then have to resolve the indeterminancy of the race and drive the machine to the next stable state determined by the model The exact process by which this is accomplished is described in the following proof. Proof 41. Assume first that condition (i) of Theorem 41 is valid, i.e., that there exists a controller C such that cs = Let sc be the stable recursion function of c, and recall that s is the stable recursion function of the model The last equality implies that sc(x,u) = s(x,u) for all pairs (x,u) XA. Now, since the controller C accesses only through its input, there is a string w(x,u) A+ such that sc(x,u) = s(x,w(x,u)) where s is the stable recursion function of Consequently, s(x,w(x,u)) = s(x,u), and the state s(x,u) is stably reachable from the state x in the machine Thus, any state that is stably reachable from the state x in the machine must also be stably reachable from the state x in the machine In other words, K() K(), and we conclude that part (i) implies part (ii).
PAGE 59
50 Conversely, assume that (ii) is true, i.e., that K() K(). We construct below a controller C that satisfies statement (i) of Theorem 41. Recalling the set D(,) of Equation 42, note that if D(,) = then the stable transition function of matches that of and no controller is needed. Next, consider the case D(,) Define the set D by replacing in D(,) all the pairs included in cycles by the corresponding generalized pairs, that is, DC := {DC(,) \ ()} {(xn+i,u) : i D(,) } (47) The set of all input characters that pair with a state x in D is given by D(x) := {u A: (x,u) D}. (48) Let x : XA X : (x,u) x be the standard projection. Then, xD is the set of all generalized states x X for which there is an input character u A such that (x,u) D. Also, let U(x) be the set of all input characters that form a stable combination with the generalized state x X. The set V := {x U(x): x xD} (49) is then the set of all generalized stable combinations with states in xD. Suppose that DN(,) Then, for each (x,u) DN(,), there exists an input string w0(x,u) such that s(x,w0(x,u)) = s(x,u) and the path P(,x,w) does not contain any cycle states. Let m(0;x,u) = w0(x,u) be the length of this string, write it in terms of its characters as w0(x,u) = w00(x,u)w01(x,u) w0m(x,u)(x,u). Then, w0(x,u) takes the machine through a succession of stable states, which we denote as follows. x0,1(x,u) := s(x,w00(x,u)),
PAGE 60
51 x0,2(x,u) := s(x0,1(x,u),w01(x,u)), x0,m(x,u)(x,u) := s(x0,m(x,u)(x,u),w0m(x,u)(x,u)), and, by selection of the string w0(x,u), s(x0,m(x,u)(x,u),w0m(x,u)(x,u)) = s(x,u). (410) Thus, to guarantee fundamental mode operation, we see that the controller must have m(0;x,u) states associated with the pair (x,u). Now, let (z1,u1), ..., (zn(N),un(N)) be the elements of DN(,). Then, for each pair (zi,ui) DN(,), the controller needs m(0;zi,ui) states to facilitate fundamental mode operation, say the states 1(zi,ui), m(0;zi,ui) (zi,ui). This leads to the set of controller states N := {1(z1,u1), m(0;z1,u1) (z1,u1), 1(zn(N),un(N)), m(0;zn(N),un(N)) (zn(N),un(N))}. (411) In case DN(,) = set N := We turn now to the set DC of Equation 47, assuming that it is not empty. Let n(C) be the number of elements of DC. Recall that, for each pair of DC, the machine must pass through at least one cycle in the process of matching the response of the model ; one of these cycles may be the initial step. Consider a pair (x,u) DC, let T(s) be the matrix of stable transitions of Recall that the state set of is X = {x1, ..., xn} and the generalized state set of is X = {x1, ..., xn+t}. In the case x is a cycle state, say x = x, where {n+1, ..., n+t}, let (x) := {x(1), ...,x(p)} X. Setting x := s(x(1),u) X, it follows by Proposition 319 that s(x(i),u) = x for all i = 1, ..., p. The fact that x := s(x(i),u) implies that K(i)() = 1, i = 1, ..., p. By Equation 41, we then have that K() = 1. The
PAGE 61
52 inequality K() K() implies then that the entry T(s) is not empty. Furthermore, letting w(x,u) be an element of T(s), it follows by Proposition 318 that s(x,u) = s(x,w(x,u)). Consider now the path P(s,x,w(x,u)). Recalling that (x,u) DC, the following hold. If x is not a cycle state, then the path P(s,x,w(x,u)) must include a cycle. If x is a cycle state, then P(s,x,w(x,u)) may or may not include an additional cycle. The string w(x,u) takes the machine through one possible outcome of each cycle encountered along the path P(s,x,w(x,u)). Depending on the outcome of the critical races that occur as the machine passes through the cycles along the path P(s,x,w(x,u)), different strings may need to be used to take the machine to the state s(x,u). Let w0(x,u) be the initial segment of the string w(x,u) that takes the machine to the state following the first cycle state along the path P(s,x,v(x,u)). By construction, the shortest length of w0(x,u) is one character, and it is obtained when the state x is itself a cycle state. The controller C initially feeds this string to the machine character by character, to achieve semifundamental mode operation. The last character of w0(x,u) leads into a critical race, as it exits from the corresponding cycle. The inequality K() K() implies that there is an input string that leads from each outcome of this race to the next cycle along its way to the state s(x,u). This string will then similarly be generated by the controller and applied to the machine This process continues through each cycle encountered along the way, and is formally described next. Writing the initial substring in terms of its individual characters, set w0(x,u) = w00(x,u)w01(x,u) w0m(0;x,u)(x,u); here, m(0;x,u) = w0(x,u) is the length of the string.
PAGE 62
53 This string take the machine through the following sequence of generalized stable states. x0,1(x,u) := s(x,w00(x,u)), x0,2(x,u) := s(x0,1(x,u),w01(x,u)), x0,m(0;x,u)(x,u) := s(x0,m(0;x,u)(x,u),w0m(0;x,u)(x,u)), X(1)(x,u) := s(x0,m(0;x,u)1(x,u),w0m(0;x,u)(x,u)), (412) where X(1)(x,u) = {x(1,1), x(1,r1)} X is the set of all states of that form possible outcomes of the critical race. Since the string w0(x,u) takes up to one step past a cycle state to the outcome of the corresponding critical race, it follows that x0,m(0;x,u)(x,u) is a cycle state. Note that if the initial state x is a cycle state, then m(0;x,u) = 1, namely, the substring w0(x,u) has just a single character. The next substring of characters in w(x,u) takes the machine from the present outcome of the cycle to the outcome of the next cycle (or to the final destination, if no other cycle is encountered). Denote this substring by w1(x,u,x(1,i1)). It takes the machine from the state x(1,i1) to the outcome of the next cycle; the process is similar to the process described in Equation 412, and w1(x,u,x(1,i1)) has at least one character. If a cycle leading to a critical race is reached at the end of the substring w1(x,u,x(1,i1)), then, letting r2(i1) be the number of its outcomes, we denote the set of outcomes by X(2,i1)(x,u) and let its members be {x(2,i1,1), x(2,i1,r2(i1))} X. Let m(1;x,u,x(1,i1)) = w1(x,u,x(1,i1)) be the length of the string, and let w10(x,u,x(1,i1)), w11(x,u,x(1,i1)), w1m(1;x,u,x(1,i1))(x,u,x(1,i1)) be its characters. The next such substring depends on the outcome of both the races encountered, and is given by w2(x,u,x(2, i1 i2 )). The number of cycles encountered may vary, depending on
PAGE 63
54 the outcome of the critical races through which the machine has passed. Let q be the number of cycles encountered along our path to the target s(x,u). The outcomes of the q critical races caused by the cycles are then denoted by x(1, i1 ), x(2, i1 i2 ), x(q, i1 ,, iq ). In order to simplify the notation, define x(k,i(k)) = x(k,i1, ik), for some k. The string of input characters that takes the machine from (x,u) to s(x,u) consists then of the following segments w(x,u) := w0(x,u) w1(x,u,x(1,i(1))) wq(x,u,x(q,i(q)), (413) where each one of the segments takes the machine from the outcome of one cycle to the outcome of the next cycle along the path. The length of the segment wj(x,u,x(j,i(j))) is m(j;x,u,x(j,i(j))) 1. Each segment can then be written in terms of its individual characters in the form wj(x,u,x(j,i(
PAGE 64
55 mode operation, the controller must generate the string segments w0(x,u), ..., wq(x,u,x(q,i(
PAGE 65
56 the controller states 00(x,u), 0m(0;x,u)(x,u), and the controller's recursion function is defined as follows. (1,(x,u)) := 00(x,u), for (x,u) D, (1,(x,t)) := 1, for all t U(x)\D(x), (0j(x,u),(x0,j(x,u),u)) := 0j+1(x,u), (0j(x,u),(z,t)) := 0j(x,u), for all (z,t) XA, (418) where 0 j m(0;x,u). We can now generate the first m(0;x,u) characters of the substring w0(x,u) by defining the controller output function as follows. (0j(x,u),(z,t)) := w0j(x,u), for all (z,t) XA, (419) where 0 j m(0;x,u). The final character of w0(x,u) is applied while the machine is in the cycle state x0,m(0;x,u)(x,u), and creates a critical race with the outcome x(1,i1), as discussed earlier. Recall that w(x,u) passes through q cycles. The controller continues to generate all the substrings wj(x,u,x(j,i(j))), j = 1, q consecutively. Let the controller states associated with the substring wj(x,u,x(j,i(j))) be j0(x,u), jm(j;x,u,x(j,i(j)))(x,u). The transition function is then given by (jh(x,u),(xj,h(x,u),u)) := jh+1(x,u), (jh(x,u),(z,t)) := jh(x,u), for all (z,t) (xj,h(x,u),u), (420) where h = 0, m(j;x,u,x(j,i(j))), and j = 1, q. The corresponding output values are generated by the controller's output function as follows. (jh(x,u),(z,t)) := wjh(x,u,x(j,i(j))), (z,t) XA, (421) where h = 0, m(j;x,u,x(j,i(j))), and j = 1, q.
PAGE 66
57 The transition from the end of one substring to the first character of the next substring of w(x,u) is accomplished by defining the controller's transition function as follows. (jm(j;x,u,x(j,i(j)))(x,u),(xj,h(x,u),u)) := j+10(x,u), (422) j = 0, q. At the end of the string w(x,u), the machine reaches the state s(x,u), required for matching the model The last character of w(x,u) is, of course, the last character of wq(x,u,x(q,i(q))). After this character is applied, the machine must remain in a stable combination with the state s(x,u) until the external input changes. To implement this requirement, the transition function of the controller is defined by (qm(q;x,u,x(q,i(q)))(x,u),(z,t)) := 1, (z,t) (s(x,u),u). (423) This completes the operation of the controller for the transition from x to s(x,u). Summarizing, the set of all controller states associated with the generation of the string w(x,u) is given by C(w(x,u)) = {00(x,u), 0m(0;x,u)(x,u), q0(x,u), qm(q;x,u,x(q,i(q)))(x,u)}. (424) Note when (x,u) DN(,), then q is taken as zero in the above construction, and w(x,u) consists of only one substring which completes the required transition. To complete the implementation of the controller C, the above construction has to be applied to each input pair (x,u) DC. To describe the state set of the controller, let the elements of DC be given by {(z1,u1), (zn(C),un(C))} and let w(zk,uk) be the string that takes from (xk,uk) to the state s(xk,uk) required to match the model for a
PAGE 67
58 specific sequence of cycle outcomes. Then, in analogy with Equation 424, the controller states associated with the generation of w(xk,uk), for a specific combination of the outcome of the cycles encountered, are C(w(xk,uk)) = {00(xk,uk), 0m(0;xk,uk) (xk,uk), q0(xk,uk), qm(q;xk,uk,x(q,i(q))) (xk,uk)}. (425) The set of all states for all combinations of outcomes of cycles are then given by C(xk,uk) = all possible w(x k ,u k ) C(w(xk,uk)). (426) Thus, the set of controller states for all the elements of DC are C = k = 1, n(C) C(xk,uk) (427) Of course, if DC = then C(xk,uk) = and C = Then the complete state set of the controller is given by = {0,1} N C. (428) By construction, the closed loop system operates in semifundamental mode and is well posed. This completes the construction of the controller C. Note that the states of the controller are not optimized. This can be done by the various state reduction techniques, e.g., KOHAVI [1970]. Further state reductions can be done by careful choice of the corrective string.
PAGE 68
CHAPTER 5 EXAMPLE This chapter demonstrates the construction of a controller C that fulfills the requirements of Theorem 41. Consider the input/state machine having the input set A = {a, b, c, d} and the state set X = {x1, x2, x3, x4}. Consider the recursion function of the machine f to be defined by Table 51 of transitions. Table 51. Transition table for the machine a b c d x1 x1 x3 x1 x1 x2 x3 x2 x4 x3 x3 x4 x4 x4 x3 x4 x2 x4 x3 x4 Applying Algorithm 38 to the above machine, the cycles in the machine can be found. We see that the cycles are 1 = {a;x2, x3, x4} and 2 = {c;x3, x4}. Now, the cycle states corresponding to the cycles 1 and 2 are x5 and x6. The generalized stable state machine s now has the state set X = {x1, x2, x3, x4, x5, x6}, as defined in Equation 38, and the same input set A. The stable recursion function s of the generalized stable state machine s is defined in the Table 52 of transitions. The generalized stable recursion function for the generalized stable state machine is defined in Equation 311. Note that when an input character is applied to a cycle state, it can result in unpredictable outcomes. This is represented as the set of all possible output states. 59
PAGE 69
60 Table 52. Stable transition table for the generalized stable state machine s a b c d x1 x1 x3 x1 x1 x2 x5 x2 x6 x3 x3 x5 x4 x6 x3 x4 x5 x4 x6 x4 x5 x5 {x2,x4} {x4,x6} {x3,x4} x6 x5 x4 x6 {x3,x4} The machine s is now an asynchronous machine with multiple race outcomes. We will now follow the procedure in Chapter 4 to calculate the skeleton matrix of this machine. As defined in Equation 312, the matrix of onestep generalized stable transitions R(s) is shown in Table 53. Table 53. Matrix of onestep generalized stable transitions R(s) x1 x2 x3 x4 x5 x6 x1 a,c,d N N N N N x2 N b N N b N x3 N d d N d d x4 b N b b,d b,d b,d x5 N a a a a a x6 N c c c c c
PAGE 70
61 Using Equation 317 and Equation 318, we construct the matrices R2(s), R3(s), R4(s), and R5(s), and then the matrix R(5)(s). Then, applying Definition 314, the matrix of stable transitions T(s) is constructed. Finally, using Definition 317, the skeleton matrix is derived. The skeleton matrix K() calculated from R(5)() is given by K() = 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 (51) Now to solve the model matching problem, we need the given stable state machine as our model. The stable recursion function for is given in Table 54 of transitions. Table 54. Stable transition function of the given model a b c d x1 x1 x3 x1 x1 x2 x4 x2 x4 x3 x3 x4 x4 x4 x3 x4 x4 x4 x4 x4 Now, the skeleton matrix for the model follows the same procedure as in the generalized stable state machine, except for the absence of the cycle states. This results in a square matrix, given by K0() = 1 0 0 0 0 1 0 0 0 1 1 0 1 1 1 1 (52)
PAGE 71
62 Following Equation 41, the augmented skeleton matrix K() is then constructed as follows. K() = 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 (53) The next step in the construction of the controller is to see if the necessary and sufficient conditions are satisfied. We find that K() K(), thus satisfying Theorem 41. To construct the controller, we need the following matrices, as explained in the proof of Theorem 41. D(,) := {(x2,a),(x3,a),(x4,a),(x2,c),(x3,c),(x4,c)}, D := {(x5,a),(x6,c),(x2,c)}, xD := {x2,x3,x4}, D(x) := {a,c}, U(x2) := {b}, U(x5) := {a}, U(x6) := {c}, DN(,) := DC := {(x2,c),(x5,a),(x6,c)}. (54) For (x2,c) DC(,), w0(x2,c) = d, w1(x2,c,x3) = b. There are two possible strings, d and db; r(x2,c) = 2. The state transitions are: (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x2,c)) := 1 for all (x2,c) V, (1,(x2,c)) := 00(x2,c), for (x2,c) D, (1,(x2,t)) := 1, for all t U(x2)\D(x2), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x2,c),(x0,1(x2,c),d)) := 10(x2,c), (00(x2,c),(z,t)) := 00(x2,c), for all (z,t) (x0,1(x2,c),d), (10(x2,c),(z,t)) := 1, (z,t) (s(x2,c),u). (55)
PAGE 72
63 The output functions are (0,(z,t)) := t for all (z,t) XA, (1,(x2,t)) := b for all (x2,t) XA, (00(x2,c),(z,t)) := w00(x2,c) = d, for all (z,t) XA, (10(x2,c),(z,t)) := w10(x2,c,x3) = b, (z,t) XA. (56) Now, consider the next element (x5,a) DC(,). For this cycle state, w0(x5,a) = d, w1(x5,a,x3) = b; as before, r(x5,a) = 2. The state transitions and output functions are given by (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x5,a)) := 1 for all (x5,a) V, (1,(x5,a)) := 00(x5,a), for (x5,a) D, (1,(x5,t)) := 1, for all t U(x5)\D(x5), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x5,a),(x0,1(x5,a),d)) := 10(x5,a), (00(x5,a),(z,t)) := 00(x5,a), for all (z,t) (x0,1(x5,a),d), (10(x5,a),(z,t)) := 1, (z,t) (s(x5,a),b), (0,(z,t)) := t for all (z,t) XA, (1,(x5,t)) := a for all (x5,t) XA, (00(x5,a),(z,t)) := w00(x5,a) = d, for all (z,t) XA, (10(x5,a),(z,t)) := w10(x5,a,x3) = b, (z,t) XA. (57) Similarly, the transition and output functions for the third element (x6,a) DC(,) are defined below. Here, w0(x6,c) = b; r(x6,a) = 1. (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x6,c)) := 1 for all (x6,c) V, (1,(x6,c)) := 00(x6,c), for (x6,c) D, (1,(x6,t)) := 1, for all t U(x6)\D(x6), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x6,c),(z,t)) := 1, (z,t) (s(x6,c),b), (0,(z,t)) := t for all (z,t) XA, (1,(x6,t)) := c for all (x6,t) XA,
PAGE 73
64 (00(x6,c),(z,t)) := w00(x6,c) = b, for all (z,t) XA. (58) This concludes the construction of the feedback controller C such that the closed loop machine cs = The equations (56), (57) and (58) give the state and transition functions of the controller C.
PAGE 74
CHAPTER 6 SUMMARY AND FUTURE WORK The present work shows the use of feedback controllers to correct one of the common hazards in the behavior of asynchronous sequential machines. Specifically, the designed controller not only eliminates the effects of infinite cycles in such a machine, but it can also drive the defective machine to match the behavior of a desired model. This approach opens an interesting arena where many open problems remain to be analyzed. In Chapter 5 of this dissertation, solutions have been presented to the model matching problem of inputstate machines involved in infinite cycles. The necessary and sufficient conditions for the existence of a controller have been stated, and an algorithm for its construction has been included, whenever a controller exists. The control of asynchronous machines is an area of research that is still ripe with possibilities. A straight forward extension of this dissertation is to the construction of a comprehensive state feedback controller that solves the the model matching problem for a machine with multiple hazards, including both races and cycles. The comprehensive controller has elements of both the race problem investigated by Murphy 1996, Murphy, Geng, and Hammer 2002, and Murphy, Geng, and Hammer 2003, as well as the controller for remedying cycles in an asynchronous machine, described in this dissertation. My future research plans include work on extending the results obtained in this dissertation to the comprehensive state feedback controller. The next logical step lies in 65
PAGE 75
66 formulating a more compact representation of the controller. A close examination of the controller structure described in Chapter 3 and Chapter 4 shows that it consists of a number of interconnected similar units. This observation leads us to believe that the controller can be assembled in a modular fashion from a collection of standard units. Formalizing this observation will lead to a simple methodology of controller design, whereby the controller is constructed simply by interconnecting a few standard blocks. Further, investigating the possibility of a comprehensive output feedback controller for a machine with multiple races and cycles is also a future research interest. The present proposal develops a controller that eliminates the negative effects of infinite cycles in asynchronous machines under the assumption that the state of the machine is available for feedback purposes. The problem of overcoming the effects of infinite cycles becomes substantially more complex if the state of the machine is not available, and only an output signal is available. The solution of this problem requires the development of concepts related to the observability of asynchronous machines, to find conditions under which an infinite cycle in state space can be detected from an observation of the output signal. The application of the obtained results to parallel and distributed systems is also an area of interest. Asynchronous sequential systems can be used to model parallel and distributed systems due to their event driven nature. It has been shown by Plateau and Atif 1991 that complex parallel networks can be modeled using stochastic automata networks. Recent work has succeeded in showing that a distributed system can be represented by cellular automata (Zambonelli et al 2003). Feedback control holds
PAGE 76
67 promise for improving the performance and reliability of such parallel and distributed systems, and it is possible to apply the principles developed in this work.
PAGE 77
LIST OF REFERENCES Alpan, G., and Jafari, M.A., 2002, Synthesis of a closedloop combined plant and controller model, IEEE Transactions on Systems, Man and Cybernetics, Vol. 32, No. 2, pp.163175. Arbib, M., 1969, Theories of abstract automata, Prentice Hall Inc., Englewood Cliffs, NJ. Armstrong, D., Friedman A., and Menon P., 1968, Realization of asynchronous sequential circuits without inserted delay elements, IEEE Transactions on Computers, C17, No. 2. Bredeson, J., and Hulina, P., 1971, Generation of a clock pulse for asynchronous sequential machines to eliminate critical races, IEEE Transactions on Computers, C20, pp. 225226. Bruschi, D., Pighizzini, G., and Sabadini, N., 1994, On the existence of minimum asynchronous automata and on the equivalence problem for unambiguous regular trace languages, Information and Computation, Vol. 108, No. 2, pp. 262285. Brzozowski, J.A., and Seger, C., 1987, A characterization of ternary simulation of gate networks, IEEE Transactions on Computers, C36, No. 11, pp. 13181327. Brzozowski, J.A., and Seger, CJ., 1989, A unified framework for race analysis of asynchronous networks, Journal of the Association for Computing Machinery, Vol. 36, No. 1, pp. 2045. Brzozowski, J.A., and Yeoli, M., 1979, On a ternary model of gate networks, IEEE Transactions on Computers, C28, pp.178183. Chiang, J., and Radhakrishnan, D., 1990, Hazardfree design of mixed operating mode asynchronous sequential circuits, International Journal of Electronics, Vol. 68, No. 1, pp. 2337. Chu, T., 1994, Synthesis of hazardfree control circuits from asynchronous finite state machine specifications, Journal of VLSI Signal Processing, Vol. 7, No. 12, pp. 6184. Chu, T., Mani, N., and Leung, C., 1993, An efficient critical racefree state assignment technique for asynchronous finite state machines, Proceedings of the 30th ACM/IEEE Design Automation Conference, Dallas, TX, pp. 25. 68
PAGE 78
69 Cole, R., and Zajicek, O., 1990, The expected advantage of asynchrony, Proceedings of the Second Annual ACM Symposium on Parallel Algorithms and Architectures, pp. 8594. Datta, P.K., Bandyopadhyay, S.K., and Choudhury, A.K., 1988, A graph theoretic approach for state assignment of asynchronous sequential machines, International Jounal of Electronics, Vol. 65, No. 6, pp. 10671075. Davis, A., Coates, B., and Stevens, K., 1993a, Automatic synthesis of fast compact asynchronous control circuits, S. Furber and M. Edwards, editors, Asynchronous Design Methodologies, Volume A28 of IFIP Transactions, Elsevier Science Publishers, pp. 193207. Davis, A., Coates, B., and Stevens, K., 1993b, The post office experience: designing a large asynchronous chip, Proceeding of the 26th Hawaii International Conference on System Sciences, Vol. 1, pp. 409418. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1994, Model matching for finite state machines, Proceedings of the IEEE Conference on Decision and Control, Vol. 3, pp. 31173124. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995a, Strong model matching for finite state machines with nondeterministic reference model, Proceedings of the IEEE conference on Decision and Control, Vol. 1, pp. 422426. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995b, Strong model matching for finite state machines, Proceedings of European Control Conference, Vol. 3, pp. 20272034. Dibenedetto, M.D., SangiovanniVincentelli, A., and Villa, T., 2001, Model matching for finitestate machines, IEEE Transactions on Automatic Control, Vol. 26, No. 11, pp. 17261743. Eichelberger, E.B., 1965, Hazard detection in combinational and sequential switching circuits, IBM Journal of Research and Development, Vol. 9, No. 2, pp. 9099. Eilenberg, S., 1974, Automata, Languages and Machines, Volume A, Academic Press, New York. Evans, J.B., 1988, Structures of discrete event simulation, Halsted Press, New York. Fisher, P., and Wu, S., September 1993, Racefree state assignments for synthesizing largescale asynchronous sequential logic circuits, IEEE Transactions of Computers, Vol. 42, No. 9, pp.10251034. Fujita, M., 1993, Methods for automatic design error correction in sequential circuits, Proceedings of the European Conference on Design Automation with the European Event in ASIC Design, pp. 7680.
PAGE 79
70 Furber, S.B., 1993, Breaking step The return of asynchronous logic, IEEE Review, pp. 159162. Geng, X. J., 2003, Model matching for asynchronous sequential machines, Ph.D. dissertation, Department of Electrical and Computer Engineering, University of Florida, Gainesville, Florida. Geng, X. J., and Hammer, J., 2003, Input/output control of asynchronous sequential machines, submitted for publication. Geng, X. J., and Hammer, J., 2004a, Asynchronous sequential machines: input/output control, Proceedings of the 12th Mediterranean Conference on Control and Automation, Kusadasi, Turkey, June 2004. Geng, X. J., and Hammer, J., 2004b, Output Feedback Control Asynchronous Sequential Machines, Proceedings of the 8th World Multiconference on Systemics, Cybernetics and Informatics (SCI 2004) to be held in Orlando, Florida.(to appear). Hammer, J., 1994, On some control problems in molecular biology, Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 40984103. Hammer, J., 1995, On the modeling and control of biological signaling chains, Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 37473752. Hammer J., 1996a, On the control of incompletely described sequential machines, International Journal of Control, Vol. 63, No. 6, pp. 10051028. Hammer J., 1996b, On the corrective control of sequential machines, International Journal of Control, Vol. 65, No. 6, pp. 249276. Hauck, S., 1995, Asynchronous design methodologies: an overview, Proceedings of the IEEE, Vol. 83, No. 1, pp. 6993. Hazeltine, B., 1965, Encoding of asynchronous sequential circuits, IEEE Transactions on Electronic Computers, EX14, pp.727729. Higham, L., and Schenk, E., 1992, The parallel asynchronous recursion model, Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp. 310316. Hlavicka, J., 1970, Essential hazard correction without the use of delay elements, IEEE Transactions on Computers, C19, No. 3, pp. 232238. Holcombe, W.M.L., 1982, Algebraic automata theory, Cambridge University Press, New York.
PAGE 80
71 Hubbard, P., and Caines, P.E., 2002, Dynamical consistency in hierarchical supervisory control, IEEE Transactions on Automatic Control, Vol. 47, No. 1, pp. 3752. Huffmann D.A., 1954a, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 161190. Huffmann D.A., 1954b, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 275303. Huffmann, D.A., 1957, The design and use of hazardfree switching networks, Journal of the Association of Computing Machinery, Vol. 4, No. 1, pp. 4762. Ingerson, T.E., and Buvel, R.L., 1984, Structure in Asynchronous Cellular Automata, Physica D, Vol. 10, pp. 5968. Kailath, T., 1980, Linear systems, Prentice Hall Inc., Englewood Cliffs, New Jersey, 1979, pp. 268272. Kalman, R.E., Falb, P.L., and Arbib, M.A., 1969, Topics in Mathematical Systems Theory, McGrawHill Book Company, New York. Kohavi, Z., 1970, Switching and finite automata theory, McGrawHill Book Company, New York, 1970. Koutsoukos, X.D., Antsaklis, P.J., Stiver, J.A., and Lemmon, M.D., 2000, Supervisory control of hybrid systems, Proceedings of the IEEE, Vol. 88, No. 7, pp. 10261049. Lavagno, L., Keutzer, K., and SangiovanniVincentelli, A., 1991, Algorithms for synthesis of hazardfree asynchronous circuits, Proceedings of the 28th ACM/IEEE Design Automation Conference, San Francisco, CA, pp. 302308. Lavagno, L., Moon, C.W., and SangiovanniVincentelli, A., 1994, Efficient heuristic procedure for solving the state assignment problem for eventbased specifications, IEEE Transactions on ComputerAided Design of Integrated Circuits and Systems, Vol. 14, pp. 4560. Lin, B., and Devadas, S., 1995, Synthesis of hazardfree multilevel logic under multipleinput changes from binary decision diagrams, IEEE Transactions on ComputerAided Design of Integrated Circuits and Systems, Vol. 14, No. 8, pp. 974985. Lin, F., 1993, Robust and adaptive supervisory control of discrete event systems, IEEE Transactions on Automatic Control, Vol. 38, No. 12, pp. 18481852. Lin, F., and Wonham, W.M., 1990, Decentralized control and coordination of discrete event systems with partial observation, IEEE Transactions on Automatic Control, Vol. 35, No. 12, pp. 13301337.
PAGE 81
72 Liu, C., 1963, A state variable assignment procedure for asynchronous sequential switching circuits, Journal of the Association of Computing Machinery, Vol. 10, pp. 209216. MacLane, S., and Birkhoff, G., 1967, Algebra, The Macmillan Company, New York. Mago, G., 1971, Realization of methods for asynchronous sequential circuits, IEEE Transactions on Computers, C20, pp. 290298. Maki, G., and Tracey, J., 1971, A state assignment procedure for asynchronous sequential circuits, IEEE Transactions on Computers, C20, pp. 666668. Marshall, A., Coates, B., and Siegel, F., 1994, Designing an asynchronous communications chip, IEEE Design & Test of Computers, Vol. 11, No. 2, pp. 821. Masuyama, H., and Yoshida, N., 1977, design of failsafe asynchronous sequential machines, Transactions of the Institute of Electronics and Communication, Vol. E60, No. 10, pp. 527532. McCluskey, E.J., 1963, Fundamental mode and pulse mode sequential circuits, Proc. IFIP Congress 1962, International Conference on Information Processing, Munich, August 27September 1, 1962, pp. 725730, Cicely M. Popplewell (ed.), North Holland Publishing Company, Amsterdam. McCluskey, E.J., 1965, Introduction to the theory of switching circuits, McGrawHill Book Company, New York. Mealy, G.H., 1955, A method for synthesizing sequential circuits, Bell Systems Technical Journal, Vol. 34, pp. 10451079. Moon, C.W., Stephan, P.R., and Brayton, R.K., 1991, Synthesis of hazardfree asynchronous circuits from graphical specifications, IEEE International Conference on ComputerAided Design, pp. 322325. Moore, E.F., 1956, Gedankenexperiments on sequential machines, Automata Studies, Annals of Mathematical Studies, No. 34, Princeton University Press, Princeton, NJ. Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D., and Robinson, P., 2000, Self calibrating clocks for globally asynchronous locally synchronous systems, Proceedings of the International Conference on Computer Design, pp 7378. Murphy, T.E., 1996, On the control of asynchronous sequential machines with races, Ph.D. Dissertation, Department of Electrical and Computer Engineering, University of Florida, Gainesville, Florida.
PAGE 82
73 Murphy, T.E., Geng, X. J., and Hammer, J., 2002, Controlling races in asynchronous sequential machines, Proceedings of the IFAC World Congress, Barcelona, July 2002. Murphy, T.E., Geng, X. J., and Hammer, J., 2003, On the control of asynchronous machines with races, IEEE Transactions on Automatic Control, Vol. 28, No. 6, pp. 10731081. Nelson, R.J., 1968, Introduction to automata, John Wiley and Sons, Inc., 1979. Nishimura, N., 1990, Asynchronous shared memory parallel computation, The 3rd ACM Symposium on Parallel Algorithms and Architectures SPAA pp. 7684. Nishimura, N., 1995, Efficient asynchronous simulation of a class of synchronous parallel algorithms, Journal of Computer and System Sciences, Vol. 50, No. 1, pp. 98113. Nowick, S.M., 1993, Automatic synthesis of burstmode asynchronous controllers, Ph.D. Dissertation, Department of Computer Science, Stanford University, Stanford, California. Nowick, S.M., and Coates, B., 1994, UCLOCK: Automated design of highperformance unclocked state machines, Proceedings of the IEEE International Conference on Computer Design (ICCD), pp. 434441. Nowick, S.M., Dean, M.E., Dill, D.L., and Horowitz, M., 1993, The design of a highperformance cache controller: A case study in asynchronous synthesis, Proceedings of the 26th Hawaii International Conference on System Sciences, pp. 419427. Nowick, S.M., and Dill, D.L., 1991, Synthesis of asynchronous state machines using a local clock, IEEE International Conference on Computer Design, pp. 192197. Oikonomou, K.N., 1992, Abstractions of finitestate machines and immediatelydetectable output faults, IEEE Transactions on Computers, Vol. 41, No. 3, pp. 325338. Oliviera, D.L., Strum, M., Wang, J.C., and Cunha, W.C., 2000, Synthesis of high performance extended burst mode asynchronous state machines, Proceedings of the 13th Symposium on Integrated Circuits and Systems Design, pp. 4146. Ozveren, C.M., and Willsky, A.S., 1990, Observability of discrete event dynamic systems, IEEE Transactions on Automatic Control, Vol. 35, No. 7, pp. 797806. Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., 1991, Stability and stabilizability of discrete event dynamics systems, Journal of the Association of Computing Machinery, Vol. 38, No. 3, pp. 730752.
PAGE 83
74 Park, SJ., and Lim, JT., 2002, Robust and nonblocking supervisory control of nondeterministic discrete event systems using trajectory models, IEEE Transactions on Automatic Control, Vol. 47, No. 4, pp. 655658. Patterson, W.W., and Metze, G., 1974, Fail safe asynchronous sequential machine, IEEE Transactions on Computers, Vol. C23, No. 4, pp. 369374. Piguet, C., 1991, Logic synthesis of racefree asynchronous CMOS circuits, IEEE Journal of SolidState Circuits, Vol. 26, No. 3, pp. 371380. Plateau, B., and Atif, K., 1991, Stochastic automata network of modeling parallel systems, IEEE Transactions on Software Engineering, Vol. 17, No. 10, pp. 10931108. Ramadge, P.J., and Wonham, W.M., 1987, Modular feedback logic for discrete event systems, SIAM Journal of Control and Optimization, Vol. 25, pp. 12021218. Ramadge, P.J., and Wonham, W.M., 1989, The control of discrete event systems, Proceedings of the IEEE, Vol. 77, No. 1, pp. 8199. Ramadge, P.J.G., and Wonham, W.M., 1987, Supervisory control of a class of discrete event processes, SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206230. Sen, R.K., 1985, On state assignment of asynchronous sequential machines, Proceedings COMPINT 85: Computer Aided Technologies, pp. 433440. Schnfisch, B., and De Roos, A., 1999, Synchronous and Asynchronous Updating in Cellular Automata, BioSystems, 51(3), pp. 123143. Shields, M.W., 1987, An introduction to automata theory, Blackwell Scientific Publications, Boston, Massachusetts. Thistle, J.G., and Wonham, W.M., 1994, Control of infinite behavior of finite automata, SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206230. Tracey, J.H., 1966, Internal state assignments for asynchronous sequential machines, IEEE Transactions on Electronic Computers, EC15, pp. 551560. Turing, A., 19361937, On computable numbers, with an application to the entscheidungsproblem, Proceedings of the London Mathematical Society, Ser. 242, pp. 230265 with a correction, Ibid, Ser. 243, pp.544546, 19361937. Unger, S.H., 1959, Hazards and delays in asynchronous sequential switching circuits, IRE Transactions on Circuit Theory, Vol. CT6, No. 1, pp.1225.
PAGE 84
75 Unger, S.H., 1969, Asynchronous sequential switching circuits, Wiley Interscience, New York, NY. Unger, S.H., 1977, Selfsynchronizing circuits and nonfundamental mode operation, IEEE Transactions on Computers, Vol. 26, No. 3, pp. 278281. Unger, S.H., 1995, Hazards, critical races and metastability, IEEE Transactions on Computers, Vol. 44, No. 6, pp. 754768. Watanable, Y. and Brayton, R., 1993, Computing permissible behaviors of FSMs, Proceedings of the International Conference on ComputerAided Design, pp. 316320. Whitaker, S., and Maki, G., 1992, Self synchronized asynchronous sequential pass transistor circuits, IEEE Transactions on Computers, Vol. 41, No. 10, pp. 13441348. Wolfram, S., 1994, Cellular automata and complexity, World Scientific Pub Co Inc., 1986. Wonham, W.M., and Ramadge, P.J.G., 1987, On the supremal controllable sublanguage of a given language, SIAM Journal of Control and Optimization, Vol. 25, pp. 637659. Yoeli, M., and Rinon, S., 1964, Application of ternary algebra to the study of static hazards, Journal of the Association of Computing Machinery, Vol. 11, No. 1, pp. 8497. Yu, M.L., and Subrahmanyam, P.A., 1992, A pathoriented approach for reducing hazards in asynchronous design, Proceedings of the Design Automation Conference, 29th ACM/IEE, pp. 239244. Zambonelli, F., Roli, A., and Mamei, M., 2003, Dissipative cellular automata as minimalist distributed systems : A study on emergent behaviors, 11th IEEE EUROMICRO Conference on Parallel, Distributed, and Network Processing, Genova (I), IEEE CS Press, pp. 250257.
PAGE 85
BIOGRAPHICAL SKETCH Niranjan Venkatraman was born in Bangalore, India, and obtained his Bachelor of Engineering (B.E.) degree in Electrical and Electronics Engineering in May 2000 from the College of Engineering, Guindy, Chennai, a part of Anna University. Since August 2000, he has been a Ph.D. student in the Department of Electrical and Computer Engineering at the University of Florida, Gainesville, FL. During the pursuit of his Ph.D., he obtained his M.S. in Electrical and Computer Engineering from the University of Florida in December 2002. His research interests include control theory, control systems, automata theory, and the application of control theory to asynchronous networks and parallel computation. 76

