Citation
On the Control of Asynchronous Machines with Infinite Cycles

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 non-profit 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:

venkatraman_n ( .pdf )

venkatraman_n_Page_74.txt

venkatraman_n_Page_08.txt

venkatraman_n_Page_75.txt

venkatraman_n_Page_09.txt

venkatraman_n_Page_65.txt

venkatraman_n_Page_04.txt

venkatraman_n_Page_03.txt

venkatraman_n_Page_24.txt

venkatraman_n_Page_77.txt

venkatraman_n_Page_72.txt

venkatraman_n_Page_54.txt

venkatraman_n_Page_66.txt

venkatraman_n_Page_68.txt

venkatraman_n_Page_17.txt

venkatraman_n_Page_63.txt

venkatraman_n_Page_62.txt

venkatraman_n_Page_84.txt

venkatraman_n_Page_05.txt

venkatraman_n_Page_85.txt

venkatraman_n_Page_36.txt

venkatraman_n_Page_52.txt

venkatraman_n_Page_80.txt

venkatraman_n_Page_78.txt

venkatraman_n_Page_34.txt

venkatraman_n_Page_79.txt

venkatraman_n_Page_46.txt

venkatraman_n_Page_18.txt

venkatraman_n_Page_38.txt

venkatraman_n_Page_40.txt

venkatraman_n_Page_25.txt

venkatraman_n_Page_57.txt

venkatraman_n_Page_55.txt

venkatraman_n_Page_43.txt

venkatraman_n_Page_60.txt

venkatraman_n_Page_23.txt

venkatraman_n_Page_45.txt

venkatraman_n_Page_12.txt

venkatraman_n_Page_13.txt

venkatraman_n_Page_82.txt

venkatraman_n_Page_83.txt

venkatraman_n_Page_41.txt

venkatraman_n_Page_15.txt

venkatraman_n_Page_61.txt

venkatraman_n_Page_29.txt

venkatraman_n_Page_69.txt

venkatraman_n_Page_26.txt

venkatraman_n_Page_16.txt

venkatraman_n_Page_53.txt

venkatraman_n_Page_81.txt

venkatraman_n_Page_59.txt

venkatraman_n_Page_30.txt

venkatraman_n_Page_10.txt

venkatraman_n_Page_67.txt

venkatraman_n_Page_33.txt

venkatraman_n_Page_50.txt

venkatraman_n_Page_22.txt

venkatraman_n_Page_71.txt

venkatraman_n_Page_42.txt

venkatraman_n_Page_37.txt

venkatraman_n_Page_39.txt

venkatraman_n_Page_49.txt

venkatraman_n_Page_47.txt

venkatraman_n_Page_58.txt

venkatraman_n_Page_64.txt

venkatraman_n_Page_28.txt

venkatraman_n_Page_31.txt

venkatraman_n_Page_51.txt

venkatraman_n_Page_21.txt

venkatraman_n_Page_02.txt

venkatraman_n_Page_56.txt

venkatraman_n_Page_48.txt

venkatraman_n_Page_20.txt

venkatraman_n_Page_35.txt

venkatraman_n_Page_07.txt

venkatraman_n_Page_11.txt

venkatraman_n_Page_44.txt

venkatraman_n_pdf.txt

venkatraman_n_Page_19.txt

venkatraman_n_Page_01.txt

venkatraman_n_Page_32.txt

venkatraman_n_Page_70.txt

venkatraman_n_Page_06.txt

venkatraman_n_Page_14.txt

venkatraman_n_Page_27.txt

venkatraman_n_Page_73.txt

venkatraman_n_Page_76.txt


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

5-1. Transition table for the m machine ........................................ ....................... 59

5-2. Stable transition table for the generalized stable state machine |ls ........................60

5-3. Matrix of one-step generalized stable transitions R(ls) ...........................................60

5-4. Stable transition function of the given model '. .............................................61

















LIST OF FIGURES


Figure


1-1. 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 cycle-free 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, self-timing

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 1-1. 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 1-1. 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 1-1. 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 two-fold: 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 model-matching 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 model-matching 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 semi-fundamental 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 low-cost 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

hazard-free 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 error-correcting code. This kind of assignment,

which can be accomplished by mapping the rows of a flow table onto the vertices of a

unit n-dimensional 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 hazard-free 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

Sangiovanni-Vincentelli (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 semi-fundamental 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

burst-mode (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 non-empty 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 non-empty 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 non-empty 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,... (2-1)

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

(2-1) 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 non-deterministic finite state machine X = (A,Y,X,xo,f,h) has the following

objects:

* A finite, non-empty set A of permissible input characters, termed as the input
alphabet;

* A finite, non-empty set Y of permissible output characters, termed as the output
alphabet;

* A finite, non-empty set X of states of the machine. Any number of the states can
be designates as initial or terminal states;

* A non-deterministic 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 non-deterministic 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 2-1.

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, ... (2-2)

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 2-2. Let x be the state of the

machine and u the input value. When a state-input 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

semi-fundamental mode. The conditions and procedures for operation in semi-

fundamental mode is described in Chapter 3.

Consider a defect-free 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...vm-1. The machine now has transitions through the states xo,..., xm,

where xi+l = f(xi,vi); i = 0,1,2,...,m-l, 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,...,m-1.

Thepath is defined as the set of pairs

P(,xo,w) = {(xo,v0), (x1,v1),...,(xm-l,vm-1), (Xm,vm-1)}. (2-3)

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,u-1), 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). (3-1)

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 state-input 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 input-state pairs. A brief examination of Equation 3-1


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 3-1 Let (x,a) be any pair of the infinite cycle p. Then, the state set of p


is {fi(x,a)}jo.


Lemma 3-1 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 3-2 A valid input/state pair (x,a) of an asynchronous machine Y can be a

member of at most one infinite cycle.

Proof 3-2. 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 3-1, we conclude that pi and p2 have the same state set. In other words, p1 =

p2, and our proof concludes. *

The above Lemma 3-1 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 3-2, 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 3-3 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) := (3-2)
F otherwise,

i, j = 1, ..., n. Multiple entries in a cell are separated using a comma. We refer to M(f)

as the one-step transition matrix of the machine E.









We now define two matrix operations for one-step transition matrices. First, the

sum of two nxn one-step transition matrices A and B is defined element wise by

(A U B)j := Aij U Bij, i, j = 1, ..., n. (3-3)


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 := (3-4)
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. (3-5)


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 one-step transition matrices, as indicated by the

following. The next statement shows that the multiplication of two one-step transition









matrices on two recursion functions is the transition matrix on the composition of the two

functions.

Lemma 3-4 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 3-4. Using Definition 3-4, we have

M(g)M(h) = Uk=l..n Mi,k(g)Mk,j(h). (3-6)


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 one-step transition matrix. Then, by Lemma 3-4, M(f)M(f) = M(f2), M(f2)M(f) =

M(f3), and so on. This leads to the following corollary.

Corollary 3-5 Let Y = (A,X,xo,Y,f,h) be an asynchronous machine. Then, for

every integer p > 0, the one-step 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 3-6 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 3-6. 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 3-2, the character u appears on the

diagonal entry (i,i) of the matrix M(ft). By Corollary 3-5, 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), ..,

fl-1(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 one-step 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 3-7 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, ..., xJi-1 of the cycle can be found from the matrix

M(f) in the following way: for every integer i = 0, ..., k-2, the index ji+l is given by the

position of the entry u in the column ji of the matrix M(f).

Proof 3-7. 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 3-7. 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 3-8 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 3-8 is pointed out by the following statement.

Proposition 3-9 Let i > 1 be an integer. Then, in the notation of Algorithm 3-8,

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 3-7 to find the other k-1

members of that cycle. Now, pick another state from the k remaining states in 4j(u),

and using Lemma 3-7, the second cycle can be determined. This procedure is extended

to any number of cycles of a certain length.

Proof 3-9. Let X = {x1, ..., xn} be the state set of Y, and let u e A be a character

of the input set. By Lemma 3-6, 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 3-7 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 3-2, 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 stable-state 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}. (3-8)


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 = (3-9)
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)}. (3-10)

Now, the function s2 : XPxA XP is defined by setting

s(xu) if x e X,
s2(x,u) := i x (3-11)
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 c|s, be the generalized stable state

machine induced by the closed loop system Ec shown in Figure 1-1. 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 3-10 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 3-10 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 3-10 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 3-11 A machine X is said to operate in semi-fundamental mode if the

machine operates in fundamental mode when it is not in an cycle. *

Recall that the states of the generalize stable-state 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 3-12 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 one-step

generalized stable transitions gives all the possible stable one-step transitions of the

machine i|s; it is an (n+t)x(n+t) matrix R(i|s), whose (i,j) entry is given by


rsx(xJ,xi) if sx(xJ,xi) # 0,
Rij(|s)- (3-12)
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 3-12 is similar to Equation 3-2, 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 := (3-13)
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 element-wise operation as


defined in Equation 3-13-

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. (3-14)
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). (3-15)
j=l,...,r


Note that the concatenation is either a subset of A*, or it is the character N. The

concatenation is non-commutative, 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. (3-16)









Using this notation, we can define powers of the one-step transition matrix

recursively, by setting

RW(l|s) := RW (Els)R(ils), |t = 2, 3, ... (3-17)

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 3-5, which

states that the powers of the one-step 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+t-1). (3-18)


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 3-9.

Lemma 3-13 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+t-1)
(ii) The ij entry Rij (Ys) N. *

Now, R(n+t-1)(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 3-14 Let Y be an asynchronous machine. The matrix of stable

transitions T(I|s) is constructed by performing the following operation on each column

of the matrix R(n+t-1)(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(I|s), it is instructive to compare it to

the matrix R(n+t-1)(lsi). A string u in the (ij) entry of the matrix R(n+t-1)(lis)

indicates, of course, that u takes I|s from xJ to xi. However, if the string u appears

in another entry in column j of R(n+t-1)(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(l|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(I|s) takes the machine YIs from the state xJ to

the state xi, and to no other state.

Definition 3-15 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 3-15, 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(I|s) will contain sets of strings

that satisfy the following proposition.

Proposition 3-16 The (i,j) entry of T(I|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(I|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(I|s)

gives a set of strings that can be used for the control process. The skeleton matrix is now

defined as follows matrix:

Definition 3-17 Let T(I|s) 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 (3-19)
0 otherwise

i= 1,...,n,j = 1,...,n+t. *

The skeleton matrix K(X) has a simple interpretation. In view of Lemma 3-13, the

following is true









Proposition 3-18 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 1-1 with the

controller C. Recall that Yc denotes the closed loop machine of Figure 1-1; let Xc|s 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 1-1 and the Model Matching Problem 3-10, we are

investigating the existence of a controller C for which c|s, = 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 semi-fundamental 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 semi-fundamental 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 1-1 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: XxE-X : 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 c|s, 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), (3-20)

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 3-19 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 c|s, 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)= (3-21)
t=xp(z) if z is a cycle state.

Note that (p(z) is always a set of regular states, not cycle states.

Theorem 3-20 (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 c|s, 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 3-20. By Proposition 3-19, 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(i-l,vm(il-), i = 1, ..., k. (3-22)

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, (3-23)


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 3-20 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)} (3-24)
^ 05- 0, 1. 5' 2'!$- --' ^2!- -, '*' ^' **' k (3-24)

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

semi-fundamental 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. (3-25)

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. (3-26)

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. (3-27)

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. (3-28)

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. (3-29)

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, (3-30)

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, (3-31)

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). (3-32)

k
i = 1,...,k. Note that, since the state-input 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, (3-33)

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 semi-fundamental mode

as the definitions of 4 and r specify. We know E is an input-state 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 stable-state model to be matched. The skeleton matrix Ko(') of the model 2' is

given as in Definition 3-17. 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, (4-1)
0 otherwise.


In view of Proposition 3-19, 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 4-1 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 4-1 Let Y be an asynchronous machine all of whose cycles are

stoppable, and let i|s = (A,XP,xo,s) be the generalized stable state machine induced by

Y. Let 2' = (A,X,xo,s') be a stable-state 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 c|s, is equivalent to

2', where cIs operates in the semi-fundamental mode and is well posed.

(ii) The skeleton matrices satisfy K(X) > K(E').

Theorem 4-1 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 c|s, 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 4-1. 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 4-1. 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

co-domain 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)}. (4-2)

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+ (4-3)

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) (4-4)

be the set of all state-input 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}. (4-5)


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'), (4-6)

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 4-1. Assume first that condition (i) of Theorem 4-1 is valid, i.e., that there

exists a controller C such that c|s, = 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 4-1. Recalling the set D(X,2') of

Equation 4-2, 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} (4-7)


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}. (4-8)

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} (4-9)

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). (4-10)

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))}. (4-11)

In case DN(X,') = 0, set EN := 0.

We turn now to the set DC of Equation 4-7, 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 4-1, 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 3-18 that s'(x,u) =

s(x,w(x,u)). Consider now the path P(l|s,x,w(x,u)). Recalling that (x,u) e DC, the

following hold. If x is not a cycle state, then the path P(l|s,x,w(x,u)) must include a

cycle. If x is a cycle state, then P(l|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(l|s,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(l|s,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 semi-fundamental 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)), (4-12)

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 4-12, 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.

q-1
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 4-12. 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 semi-fundamental









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. (4-15)

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. (4-16)

For semi-fundamental 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. (4-17)

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, (4-18)

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, (4-19)

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), (4-20)

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), (4-22)

j = 0, ..., q-1.

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 4-24, 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) } (4-25)

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)). (4-26)

Thus, the set of controller states for all the elements of DC are

Ec = Uk = 1,..., n(C) E(xk,uk) (4-27)


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. (4-28)

By construction, the closed loop system operates in semi-fundamental 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 4-1. 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 5-1 of transitions.

Table 5-1. 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 3-8 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 3-8, and the same input set A. The stable recursion function s of the

generalized stable state machine I|s is defined in the Table 5-2 of transitions. The

generalized stable recursion function for the generalized stable state machine is defined in

Equation 3-11. 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 5-2. 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 I|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 3-12, the matrix of one-step generalized stable

transitions R(Xls) is shown in Table 5-3.

Table 5-3. Matrix of one-step generalized stable transitions R(YIs)

x1 X2 x3 x4 x5 x6


a,c,d

N

N

b

N

N









Using Equation 3-17 and Equation 3-18, we construct the matrices R2(Xis), R3( ls),

R4( |s), and R5(Els), and then the matrix R(5)(EIs). Then, applying Definition 3-14, the

matrix of stable transitions T(I|s) is constructed. Finally, using Definition 3-17, 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 (5-1)
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 5-4 of

transitions.

Table 5-4. 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 (5-2)
1 1 1 1
I I I I
_2 i i











Following Equation 4-1, the augmented skeleton matrix K(E') is then constructed

as follows.


K(')= 0 1 0 0 0 (5-3)
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 4-1.

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)}. (5-4)

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). (5-5)









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. (5-6)

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. (5-7)

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. (5-8)

This concludes the construction of the feedback controller C such that the closed

loop machine c|s = Y'. The equations (5-6), (5-7) and (5-8) 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 input-state 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 closed-loop combined plant and
controller model," IEEE Transactions on Systems, Man and Cybernetics, Vol. 32,
No. 2, pp.163-175.

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, C-17, 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,
C-20, pp. 225-226.

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. 262-285.

Brzozowski, J.A., and Seger, C., 1987, "A characterization of ternary simulation of gate
networks," IEEE Transactions on Computers, C-36, No. 11, pp. 1318-1327.

Brzozowski, J.A., and Seger, C-J., 1989, "A unified framework for race analysis of
asynchronous networks," Journal of the Association for Computing Machinery,
Vol. 36, No. 1, pp. 20-45.

Brzozowski, J.A., and Yeoli, M., 1979, "On a ternary model of gate networks," IEEE
Transactions on Computers, C-28, pp.178-183.

Chiang, J., and Radhakrishnan, D., 1990, "Hazard-free design of mixed operating mode
asynchronous sequential circuits," International Journal of Electronics, Vol. 68, No.
1, pp. 23-37.

Chu, T., 1994, "Synthesis of hazard-free control circuits from asynchronous finite state
machine specifications," Journal of VLSI Signal Processing, Vol. 7, No. 1-2, pp.
61-84.

Chu, T., Mani, N., and Leung, C., 1993, An efficient critical race-free state assignment
technique for asynchronous finite state machines," Proceedings of the 30th
ACM/IEEE Design Automation Conference, Dallas, TX, pp. 2-5.









Cole, R., and Zajicek, 0., 1990, "The expected advantage of asynchrony," Proceedings of
the Second Annual ACM Symposium on Parallel Algorithms and Architectures,
pp. 85-94.

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. 1067-1075.

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 A-28 of IFIP Transactions, Elsevier Science
Publishers, pp. 193-207.

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. 409-418.

Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., 1994, "Model
matching for finite state machines," Proceedings of the IEEE Conference on
Decision and Control, Vol. 3, pp. 3117-3124.

Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, 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. 422-426.

Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., 1995b, "Strong model
matching for finite state machines," Proceedings of European Control Conference,
Vol. 3, pp. 2027-2034.

Dibenedetto, M.D., Sangiovanni-Vincentelli, A., and Villa, T., 2001, "Model matching
for finite-state machines," IEEE Transactions on Automatic Control, Vol. 26, No.
11, pp. 1726-1743.

Eichelberger, E.B., 1965, "Hazard detection in combinational and sequential switching
circuits," IBM Journal of Research and Development, Vol. 9, No. 2, pp. 90-99.

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, "Race-free state assignments for synthesizing
large-scale asynchronous sequential logic circuits," IEEE Transactions of
Computers, Vol. 42, No. 9, pp.1025-1034.

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. 76-80.






70


Furber, S.B., 1993, "Breaking step The return of asynchronous logic," IEEE Review,
pp. 159-162.

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. 4098-4103.

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. 1005-1028.

Hammer J., 1996b, "On the corrective control of sequential machines," International
Journal of Control, Vol. 65, No. 6, pp. 249-276.

Hauck, S., 1995, "Asynchronous design methodologies: an overview," Proceedings of the
IEEE, Vol. 83, No. 1, pp. 69-93.

Hazeltine, B., 1965, "Encoding of asynchronous sequential circuits," IEEE Transactions
on Electronic Computers, EX-14, pp.727-729.

Higham, L., and Schenk, E., 1992, "The parallel asynchronous recursion model,"
Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp.
310-316.

Hlavicka, J., 1970, "Essential hazard correction without the use of delay elements," IEEE
Transactions on Computers, C-19, No. 3, pp. 232-238.

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. 37-52.

Huffmann D.A., 1954a, "The synthesis of sequential switching circuits," J. Franklin Inst.,
Vol. 257, pp. 161-190.

Huffmann D.A., 1954b, "The synthesis of sequential switching circuits," J. Franklin Inst.,
Vol. 257, pp. 275-303.

Huffmann, D.A., 1957, "The design and use of hazard-free switching networks," Journal
of the Association of Computing Machinery, Vol. 4, No. 1, pp. 47-62.

Ingerson, T.E., and Buvel, R.L., 1984, "Structure in Asynchronous Cellular Automata,"
Physica D, Vol. 10, pp. 59-68.

Kailath, T., 1980, "Linear systems," Prentice Hall Inc., Englewood Cliffs, New Jersey,
1979, pp. 268-272.

Kalman, R.E., Falb, P.L., and Arbib, M.A., 1969, "Topics in Mathematical Systems
Theory," McGraw-Hill Book Company, New York.

Kohavi, Z., 1970, "Switching and finite automata theory," McGraw-Hill 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 Sangiovanni-Vincentelli, A., 1991, "Algorithms for
synthesis of hazard-free asynchronous circuits," Proceedings of the 28th
ACM/IEEE Design Automation Conference, San Francisco, CA, pp. 302-308.

Lavagno, L., Moon, C.W., and Sangiovanni-Vincentelli, A., 1994, "Efficient heuristic
procedure for solving the state assignment problem for event-based specifications,"
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems,
Vol. 14, pp. 45-60.

Lin, B., and Devadas, S., 1995, "Synthesis of hazard-free 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. 974-985.

Lin, F., 1993, "Robust and adaptive supervisory control of discrete event systems," IEEE
Transactions on Automatic Control, Vol. 38, No. 12, pp. 1848-1852.

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. 1330-1337.









Liu, C., 1963, "A state variable assignment procedure for asynchronous sequential
switching circuits," Journal of the Association of Computing Machinery, Vol. 10,
pp. 209-216.

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, C-20, pp. 290-298.

Maki, G., and Tracey, J., 1971, "A state assignment procedure for asynchronous
sequential circuits," IEEE Transactions on Computers, C-20, pp. 666-668.

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 fail-safe asynchronous sequential
machines," Transactions of the Institute of Electronics and Communication, Vol.
E60, No. 10, pp. 527-532.

McCluskey, E.J., 1963, "Fundamental mode and pulse mode sequential circuits," Proc.
IFIP Congress 1962, International Conference on Information Processing, Munich,
August 27-September 1, 1962, pp. 725-730, Cicely M. Popplewell (ed.), North
Holland Publishing Company, Amsterdam.

McCluskey, E.J., 1965, "Introduction to the theory of switching circuits," McGraw-Hill
Book Company, New York.

Mealy, G.H., 1955, "A method for synthesizing sequential circuits," Bell Systems
Technical Journal, Vol. 34, pp. 1045-1079.

Moon, C.W., Stephan, P.R., and Brayton, R.K., 1991, "Synthesis of hazard-free
asynchronous circuits from graphical specifications," IEEE International
Conference on Computer-Aided Design, pp. 322-325.

Moore, E.F., 1956, "Gedanken-experiments 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 73-78.

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.
1073-1081.

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. 76-84.

Nishimura, N., 1995, "Efficient asynchronous simulation of a class of synchronous
parallel algorithms," Journal of Computer and System Sciences, Vol. 50, No. 1, pp.
98-113.

Nowick, S.M., 1993, "Automatic synthesis of burst-mode asynchronous controllers,"
Ph.D. Dissertation, Department of Computer Science, Stanford University,
Stanford, California.

Nowick, S.M., and Coates, B., 1994, "UCLOCK: Automated design of high-performance
unclocked state machines," Proceedings of the IEEE International Conference on
Computer Design (ICCD), pp. 434-441.

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.
419-427.

Nowick, S.M., and Dill, D.L., 1991, "Synthesis of asynchronous state machines using a
local clock," IEEE International Conference on Computer Design, pp. 192-197.

Oikonomou, K.N., 1992, "Abstractions of finite-state machines and immediately-
detectable output faults," IEEE Transactions on Computers, Vol. 41, No. 3, pp.
325-338.

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. 41-46.

Ozveren, C.M., and Willsky, A.S., 1990, "Observability of discrete event dynamic
systems," IEEE Transactions on Automatic Control, Vol. 35, No. 7, pp. 797-806.

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. 730-752.









Park, S-J., and Lim, J-T., 2002, "Robust and nonblocking supervisory control of
nondeterministic discrete event systems using trajectory models," IEEE
Transactions on Automatic Control, Vol. 47, No. 4, pp. 655-658.

Patterson, W.W., and Metze, G., 1974, "Fail safe asynchronous sequential machine,"
IEEE Transactions on Computers, Vol. C-23, No. 4, pp. 369-374.

Piguet, C., 1991, "Logic synthesis of race-free asynchronous CMOS circuits," IEEE
Journal of Solid-State Circuits, Vol. 26, No. 3, pp. 371-380.

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. 1202-1218.

Ramadge, P.J., and Wonham, W.M., 1989, "The control of discrete event systems,"
Proceedings of the IEEE, Vol. 77, No. 1, pp. 81-99.

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.
206-230.

Sen, R.K., 1985, "On state assignment of asynchronous sequential machines,"
Proceedings COMPINT 85: Computer Aided Technologies, pp. 433-440.

Schonfisch, B., and De Roos, A., 1999, "Synchronous and Asynchronous Updating in
Cellular Automata", BioSystems, 51(3), pp. 123-143.

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, EC-15, pp. 551-560.

Turing, A., 1936-1937, "On computable numbers, with an application to the
entscheidungs-problem," Proceedings of the London Mathematical Society, Ser. 2-
42, pp. 230-265 with a correction, Ibid, Ser. 2-43, pp.544-546, 1936-1937.

Unger, S.H., 1959, "Hazards and delays in asynchronous sequential switching circuits,"
IRE Transactions on Circuit Theory, Vol. CT-6, No. 1, pp.12-25.






75


Unger, S.H., 1969, "Asynchronous sequential switching circuits," Wiley Interscience,
New York, NY.

Unger, S.H., 1977, "Self-synchronizing circuits and non-fundamental mode operation,"
IEEE Transactions on Computers, Vol. 26, No. 3, pp. 278-281.

Unger, S.H., 1995, "Hazards, critical races and metastability," IEEE Transactions on
Computers, Vol. 44, No. 6, pp. 754-768.

Watanable, Y. and Brayton, R., 1993, "Computing permissible behaviors ofFSM's,"
Proceedings of the International Conference on Computer-Aided 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.
84-97.

Yu, M.L., and Subrahmanyam, P.A., 1992, "A path-oriented approach for reducing
hazards in asynchronous design," Proceedings of the Design Automation
Conference, 29th ACM/IEE, pp. 239-244.

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. 250-257.















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 5-1. Transition table for the machine ...........................................................................59 5-2. Stable transition table for the generalized stable state machine |s..........................60 5-3. Matrix of one-step generalized stable transitions R(|s)...........................................60 5-4. Stable transition function of the given model .......................................................61 vi

PAGE 7

LIST OF FIGURES Figure page 1-1. 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 cycle-free 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, self-timing 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 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

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 1-1. 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 1-1. 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 1-1. 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 two-fold: 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 model-matching 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 model-matching 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 semi-fundamental 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 low-cost 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 hazard-free 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 error-correcting code. This kind of assignment, which can be accomplished by mapping the rows of a flow table onto the vertices of a unit n-dimensional 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 hazard-free 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 Sangiovanni-Vincentelli (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 semi-fundamental 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 burst-mode (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 non-empty 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 non-empty 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 non-empty 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, (2-1) 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 (2-1) 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 non-deterministic finite state machine = (A,Y,X,x0,f,h) has the following objects: A finite, non-empty set A of permissible input characters, termed as the input alphabet; A finite, non-empty set Y of permissible output characters, termed as the output alphabet; A finite, non-empty set X of states of the machine. Any number of the states can be designates as initial or terminal states; A non-deterministic 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 non-deterministic 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 2-1. 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, (2-2) 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 2-2. Let x be the state of the machine and u the input value. When a state-input 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 semi-fundamental mode. The conditions and procedures for operation in semi-fundamental mode is described in Chapter 3. Consider a defect-free 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)}. (2-3) 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,u-1), 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). (3-1) 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 state-input 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 input-state pairs. A brief examination of Equation 3-1 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 3-1 Let (x,a) be any pair of the infinite cycle Then, the state set of is {fj(x,a)}j=0. Lemma 3-1 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 3-2 A valid input/state pair (x,a) of an asynchronous machine can be a member of at most one infinite cycle. Proof 3-2. 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 3-1, we conclude that 1 and 2 have the same state set. In other words, 1 = 2, and our proof concludes. The above Lemma 3-1 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 3-2, 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 3-3 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) := (3-2) i, j = 1, ..., n. Multiple entries in a cell are separated using a comma. We refer to M(f) as the one-step transition matrix of the machine iju A : x f(x,u), otherwise,

PAGE 32

23 We now define two matrix operations for one-step transition matrices. First, the sum of two nn one-step transition matrices A and B is defined element wise by (A B)ij := Aij Bij, i, j = 1, ..., n. (3-3) 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 := (3-4) 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. (3-5) 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 one-step transition matrices, as indicated by the following. The next statement shows that the multiplication of two one-step transition

PAGE 33

24 matrices on two recursion functions is the transition matrix on the composition of the two functions. Lemma 3-4 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 3-4. Using Definition 3-4, we have M(g)M(h) = k=1..n Mi,k(g)Mk,j(h). (3-6) 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 one-step transition matrix. Then, by Lemma 3-4, M(f)M(f) = M(f2), M(f2)M(f) = M(f3), and so on. This leads to the following corollary. Corollary 3-5 Let = (A,X,x0,Y,f,h) be an asynchronous machine. Then, for every integer p > 0, the one-step 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 3-6 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 3-6. 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 3-2, the character u appears on the diagonal entry (i,i) of the matrix M(f). By Corollary 3-5, 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 one-step 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 3-7 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 3-7. 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 3-7. 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 3-8 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). (3-7) Stop the algorithm for the character u when i+1 > n ij=1 #j(u). The significance of Algorithm 3-8 is pointed out by the following statement. Proposition 3-9 Let i 1 be an integer. Then, in the notation of Algorithm 3-8, 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 3-7 to find the other members of that cycle. Now, pick another state from the remaining states in (u), and using Lemma 3-7, the second cycle can be determined. This procedure is extended to any number of cycles of a certain length. Proof 3-9. Let X = {x1, ..., xn} be the state set of and let u A be a character of the input set. By Lemma 3-6, 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 3-7 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 3-2, 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 stable-state 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}. (3-8) 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) = (3-9) 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)}. (3-10) Now, the function s2 : XA X is defined by setting s2(x,u) := (3-11) 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 c|s be the generalized stable state machine induced by the closed loop system c shown in Figure 1-1. 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 3-10 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 c|s = When C exists, provide a method for its design. The controller C of Problem 3-10 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 3-10 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 3-11 A machine is said to operate in semi-fundamental mode if the machine operates in fundamental mode when it is not in an cycle. Recall that the states of the generalize stable-state machine |s are either potentially stable states of or cycle state that represent cycles. Thus, semi-fundamental mode operation of becomes fundamental mode operation of |s. Definition 3-12 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 one-step generalized stable transitions gives all the possible stable one-step 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, (3-12) 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 3-12 is similar to Equation 3-2, 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 := (3-13) 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 element-wise operation as defined in Equation 3-13As 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) := (3-14) 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). (3-15) i=1,...,qj=1,...,r Note that the concatenation is either a subset of A*, or it is the character N. The concatenation is non-commutative, 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. (3-16)

PAGE 45

36 Using this notation, we can define powers of the one-step transition matrix recursively, by setting R(|s) := R(|s)R(|s), = 2, 3, (3-17) 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 3-5, which states that the powers of the one-step 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). (3-18) 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 3-9. Lemma 3-13 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 3-14 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 3-15 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 3-15, 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 3-16 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 3-17 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() = (3-19) ij|s1 if T() N,0 otherwise i = 1,,n, j = 1,,n+t. The skeleton matrix K() has a simple interpretation. In view of Lemma 3-13, the following is true

PAGE 48

39 Proposition 3-18 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 1-1 with the controller C. Recall that c denotes the closed loop machine of Figure 1-1; let c|s 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 1-1 and the Model Matching Problem 3-10, we are investigating the existence of a controller C for which c|s = 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 semi-fundamental 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 semi-fundamental 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 1-1 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 c|s. We know that the output of c|s is the state of So, if c|s = then, for every valid pair (x,v) of there is a state for which (x,,v) is a valid pair of c|s. This leads to the conclusion hc(x,,v) = s(x,v), (3-20) 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 3-19 Let and be two machines, where is a stable state machine. Assume that there is a controller C such that c|s = If the closed loop machine c|s 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) = (3-21) 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 3-20 (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 c|s 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 semi-fundamental mode. Proof 3-20. By Proposition 3-19, 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. (3-22) 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, (3-23) 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 3-20 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}. (3-24) 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 semi-fundamental 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. (3-25) 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. (3-26) 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. (3-27) 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. (3-28) 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. (3-29) 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, (3-30) 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, (3-31) 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. (3-32) i = 1,,k. Note that, since the state-input 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, (3-33) 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 semi-fundamental mode as the definitions of and specify. We know is an input-state 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 stable-state model to be matched. The skeleton matrix K0() of the model is given as in Definition 3-17. 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() = (4-1) 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 3-19, 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 4-1 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 4-1 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 stable-state 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 c|s is equivalent to where c|s operates in the semi-fundamental mode and is well posed. (ii) The skeleton matrices satisfy K() K(). Theorem 4-1 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 c|s 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 4-1. Consequently, there is a controller C for which c|s = 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 4-1. 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 co-domain 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)}. (4-2) 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+ (4-3) 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} (4-4) be the set of all state-input pairs involved in cycles. Define the set DN(,) := {(x,u) D(,) : there is a string w S(x,u) such that P(,x,w) () = }. (4-5) 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(,), (4-6) 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 4-1. Assume first that condition (i) of Theorem 4-1 is valid, i.e., that there exists a controller C such that c|s = 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 4-1. Recalling the set D(,) of Equation 4-2, 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(,) } (4-7) The set of all input characters that pair with a state x in D is given by D(x) := {u A: (x,u) D}. (4-8) 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} (4-9) 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). (4-10) 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))}. (4-11) In case DN(,) = set N := We turn now to the set DC of Equation 4-7, 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 3-19 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 4-1, 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 3-18 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 semi-fundamental 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)), (4-12) 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 4-12, 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)), (4-13) 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, (4-18) 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, (4-19) 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), (4-20) 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, (4-21) 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), (4-22) 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). (4-23) 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)}. (4-24) 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 4-24, 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)}. (4-25) 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)). (4-26) Thus, the set of controller states for all the elements of DC are C = k = 1, n(C) C(xk,uk) (4-27) 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. (4-28) By construction, the closed loop system operates in semi-fundamental 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 4-1. 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 5-1 of transitions. Table 5-1. 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 3-8 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 3-8, and the same input set A. The stable recursion function s of the generalized stable state machine |s is defined in the Table 5-2 of transitions. The generalized stable recursion function for the generalized stable state machine is defined in Equation 3-11. 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 5-2. 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 3-12, the matrix of one-step generalized stable transitions R(|s) is shown in Table 5-3. Table 5-3. Matrix of one-step 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 3-17 and Equation 3-18, we construct the matrices R2(|s), R3(|s), R4(|s), and R5(|s), and then the matrix R(5)(|s). Then, applying Definition 3-14, the matrix of stable transitions T(|s) is constructed. Finally, using Definition 3-17, 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 (5-1) 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 5-4 of transitions. Table 5-4. 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 (5-2)

PAGE 71

62 Following Equation 4-1, 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 (5-3) 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 4-1. To construct the controller, we need the following matrices, as explained in the proof of Theorem 4-1. 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)}. (5-4) 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). (5-5)

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. (5-6) 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. (5-7) 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. (5-8) This concludes the construction of the feedback controller C such that the closed loop machine c|s = The equations (5-6), (5-7) and (5-8) 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 input-state 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 closed-loop combined plant and controller model, IEEE Transactions on Systems, Man and Cybernetics, Vol. 32, No. 2, pp.163-175. 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, C-17, 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, C-20, pp. 225-226. 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. 262-285. Brzozowski, J.A., and Seger, C., 1987, A characterization of ternary simulation of gate networks, IEEE Transactions on Computers, C-36, No. 11, pp. 1318-1327. Brzozowski, J.A., and Seger, C-J., 1989, A unified framework for race analysis of asynchronous networks, Journal of the Association for Computing Machinery, Vol. 36, No. 1, pp. 20-45. Brzozowski, J.A., and Yeoli, M., 1979, On a ternary model of gate networks, IEEE Transactions on Computers, C-28, pp.178-183. Chiang, J., and Radhakrishnan, D., 1990, Hazard-free design of mixed operating mode asynchronous sequential circuits, International Journal of Electronics, Vol. 68, No. 1, pp. 23-37. Chu, T., 1994, Synthesis of hazard-free control circuits from asynchronous finite state machine specifications, Journal of VLSI Signal Processing, Vol. 7, No. 1-2, pp. 61-84. Chu, T., Mani, N., and Leung, C., 1993, An efficient critical race-free state assignment technique for asynchronous finite state machines, Proceedings of the 30th ACM/IEEE Design Automation Conference, Dallas, TX, pp. 2-5. 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. 85-94. 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. 1067-1075. 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 A-28 of IFIP Transactions, Elsevier Science Publishers, pp. 193-207. 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. 409-418. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., 1994, Model matching for finite state machines, Proceedings of the IEEE Conference on Decision and Control, Vol. 3, pp. 3117-3124. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, 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. 422-426. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., 1995b, Strong model matching for finite state machines, Proceedings of European Control Conference, Vol. 3, pp. 2027-2034. Dibenedetto, M.D., Sangiovanni-Vincentelli, A., and Villa, T., 2001, Model matching for finite-state machines, IEEE Transactions on Automatic Control, Vol. 26, No. 11, pp. 1726-1743. Eichelberger, E.B., 1965, Hazard detection in combinational and sequential switching circuits, IBM Journal of Research and Development, Vol. 9, No. 2, pp. 90-99. 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, Race-free state assignments for synthesizing large-scale asynchronous sequential logic circuits, IEEE Transactions of Computers, Vol. 42, No. 9, pp.1025-1034. 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. 76-80.

PAGE 79

70 Furber, S.B., 1993, Breaking step The return of asynchronous logic, IEEE Review, pp. 159-162. 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. 4098-4103. 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. 1005-1028. Hammer J., 1996b, On the corrective control of sequential machines, International Journal of Control, Vol. 65, No. 6, pp. 249-276. Hauck, S., 1995, Asynchronous design methodologies: an overview, Proceedings of the IEEE, Vol. 83, No. 1, pp. 69-93. Hazeltine, B., 1965, Encoding of asynchronous sequential circuits, IEEE Transactions on Electronic Computers, EX-14, pp.727-729. Higham, L., and Schenk, E., 1992, The parallel asynchronous recursion model, Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp. 310-316. Hlavicka, J., 1970, Essential hazard correction without the use of delay elements, IEEE Transactions on Computers, C-19, No. 3, pp. 232-238. 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. 37-52. Huffmann D.A., 1954a, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 161-190. Huffmann D.A., 1954b, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 275-303. Huffmann, D.A., 1957, The design and use of hazard-free switching networks, Journal of the Association of Computing Machinery, Vol. 4, No. 1, pp. 47-62. Ingerson, T.E., and Buvel, R.L., 1984, Structure in Asynchronous Cellular Automata, Physica D, Vol. 10, pp. 59-68. Kailath, T., 1980, Linear systems, Prentice Hall Inc., Englewood Cliffs, New Jersey, 1979, pp. 268-272. Kalman, R.E., Falb, P.L., and Arbib, M.A., 1969, Topics in Mathematical Systems Theory, McGraw-Hill Book Company, New York. Kohavi, Z., 1970, Switching and finite automata theory, McGraw-Hill 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 Sangiovanni-Vincentelli, A., 1991, Algorithms for synthesis of hazard-free asynchronous circuits, Proceedings of the 28th ACM/IEEE Design Automation Conference, San Francisco, CA, pp. 302-308. Lavagno, L., Moon, C.W., and Sangiovanni-Vincentelli, A., 1994, Efficient heuristic procedure for solving the state assignment problem for event-based specifications, IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, Vol. 14, pp. 45-60. Lin, B., and Devadas, S., 1995, Synthesis of hazard-free 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. 974-985. Lin, F., 1993, Robust and adaptive supervisory control of discrete event systems, IEEE Transactions on Automatic Control, Vol. 38, No. 12, pp. 1848-1852. 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. 1330-1337.

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. 209-216. 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, C-20, pp. 290-298. Maki, G., and Tracey, J., 1971, A state assignment procedure for asynchronous sequential circuits, IEEE Transactions on Computers, C-20, pp. 666-668. 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 fail-safe asynchronous sequential machines, Transactions of the Institute of Electronics and Communication, Vol. E60, No. 10, pp. 527-532. McCluskey, E.J., 1963, Fundamental mode and pulse mode sequential circuits, Proc. IFIP Congress 1962, International Conference on Information Processing, Munich, August 27-September 1, 1962, pp. 725-730, Cicely M. Popplewell (ed.), North Holland Publishing Company, Amsterdam. McCluskey, E.J., 1965, Introduction to the theory of switching circuits, McGraw-Hill Book Company, New York. Mealy, G.H., 1955, A method for synthesizing sequential circuits, Bell Systems Technical Journal, Vol. 34, pp. 1045-1079. Moon, C.W., Stephan, P.R., and Brayton, R.K., 1991, Synthesis of hazard-free asynchronous circuits from graphical specifications, IEEE International Conference on Computer-Aided Design, pp. 322-325. Moore, E.F., 1956, Gedanken-experiments 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 73-78. 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. 1073-1081. 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. 76-84. Nishimura, N., 1995, Efficient asynchronous simulation of a class of synchronous parallel algorithms, Journal of Computer and System Sciences, Vol. 50, No. 1, pp. 98-113. Nowick, S.M., 1993, Automatic synthesis of burst-mode asynchronous controllers, Ph.D. Dissertation, Department of Computer Science, Stanford University, Stanford, California. Nowick, S.M., and Coates, B., 1994, UCLOCK: Automated design of high-performance unclocked state machines, Proceedings of the IEEE International Conference on Computer Design (ICCD), pp. 434-441. 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. 419-427. Nowick, S.M., and Dill, D.L., 1991, Synthesis of asynchronous state machines using a local clock, IEEE International Conference on Computer Design, pp. 192-197. Oikonomou, K.N., 1992, Abstractions of finite-state machines and immediately-detectable output faults, IEEE Transactions on Computers, Vol. 41, No. 3, pp. 325-338. 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. 41-46. Ozveren, C.M., and Willsky, A.S., 1990, Observability of discrete event dynamic systems, IEEE Transactions on Automatic Control, Vol. 35, No. 7, pp. 797-806. 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. 730-752.

PAGE 83

74 Park, S-J., and Lim, J-T., 2002, Robust and nonblocking supervisory control of nondeterministic discrete event systems using trajectory models, IEEE Transactions on Automatic Control, Vol. 47, No. 4, pp. 655-658. Patterson, W.W., and Metze, G., 1974, Fail safe asynchronous sequential machine, IEEE Transactions on Computers, Vol. C-23, No. 4, pp. 369-374. Piguet, C., 1991, Logic synthesis of race-free asynchronous CMOS circuits, IEEE Journal of Solid-State Circuits, Vol. 26, No. 3, pp. 371-380. 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. 1202-1218. Ramadge, P.J., and Wonham, W.M., 1989, The control of discrete event systems, Proceedings of the IEEE, Vol. 77, No. 1, pp. 81-99. 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. 206-230. Sen, R.K., 1985, On state assignment of asynchronous sequential machines, Proceedings COMPINT 85: Computer Aided Technologies, pp. 433-440. Schnfisch, B., and De Roos, A., 1999, Synchronous and Asynchronous Updating in Cellular Automata, BioSystems, 51(3), pp. 123-143. 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, EC-15, pp. 551-560. Turing, A., 1936-1937, On computable numbers, with an application to the entscheidungs-problem, Proceedings of the London Mathematical Society, Ser. 2-42, pp. 230-265 with a correction, Ibid, Ser. 2-43, pp.544-546, 1936-1937. Unger, S.H., 1959, Hazards and delays in asynchronous sequential switching circuits, IRE Transactions on Circuit Theory, Vol. CT-6, No. 1, pp.12-25.

PAGE 84

75 Unger, S.H., 1969, Asynchronous sequential switching circuits, Wiley Interscience, New York, NY. Unger, S.H., 1977, Self-synchronizing circuits and non-fundamental mode operation, IEEE Transactions on Computers, Vol. 26, No. 3, pp. 278-281. Unger, S.H., 1995, Hazards, critical races and metastability, IEEE Transactions on Computers, Vol. 44, No. 6, pp. 754-768. Watanable, Y. and Brayton, R., 1993, Computing permissible behaviors of FSMs, Proceedings of the International Conference on Computer-Aided 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. 84-97. Yu, M.L., and Subrahmanyam, P.A., 1992, A path-oriented approach for reducing hazards in asynchronous design, Proceedings of the Design Automation Conference, 29th ACM/IEE, pp. 239-244. 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. 250-257.

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