Citation
Input/Output Control of Asynchronous Machines with Races

Material Information

Title:
Input/Output Control of Asynchronous Machines with Races
Creator:
Peng, Jun
Place of Publication:
[Gainesville, Fla.]
Florida
Publisher:
University of Florida
Publication Date:
Language:
english
Physical Description:
1 online resource (81 p.)

Thesis/Dissertation Information

Degree:
Doctorate ( Ph.D.)
Degree Grantor:
University of Florida
Degree Disciplines:
Electrical and Computer Engineering
Committee Chair:
Hammer, Jacob
Committee Members:
McNair, Janise Y.
Latchman, Haniph A.
Schueller, John K.
Graduation Date:
8/11/2007

Subjects

Subjects / Keywords:
Alphabets ( jstor )
Automatic control ( jstor )
Control units ( jstor )
Feedback control ( jstor )
Hammers ( jstor )
Input output ( jstor )
Machinery ( jstor )
Recursive functions ( jstor )
Skeleton ( jstor )
Trajectories ( jstor )
Electrical and Computer Engineering -- Dissertations, Academic -- UF
asynchronous, control, feedback, input, machine, output
City of Gainesville ( local )
Genre:
bibliography ( marcgt )
theses ( marcgt )
government publication (state, provincial, terriorial, dependent) ( marcgt )
born-digital ( sobekcm )
Electronic Thesis or Dissertation
Electrical and Computer Engineering thesis, Ph.D.

Notes

Abstract:
The occurrence of races causes unpredictable and undesirable behavior in asynchronous sequential machines. In the present work, traditional feedback control techniques are used to control a race-afflicted machine, so as to turn it into a deterministic machine that matches a desired model. Instead of replacing or redesigning the whole machine, I add an output feedback controller to the original defective machine, and the controller eliminates the negative effects of the critical races. The present work focuses on asynchronous sequential machines in which the state of the machine is not provided as an output. The results include the necessary and sufficient conditions for the existence of controllers that eliminate the effects of a critical race, as well as algorithms for their design. The necessary and sufficient conditions for the existence of controllers are presented in terms of certain matrix inequalities. ( en )
General Note:
In the series University of Florida Digital Collections.
General Note:
Includes vita.
Bibliography:
Includes bibliographical references.
Source of Description:
Description based on online resource; title from PDF title page.
Source of Description:
This bibliographic record is available under the Creative Commons CC0 public domain dedication. The University of Florida Libraries, as creator of this bibliographic record, has waived all rights to it worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
Thesis:
Thesis (Ph.D.)--University of Florida, 2007.
Local:
Adviser: Hammer, Jacob.
Statement of Responsibility:
by Jun Peng.

Record Information

Source Institution:
UFRGP
Rights Management:
Copyright Peng, Jun. Permission granted to the University of Florida to digitize, archive and distribute 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.
Classification:
LD1780 2007 ( lcc )

Downloads

This item has the following downloads:


Full Text





Zij := =1 conc(Cik,Dkj), ij = 1, ..., n. (3-4)

abN NbNJ
For example, consider two 3x3 matrices A = b NN and B= c NN .Then the
aac abb

product of A and B is

cb ba N
Z =AB= N bb N
{ac,ca} {ba,bc} bc

Using the operation of product, we can define powers of the generalized one-step

reachability matrix by setting

Rq(Xg) := R-'(g)R(g), q = 2, 3, ... (3-5)

Proposition 3-6 All transitions of the matrix Rq( g) are stable and detectable transitions.

Proof According to the definition of the generalized one-step reachability matrix, each

non-zero entry of the matrix refers to a stable and detectable transition. After the operation of

product, every non-zero entry of a generalized multi-step reachability matrix refers to a

combination of multi-step stable and detectable transitions. This operation does not change either

the stability or the detectability of the transitions. Thus, for every entry of the matrix R'q(g), if it

is not N, it stands for a stable and detectable transition. *

Based on Proposition 3-6, for an integer q > 1, the matrix Rq(Xg) describe if the machine

can reach one state from another state through exact q stable and detectable transitions. If the

(ij) entry of the matrix Rq(Xg) is not N, then it is the set of all input strings that can takes the

machine Yg from the state x' to the state xj via a q-step stable and detectable transition. If the

(ij) entry is N, then it is impossible to reach the state xj from the state x' in exact q stable and

detectable transitions. Though, it might be possible to reach from x' to xj in 0 stable and










2) For all burst state x e Xb, let S(x) be the burst equivalent set that is associated with the

burst state x. Set

hg(x):= h(x'), x' e S(x). *

For example, consider the machine X with transition table of Table 2-1, which has one

critical race s(x', c) = {x2, x3}. Using Algorithm 2-13, we can get the burst state set Xb = {x5}

and x5 represents the subset {x2, x3}. The generalized stable recursion function sg and the

generalized output function hg of the machine X can also be defined (Table 2-3).



Table 2-3. Stable transition table of the generalized X
a b c Y
x' x' x4 x5 0
X2 x' x4 X2 1
x x x x 1
X3 x X3 1
X4 x' X4 2
x x' X5 1



Definition 2-16 Let Y = (A, Y, X, x0, f, h) be an asynchronous machine with the stable


state machine = (A, Y, X, xo, s, h). Then, g = (A, Y, X, xo, sg, hg) is the generalized


machine associated with Y, where X is the generalized state set, s, is the generalized stable

recursion function, and hg is the generalized output function of the machine Y. +

When an asynchronous machine is enhanced into a generalized machine, it still keeps some

properties. We address two properties of the generalized machine in these two statements.

Lemma 2-17 Given an asynchronous machine Y with a state set X, which contains finite

number of states. Then the associated generalized machine Yg also has a generalized state set


X with finite number of states.









Next, let us introduce a notion which underlies the solution of the model matching problem

for asynchronous machines. Given two sets S1 and S2 and a function g: S1 -> S2, denote by

g' the inverse set function of g; i.e., for an element s e S2, the value g' (s) is the set of all

elements a E S1 that satisfies g(a) = s.

Definition 4-3 Let X = (A, Y, X, s, h) and X' = (A, Y, X', C0, f, h') be two machines


having the same input and the same output sets. Let g = (A, Y, X, s9, hg) be a generalized

machine induced from the machine Y. The state set X' of X' consist of the q state (C, ..., .

Define the subsets Ei := hglh'(C) c X, i = 1, ..., q. Then, E(Eg, Z') := E1, ..., E'} is the output

equivalence list of Yg with respect to X'. +

An equivalence list is characterized by the following property: the value of the output

function hg of Yg at any state of the set E' is equal to the value of the output function h' of X'

at the state ('. The members of an output equivalence list are not necessarily disjoint sets.

Definition 4-4 Let Yg be a generalized machine with generalized state set X = {x1, ...,


xm}, and let A1 and A2 be two nonempty subsets of X. The reachability indicator r(Xg, A1, A2)

is defined as 1 if every element of A1 can reach an element of A2 through a chain of stable

and detectable transitions; otherwise, r(Yg, A1, A2) = 0.


Example 4-5 Let Yg be a generalized machine with generalized state set X = {x1, x2, x3}

and the preliminary generalized skeleton matrix is K,(Yg),










After introducing the common-output state of the machine -g, we should update the

generalized one-step reachability matrix R(Xg) and the generalized reachability matrix F(Xg).

The transitions from one generalized state to a subset of states, which have the same output

value, will be replaced by the single transition from the starting state to a newly defined

common-output state.

Example 3-13 Consider a machine Y with the input alphabet A= {a, b, c}, the output

alphabet Y = {0, 1, 2}, and the state set X = {x x2, 3, x4, x5}. There is a critical race pair (x1,

c) in the machine Y (Table 3-2).

Table 3-2. Transition table of the machine _
a b c Y
x' x' X4 {x4, 5} 0
X2 X2 X1 X2 1
x2 x2 xI x 1
x3 x X5 X3 1
x4 x' X4 X2 2
x5 x2 x5 X3 2



The stable state machine of Y is s, (Table 3-3).

Table 3-3. Transition table of the machine I
a b c Y
x1 x1 X4 {x2, X3} 0
x2 X2 X4 X2
x3 x X5 X3 1
x4 x' X4 X2 2
x5 x2 x5 X3 2



Using Algorithm 2-13, we get the generalized stable recursion function sg of the machine

Yg. Associate a burst state x6 with the subset {x2, x3}. Then the generalized machine g has a


generalized state set X = {x1, ..., x6}. Assign a common-output state x7 to represent the subset









However, the detectability of each transition needs to be checked according to proposition 2-10

in the construction of the generalized one-step reachability matrix. Therefore, each entry of the

generalized one-step reachability matrix characterizes if the machine Yg can go from one

generalized state to another through a stable and detectable transition.

Let Y = (A, Y, X, x0, f, h) be an asynchronous machine with the state set X = {x1, ..., x"}


and let g = (A, Y, X, x0, sg, hg) be the generalized machine associated with Y, where X = { x1,


..., x", x+, ..., xn+t} is the generalized state set and Xb = { xn+, ..., x+t } c X is the burst state

set. According to Definition 3-1, we can obtain the one-step reachability matrix R(X) of the

machine Y. For the generalized machine -g, the construction the generalized one-step

reachability matrix R( g) contains two tasks: 1) Determine the necessary burst states; and 2)

Add to the reachability matrix rows and columns corresponding to the burst states. Then, we can

divide R(Xg) into 4 blocks

[FR,,_IR1
ER11 12
R(Xg) = R |R '2
LR21 R22J

where, R,1 is nxn; R12 is nxt, R21 is txn, and R22 is txt. The matrix R,1 describes

one-step deterministic transitions among regular states of Y, while R22 describes one-step

transitions among burst states. The submatrix R12 represents one-step transitions from regular

states to burst states, while R21 represents one-step transitions from burst states to regular states.

Example 3-2 Consider the machine Y with transition table of Table 2-1, which has the

input alphabet A = {a, b, c}, the output alphabet Y = {0, 1, 2}, and the state set X = {x1, x2, x3,

x4, 5)}. There is a critical race pair (x1, c) in the machine Y.









1 0 0 1 1

1 1 0 1 1

Ki(yg) = 1 0 1 1 1

1 0 0 1 1

1 0 0 1 1 -



K(E') = 1 1 1

0 0 1

The subordinate list A of the output equivalence list E(Eg, E') is

Al(1) = {x}, A2(1) = x2, X5, 3(1) = x4}.

The fused skeleton matrix is A(Xg, A) that satisfies

1 1 1 1 1 1

A(g, A)= 1 1 1 1 = K(E')

1 1- 0 0 1

Thus, there exists a controller C to turn the machine E into a deterministic machine that

matches the model E'.

We have a generalized machine g = (A, Y, X, X0, sg, hg) with the state set X ={x, ..,

x5} and a subordinate list A(1) ={A1(1)), A3(1)} that satisfies A(Eg, A(1)) > K(E') and x1

SAl(1). According to the process of construction of the controller C that is described before,

we derive the control unit F and combine it with the observer B of Equation 2-4. Then, we

have the corrective controller C as shown in Figure 2-3.









To guaranty the proper behavior of an asynchronous machine, some care has to be

exercised during its operation. In particular, one has to avoid changing values of input variables

while the machine undergoes a succession of state transitions. If an input change occurs while

the machine is not in a stable state, then, due to asynchrony, it is not possible to predict the state

of the machine at the instant in which the input change occurs. As the response of the machine

depends on its state, this may result in an unpredictable response of the machine. In other words,

the response may vary depending on the specific state of the machine at the instant of the input

change. To avoid this situation, asynchronous machines are normally operated so as to guaranty

that input changes occur only while the machine is in a stable state. When this precaution is

taken, we say that the machine operates in fundamental mode. In this dissertation, all

asynchronous machines are operated in fundamental mode.

The development of necessary and sufficient conditions for the existence of a model

matching controller C and the algorithm for its construction depend on a certain generalized

concept of state, introduced in chapter 2 below. A generalized state describes a persistent state of

the machine X about which only partial information is available. More specifically, as X is an

input/output machine, it is not always possible to determine its current state from available

input/output data. A generalized state indicates a situation in which it is known that X is in a

stable state, but the exact state of X is not known; the machine can be in any one of a pre-

determined set of stable states. The generalized state allows us to use the partial information

available about the state of X to continue controlling the machine as best as possible toward the

goal of achieving model matching, while taking best advantage of the available information

about Y. The generalized state allows us to formalize in a concise and functional way the future

implications of uncertainties in the present state of the machine Y.









CHAPTER 2
TERMINOLOGY AND BACKGROUND

2.1 Asynchronous Sequential Machines

Definition 2-1 An asynchronous sequential machine X is defined by a sextuple (A, Y, X,

x0, f, h), where A, Y and X are nonempty finite sets: A is the input set, Y is the output set,

and X is the state set. x0 e X is the initial state of the machine. The partial function f: AxX ->

X is the state transition function (or recursion function) and the partial function h : AxX -> Y

is the output function. When the output function h does not depend on the input character (i.e.,

when h: X -> Y), the machine X is called a Moore machine in Moore (1956). +

Note that every asynchronous machine can be represented as a Moore machine. The

machine X operates according to a recursion form

Xk+1 =f(Xk,Uk),
yk h(xk), k= 0,1,2,... (2-1)

Where, k counts the steps of the machine E. The sequences xk, Uk, and Yk are the state

sequence, the input sequence and the output sequence, respectively. +

The machine E is an input/state machine if Y = X, or Yk = Xk for each step k > 0. When

the output is not the state, then the machine is an input/output machine. The present paper

focuses on input/output machines.

Definition 2-2 Let E be an asynchronous machine represented by sextuple (A, Y, X, x0,

f, h). A pair (x, u) E X x A is called a valid pair if the recursion function f is defined at it. If x

= f(x, u), then the combination (x, u) is a stable combination. +

Definition 2-3 Let (x, u) be a valid pair of the machine E = (A, Y, X, x0, f, h). If(x, u) is

not a stable combination, then the machine generates a chain of transitions x1 = f(x, u), x2 = f(1,









ACKNOWLEDGMENTS

I thank my advisor, Dr. Jacob Hammer, for his excellent, professional guidance and

support during my four years at the University of Florida. I thank Dr. John Schueller, Dr. Haniph

Latchman, and Dr. Janise McNair, for serving on my Ph.D. supervisory committee and for their

continuous help and advice.

I thank my officemates, Debraj Chakraborty and Niranjan Venkatraman, for interesting

and joyful discussions. I thank all my friends for their care and friendship.

Last but not least, I thank my brother and his wife for their understanding, support and love

throughout my school years. I thank my parents, Mingqing Peng and Mingxia Wu, whose

unceasing love and whole-hearted support made finishing this work possible. I thank my

husband, Zhipeng Liu, for his love and faith in me.


































To Mom and Dad.


















Figure 1-1. Control configuration for the asynchronous machine Y

Here, Y is the machine being controlled and C is another asynchronous machine that

serves as an output feedback controller. We denote by YC the machine described by the closed

loop. The objective is to find a controller C for which the closed loop machine 2c exhibits

desirable behavior.

I represent the behavior desired for the closed loop system by an asynchronous machine

2', called a model. In these terms, the objective is to design a controller C for which the closed

loop machine 2c simulates the model 2'. Of course, the machine 2' that represents the desired

behavior is not afflicted by any critical races. Thus, by simulating the behavior of 2', the closed

loop system eliminates the ill effects of the critical races present in Y. The problem of designing

such a controller C is often referred to as the model-matching problem. The objective, then, is

to find necessary and sufficient conditions for the existence of the controller C that solves the

model matching problem. When such a controller exists, I also provide an algorithm for its

construction.

The literatures regarding the model-matching problem of asynchronous machines with

races has focused so far on asynchronous sequential machines in which the state is provided as

the output of the machines (input/state machines). In Murphy et al. (2002, 2003), the control of

asynchronous machines was discussed and state feedback controllers that eliminate the effects of

critical races in asynchronous machines were developed. In Venkatraman and Hammer (2004),









CHAPTER 5
SUMMARY AND FUTURE WORK

In the present work, the feedback controllers are introduced to correct the faulty behavior

of asynchronous machines. When critical races afflict the asynchronous machine, the existence

of the controllers offer a solution to eliminate the effects of the critical races while controlling

the machine to match a desirable race-free model. We call the problems as Model-Matching

Problems. This approach discloses an interesting and constructive field in which many related

topics are worth investigating.

The solutions have been obtained to the Model-Matching Problem for asynchronous

input/output machines. The concept of generalized state has been used to describe a persistent

state of the machine X about which only partial information is available. The generalized state

allows us to use the partial information available about the state of X to continue controlling the

machine as best as possible toward the goal of achieving model matching, while taking best

advantage of the available information about Y. The results of the Model-Matching Problem

include necessary and sufficient conditions for the existence of the controller, and algorithms for

its construction whenever a controller exists.

The following list is the possible topics for future research:

(i) The algorithm for transforming the generalized stable reachability matrix into skeleton
matrix has been proposed in chapter 3. However, before that we need to raise the power of the
generalized one-step reachability matrix, which requires a large amount of computation. When
the state set of the machine is large, this issue is more significant. If we can obtain a likely one-
step skeleton matrix from the one-step reachability matrix and raise the power of this numerical
skeleton matrix instead, then the calculation is much simpler. But we need spend time to keep all
the information that we need in the transforming and computation.

(ii) The introduction of generalized state transforms an asynchronous machine with critical
races into a deterministic machine. However, the state space is enlarged depending on the
number of critical races. If we can minimize the state space, then it will increase the speed of
computation significantly too.









{a,b,ba,ab,ac}

ba

{a,ba,ac}

{b,ab,ba}

- {a,ba,ac}


N

{c,ca}

N

{c,ca}

ca


Continue raising the power of the R(Xg) until the (n + t


ac

{a,ac}

N

{a,ac}

{a,ac}


{c, ca,cb}

N

ca

cb

{c,ca}


1) = 4. Then we have


- j a,ab,ac,aba,aca 1
[abab,abac,acab,acacJ

fa,ab,ac,aba,abc1
Saca,abab,abac J

fa,ac,aba,aca1
Sabac,acac J

{a,ab,aba,aca{
a abab,acab

f a,ac,aba,aca{
- 1 abac,acac


Nb,ba,bab,bac1
N N 1 baba,baca J

N b,ba,bc,bab,bac1
c N lbaba,babc,baca


N c {ba,bc,bac,baca,baba}


N N {b,ba,bab,baba,baca}


N N {ba,bac,baba,baca}


fc,ca,cab,cac1
Scaba,caca J

Sca,cab,cac,cabal
1 cabc,caca J

{ca,cac,caba,caca}


{ca,cab,caba,caca}


{ c,ca,cac,caba,caca}


According to Definition 3-7 and Definition 3-9, we obtain the generalized stable

reachability matrix F(Eg) of the machine g as follow:


R2(yg)


R4 ()









The notion of a generalized state was also used in Venkatraman and Hammer (2004) to

represent phenomena related to the presence of infinite cycles. In the present paper, I show that a

generalized notion of state can also be used to represent uncertainty in asynchronous machines

with critical races, in situations where the exact state of the machine is not known.

The mathematical background of our discussion is based on Eilenberg (1974). Studies

dealing with other aspects of the control of sequential machines can be found in Ramadge and

Wonham (1987) and in Thistle and Wonham (1994), where the theory of discrete event systems

is investigated; in Ozveren, Willsky, and Antsklis (1991), where stability issues of sequential

machines are analyzed; and in Hammer (1994, 1995, 1996a and b, 1997), Dibenedetto, Saldanha,

and Sangiovanni-Vincentelli (1994), Barrett and Lafortune (1998), where issues related to

control and model matching for sequential machines are considered. These discussions do not

take into consideration specialized issues related to the function of asynchronous machines, like

the issues of stable states, unstable states, and fundament mode operation. As a result, these

works refer mostly to the control of synchronous machines.









CHAPTER 3
REACHABILITY OF A GENERALIZED MACHINE

The occurrence of critical races in an input/output asynchronous machine causes the lacks

of information about the exact state of the machine. We use the concept of generalized states to

deal with this uncertainty and keep a machine operate in fundamental mode. In this chapter, we

use generalized states to characterize the reachability properties of an asynchronous machine

with critical races.

First, let me introduce some important concepts that will be used in latter part of this

chapter.

3.1 Generalized Reachability Matrix

Definition 3-1 Let X = (A, Y, X, x0, f, h) be an asynchronous machine with the state set


X = {x1, ..., xn} and let g = (A, Y, X, x0, s9, hg) be the generalized machine associated with Y,


where X = { x1, ..., n, xn+1, ..., xn+t} is the generalized state set. The generalized one-step

reachability matrix R(g ) is defined as a (n+t)x(n+t) matrix with entry Rij, where Ri. is the

set of all characters a e A for which xi e sg(x', a) and for which the transition x' xi is a

detectable transition. If there is no such character a, then set Rij := N, where N is a character

not in the alphabet A. *

Note that when the generalized machine g is equal to the machine Y (i.e., when there

are no burst states), then the generalized one-step reachability matrix reduces to the one-step

reachability matrix R(X).

In view of the earlier discussion in Geng and Hammer (2005), only transitions that are

both stable and detectable can be used when constructing a controller. The stability of the

transition is guarantied by the generalized stable recursion function of the controlled machine Y.









Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., "Implicit computation of
compatible sets for state minimization of ISFSMs," IEEE Transactions on Computer Aided
Design, vol. 16, 1997, pp. 657-676.

Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., "Theory and algorithms for
state minimization of nondeterministic FSMs," IEEE Transactions on Computer Aided
Design, vol. 16, 1997, pp. 1311-1322.

Kohavi, Z., "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., "Supervisory control of
hybrid systems," Proceedings of the IEEE, vol. 88, no. 7, 2000, pp. 1026-1049.

Lavagno, L., Keutzer, K., and Sangicivanni-Vincentelli, A., "Algorithms for synthesis of hazard-
free asynchronous circuits," Proceedings of the 28th ACM/IEEE Conference on Design
Automation, 1991, pp. 302-308.

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

Lin, B. and Devadas, S., "Synthesis of hazard-free multilevel logic under multiple-input changes
from binary decision diagrams," IEEE Trans. on Computer-Aided Design ofIntegrated
Circuits and Systems, vol. 14, no. 8, 1995, pp. 974-985.

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

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

Marshall, A., Coates, B. and Siegel, F., "Designing an asynchronous communications chip,"
IEEE Design & Test of Computers, Vol. 11, no. 2, 1994, pp. 8-21.

Mealy, G.H., "A method for synthesizing sequential circuits," Bell System Tech. J., vol. 34,
1955, pp. 1045-1079.

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

Moore, B. and Silverman, L., "Model matching by state feedback and dynamic compensation,"
IEEE Trans. Automatic Control, vol. 17, 1972, pp. 491-497.

Moore, E.F., "Gedanken-experiments on sequential machines," Automata Studies, Annals of
Mathematical Studies, no. 34, Princeton University Press, N.J., 1956.









TABLE OF CONTENTS

page

A CK N O W LED G M EN T S ................................................................. ........... ............. .....

L IST O F T A B L E S ..................................................................................................... . 6

LIST OF FIGURES .................................. .. ..... ..... ................. .7

A B S T R A C T ......... ....................... .................. .......................... ................ .. 8

1 INTRODUCTION ............... ............................ .................................9

2 TERMINOLOGY AND BACKGROUND ................................... ................................... 14

2.1 Asynchronous Sequential M achines.................................................... ...... ......... 14
2.2 Generalized M machines, States and Functions ...................................... ............... 21
2 .3 O b serve er............................. .................................................................. ............... 2 7

3 REACHABILITY OF A GENERALIZED MACHINE ....................... ........................... 31

3.1 G eneralized R eachability M atrix ......................................................... .....................31
3.2 Com m on-output G eneralized States................................................................... .... ..41
3.3 O utput Feedback Trajectory ................................................... ... ........ ............... 44
3.4 Prelim inary G generalized Skeleton M atrix ........................................... .....................51

4 MODEL MATCHING FOR INPUT/OUTPUT ASYNCHRONOUS MACHINES
W IT H R A C E S ...............................................................................56

4.1 M odel M watching Problem ............. ...................................................... ............... 56
4 .2 E existence of C controllers ......................................................................... ..................60
4.3 A Comprehensive Example of Controller Design..................................67

5 SUMMARY AND FUTURE WORK .............................................................................74

L IST O F R E F E R E N C E S ......... .. ............... ............................................................................76

B IO G R A PH IC A L SK E T C H .............................................................................. .....................81









2.2 Generalized Machines, States and Functions

The next notion is central to our discussion. It is sometimes convenient to consider certain

sets of states of a machine as one quantity. This is convenient, for example, in cases where the

available data at a certain point in time does not permit us to distinguish between these states.

This leads us to the following notion of a generalized machine.

Definition 2-11 Let Y be a machine with the state set X and input set A, let S(3) be a

burst equivalent set with respect to u of the machine Y containing more than one state, and let

E be a set disjoint from X, and let 0 : P(X) -> E be a function. Associate with S(3) the

element xb := ((S(3)); we call xb a burst state. The set E is then called the set of potential

burst states and D is called the burst state assignment function. Let A be the set of all common

input characters of the states in S(P). Then, the set of all valid pairs of xb is given by {( xb, a) :

a e A}. The set A is also called the valid input set of the burst state xb. Let Xb c E be the set


of all burst states of the machine Y. The generalized state set X of Y is the union X U Xb. The

burst equivalent set S(3) represented by a burst state xb is also recorded as S(xb). *

Let s = (A, Y, X, xo, s, h) be the stable state machine of an asynchronous machine Y.

Let Xr := {xi(), ..., xi(m)} c X be a set of states of the machine Y, and assume they have a non-

empty set U of common input characters. For an element u e U, let s[Xr, u] be the set of all

possible next stable states. Let B(Xr, u) = { 31, 2, ..., P, be the set of all possible bursts

generated by the transition (XV, u) -> s[X, u], and let S(P3), S(32), ..., S(P1) be the burst

equivalent sets in s[Xr, u]. For each i = 1, 2, ..., ?, we distinguish between two cases:

1) The set S(13) contains a single state x e X. Then, we identify S(13) with the state x.









Add the burst state x := O(S) to Xb, i.e., set Xb:= Xb U x'.


Let A, := {u1, u2, ..., Ug(j)} be the valid input set of the burst state x'. Let r := #K be the

number of elements of the set K. Add to K the elements (r +, v +) := (xJ, u), ac = 1, ..., g(i,j).

Add the burst state O(S) to Z.

If j < k, then go back to Step 3.

Step 4.

Set sg(xi, ui) := Z.

Step 5.

If i < #K, then set i = i + 1 and go back to step 1. Otherwise, terminate the algorithm. *

The set X:= X u Xb is the generalized state set of the machine Y. The generalized stable


transition function is s : XxA P(X).

According to definition of the burst of a string, the last character of a burst is the output

value of the system for the corresponding state. Consequently, all states in a burst equivalent set

have the same output value. This implies that the following is true.

Lemma 2-14 The output value of a burst state x is the output value of any state in the

corresponding burst equivalent set S(x). +

Definition 2-15 Let Y = (A, Y, X, x0, f, h) be an asynchronous machine with a generalized


state set X = Xb u X, where X is the regular state set of Y and Xb is the burst state set of the

machine Y. Let x be a generalized state of the machine Y. The generalized output function h:


XxA Y of Y is defined as follows:

1) For all states x e X, set hg(x) = h(x);









An operation involving strings of A and zero and 1 should be defined before giving the

algorithm.

Definition 3-17 Let o be a character not included in A. The meet operation between two

strings of A+ and zero and 1 is defined as follow:

0 A := 0, 0 A 1 = 1 0 := 0, 1 1 := 1,

0Aa= a A 0:=0, 1a=a Al :=o, forall aeA+.

The meet of two vectors with r > 1 components is defined entrywise as the vector of the

meets of the corresponding components. *


Algorithm 3-18 Let Yg be an asynchronous machine with the generalized state set X =

{x1, ..., xm} and let F( g) be the generalized stable reachability matrix of the generalized

machine Yg.

Step 1: Transpose the matrix F(Xg) and denote the resulting matrix by F'(Xg).

Step 2: Replace all entries of N in the matrix F'(Xg) by the number 0; denote the

resulting matrix by K1.

Step 3: Perform (a) below for each i,j = 1, ..., m; then continue to (b):

1
(a) If Ki includes a string of A+ that does not appear in any other entry of the same
1 1
column j, then replace entry Ki by the number 1. Otherwise, let the entry Ki remain.

(b) Set k:= 1 and denote the resulting matrix by K(k).

Step 4: If all entries of row k of the matrix K(k) are 1 or 0, then set K(k+l):= K(k)

and set k := k+1.

Step 5: If k = m + 1, then set K1,( ) := K(k) and terminate the algorithm. Otherwise, go

to step 6.









Ramadge, P.J.G., and Wonham, W.M., "supervisory control of a class of discrete event
processes," SIAM Journal of Control and Optimization, vol. 25, no. 1, 1987, pp. 206-230.

Ramadge, P.J.G., and Wonham, W.M., "The control of discrete event systems," Proceedings of
IEEE, vol. 77, no. 1, 1989, pp. 81-98.

Cole, R. and Zajicek, O., "The expected advantage of asynchrony," Journal of Computer and
System Science, vol. 51, no. 2, pp. 286-300.

Shields, M.W., "An Introduction to Automata Theory, Blackwell Scientific Publications,
Boston, 1987.

Thistle, J. G. and Wonham, W.M., "Control of infinite behavior of finite automata, SIAM
Journal on Control and Optimization, vol. 32, no. 4, 1994, pp 1075-1097.

Unger, S. H., "Asynchronous Sequential Switching Circuits, Wiley-Interscience, New York,
NY, 1969.

Unger, S. H., "Self-synchronizing circuits and non-fundamental mode operation," IEEE Trans.
Computers, vol. 26, no. 3, 1977, pp. 278-281.

Unger, S. H., "Hazards, critical races, and metastability, IEEE Trans. on Computers, vol. 44,
no. 6, 1995, pp 754-768.

Venkatraman, N., "On the control of asynchronous sequential machines with infinite cycles, "
Ph.D. Dissertation, Department of Electrical and Computer Engineering, University of
Florida, Gainesville, FL 32611, USA, 2004

Venkatraman, N., "On the control of asynchronous sequential machines with infinite cycles, "
International Journal of Control, Vol. 79, No. 07, 2006, pp. 764-785.

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









1 1 1

Ki(Xg) = 1 1 1 .

0 0 1

Let A1 = {x1, x2} and A2 = {x2, x3} be two state subsets. Then

r(g, A1, A2)= 1.

Definition 4-6 Let Yg be a generalized machine with generalized state set X = {x1, ...,

xm}, and let A = {A1, ..., A'} be a list of m > 1 nonempty subsets of X. The fused skeleton

matrix A(Xg, A) of A is an qxq matrix whose (i,j) entry is

Aij(Xg, A) = r(Xg, A1, AJ).

Example 4-7 Consider the machine Y and the two state subsets A1 and A2 in the

Example 4-5. Let A := {A, A2} be a list of subsets of X. Then the fused skeleton matrix A(g,

A) of A is A(Xg, A).


A(Xg, A) 1


Definition 4-8 Let A = {A1, ..., A'} and W={W1, ..., W} be two lists of subsets of X.

The length of the list A is the number q of its members. The list W is a subordinate list of the

list A, denoted as W -< A, if it has the same length q as the list A and if W' A' for all i=1,

..., m. A list is deficient if it includes the empty set 0 as one of its members. *









LIST OF FIGURES


Figure page

1-1 Control configuration for the asynchronous machine Y .........................................10

2-1 State flow diagram of the m machine ........................................... .......................... 17

2-2 State flow diagram of the machine s ........... ...........................18

2-3 Control configuration for the closed-loop system ....................................................... 28

3-1 State flow diagram of the machine g ....................................... ................ 33

4-1 Equivalence of two asynchronous machines X' and ..................................... 63

4-2 State flow diagram of the m machine X' .............. ...................................... ............... 68

4-3 State transitions diagram of control unit F............................................. ............... 73

4-4 State transitions diagram of observer B ........................................ ........................ 73








generalized state x'. Since we have a output feedback trajectory {So, S, ..., Sp}, we need P new

states for F, where

P = #nSo + #nS + ...+ #ISp. (3-7)

Denote the state of F as ,k(xJ, w, x), where xelHSk and k = 1, ..., p. When the input

character switches to w, the control unit F moves to the state $o(xJ, w, xJ) and it begins to

generate the first input character u0 to feed g,, where uOeA is an character that satisfies (xj,

u0)E So. To implement this, we set

(,(xJ), x', w) := (xJ, w, xj) for all w e W;

(,(xJ), xj, v) := (x ) for all v e U(x) \ W;

(,(xJ), x, v) := 0 for all v V U(x) U W;

r((xj, w, x), x, v) := u0 for all (x, v) e XxA.

After u0 is applied to Xg the machine will move to a generalized stable combination with

a generalized state x IexS After the observer B detects this transition, the control unit F

moves to the next state (l(xj, w, x) and generates the next input character u1 to the machine

Y. The process continues similarly until x' is reached. Then at the step ke { 1, 2,..., p} the

function 4 and r must be defined as follows

(k-l(xJ, W, Xk-1), Xk, W) := k(XJ, Xk),

r(k(xj, Xk), ) := Uk for all (x, v)eXxA.

At the k=p step, the machine Yg reaches a state x pExS,. Set s (xp, up) := x', where u

is an character satisfies (x, up)eSp. This is accomplished by setting

(WP(x w, xi), Xk, W) := P+1(xw, W, ),









(ii) S = {(x, uo)},

(iii) sg [S J c x[SJ+], a = 0, ..., p-l,

(iv) s, [S] = {x'}. *

For example, consider the machine g in Example 3-13. The output feedback trajectory

from the generalized state x6 to the generalized state x4 is: So = {(x6, a)}, S, ={(x1, b), (x2, b)}.

Proposition 3-16 Let g be a generalized machine and let xj and x' be two generalized

states of Yg. The following two statements are equivalent.

(a) There exists an output feedback controller C that drives Yg through a deterministic

transition from xJ to x'.

(b) There is an output feedback trajectory from xj to x'.

Proof Suppose that the part (b) is valid, and let { So, S,, ..., S } be an output feedback

trajectory from xj to x. We construct an output feedback controller C that takes the machine

g from xj to x' through a string of deterministic transitions. This output feedback controller C

has two inputs: one is the output burst 3 e Y* of -g, and the other is the external input veA,

which is also the command input of the controller C. Given a set of characters WEA, we need

to construct a controller C(xj, x', W). This controller takes the machine g from generalized

state xj to x' through deterministic transitions as the response to an input character weW.

The controller C(xj, x', W) is a combination of an observer B and a control unit F as

shown in Figure 2-3. Where, the observer is an input/state machine B = (A x Y*, X, Z, z0, C, I)

with two inputs: the input character u e A of Yg and the output burst 3 e Y* of Yg; the state


set Z is identical to the generalized state set X, and the initial condition is identical to that of









and the generalized one-step reachability matrix of the machine Y- is

a N N b c

a c N b N


R(Yg)= a N c N N

a N N b N

a N N N c


The submatrix R22 = [c] in the matrix R(Yg) describes the stable and detectable

transitions inside the burst state set Xb. *

After obtaining the generalized stable recursion function s, we can get the generalized

one-step reachability matrix R(Yg) as above. Similar to the one-step transition matrix in

Venkatraman and Hammer (2004), we define some operations on the generalized one-step

reachability matrix R(Yg). Based on these operations we can obtain the overall view of reachable

states in the generalized machine Y and the information about how to approach the destination

of any transition. The latter information is very useful in the construction of the controller of the

closed loop system.

Definition 3-3 Let A* be the set of all strings of characters of the alphabet A and let wi

be a subset of A* or the character N, i = 1, 2. The operation U of unison is defined by

1 U w2 if w2 e A*
1W w if w1 e A* and w2 =N
wl w ., 2 (3-1)
W2 if w1 =N and w2 A
N if w1 = w2 = N.



































(D2007 Jun Peng









Yg, i.e., z0 =x0. And the function o : Z x A x Y* Z is the stable recursion function of B. Let

zk be the state of the observer B at the step k, while cok be the output of B. The observer B

is an input/state machine defined by the recursion (Eq. 2-4)

The control unit F is also an input/state asynchronous machine F = (A x X, A, E, ,0, 4,


r) with two inputs: the external input veA and the output co eX of the observer B. To

complete the construction of the controller C, we need to derive the recursion function ) and

the output function r of the unit F.

According to Figure 2-3, as long as vVW, the controller C stays in its initial state (zo, o0)

and the input character u of the machine Yg equals to the external input character v. After the

machine g arrives a stable combination of state xJ, if the external input v changes to a

character of W, then the controller C starts working. The observer B collects both the input

character u and the output burst 3(xj) of the machine Y- and feeds the control unit F with the

state of the machine The control unit F generates a string of characters u1u2...ur and apply

it to the machine Yg. This input string u1u2...ur will drive the machine Y from the state xi to

x' through a string of detectable and stable deterministic transitions.

Recalling that the control unit is an input/state asynchronous machine F = (A x X, A, E,


40), r). The recursion function of F is a function ):ExXxA-> E and the output function of F


is denoted by r : ExXxA-> A. Referring to Figure 2-3, the output coeX of the observer B is

one of the inputs of F, and the other input is the external input veW. Then the control unit F

generate the string ueA to feed the controlled machine Yg. Note that the control unit F must









We can now summarize the implications of our recent observations on the control

configuration Figure 1-1. Fundamental mode operation requires the output of the controller C to

remain constant while the system Eg is in transition. In order to fulfill this requirement, it must

be possible for the controller C to detect the point at which g has completed its transition

process. As discussed above, the output of the observer B switches to the state that represents

the next generalized stable state of Eg immediately after E has reached that state; this signifies

the end of the transition process and indicates the most recent stable state of Eg. In this way, the

observer B helps create an environment in which the machine Eg can be controlled in

fundamental mode operation.










The above state set can be reduced to three states and F can be depicted by Figure 4-3 (the

notation near the arrows indicates the information of (output of the observer B, input of

X,)/output of F).




(x1, b)/c (x1, a)/a (xl, c)/b




(x2, a)/a

(x3, a)/a

(x5, a)/a

Figure 4-3. State transitions diagram of control unit F


The observer B = (A x Y*, X, Z, z0, o, I) is defined according to Equation 2-4 and


described by Figure 4-4. The controller is the combination of F and B according to Figure 2-3.


(c,1)

(c,1) x 3
(a,120)
(a, 120)
(a,O) \


(cO( (a,20)





(a,120)
(c,1) x


(b,2)


Figure 4-4. State transitions diagram of observer B









operates in a fundamental mode, so the whole system must have reached a stable combination

before the F generates the next input character for Yg. Assume that F will generate r input

characters u u2...ur to feed Zg, then it needs r states l1(xj, w), ,2(xj, w), ..., r(xJ w). Denote

this set by E(x, w):={,(xj, w), 2(x, w), ..., r(x, w)}. We define the recursion function 4 and

output function r of the F as follows.

(i) Let U(xJ)cA be the set of all input characters that form stable combination with the

generalized state xJ, and let z0 be the initial state of B and o0 be the initial state of F. Set


W(o, (z, t)) := o for all (z, t)e XxA\xJU(xJ),

W(,o, (x, v)) := 1(XJ) for all veU(xJ).

Where ,1(xj) is the state of F, when observer B detects a stable combination with xj.

When both B and F are at initial states, the controller C(xJ, x', W) directly applies the

external input v to -g, thus set


r&(S, (z, v)) :=v for all (z, v)e XxA.

(ii) When the observer B detects a stable combination of g with the generalized state

xj, suppose the external input switches to a character weW. We choose a character uj U(xJ)

and set

rJ(( x'), (x, t)) := uj for all tU(xJ).

In this way, the machine Yg lingers in the state xj when the external input switches to a

character of W. Hence, the fundamental mode operation of the machine is guaranteed. Then the

control unit F will generate an input string u=u u2...ur to drive the machine g to the









detectable transitions, where 0 < q or 0 > q. Since we are also interested in if the machine can

reach one state from another in fewer transitions, it is needed to construct a multi-step

reachability matrix.

Definition 3-7 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine and

let R(Xg) be the generalized one-step reachability matrix of the machine Xg. The generalized q-

step reachability matrix is defined by

R(q( g) := r= 1.... qRr(Xg), q = 2, 3, ... (3-6)

Note that the (ij) entry of R(q)(Xg) contains the reachability information from the state xi

to the state xj. If the (i,j) entry is not N, it consists all strings that may take the machine Yg

from x' xJ through stable and detectable transitions in q or fewer steps. It leads to the

following statement and its proof is similar to Murphy, Geng and Hammer (2003).

Lemma 3-8 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine with n

states and t burst states, and let R(Xg) be the generalized reachability matrix of the machine

Yg. Then the following two statements are equivalent:

(i) The generalized state xJ is stably reachable through a detectable transition from the

generalized state x'.

(ii) The (ij) entry of R(n+t 1)(yg) is not N. *

Proof Let A* be the set of all strings of characters of the alphabet A.

If the first statement is true, namely, the state xj is stably reachable from x', then there is

an input string u' := uk-...ulu0, which satisfies xj = sg(x, u) and the transition from x' to xj is









constructed as follows. First, using the generalized stable recursion function sg, define the

function X: Z x Ax {0, 1} ->Z by setting

s(z, u) if a = 1;
X(z, u, a) := if a = (2-2)

Now, assume that the machine Eg is in a stable combination (x, ui1), when the input

character changes to ui, where (x, ui) is also a detectable pair. The change of the input character

may give rise to a chain of transitions of Yg. Let k > i be a step during this chain of transitions,

let 3k be the burst of Eg from step i to step k, and let uk be the input character of Eg at step

k. Since fundamental mode operation requires that the input character be kept constant during a

chain of transitions, we have uk =ui. Define

{s(x, uk) ifPk = 3(x, Uk);
Y(X, Uk, P S(U) Ik) U)= (2-3)
Skx I otherwise.

Let zk be the state of the observer B at the step k, while cok be the output of B. The

observer B is then an input/state machine defined by the recursion

Zk+1 a(Zk, uk, k)
B := (2-4)
Cok =Zk

The observer B is a stable state machine.

To describe the operation of the observer, assume that the observer switched to the

generalized state x immediately after Eg has reached the stable combination (x, ui-). Let p >

i be the step at which the chain of transitions from (x, ui) to the next stable state x' = sg(x, ui)

terminates; then, jp = 3(x, ui). As the pair (x, ui) is detectable, it follows by the definition of

c that the output of the observer B switches to the state x' at the step p+l.









INPUT/OUTPUT CONTROL OF ASYNCHRONOUS MACHINES WITH RACES


By

JUN PENG













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

2007









The proof of Theorem 4-10 includes an algorithm for the construction of a controller C

solving the model matching problem. Then, we use the Algorithm 4.14 in Geng and Hammer

(2005) to build a list A that satisfies condition (ii) of this theorem whenever such a list exists.

This algorithm and Theorem 4-10 give a comprehensive and constructive solution of the model

matching problem. A recursive process is used in the algorithm to build a decreasing chain of

subordinate lists. The last list in this chain, if not deficient, satisfies condition (ii) of Theorem 4-

10; if the last list of the chain is deficient, then there is no controller that solves the requisite

model matching problem.

Let Xg=(A, Y, X, x0, sg, hg) and X'=(A, Y, X', s', h') be the machines of Theorem 4.8, let

E(g, X') = {E1, ..., E'} be their output equivalence list, and let K(X') be the skeleton matrix of

X'. The following steps yield a decreasing chain A(0) >- A(1) >- ... -A(r) of subordinate lists of

E(Xg, X'). The members of the list A(i) are denoted by Al(i), ..., Aq(i); they are subsets of the


state set X of Xg.


Algorithm 4-11 Let -g=(A, Y, X, x0, sg hg) and X'=(A, Y, X', s', h') be the machines of

Theorem 4-10, let E(g X') = {E1, ..., E'} be their output equivalence list, and let K(X') be the

skeleton matrix of X'. The following steps yield a decreasing chain A(0) >- A(1) >- ... >-A(r) of

subordinate lists of E(Xg, X'). The members of the list A(i) are denoted by Al(i), ..., Aq(i); they


are subsets of the state set X of Eg.

Start Step: Set A(0) := E(Xg, X').

Recursion Step: Assume that a subordinate list A(k)= {Al(k), ..., Aq(k)} of E(Xg, X') has

been constructed for some integer k > 0. For each pair of integers ij e {1, ..., q}, let Si(k) be









f a,ab,ac,aba,aca N Nb,ba,bab,bac c,ca,cab,cac
abab,abac,acab,acacJ baba,baca J caba,caca

fa,ab,ac,aba,abc fNb,ba,bc,bab,bac1 Ica,cab,cac,cabal
aca,abab,abac c N Ibaba,babc,bacaJ cabc,caca J

fa,ac,aba,aca
F(Yg)= aaba,acac N c {ba,bc,bac,baca,baba} {ca,cac,caba,caca} .*
abac acac

a,ab,aba,aca N N {b,ba,bab,baba,baca} {ca,cab,caba,caca}
Saabab,acab

Sacabaaca N N {ba,bac,baba,baca} { c,ca,cac,caba,caca}
L abac,acac 1 -

3.2 Common-output Generalized States

As we have mentioned before, if the outcomes of a critical race (r, v) can be divided into

more than one burst equivalent set, then sg(r, v) consists of more than one generalized state. This

situation is shown in the generalized one-step reachability matrix as one input string appears

more than once in different entries of a single row. Consider both this fact and the Lemma 3-8,

we have the statement below.

Proposition 3-11 Let g = (A, Y, X, x0, s9, hg) be a generalized asynchronous machine

with n states and t burst states, and let F (Eg) be the generalized stable reachability matrix of

the machine Eg. Then the following two statements are equivalent for all input strings u E A

and for all j = 1, ..., n + t.

(i) Applying u at the generalized state x' generates a critical race.

(ii) The string u appears in more than one entry of row i of the matrix F (E ). *

Note that the above conclusion is similar with the Proposition 4-16 in Venkatraman and

Hammer (2004).









LIST OF REFERENCES


Alpan, G. and Jafari, M.A., "Synthesis of a closed-loop combined plant and controller model,"
IEEE Trans. on Systems, Man and Cybernetics, vol. 32, no. 2, 2002, pp. 163-175.

Barrett, G., and Lafortune, S., "Bisimulation, the supervisory control problem, and strong model
matching for finite state machines," Journal of Discrete Event Dynamic Systems, Volume
8, number 4, 1998, pages 377-429.

Chu, T., "Synthesis of hazard-free control circuits from asynchronous finite state machines
specifications," Journal of VLSI Signal Processing, vol.7, no. 1-2, 1994, p. 61-84.

Datta, P.K., Bandyopadhyay, S.K. and Choudhury, A.K., "A graph theoretic approach for state
assignment of asynchronous sequential machines," International Journal ofElectronics,
vol.65, no.6, 1988, p. 1067-75.

Davis, A., Coates, B. and Stevens, K., "The post office experience: designing a large
asynchronous chip," Proceeding of the Twenty-Sihx i Hawaii International Conference on
System Sciences, vol.1, pp. 409-418.

Dibenedetto, M.D., "Nonlinear strong model matching," IEEE Trans. Automatic Control, vol.
39, 1994, pp. 1351-1355.

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

Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., "Strong model matching for
finite state machines with nondeterministic reference model," Proceedings of the IEEE
Conf. on Decision and Control, vol. 1, 1995, pp. 422-426.

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

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

Eilenberg, S., "Automata, Languages, and Machines," Academic Press, NY, 1994.

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

Fisher, P.D., and Wu S. F., "Race-free state assignments for synthesizing large-scale
asynchronous sequential logic circuits," IEEE Transactions on Computers, vol. 42, no. 9,
1993, pp. 1025-1034.









(~P+((xJ, w, xi), z, t) := 0o for all (z, t)eXxA\W.

r(P 1(x, x, x, v) := Up for all (x, v)eXxA.

As long as the external input remains as a character in set W, the machine will linger in

the stable combination (xl, up). If the external input is no longer belongs to W, the controller

returns to the initial state o,. We build the controller as well as prove that statement (b) implies

statement (a) as above.

Conversely, assume part (a) is valid. Let o be the initial state of the controller C and let

C(,, x, u) be the output value produced by the controller C when it is at the next stable state

corresponding to its state ,, Yg is at the state x and the external input is u. By assumption,

there is an external input value w that induces the controller C to generate an input string

Si
u0u1...u, for the machine Xg from the generalized state x to the generalized state x via

deterministic transition. The first character of this input string is u0 = C(o0, x, u). Define the set

So := {(x, uo)}

Let sg be the generalized stable recursion function of Yg. when the input from the

controller to Y, changes to u0, Yg moves to a generalized stable combination with one of the

states of the set s(x, u0) = s[S]. When this state is reached by Y the controller C detects the

new state and controller moves to its own next stable state. Let (x, u0) be the next stable state

of the controller and let u1 = C((x, u0), x, w) e A be the output character generated by the

controller once C reaches (x, uo). Define the set

Si := {(x, C(t(x, uo), x, w)) :x e s(So)}.

Continue operating like that until the set Sk, k > 0, is defined. Build a new set by setting









- 1) step reachability matrix R(n+t 1)(g) only contains detectable transitions. So, the generalized

state xJ is stably reachable from the generalized state x'. *

Therefore, all possible stable and detectable transitions for the machine Yg can be found

in the matrix R(n+t1)(Xg), i.e., the generalized (n + t 1) step reachability matrix characterizes

the reachability property of the machine Yg with n states and t burst states.

Definition 3-9 Let R(Xg) be the generalized one-step reachability matrix of the machine

Xg, which has n + t generalized states. The generalized stable reachability matrix of the machine

Eg is F( g):= R(n+t 1(g).

Example 3-10 Consider the machine X and the generalized machine Yg of Example 3-2.

X has a generalized state set X = {x x2, 3, x4, x5} and (n +t 1)= 4.

Raise the power of the R(Xg) as follows:

{aa,ba,ab,bb,ac} N N ac {ca,cb,cc} -

ba {cc,ca} N {ac,aa} N

R2() = {aabaac} N cc N ca

{ab,bb,ba} {cc,ca} N {ac,aa} cb

S {aa,ba,ac} ca N {aa,ac} {ca,cc} -

After a stable transition, repeat applying the same input character will not change the state

of the machine. Thus, all same consecutive input character can be replaced by one character. For

instance, the input string "aa" can be replaced by "a" and it will not affect the stable transitions

of the machine. Hence, we obtain









The unison C := A U B of two nxn matrices A and B, whose entries are either subsets

of A* or the character N, is defined entrywise by Ci := Aij U Bij, i, j = 1, ..., n.

Note that N takes the role of zero.

abN NbN
For example, given two 3x3 matrices A= bNN and B= cN the unison of A
a a cabb

and B is

a b N
C :=AUB = b,c} N N
a {a,b} {b,c}

Definition 3-4 Let A* be the set of all strings of characters of the alphabet A and let wl,

w2 be two subsets of A* or the character N. Concatenation of elements wl, w2 e A* UN is

defined by

{w2w1 ifw1, w2 e A*
conc(w,w2) := if w w2 (3-2)
SN if w = N or w2 = N.

Let W = {w, w2, ..., wq} and V = {v, v2, ..., Vr} be two subsets, whose elements are

either subsets of A* or the character N. Define

conc(W, V) := U i = 1, ..., q conc(wi,vj) (3-3)
j = 1, ...,r

For instance, consider two subsets W = {a,N,{b,c}} and V= {N,a,{a,b}}. The

concatenation of W and V is

conc(W, V) = {a,aa,{aa,ba},N,{a,b},{b,c},{ab,ac},{ab,bb,ac,bc }.

Definition 3-5 Let C and D be two nxn matrices whose entries are either subsets of A*

or the character N. Let Cij and Dij be the (ij) entries of the corresponding matrices. Then, the

product Z := CD is an nxn matrix, whose (ij) entries Zij is given by









CHAPTER 4
MODEL MATCHING FOR INPUT/OUTPUT ASYNCHRONOUS MACHINES WITH
RACES

In the present chapter we start to address the model-matching problem for input/output

asynchronous machines with critical races. In last chapter the reachability properties of an

input/output asynchronous machine with critical races has been discussed and corresponding

generalized machine has been derived. The newly defined generalized machine with related

generalized state set and generalized functions of the machine could be controlled as a

deterministic machine without critical races. The control of this kind of asynchronous machines

has been discussed in Geng and Hammer (2005). Thus, the controller will be designed to correct

the input/output machine under the configuration of Fig. 2-3, so that the closed-loop system

possesses an equivalent input/output behavior as that of a prescribed model.

Since we are discussing the input/output machines, we first study the equivalent list of

the generalized machine Zg, with respect to the model 2'. Then we work on the sufficient and

necessary conditions of the existence of the output feedback controllers so as to solve the model

matching problem. When such a controller exists, we provide an algorithm to construct the

controller. Finally, an example is presented to illustrate how the control system operates.

4.1 Model Matching Problem

As we mentioned before, the design of a controller to eliminate the effects of critical races

of an existing asynchronous machine is called the Model-Matching Problem. Specifically, the

formal statement of the model matching problem is as follows. Let Y be a machine that exhibits

undesirable behavior. Assume that the desirable behavior is specified by an asynchronous

machine Y'. The machine 2' is called the model. Our objective is to design a controller C for

which the behavior of the closed loop system 2c simulates the behavior of the model Y'. It is











Transition table
a


31


of the machine X'
b c
(2 3
2
43


C)


Figure 4-2. State flow diagram of the machine X'


Table 4-2. Stable state transition table of the machine Y
a b c Y
x' x1 x4 x5 0
X2 x1 X4 X2
x x x x 1
X3 x X3 1
X4 x' X4 2
X5 x X5 1


The initial state of Yg is x = x1. From Table 2-1 and Table 4-2., the output equivalence


list is E(Xg, X') ={E1, E2, E3}, where El={xl}, E2= x2, x3, x5}, E3={x4}. The preliminary


generalized skeleton matrix of the generalized machine is K,(Xg) and the skeleton matrix of the


model is K(X').


Table 4-1.



(2
3









Sk+1 := {(x', C((x', Uk), x', W)) : X' S(Sk)}


By assumption, the controller C drives Y to the state x through deterministic transitions.
i
Consequently, there exists an integer p such that s(Sp) = x. Then, the list So, S,, ..., S, forms a

output feedback trajectory. So, the existence of a output feedback controller C that drive Y

j i
from x to x through deterministic transitions, implies the existence of a output feedback
j i
trajectory So, S, ..., SP from x to x. Namely, part (a) implies part (b). This completes the

proof. +

3.4 Preliminary Generalized Skeleton Matrix

Using the algorithm in the above proof of Proposition 3-16, we can check the basic

connection between any two generalized states of the machine g, namely, the existence of the

output feedback trajectory between any pair of generalized states. If we focus on the stable and

detectable reachability properties, then we don't need to record all the input strings. Instead, we

can use a numerical matrix, which has only entries of one and zero, to represent this one-step

stable and detectable reachability properties. This numerical matrix can be called "preliminary

generalized skeleton matrix" of the machine Yg. Afterwards, it is easier to calculate the power of

it and obtain the "overall preliminary generalized skeleton matrix". For the machine Y with m

generalized states, the overall preliminary generalized skeleton matrix characters all the stable

and detectable transitions among the generalized states of the machine within m steps. We can

use the following algorithm to gradually transform the generalized one-step reachability matrix

into the preliminary one-step generalized skeleton matrix. Meanwhile, the machine g is

transformed into a deterministic machine on the generalized state basis with an output feedback

controller C.









subsets in X is 2". Hence, the number of burst equivalent sets is equal or less than 2".

Namely, the number of burst states generated in the machine Y is finite. Then the first

requirement is guaranteed. In the previous discussion, we have excluded asynchronous machine

with infinite cycles. So, any transition starting from a regular state of a machine in this paper

ends at the next stable states. Similarly, under the definitions of the generalized state and

generalized stable transition function, for each valid state-input pair there is one or more next

stable states. Hence, each transition starting from a generalized state ends at the next stable

states, i.e., no infinite cycles will be created in the process of defining the generalized stable

transition function s9.

Consider an asynchronous machine Y = (A, Y, X, xo, f, h) with stable state machine s


= (A, Y, X, xo, s, h). Let X = Xb u X be the generalized state set and let Xb:= {1, 2, ...,

be the burst state set of Y. For every burst state c e Xb, let Ab := {a, a2, ..., ag(c)} be the valid

input set of ,c. For every valid pair (, a), e Xb and a e Ab, let S(,) be the set of regular

states represented by and let s[S(,), a) be the set of all possible next stable states of [S(,),

a]. Assume that 2s have p critical races (r v1), (r2, v2), ..., (r, Vp), and let T(ri, vi) := {ri, ri,

.. rm(i)} c X be the set of all outcomes of the critical race (ri, vi), i =1,..., p. We build the

generalized stable transition function sg with the following algorithm.

Algorithm 2-13 Consider an asynchronous machine Y = (A, Y, X, x0, f, h) with stable


state machine Xs = (A, Y, X, xo, s, h). Let X = Xb u X be the generalized state set, where Xb

is the burst state set and X is the regular state set. Assume that is has p critical races (r1, v,),

(r2, v2), ..., (rp, Vp), and let T(ri, vi) := {ri, rt, of the ..., rm(i)} c X be the set of all outcomes









indicated in Kohavi (1970) that the practical performance of an asynchronous machine is

determined by its stable-state behavior. Thus, the stable-state behavior of YC need to be

equivalent to the stable-state behavior of 2'. Let us first introduce the classical notions of

equivalence.

Definition 4-1 Let Y = (A, Y, X, x0, f, h) and 2' = (A, Y, X', C0, f, h') be two machines

having the same input and the same output sets, and let Es and E's be the stable state machines

induced by and 2', respectively. Two states xe X and C e X' are stably equivalent (x )

if the following conditions are true: When Es starts from the state x and E's starts from the

state C, then (i) Es and 2's have the same permissible input strings; (ii) Es and 2's generate

the same output string for every permissible input string. The two machines and 2' are

stably equivalent if their initial states are stably equivalent, i.e., if x0 Co. *

Note that two machines Y = (A, Y, X, x0, f, h) and 2' = (A, Y, X', C0, f, h') that are stably

equivalent appear identical to a user.

Definition 4-2 Given a machine Y and 2', find necessary and sufficient conditions for the

existence of a controller C such that YC is stably equivalent to 2' and operates in fundamental

mode. If such a controller C exists, derive an algorithm for its design. *

In this dissertation, the model matching problem concentrates on matching the stable

input/output behavior of the model. The model 2' can be taken as a stably minimal machine.

Let Yg be a generalized machine with the generalized state set {x x2, ..., xm} which is induced

from the machine Y. Our objective is then to match the input/output behavior of the generalized

machine Y and the model Y'.












The generalized machine Yg derived from the X has a generalized state set X= {x1, ..., x },


and it can be depicted as follows.


Table 3-1. Stable state transition table of the machine Yg

a b c Y
x' x1 x4 x5 0
X2 X1 X4 X2 1
x x3 xI x 1
X3 x X3 1
X4 x' X4 2
5 x X5 1



a


xl

b

a


b x4 X5 C



a a




x2 X3



Figure 3-1. State flow diagram of the machine g


According to Definition 3-1, the one-step reachability matrix of the original machine X is


a c c b


a c N b
R(X) =
a N c N


Sa N N b









After using burst states to represent subsets of states which have the same output value and

same burst, we can see there are still critical races in the machine on the generalized state base.

Some input strings may be repeated in more than one entries of a row of the generalized stable

reachability matrix (Example 3-10). That is caused by the existence of critical races.

In the present discussion, the machine F(Xg) is an input/output machine. Thus, what

matters to the user are the output value but not the state of the machine itself. Next we check if

the machine can be led from different outcomes of the critical races to the same output value. In

Venkatraman and Hammer (2004), if the machine can be led from different outcomes of the

critical races to the same state, then it means the existence of a feedback trajectory. Here, we can

loose the restriction to a subset of states which have the same output value. They can be also

called "common-output generalized states".

Definition 3-12 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine with


a generalized state set X = Xb u X. Assume that the machine g have p critical races (rl, v1),

(r2, v2), ..., (rp, vp), and let T(ri, Vi) := {r,, ,..., rmii)} c X be the set of all outcomes of the

critical race (ri, vi), i =1,..., p. Divide T(ri, vi) into subsets CI, C C, ..., Cmi) according to the

output value of ri, ri, ..., rm"i). These subsets C!, C;, ..., C"mi) can be represented by x1, x2,...,

xo, which are called the common-output states of the machine Yg. Set m = n + t + c, then the


generalized state set increases to X = {x1, ..., xm}.

Note that the outcomes of the critical races may be a combination of burst states and

regular states. Moreover, if two subsets contain the same states, then they are represented by the

same common-output state.









Geng, X., "Model matching for asynchronous sequential machines," Ph.D. Dissertation,
Department of Electrical and Computer Engineering, University of Florida, Gainesville,
FL 32611, USA, 2003

Geng, X., Hammer, J., "Input/output control of asynchronous sequential machines, IEEE
Trans. on Automatic Control, Vol. 50, No. 12, pp 1956-1970.

Hammer, J., "On some control problems in molecular biology, Proceedings of the IEEE
Conference on Decision and Control, Vol. 4, 1994, pp. 4098-4103.

Hammer, J., "On the modeling and control of biological signaling chains, Proceedings of the
IEEE Conference on Decision and Control, Vol. 4, 1995, pp. 3747-3752.

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

Hammer, J., "On the control of incompletely described sequential machines, International
Journal of Control Vol. 63, No. 6, 1996, pp. 1005-1028.

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

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

Holcombe, W.M.L, "Algebraic Automata Theory, Cambridge University Press, New York,
1982.

Hubbard, P. and Caines, P.E., "Dynamical consistency in hierarchical supervisory control," IEEE
Trans. on Automatic Control, vol. 47, no. 1, 2002, pp. 37-52.

Huffman, D.A., [1954a] "The synthesis of sequential switching circuits, J. Franklin Inst., vol.
257, pp. 161-190.

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

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

Isidori, A., "The matching of a prescribed linear input-output behavior in a nonlinear system,"
IEEE Trans. Automatic Control, vol. AC-30, 1985, pp. 258-265.

Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., "Synthesis ofFSMs :
Functional Optimization, Boston, MA: Kluwer, 1997.










Controller C


SI I!


x B



Figure 2-3. Control configuration for the closed-loop system YC

Here, the observer B estimates the uncertainty caused by critical races with the

input/output information of Y and generates estimate state of Y to feed F. With the external

input of the whole system and the estimate state of Y, the control unit F generates a sequence of

input to drive Y to match the model. We denote the controller C with (F, B).

We use the observer in a way that is similar as it is used in other branches of control

theory. Specifically, the observer here is an asynchronous input/state machine, which has two

functions: a) check if the asynchronous machine Y has reached its next stable state; b) use the

input/output information to estimate the current state of Y.


Let g = (A, Y, X, x0, s9, hg) be the generalized machine derived from Y. Similarly as in

Geng and Hammer (2005), we can build an observer that reproduces all stable and detectable

transitions of the machine Yg. The observer for g is an input/state machine B = (A x Y*, X,

Z, zo, c, I) with two inputs: the input character u e A of Y and the output burst 3 e Y* of


Y ; the state set Z is identical to the generalized state set X, and the initial condition is

identical to that of g i.e., z0 =x0. The recursion function o : Z x A x Y* Z of B is










{x4, x5}. Now the generalized machine g has a generalized state set X:

7. The generalized one-step reachability matrix is

-a N N b N c


R(Xg)


N {a,c} N


a N


: {1, ..., Xm} and m


b N N


c N b N N


a c N b N N N


N a c

a a N


La

Definition 3-14 Let


N N

c b


N N N c b J

s be a generalized stable state machine with the generalized stable


recursion function sg, and let u be an input string of Xs The transition induced by u from a

generalized state x is a deterministic transition if sg(x, u) consists of a single state. The

machine Yg is a deterministic machine if all transitions of ,s are deterministic. *

3.3 Output Feedback Trajectory

From the definition of the critical race, we know a transition from a critical race pair to the

outcomes is not a deterministic transition. So, originally, an asynchronous machine with critical

races is not a deterministic machine. If we can transform the machine with critical races into a

deterministic machine on a specific basis, then we actually get rid of the effect of the critical

races to the machine. The following procedure helps us to transform a machine with critical races

into a deterministic machine.

Consider a generalized machine Yg with the generalized state set {x1, x2, ..., xm} and

input set A. Assume the machine has a critical race (xJ, v) with the outcomes {xp, xq} and p









Now consider the other option: the machine Yg is at a stable combination with the state x1

e A1 and X' is at a stable combination with the state (1, when the external input character

switches from a to c. For the machine y', s'((1, c) = C3 and h'((1) = 0 and h'((3) = 2. Thus

this transition is detectable as well. To simulate this transition, the machine Yg needs to move to

a state in A3={x4}, i.e. to x4 So does the real machine X. Since s(x1, b) = x4, the control unit F

needs to generate the character b and this leads to the following

F: (40, (x1, c)) = ((x% c),

r(( (x1, (, c), (x1, c))= b.

Yg: s(x1, b)= x4,

P(x1, b)= h(x)h(x4) = 02

1 ( ) x4 for = 02;
B: y(1, (b, x otherwise.

Then, assume the machine X stays at a stable combination with the state x2 e A2 and the

model is at a stable combination with the state (2, when the external input character switches to

a. The model's response is s'((2, a) =1 so F needs to generate an input character a to drive X

to a state in A1 ={x1}. So we have

F: 4( (xl, C1, b), (x2 a)) = 1(x2, (2, a),

r(((x2, C a), (2 a)) = a.

Yg: s(x2, a)= x1,

P(x2, a)= h(x2)h(x) = 10

B: x, (a, forp 1=0;
B x2 otherwise.









(iii) Although we can construct an output feedback controller for the closed loop system to
eliminate the effects of critical race whenever a controller exists, this controller may not be
minimal. We can also work on this issue to find out a good strategy to minimize the controller.

(iv) The present discussion excludes the existence of infinite cycles in the existing
machine. We shall deal with the situation when both critical races and infinite cycles occur in the
defective machine.

The controller constructed in the present work ensures that the closed-loop system in

Figure 1-1 and Figure 2-3 operates in fundamental mode. The input changes were only allowed

during stable combinations. This requires the restriction of the controlled machine to those

without any unstable cycles; otherwise the controller can't do anything to correct the machine

once the machine enters a cycle.









e B(Xr, u), where Pi leads to the state x', while Pj leads to the state xi. Assume first that Y is

detectable at the pair (Xr, u). By contradiction, assume that Pi is a strict prefix of Pj, i.e.,

Pi = YY2..Yk-lYk

and

Pj = YlY2 .. Yk-YkYk+l .. y, where, Yk Yk-1 and y, # y,.

Once the change from yk-1 to Yk is observed, it is not possible to determine whether the

machine Y has reached the next stable state x' or whether it is still in the transition to next

stable state xJ. Thus the machine Y cannot be detectable at (Xr, u), a contradiction. This shows

that condition (b) must be valid whenever Y is detectible at (X, u).

Conversely, assume that conditions (a) and (b) are both valid, and let P3 B(Xr, u) be a

burst, and let X' c s[Xr, u] be the set of all states to which the burst 3 leads. Now, since 3 is

not a strict prefix of any other burst in B(Xr, u), it follows that, at the end of the burst 3, the

machine Y must be at one of the states of the set X', say the state x' (i.e., Y cannot be on its

way to other states). Furthermore, since P_ P13, the end of the burst 3 can be determined, and

whence it can be determined that Y has reached a stable combination with a state of X' (note

that it cannot be determined from the burst which state of X' has been reached). This completes

our proof.

For example, consider the machine Y with transition table of Table 2-1, let Xr= {x, x2},

then U = {a, b, c). Let us check the detectability of the combination (Xr, a). The next stable

states set s[Xr, a] = {x4}. The burst from the state x1 to the state x4 is P = 02 and the burst

from the state x2 to the state x4 is P2= 102. The burst set P(x4, Xr, a)= (P, P2}. Since the burst

P, is not a strict prefix of P,, and vice versa, the transition from (Xr, a) to x4 is detectable.








Recall that the initial state of Y is x = x1 and the initial state of 2' is C = ~1. Maintain

the external input character as a to keep 2' at the state C and maintain the external input

character as a to keep Yg at the state x1. Now we construct F as follows. Set the initial state

of F to o. Denote the states of the observer B by {x x2, x3, x4, x5} and set the initial state of

B to x1. Thus, we have U(x) = {a} and U'(1) = {a} and

F: W(o, (x a)) := o

r&(o, (x1, a)) := a.

B: o(x1, (a, )) = x1 for all Pe Y*.

Assume then the external input character switches from a to b. For the machine Y', s'(l,

b) = C2 and h'(C1) = 0 and h'(C2) = 1, so this transition is detectable. In order to simulate this

transition, the system Yg has to move to a state in A2= {x2, x3, X5}. Since s (x1, c)= x5. For the

real machine Y, it needs to move to either state x2 or state x3 and it does not matter in which

state the Y really stays. In either case, the control unit F needs to generate the character c to

serve as input for Z so that

F: W(o, (x1, b))= $1(xl, C1, b),

r( (xl, C', b), (x1, b)) = c.

B x1,x5 for = 01;
( xl otherwise.

F: 4(5((x1, C', b), (x5, b)) = 1(x1, C', b),

r(S((x1, C', b), (x5, b)) = c.

B: o(x5, (c, P)) = x5 for all PE Y*.









Note that this preliminary generalized skeleton matrix Ki,(g) of the generalized machine

g is similar to the one-step fused skeleton matrix A(X) of an asynchronous machine Y in

Geng and Hammer (2005).

Example 3-20 Consider the machine Y and the generalized machine Y of Example 3-

10. The generalized stable reachability matrix F(Xg) of the machine g is



f a,ab,ac,aba,aca 1 fb,ba,bab,bac1 fc,ca,cab,cac1
labab,abac,acab,acac N N baba,baca J 1 caba,caca J

fa,ab,ac,aba,abc1 fb,ba,bc,bab,bac1 fca,cab,cac,cabal
aca,abab,abac c N Ibaba,babc,bacaJ cabc,caca J


F(Sg)= a,ac,aba,aca N c {ba,bc,bac,baca,baba} {ca,cac,caba,caca}
i abac,acac I

{a,ab,aba,aca1 T T (i ] f
aababa,acab N N {b,ba,bab,baba,baca} {ca,cab,caba,caca}
Saacabab,acab

S a,ac,aba,aca N N {ba,bac,baba,baca} { c,ca,cac,caba,caca}
abac,acac J



Applying the Algorithm 3-18 to the matrix F(Xg), we can obtain the preliminary

generalized skeleton matrix Kl,(g) of the machine g is

S1 0 0 1 1

1 1 0 1 1

K,(Xg) = 1 0 1 1 1 .

1 0 0 1 1

1 0 0 1 1 -









CHAPTER 1
INTRODUCTION

Asynchronous sequential machines are digital logic circuits without synchronizing clock,

so they are also called clockless logic circuits. The lack of a synchronizing clock allows

asynchronous machines to operate much faster. In addition, there are practical applications, such

as parallel computation, where the underlying system is inherently asynchronous. Asynchronous

design techniques can also be used to achieve maximum efficiency in parallel computation (Cole

and Zajicek (1990), Higham and Schenk (1992), Nishimura (1995)). The design of asynchronous

machines has been an active area of research since mid 1950s (Huffman (1954, 1955)). Potential

difficulties, such as critical races and infinite cycles that may arise in the design of asynchronous

machines are discussed in the literature (Kohavi (1970), Unger (1959)).

Both critical races and infinite cycles are flaws in the operation of an asynchronous

sequential machine. In this dissertation, I will focus on asynchronous machines with critical

races. A critical race drives the machine to exhibit nonpredictable behavior, and it may be caused

by malfunctions, by design flaws, or by implementation flaws. Common practice is to rebuild a

machine that is afflicted by a critical race, and replace it with a race-free machine.

In the present work, I use traditional feedback control techniques to control a race-afflicted

machine, so as to turn it into a deterministic machine that matches a desired model. Instead of

replacing or redesigning a defective machine, I add an output feedback controller, and the

controller eliminates the effects of the critical races. The feedback controller turns the closed

loop system into a deterministic machine, and the closed loop system imitates the desired model

(Figure 1-1).









detectable. Here, u' e A* and k := lu'|. If lu'l < (n + t 1), then take u := u'. Thus, the (i,j)

entry of R(n+t-1)( g) is Uk-l...U1U0.

If lu'l > (n + t 1), then we need to show that a shorter string u* in the string u' still

satisfies x = s (x', u*) and lu*| < (n + t 1). Define recursively a string of states x0, x1, ..., Xk,

by setting x0 := x' and Xm+1 := s,(xm, um), for m = 0, 1, ..., k-1. This implies xk = x. The length

of the string x0, ..., Xk, k +1 is greater or equal to (n + t). However, there are totally only (n + t)

distinct generalized states of the machine Yg. So, at least one generalized state must be repeated

in the string x0, ..., xk. Suppose xp = xq, for 0 < p < q < k. Remove from u' the string v, which

satisfies x' = s (xP, v). Afterwards the shortened input string

u" := uoul.. .UpUq...uk1 Uk... UqUp-l...U U0 (or U" := Uk-l.. .Uq when p = 0).

This shortened u" still satisfies xJ = s (x', u"). Keep shortening the input string until an

input string u* of length |u*| < (n + t 1) still satisfying x = s (x', u*).

Conversely, if the second statement is true, then it implies that there is an input string u e

A* of length ul < (n + t 1). Suppose the (i,j) entry of R(n+t 1)('g) is the string

u := uk-...U1U0. There are k input characters in the string u and those characters satisfy the

following equation:

setting x0 := x' and xm+1:= s,(xm, um), for m = 0, 1, ..., k-1. Then we have xk = x.

According to the definitions of the generalized stable recursion function, the machine Y is only

involved into stable transitions here. Meanwhile, in the construction of the generalized

reachability matrix R(Xg), all undetectable transitions are eliminated. Thus, the generalized (n + t









LIST OF TABLES

Table page

2-1 Transition table of the machine ............................................. ............................ 17

2-2 Transition table of the m machine ............................................................................... ... 17

3-1 Stable state transition table of the machine g ............... ...................................33

3-2 Transition table of the m machine .......................................................... .....................43

3-3 T transition table of the m machine ......................................................... .....................43

4-1 Transition table of the machine ..............................................................................68

4-2 Stable state transition table of the machine g ............... ...................................68









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

INPUT/OUTPUT CONTROL OF ASYNCHRONOUS MACHINES WITH RACES
By

Jun Peng

August 2007

Chair: Jacob Hammer
Major: Electrical and Computer Engineering

The occurrence of races causes unpredictable and undesirable behavior in asynchronous

sequential machines. In the present work, traditional feedback control techniques are used to

control a race-afflicted machine, so as to turn it into a deterministic machine that matches a

desired model. Instead of replacing or redesigning the whole machine, I add an output feedback

controller to the original defective machine, and the controller eliminates the negative effects of

the critical races. The present work focuses on asynchronous sequential machines in which the

state of the machine is not provided as an output.

The results include the necessary and sufficient conditions for the existence of controllers

that eliminate the effects of a critical race, as well as algorithms for their design. The necessary

and sufficient conditions for the existence of controllers are presented in terms of certain matrix

inequalities.









As the combinations (xi, ui), i= 1, ..., r, are all stable and detectable combinations, the

states x1, ..., Xr appear as output values of the observer B immediately after having been

reached by Yg. The situation can be depicted as follows.



w

U1U2 ..Ur
Yg: X e A' xr E Aj

Figure 4-1. Equivalence of two asynchronous machines 2' and Y,



The objective of the control unit F is to generate the string u = u u2...ur and apply it as

input to the real machine Y. This action achieves model matching for the present transition for

the following reason. The string u drives the system Yg to the stable state xr, which then

becomes the next stable state of the closed loop system 2c. Then, since h(xr) = h[Ai] = h'(j), the

next stable state of YC produces the same output value as the model 2' to match the model's

response.

Note that the control unit F must operates in a fundamental mode, so the whole system

must have reached a stable combination before the F generates the next input character for Y.

Then, we construct a recursion function 4 for F to implement the above behavior. Keeping in

mind the requirement of fundamental mode operation of the machines, we need to make sure that

the control unit F generates the string u one character at a time and at each step that the

composite system has reached a stable combination before generating the next character. As the

string u has r characters, the control unit F needs r states to accomplish this: 1((x, Ci, w), ..,

r(X, w). The resulting set of states











A= {a, b, c}, the output alphabet Y= {0, 1, 2, and the state set X= {x1, x2, X3, 4 }. There is a


critical race pair (x1, c) in the machine. This machine X is depicted by a chart (Table 2-1) or a


figure (Figure 2-1). So is the stable state machine Yls of X (Table 2-2, Figure 2-2).


Table 2-1. Transition table of the machine X
a b c Y
x1 x1 x4 {x2, X3} 0
X2 X4 X1 X2 1
x2 x4 xI x 1
X3 X4 X3
x4 x' x4 2



a


Xi
























a b c Y
3 1













X3 X' -X3 1
b

Figure 2-1. State flow diagram of the machine Y,

Table 2-2. Transition table of the machine YEs

a b c Y
xl xl X4 fx2, X3} 0
X2 X1 X4 X2
X3 x X3 1
X4 x- X4 2









4.2 Existence of Controllers

Next, we give the condition of the existence of a controller C for which 2c is stably

equivalent to a specified model 2'. Given two pxq numerical matrices A and B, the

expression A > B indicates that every entry of the matrix A is not less than the corresponding

entry of the matrix B, i.e., Ai > Bij for all i = 1,..., p and for all j = 1, ..., q.


Lemma 4-9 Let g=(A, Y, X, x0, s9, hg) and 2'=(A, Y, X', s', h') be asynchronous

machines, where 2' is stably minimal. Let X'= {f, ..., q}) be the state set of 2', where the

initial condition of 2' is C0 = Cd. Assume that there is a controller C for which 2c is stably

equivalent to 2' and operates in fundamental mode. Then, there is a non-deficient subordinate

list A of the output equivalence list E(Xg, 2') for which A(Xg, A) > K(2') and x0 e Ad. *

The proof of the above Lemma 4-9 is similar to the proof of the Lemma 4.11 in Geng and

Hammer (2005). The difference is that a generalized machine appears here instead of a regular

machine Y. Recall that all the underlying states of a burst state or a common output state in the

generalized machine g are the same states in the original machine Y and those underlying

states have the same output value. Thus, when applying a real input character u to the

generalized machine g at a generalized state x', it is the same to apply this input character u

to the real machine Y at any underlying state of that generalized state x'. The real machine Y

will generates the same output value as the generalized machine g does.

The condition of Lemma 4-9 is not only a necessary condition, but also a sufficient

condition for the existence of a controller to solve the model matching problem. The inequality

A(Xg, A) > K(2') guarantees that the corresponding output values of the two machines match. If

the model 2' has a stable transition from a state C to state C, then the machine Y has a









Proof Let us suppose the machine X has a state set X = {x1, x2, ..., x"} and the


generalized machine Y- has a generalized state set X = {x1, x2, ..., xn+t} From the definition

of burst equivalent set, any burst equivalent set S(3) is a subset of the state set X. Then, the

maximum number of burst equivalent sets cannot be larger than the number of subsets of X, i.e.,

2n, and hence is finite. +

Lemma 2-18 If the machine Y has no infinite cycles, neither does the machine Xg.

Proof Assume the machine Y has no infinite cycles but the generalized machine Xg

which is derived from the machine Y, has one infinite cycle x of length i, where i > 1. Suppose

that i generalized states x1, x2, ..., xi are involved in this infinite cycle x. The states x1, x2,...,

xi may be regular states or burst states. Let us consider the following two cases: i) If all these i

states are regular states. Then it implies that the machine Y has at least one infinite cycle x'.

And the infinite cycle involves the i states x, x2, ..., xi of the machine Y. It conflicts with the

assumption that the machine Y has no infinite cycles. ii) If in the i states x, x2, ..., xi there is

at least one burst state xp, where 1 < p < i. Suppose that the underling regular states of the burst

state x are x1, ..., x Then the infinite cycle x actually involves the following regular states:

1, ..., Xl, x xp+1 ..., xi, where 1 < j < k. Hence there is an infinite cycle x" that involves i

regular states of the machine Y. It conflicts with the assumption that the machine X has no

infinite cycles. This completes the proof. +

2.3 Observer

As depicted in Figure 1-1, we build an output feedback loop with a controller C, which is

also an asynchronous machine. Specifically, this controller C is composed of two asynchronous

machine: an observer B and a state-feedback control unit F (Figure 2-3).









r(,,(X,a)) := c for all a e A.

This guaranties that the closed loop system 2c and the model X' operate in fundamental mode.

(ii) Suppose that the external input switches to a character w satisfying s'(C', w) = QJ.

Then, the control unit F needs to generate the input string u = uu2...Ur, to take Zg through the

chain of states xl, ..., xr to the state xr e Aj. Meanwhile the output of the observer B will track

the state sequence xl, ..., xr. Thus, the recursion function 4 is defined as follows.

(,(x, w)) := 1(X', ci, W),

1(k(X' i, W),(Xk, w)) := k+l i, w), k = 1, 2, ..., r-1,

r(k((X, w, W),(z, b)) := uk, for any (z,b) e XxA, k = 1, 2, ..., r.

(iii) In response to the last input character ur produced by F, the machine Xg reaches the

desired stable state xr, which implies the real machine X reaches one of the underlying states of

the generalized stable state xr. The machine Xg needs to remain at the state xr until the external

input switches from w to another character. Then, choose an element v e U(Xr) and assign

(('r(X, C, w),(Xr, w)) := r(x, C, W),

r((~r(, C, w),(z, b)) := v, for all (z,b) e XxA.

This completes the construction of the control unit F. Note that whenever the machine Xg

is at a generalized state x, the real machine X is at an corresponding underlying state x' of this

generalized state x and hg(x) = h(x'). This construction achieves model matching of the

generalized machine Xg to the model X' with fundamental model operation as well. This

concludes the proof. +









Step 6: Perform the following operations:

(a)If there is a character u e A that appears in row k of K(k), then let j1, ..., q be the

columns of row k of K(k) that include u. Denote by J(u) the meet of rows Ji, j,q of the

matrix K(k).

(b) If J(u) has no entries other than 0 or 1, then delete u from all entries of row k of

the matrix K(k); set all empty entries, if any, to the value 0. Continue to (c).

(c) If J(u) has no entries of 1, then return to Step 3. Otherwise, continue to (d).

(d) If J(u) has entries of 1, then let j1, ..., Jr be the entries of J(u) having the value 1.

Let S(k) be the set of rows of K(k) that consists of row k and of every row that has the

number 1 in row k. In the matrix K(k), perform the following operations on every row of

S(k):

Delete from the column all occurrences of input characters that appear in columns j j2,

.., jr of the row.

Replace rows j J2 ..., of the column by the number 1.

If any entries of K(k) remain empty, then replace them by the number 0. Return to Step

4.

The final resulting matrix K,(g ) is called the preliminary generalized skeleton matrix of

the machine g. +

Definition 3-19 The outcome Ki(Xg) of Algorithm 3.23 is defined as the preliminary

generalized skeleton matrix of the generalized asynchronous machine Y. +









Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D. and Robinson, P., "Self-calibrating
clocks for globally asynchronous locally synchronous systems," Proceedings ofInter.
Confer. on Computer Design, 2000, pp. 73-78.

Morse, A.S., "Structure and design of linear model following systems", IEEE Trans. Automatic
Control, vol. 18, 1973, pp. 346-354.

Murphy T.E., Geng X., and Hammer J., "Controlling races in asynchronous sequential
machines," Proceeding of the IFAC World Congress, Barcelona, July 2002..

Murphy T.E., Geng X., and Hammer J., "On the control of asynchronous machines with races,"
IEEE Transactions on Automatic Control, vol. 48, no. 6, pp. 1073-1081.

Murphy, T.E., "On the control of asynchronous sequential machines with races, Ph.D.
Dissertation, Department of Electrical and Computer Engineering, University of Florida,
Gainesville, FL 32611, USA, 1996.

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

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

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

Nowick, S.M., Dean, M.E., Dill, D.L. and Horowitz, M., "The design of a high-performance
cache controller: a case study in asynchronous synthesis," Proceedings of the 26th Hawaii
International Conference on System Sciences, 1993, pp. 419-427.

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

Oliveira, D.L., Strum, M., Wang, J.C. and Cunha, W.C., "Synthesis of high performance
extended burst mode asynchronous state machines," Proceedings. 13th Symposium on
Integrated Circuits and Systems Design, 2000, pp. 41-46

Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., "Stability and stabilizability of discrete event
systems, J ACM, Vol. 38, 1991, pp. 730-752.

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

Peterson, J.L., "Petri Net Theory and The Modeling of Systems, Prentice-Hall, NJ, 1981.









2) The set S(13) contains more than one state. Then, we associate with S(13) a burst

state, which represents the fact that these states are indistinguishable in this transition.

For the second case, let Ai be the set of all common input characters of S(Pi), i = 1, 2, ..

L. Note that Ai cannot be empty, since at least Ai contains the element u.

Definition 2-12 Let Y = (A, Y, X, x0, f, h) be an asynchronous machine with a generalized


state set X = Xb u X, where X is the regular state set of Y and Xb is the burst state set of the


machine Y. We build now a generalized stable transition function s : XxA P(X) as follows:

1) For all states x e X and all input characters u e A, set sg(x, u) := s(x, u).

2) For a burst state x e Xb, let U(x) c A be the set of all input characters that form valid

pairs with x. Let S(x) be the burst equivalent set represented by the burst state x. For an input

character a e U(x), let A1, A2, ..., Am be the set of all burst equivalent subsets of s[S(x), a]. If

A' contains more than one state, then let x' be the burst state associated with the set A';

otherwise A' is represented by its only state x', i = 1, ..., m. Then, sg(x, a) := {x1, ..., xm}. *

Note that the next stable states of a machine can be a combination of burst states and

regular states.

In the next discussion, I will give a more specific algorithm to build the generalized stable

transition function. As a practical process, the algorithm should avoid getting involved into

infinite loops. Thus, before the construction we need to make sure about two issues: a) the

process of building the generalized stable transition function includes finite steps; b) there is no

infinite cycles created in the construction. Since every burst equivalent set S(3) is a subset of

the state set X, for an asynchronous machine Y with n regular states, the maximum number of









the set of all states x e A'(k) for which the (ij) element of A(g, AN(k)) is 0; i.e., Sij(k) consists

of all states x E AI(k) for which there is no chain of stable and detectable transitions to a state of

AN(k). Note that Si(k) may be empty. Then set

T ._jSij(k) if Kij(X')=1;
Ti(k): 4 ifKij(X')=0.

Now, using \ to denote set difference, define the subsets

V'(k) := ...,q (k), i = 1, ..., q

A1(k+l) := A(k)\V1(k), i = 1, ..., q

Then, the next subordinate list in our decreasing chain is given by

A(k+l) := { Al(k+l), ..., Aq(k+l)}.

Test Step: the algorithm terminates if the list A(k+l) is deficient or if A(k+l) = A(k);

otherwise, repeat the Recursion Step, replacing k by k+1. *

4.3 A Comprehensive Example of Controller Design

Consider an asynchronous machine X = (A, Y, X, x0, f, h) with the input alphabet A={a, b,

c}, the output alphabet Y={0, 1, 2}, and the state set X={x1, x2, x3, x4}. There is a critical race

pair (x1, c) in the machine (Tables 2-1, Figure 2-1). Let another machine X' = (A, Y, X', Co, f,

h') be the desired model (Table 4-1, Figure 4-2).

The initial state of X is x = x1 and the initial state of X' is C, = i'. After introducing a

burst state x5 = {x2, X3}, we have the generalized machine Yg of X (Table 4-2).









E(X, wi, w) := {t1(x, Ci, w), ..., (, i, w)}

is associated with the state C' of Y', the state X of E, and the external input character w. To

account for all possible such combinations, the control unit F needs the state set

E := 0 U {Uil,.., UX- A i E(X, 1, Co)},
weA

where o is the initial state of F. We shall use the following notation. For a state x of the

machine Y, let

U(x) := {ae A : sg(x, a) = x

be the set of all input characters that form stable combinations with x. Similarly, for a state C of

the machine 2', let

U'() := {ae A: s'(, a) =

be the set of all input characters that form stable combinations with Q.

Recalling that the control unit is an input/state asynchronous machine F = (A x X, A, E,


0 r, ). The recursion function of F is a function 4:ExXxA-> E and the output function of F

is denoted by r : ExXxA- A. Referring to the configuration (2.24), the output o eX of the

observer B is one of the inputs of F, and the other input is the external input veW. Then, 4

and r are defined as follows.

(i) Let the closed loop system Ec be at a stable combination, where g is at the state X,

namely, the real machine E is at one of the underlying states of the generalized state X. The

observer B has he output value o(=X, and control unit F is at a state e E. Select an element

ceU(X), and define

(,(X,b)) := for all b e U'(),









introducing of the generalized machine. Thus, we can use the same method in Geng and Hammer

(2005) on the generalized machine, i.e., to find a controller for Xg.

The Lemma 4-9 indicates that statement (i) implies statement (ii). Now let us assume that

(ii) is valid. Let A={A1, ..., A'} be a subordinate list of E(Xg, 2') satisfying A(Xg, A) > K(2')

and x0 e Ad. Using A, we build a controller C for which the closed loop system Xc of 1.1 is

stably equivalent to the model X', is well posed, and operates in fundamental mode. The

controller C is a combination of an observer B and a control unit F as depicted in Figure 2-3.

The observer B is given by Proposition 3-16, so we complete the proof by constructing the

control unit F. Recall that the control unit F is an asynchronous machine F = (A x X, A, E, o0,


q, r) with two inputs: the external input veA and the output co EX of the observer B. To

complete the construction of the controller C, we need to derive the recursion function 4 and

the output function r of the unit F.

Assume that X' is at the stable state C and that Y is at a stable state x e A'. Note that C

is either the initial condition x0EAd of 2' or the outcome of a detectable stable transition; x is

either the initial condition x0EAd of g or the outcome of a detectable stable transition.

Assume the external input character switches to the character w. Then the model X' moves to

its next stable state s'(C', w)=j. Recall that s9 is the generalized stable recursion function of Xg.

The inequality A(Xg, A) > K(2') implies that there is an input string u=u u2...ur such that the

stable combinations (X, ul), (sg(X, u U), u2), ..., (sg(X, u1u2.. .uri), ur) are all detectable, and such

that the state xr := sg(X, u) belongs to Aj. Define the intermediate states

X, := Sg(X, Ui), x2 := Sg(X1, U2), ..., Xr = Sg(Xr-1, Ur). (4-1)









u), .... If the chain does not terminate, then the machine X contains an infinite cycle. If the

succession of transitions ends at a stable combination (xi, u), then xi is the next stable state of x

with the input character u. *

In the present work, I assume that none of our asynchronous machines possess infinite

cycles.

Definition 2-4 Let Y be an alphabet and let yi, ..., yq Y be a list of characters such that

yi+l yi for all i = 1, ..., q 1. Then, the burst of a string

y = YlYl ... y1 y22 .. Y2 YqYq" Yq is P(y) := yl y2 ( Yq-1 Yq

and PJ1(y) : = 2...yq-1, for q > 1; P31: = 0, for q = 1.

Let xlx2X3 ...xm be the string of states generated by the machine X from valid pair (x, u)

and xm is the next stable state. Then, the burst of the valid pair (x, u) is defined as

(xm, x, u) := P(h(x)h(xl)h(x2)... h(xm-l)h(xm)). *

Definition 2-5 Let p, and p2 be two strings of the alphabet A. As usual, p2 is a prefix of

p, if there is a string p3 such that p, = p2P3. We say that p2 is a strict prefix of p, if p3 0,

the empty string. +

For example, given three strings pl, p2, and p3: P1 = 1y1y2y3; P2 = y1yy2y3; and p3

y1y1y2y3y2y3. The string p, and p2 are each other's prefix string. Both p1 and p2 are strict

prefix strings of the string p3.

Definition 2-6 A state-input pair (r, v) for which the next stable state of the machine is

unpredictable is called a critical race pair, or, briefly, a critical race.

There may be more than one possible next stable states of the critical race pair (r, v). Let

us suppose there are m possible next stable states of (r, v). The set of all these states {r1, r2, ,









Another possibility is that Y is in a stable combination with the state x3 e A2 and the

model is at a stable combination with the state C2, when the external input character switches

from b to a. The model's response is s'(C2, a) = C so F needs to generate an input character a

to drive Y to a state in A1 ={x1}. Then

F: (5((xl, C1, b), (x3, a)) = 1(x3, 2, a),

r(l(x3, 2, a), (x3, a)) = a.

g : s(x3, a) = x1,

P(x3, a) h(x3)h(x1)= 10

3 x1 for P = 10;
B: o(x3, (a, )) otherwise.

Assume further that Yg is in a stable combination with the state x5 e A2 and the model is

at a stable combination with the state C2, when the external input character switches from b to

a. This case is a combination of the above two cases. Thus, F will generate an input a to drive X

to a state in A1 ={x1}.

F: (5((xl, C1, b), (x5, a)) = 1(x5, C2, a),

r(1(x5, 2, a), (x5, a)) = a.

g : s(x5, a) = x1,

P(x a) = h(x3)h(x) = 10

Sx1 for = 10;
B: o(x (a, x))5= 5 '
: x(a, 13)) otherwise.

This completes the construction of the corrective controller C for the model matching

problem. The state set of the control unit F is

E = {,0, ,1(xl, C1, b), ,1(xl, C1, c), ,1(x2, C2, a), ,1(x3, C2, a), ,1(x5, C2, a)}.









BIOGRAPHICAL SKETCH

Jun Peng was born in Wuhan, Hubei Province, China. She received her bachelor's degree

in automatic control and master's degree in control theory and control engineering from

Shanghai Jiao Tong University, Shanghai, China, in July 2000 and in April 2003, respectively.

She began her Ph.D. program in the Department of Electrical and Computer Engineering at

University of Florida, Gainesville, FL in August 2003. Her research interests include

asynchronous sequential circuits, application of asynchronous sequential systems in computer

architecture, artificial intelligence and biological systems, control theory, control systems, and

applications of control theory in computer communication networks. She received her Ph.D. in

August 2007.









state feedback controllers were used to eliminate the effects of infinite cycles on asynchronous

machines; and in Geng and Hammer (2005), the problem of model matching with output

feedback controllers was considered for asynchronous machines with no critical races. In the

present work, I concentrate on the problem of designing output feedback controllers that

eliminate the effects of critical races in asynchronous machines. The problem of eliminating the

effects of critical races with output feedback requires the development of additional notions as

well as the development of new design algorithms for controllers, and these are the subjects of

our present discussion. To introduce these notions, I start with a brief review of some of the

underpinnings of the theory of asynchronous machines.

Unlike a synchronous machine, which is driven by clock pulses, an asynchronous machine

is driven by changes of its input variables. A stable state is a state at which the machine lingers

until a change occurs in one of its input variables. In general, the change of an input variable

causes an asynchronous machine to go through a succession of state transitions. If this

succession of transitions ends, then the final state reached by the machine is a stable state; the

states through which the machine passes during the succession are unstable states. Ideally, an

asynchronous machine passes through an unstable state in zero time. Thus, unstable states are not

noticeable to the user.

If an asynchronous machine has a succession of state transitions that does not terminate,

then the machine has an infinite cycle. Infinite cycles form another class of potential defects of

an asynchronous machine. The elimination of the effects of infinite cycles by the use of state

feedback was discussed in Venkatraman and Hammer (2004). Asynchronous machines with

infinite cycles are not discussed in this dissertation; I assume that all machines under

consideration have no infinite cycles.

















c x' b a c







b

Figure 2-2. State flow diagram of the machine Es

Let Xr= {x1, x2, x3}, then U = {a, c}. Given u= a, the next stable states set is s[Xr, a]=

{x1}. The burst set is B(Xr, u) = {3P, 32} = {0, 020} and the two burst equivalent subsets of

s[Xr, a] are: S= {x1} and S2= {x1}. The state in S1 can be reached via burst P,=0 and the

state in S2 can be reached via burst 32=020, so S, and S2 are two burst equivalent sets.

From the above example, we notice that those states in a burst equivalent set of an

asynchronous machine cannot be distinguished from each other by an external observer. So, we

need a new method to deal with this kind of situation.

Definition 2-9 Let Xr := xi(), ..., xi(m)} be a set of states of the machine Y, assume they

have a non-empty set U of common input characters, and let u e U be a character. The

asynchronous machine Y = (A, Y, X, x0, f, h) is detectable at the set pair (Xr, u) if it is possible

to determine from input/output data whether all outcomes s[Xr, u] have reached their next stable

state; if so, the set of transitions from (Xr, u) to s[Xr, u] is called a stable and detectable

transition set. *









Proposition 3-21 Let Yg be a generalized machine with the preliminary generalized

skeleton matrix K1(Xg), and let x' and xj be two generalized states of Xg. Then the following

two statements are equivalent.

(a) There exists an output feedback trajectory from xi to x'.

(b) The (i, j) entry of Ki,(g) is 1.*









It was shown in Geng and Hammer (2005) that a stable transition is detectable if and only

if its burst switches output characters in its last step. When dealing with detectability of sets of

states, the situation is somewhat more complicated. The outcomes of a state-set-input pair (X,

u) form a set of states s[Xr, u] and all bursts from the set Xr to s[Xr,u] form a set of bursts

B(Xr, u). Even if every burst in B(Xr, u) is detectable individually, it is still possible that one

cannot determine whether the machine has reached its next stable state. For instance, consider

two bursts in B(Xr, u): 3(xl, Xr, u) and P(x2, Xr, u). The burst 3(xl, Xr, u) is a strict prefix of the

burst P(x2, Xr, u), say 3(xl, Xr, u) = y1y2y3 and P(x2 u) = yy2y3y4yy3. Clearly, then, at the

point where the burst 3(x, Xr, u) ends, it is not possible to tell whether the machine has reached

its next stable combination, as the machine might actually be on its way to the state x2. This

discussion leads us to the following statement.

Proposition 2-10 Let Xr := {xi(), ..., xi()} be a set of states of the machine Y, and

assume they have a non-empty set U of common input characters. For an element u e U, let

s[Xr, u] be the set of all possible next stable states, where s is the stable transition function of

the machine Y. Let B(Xr, u) be the set of all possible bursts generated by the pair (Xr, u). The

asynchronous machine X is detectable at the set pair (Xr, u) if and only if the following

conditions are satisfied:

(a) P31 P for all P e B(Xr, u);

(b) P is not a strict prefix of 3' for any 3, 3V' e (Xr, u).

Proof The first condition has been proved in Geng and Hammer (2005). Let us examine

the second condition. The first condition guarantees the detectability of the end of each burst in

B(Xr, u), so the only confusion is from other bursts in the set B(Xr, u). Consider two bursts Pi, P3









q. If the h(xP) = h(x'), then we can define a burst state or a common-output state to make the

transition from xJ to the subset {xp, x'} a deterministic transition. So, we only need to focus on

the situation that the outcomes have different output values, i.e., h(xP) h(x'). In another word,

we cannot make the generalized machine Yg transform into a deterministic one simply with a

generalized state set. When h(xP) h(x'), if there exist input strings which can take the machine

Y from these two states (also two output values) to a single generalized state xs through

deterministic transitions, then the effect of the critical race (xi, v) can be eliminated. Assume

there exist input strings u1, u2 E A, where u1 takes the machine from xp to xs

deterministically and u2 takes the machine from x' to xs deterministically. That means s (x',

u1) = s g(x, u2) = Xs. Then we can generate a deterministic transition from xj to xs with

introducing an output feedback controller to the machine g as follows: After applying the input

v at the state xj, check the outcomes. If the outcome is xp, then apply u1 to the machine. If the

outcome is x', then apply u2 to the machine. Hence, based on the generalized state set of a

generalized machine -, we can turn the machine Y into a deterministic machine with an

output feedback controller. This controller sets up a standard projection on the generalized state

set X, which can be denoted by I : X x A X : Hx(x, u) = x.


Definition 3-15 Let g be an asynchronous machine with the generalized state set X =

{x1, ..., xm}, the input alphabet A, and the generalized stable recursion function sg. An output

feedback trajectory from the generalized state xJ to the common-output state x' is a list {So, S1,

..., S } of sets of valid pairs of Ys with the following properties:

(i) s, (x, u) is a detectable transition for all (x,u) e Uj ,..,p Sj,









critical race (ri, vi), i =1,..., p.

For every state x e X and u e A, if s(x, u) is a single state, then set sg(x, u) := s(x, u).

Set Xb := 0 and let K := (r1, vl), (r2, v2), ..., (r, vp)} be the set of all critical race pairs of the

machine X. Set i := 1 and run the following steps:

Step 1:

a) Consider the i-th element (ri, vi) of the set K. If i < p, then let Xi:= {r{, ri, ..., rmi)}

be the outcomes of the critical race (ri, vi).

b) Ifi > p, then the i-th element (ri, vi) of the set K is a burst-state-input pair created in

Step 3 of a previous cycle of the algorithm. Let S(ri) be the state set associated with the burst

state ri. Let Xi := s[S(ri), vi] be the set of all possible next stable states of the set of states S(ri)

with the input character vi.

Step 2:

Set j = 0. Partition the set Xi into its burst equivalent subsets T1, T2, ..., Tt with respect

to the input character vi, and denote by T := {T1, T2, ..., Tjt the corresponding class of subsets.

Let Z be the set consisting of all subsets Tj that contain a single state; if there are no such

subsets in T, then set Z := 0. Denote by S := T \ Z the corresponding difference set. If S' =

0, then set k := 0 and go to Step 4. Otherwise, Let S S, ..., Sk be the members of S'.

Step 3 :

Set j:=j+l and check the set S' as follows. Let E be the set of potential burst states and

let 0 : P(X) E be the burst state assignment function.

If O(SJ) V Xb, then proceed as follows; otherwise, go to b).









stable and detectable transition from every state in A' to a state in Aj. Thus, we only need to

construct a controller C which generates the input string that takes g from a state in A' to a

state in Aj. This controller should be a combination of an observer and a control unit as

described in Figure 2-3.

Theorem 4-10 Let -g=(A, Y, X, x0, sh hg) and 2'=(A, Y, X', s', h') be stably reachable

asynchronous machines, where 2' is stably minimal. Let X'= {~ 1., ...} be the state set of

2', where the initial condition of 2' is C0 = Cd. Then the following two statements are

equivalent.

(i) There is a controller C for which C, = ', where YC operates in fundamental mode

and is well posed.

(ii) There is a non-deficient subordinate list A of the output equivalence list E(2g, Y')

such that A(Yg, A) > K(2') and x0 e Ad.

Moreover, when (ii) holds, the controller C can be designed as a combination of an

observer B and a control unit F as depicted in Figure 2-3 and the observer is given by Equation

2-4.4


Proof The generalized machine Y has a generalized state set X = {x1, x2, ..., xt}. All the


underlying states of the generalized states {x1, x2, ..., xt} in this set X are the same states in the

set X of the original machine Y. Since all the real states included in a burst state or in a

common output state will work with the same input value, the same input value can be used on

the real machine. Furthermore, the output of a burst state or a common output state is the same as

that of the underlying states. Hence, the operation of the real machine is as same as before the









rm} is called the outcomes of the race. Correspondingly, there are m bursts for the critical race

pair (r, v), one for each possible outcome of the race. Let 3i be the burst generated by the

machine Y when the outcome of the race is ri. Then, we refer to the set 3(r, v) := {3(r1, r, v),

p(r2, r, v), ..., P(rm, r, v)} as the burst set of the critical race (r, v).

More details about races of asynchronous machines can be found in Kohavi (1970).

Definition 2-7 For a deterministic asynchronous machine Y = (A, Y, X, x0, f, h), let x' be

the next stable state of a valid pair (x, u). The stable recursion function s : X x A X of Y is

given by s(x, u) := x' for all valid pairs (x, u) E X x A. The stable state machine induced by Y

is represented by the sextuple Yi = (A, Y, X, x0, s, h).

For an asynchronous machine Y with a critical race pair (r, v), the stable recursion

function s has multiple values at the pair (r, v), say, s(r, v) := {r ..., rm}. Here, r r2, ..., r

are the outcomes of the critical race (r, v). +

Definition 2-8 Let Xr := {xi(), ..., xi(m)} be a set of states of the machine Y, and assume

they have a non-empty set U of common input characters. For an element u e U, let s[X, u]

be the set of all possible next stable states, where s is the stable transition function of the

machine Y. Let B(Xr,u) be the set of all bursts from Xr to s[Xr, u]. For each burst 3 e B(X,

u), let X(P) c s[Xr,u] be the set of all states x e s[Xr, u], i.e., the set of all states that can be

reached from Xr via the burst P. We refer to X(3) as a burst equivalent set for the burst

P with respect to input u. +

Note that the burst equivalent sets in s[Xr, u] may not be disjoint.

The following is an example to show how to obtain the stable state machine and transition

equivalent set for a given subset of its state set. Consider a machine Y with the input alphabet




Full Text

PAGE 1

1 INPUT/OUTPUT CONTROL OF ASYNC HRONOUS MACHINES WITH RACES By JUN PENG 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 2007

PAGE 2

2 2007 Jun Peng

PAGE 3

3 To Mom and Dad.

PAGE 4

4 ACKNOWLEDGMENTS I thank my advisor, Dr. Jacob Hammer, fo r his excellent, professional guidance and support during my four years at th e University of Florida. I th ank Dr. John Schueller, Dr. Haniph Latchman, and Dr. Janise McNair, for serving on my Ph.D. supervisory committee and for their continuous help and advice. I thank my officemates, Debraj Chakraborty and Niranjan Venkatr aman, for interesting and joyful discussions. I thank all my friends for their care and friendship. Last but not least, I thank my brother and his wife for their understandin g, support and love throughout my school years. I thank my pa rents, Mingqing Peng and Mingxia Wu, whose unceasing love and whole-hearted support made finishing this work possible. I thank my husband, Zhipeng Liu, for his love and faith in me.

PAGE 5

5 TABLE OF CONTENTS page ACKNOWLEDGMENTS...............................................................................................................4 LIST OF TABLES................................................................................................................. ..........6 LIST OF FIGURES................................................................................................................ .........7 ABSTRACT....................................................................................................................... ..............8 1 INTRODUCTION................................................................................................................... .9 2 TERMINOLOGY AND BACKGROUND............................................................................14 2.1 Asynchronous Sequential Machines...............................................................................14 2.2 Generalized Machines, States and Functions.................................................................21 2.3 Observer................................................................................................................. .........27 3 REACHABILITY OF A GENERALIZED MACHINE........................................................31 3.1 Generalized Reachability Matrix....................................................................................31 3.2 Common-output Generalized States...............................................................................41 3.3 Output Feedback Trajectory...........................................................................................44 3.4 Preliminary Generalized Skeleton Matrix......................................................................51 4 MODEL MATCHING FOR INPUT/OUT PUT ASYNCHRONOUS MACHINES WITH RACES..................................................................................................................... ...56 4.1 Model Matching Problem...............................................................................................56 4.2 Existence of Controllers.................................................................................................60 4.3 A Comprehensive Exampl e of Controller Design..........................................................67 5 SUMMARY AND FUTURE WORK....................................................................................74 LIST OF REFERENCES............................................................................................................. ..76 BIOGRAPHICAL SKETCH.........................................................................................................81

PAGE 6

6 LIST OF TABLES Table page 2-1 Transition table of the machine .....................................................................................17 2-2 Transition table of the machine s.....................................................................................17 3-1 Stable state transition table of the machine g..................................................................33 3-2 Transition table of the machine .....................................................................................43 3-3 Transition table of the machine s....................................................................................43 4-1 Transition table of the machine ....................................................................................68 4-2 Stable state transition table of the machine g..................................................................68

PAGE 7

7 LIST OF FIGURES Figure page 1-1 Control configuration for the asynchronous machine ...................................................10 2-1 State flow diagram of the machine ................................................................................17 2-2 State flow diagram of the machine s...............................................................................18 2-3 Control configuration for the closed-loop system c.........................................................28 3-1 State flow diagram of the machine g...............................................................................33 4-1 Equivalence of two asynchronous machines and g..................................................63 4-2 State flow diagram of the machine ...............................................................................68 4-3 State transitions diag ram of control unit F........................................................................73 4-4 State transitions di agram of observer B............................................................................73

PAGE 8

8 Abstract of Dissertation Pres ented to the Graduate School of the University of Florida in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy INPUT/OUTPUT CONTROL OF ASYNC HRONOUS MACHINES WITH RACES By Jun Peng August 2007 Chair: Jacob Hammer Major: Electrical and Computer Engineering The occurrence of races causes unpredictable and undesirable behavior in asynchronous sequential machines. In the pres ent work, traditional feedback control techniques are used to control a race-afflicted machine, so as to turn it into a deterministic machine that matches a desired model. Instead of replaci ng or redesigning the whole machine, I add an output feedback controller to the original defective machine, and the controller eliminates the negative effects of the critical races. The present work focuses on asynchronous sequential machines in which the state of the machine is not provided as an output. The results include the necessary and sufficient conditions for the existence of controllers that eliminate the effect s of a critical race, as well as al gorithms for their design. The necessary and sufficient conditions for the existence of contro llers are presented in terms of certain matrix inequalities.

PAGE 9

9 CHAPTER 1 INTRODUCTION Asynchronous sequential machines are digital logic circuits without synchronizing clock, so they are also called clockless logic circui ts. The lack of a synchronizing clock allows asynchronous machines to operate much faster. In addition, there are practical applications, such as parallel computation, where the underlying system is inherently asynchronous. Asynchronous design techniques can also be used to achieve ma ximum efficiency in parallel computation (Cole and Zajicek (1990), Higham a nd Schenk (1992), Nishimura (1995 )). The design of asynchronous machines has been an active area of research since mid 1950s (Huffman (1954, 1955)). Potential difficulties, such as critical races and infinite cycles that may arise in the design of asynchronous machines are discussed in the litera ture (Kohavi (1970), Unger (1959)). Both critical races and infinite cycles are flaws in the operation of an asynchronous sequential machine. In this dissertation, I w ill focus on asynchronous machines with critical races. A critical race drives the machine to ex hibit nonpredictable behavior, and it may be caused by malfunctions, by design flaws, or by implementa tion flaws. Common practice is to rebuild a machine that is afflicted by a critical race, and replace it with a race-free machine. In the present work, I use tradit ional feedback control techniqu es to control a race-afflicted machine, so as to turn it into a deterministic machine that matches a desired model. Instead of replacing or redesigning a defective machine, I add an output feedback controller, and the controller eliminates the effects of the critical races. The feedb ack controller turns the closed loop system into a deterministic machine, and th e closed loop system imitates the desired model (Figure 1-1).

PAGE 10

10 Figure 1-1. Control configuration for the asynchronous machine Here, is the machine being controlled and C is another asynchronous machine that serves as an output feedback controller. We denote by c the machine described by the closed loop. The objective is to fi nd a controller C for which the closed loop machine c exhibits desirable behavior. I represent the behavior desired for the clos ed loop system by an asynchronous machine called a model. In thes e terms, the objective is to design a controller C for which the closed loop machine c simulates the model Of course, the machine that represents the desired behavior is not afflicted by any critical races. Thus, by si mulating the behavior of the closed loop system eliminates the ill effects of the critical ra ces present in The problem of designing such a controller C is often referred to as th e model-matching problem. The objective, then, is to find necessary and sufficient conditions for the existence of the controller C that solves the model matching problem. When such a controller exists, I also provide an algorithm for its construction. The literatures regarding the model-matchi ng problem of asynchronous machines with races has focused so far on asynchronous sequential machines in which the state is provided as the output of the machines (input/state machines). In Murphy et al. (2002, 2003), the control of asynchronous machines was discussed and state feedb ack controllers that e liminate the effects of critical races in asynchronous machines were developed. In Venkatraman and Hammer (2004), C u y v

PAGE 11

11 state feedback controllers were used to eliminate the effects of infinite cycles on asynchronous machines; and in Geng and Hammer (2005), th e problem of model matching with output feedback controllers was considered for asynchr onous machines with no cr itical races. In the present work, I concentrate on the problem of desi gning output feedback controllers that eliminate the effects of critical races in asynchronous machines. The problem of eliminating the effects of critical races with output feedback requires the development of additional notions as well as the development of new design algorithms for controllers, and these are the subjects of our present discussion. To introduc e these notions, I start with a brief review of some of the underpinnings of the theory of asynchronous machines. Unlike a synchronous machine, which is driven by clock pulses, an asynchronous machine is driven by changes of its input variables. A stable state is a st ate at which the machine lingers until a change occurs in one of its input variables. In general, the change of an input variable causes an asynchronous machine to go through a succession of state transitions. If this succession of transitions ends, then the final stat e reached by the machine is a stable state; the states through which the machine passes during the succession are unstable states. Ideally, an asynchronous machine passes through an unstable stat e in zero time. Thus, unstable states are not noticeable to the user. If an asynchronous machine has a succession of st ate transitions that does not terminate, then the machine has an infinite cycle. Infinite cycles form another class of potential defects of an asynchronous machine. The elimination of the effects of infinite cycles by the use of state feedback was discussed in Venkatraman a nd Hammer (2004). Asynchronous machines with infinite cycles are not discu ssed in this dissertation; I a ssume that all machines under consideration have no infinite cycles.

PAGE 12

12 To guaranty the proper behavior of an as ynchronous machine, some care has to be exercised during its operation. In pa rticular, one has to avoid cha nging values of input variables while the machine undergoes a succession of state transitions. If an input change occurs while the machine is not in a stable state, then, due to asynchrony, it is not possi ble to predict the state of the machine at the instant in which the input change occurs. As the response of the machine depends on its state, this may result in an unpredic table response of the machine. In other words, the response may vary depending on the specific state of the machine at the instant of the input change. To avoid this situation, asynchronous m achines are normally operated so as to guaranty that input changes occur only while the machine is in a stable st ate. When this precaution is taken, we say that the machin e operates in fundame ntal mode. In this dissertation, all asynchronous machines are operated in fundamental mode. The development of necessary and sufficien t conditions for the existence of a model matching controller C and the algorithm for its construction depend on a certain generalized concept of state, introduced in ch apter 2 below. A generalized state describes a persistent state of the machine about which only partial information is available. More specifically, as is an input/output machine, it is not always possible to determine its current state from available input/output data. A generalized state indicate s a situation in which it is known that is in a stable state, but the exact state of is not known; the machine can be in any one of a predetermined set of stable states. The generalized state allows us to use the partial information available about the state of to continue controlling the mach ine as best as possible toward the goal of achieving model matching, while taking be st advantage of the available information about The generalized state allows us to formaliz e in a concise and functional way the future implications of uncertainties in the present state of the machine

PAGE 13

13 The notion of a generalized state was also used in Venkatraman and Hammer (2004) to represent phenomena related to the presence of infi nite cycles. In the present paper, I show that a generalized notion of state can also be used to represent uncertainty in asynchronous machines with critical races, in situa tions where the exact state of the machine is not known. The mathematical background of our discussi on is based on Eilenberg (1974). Studies dealing with other aspects of the control of sequential machin es can be found in Ramadge and Wonham (1987) and in Thistle a nd Wonham (1994), where the theory of discrete event systems is investigated; in Ozveren, Willsky, and Antskl is (1991), where stability issues of sequential machines are analyzed; and in Hammer ( 1994, 1995, 1996a and b, 1997), Dibenedetto, Saldanha, and Sangiovanni-Vincentelli (1994), Barrett an d Lafortune (1998), where issues related to control and model matching for sequential machin es are considered. Th ese discussions do not take into consideration specialized issues related to the f unction of asynchronous machines, like the issues of stable states, unstable states, and fundament mode operation. As a result, these works refer mostly to the c ontrol of synchronous machines.

PAGE 14

14 CHAPTER 2 TERMINOLOGY AND BACKGROUND 2.1 Asynchronous Sequential Machines Definition 2-1 An asynchronous sequential machine is defined by a sextuple (A, Y, X, x0, f, h), where A, Y and X are nonempty finite sets: A is the input set, Y is the output set, and X is the state set. x0 X is the initial state of the m achine. The partial function f : A X X is the state transition function (or recurs ion function) and the partial function h : A X Y is the output function. When the output function h does not depend on th e input character (i.e., when h : X Y), the machine is called a Moore machine in Moore (1956). Note that every asynchronous machine can be represented as a Moore machine. The machine operates according to a recursion form xk+1 = f(xk,uk) yk = h(xk) k = 0 1 2 ... (2-1) Where, k counts the steps of the machine The sequences xk, uk, and yk are the state sequence, the input sequence and the output sequence, respectively. The machine is an input/state machine if Y = X, or yk = xk for each step k 0. When the output is not the state, then the machine is an input/output machine. The present paper focuses on input/output machines. Definition 2-2 Let be an asynchronous machine repr esented by sextuple (A, Y, X, x0, f, h). A pair (x, u) X A is called a valid pair if the recursi on function f is defined at it. If x = f(x, u), then the combination ( x, u) is a stable combination. Definition 2-3 Let (x, u) be a vali d pair of the machine = (A, Y, X, x0, f, h). If (x, u) is not a stable combination, then the machin e generates a chain of transitions x1 = f(x, u), x2 = f(x1,

PAGE 15

15 u), If the chain does not te rminate, then the machine contains an infinite cycle. If the succession of transitions ends at a stable combination (xi, u), then xi is the next stable state of x with the input character u. In the present work, I assume that none of our asynchronous machines possess infinite cycles. Definition 2-4 Let Y be an alphabet and let y1, yq Y be a list of characters such that yi+1 yi for all i = 1, q 1. Then, the burst of a string y = y1y1 y1y2y2 y2 yqyqyq is (y) : y1 y2 yq-1 yq and -1(y) y1y2 yq-1, for q > 1; -1 for q = 1. Let x1x2x3 xm be the string of states generated by the machine from valid pair (x, u) and xm is the next stable state. Then, the burst of the valid pair ( x, u) is defined as (xm, x, u) : (h(x)h(x1)h(x2)h(xm-1)h(xm)). Definition 2-5 Let p1 and p2 be two strings of the alphabet A. As usual, p2 is a prefix of p1 if there is a string p3 such that p1 = p2p3. We say that p2 is a strict prefix of p1 if p3 the empty string. For example, given three strings p1, p2, and p3: p1 = y1y1y2y3; p2 = y1y1y2y3; and p3 = y1y1y2y3y2y3. The string p1 and p2 are each others prefix string. Both p1 and p2 are strict prefix strings of the string p3. Definition 2-6 A state-input pair (r, v) for which the next stable state of the machine is unpredictable is called a cr itical race pair, or, brie fly, a critical race. There may be more than one possible next stable states of the critical race pair (r, v). Let us suppose there are m possible next stable stat es of (r, v). The set of all these states {r1, r2,

PAGE 16

16 rm} is called the outcomes of the race. Correspondingl y, there are m bursts for the critical race pair (r, v), one for each possible outcome of the race. Let i be the burst generated by the machine when the outcome of the race is ri. Then, we refer to the set (r, v) : { (r1, r, v), (r2, r, v) (rm, r, v)} as the burst set of the critical race (r, v). More details about races of asynchronous machines can be found in Kohavi (1970). Definition 2-7 For a deterministic asynchronous machine = (A, Y, X, x0, f, h), let x be the next stable state of a valid pair (x, u). The stab le recursion function s : X A X of is given by s(x, u) : x for all valid pairs (x, u) X A. The stable state machine induced by is represented by the sextuple |s = (A, Y, X, x0, s, h). For an asynchronous machine with a critical race pair (r, v), the stable recursion function s has multiple values at the pair (r, v), say, s(r, v) : {r1, r2, rm}. Here, r1, r2, rm are the outcomes of the critical race (r, v). Definition 2-8 Let Xr := {xi(1), ..., xi(m)} be a set of states of the machine and assume they have a non-empty set U of comm on input characters. For an element u U, let s[Xr, u] be the set of all possible next stable states, wh ere s is the stable transition function of the machine Let B(Xr,u) be the set of all bursts from Xr to s[Xr, u]. For each burst B(Xr, u), let X( ) s[Xr,u] be the set of all states x s[Xr, u], i.e., the set of all states that can be reached from Xr via the burst We refer to X( ) as a burst equivalent set for the burst with respect to input u. Note that the burst equi valent sets in s[Xr, u] may not be disjoint. The following is an example to show how to obtain the stable state machine and transition equivalent set for a given subset of its state set. Consider a machine with the input alphabet

PAGE 17

17 A={a, b, c}, the output alphabet Y={0, 1, 2}, and the state set X={x1, x2, x3, x4 }. There is a critical race pair (x1, c) in the machine. This machine is depicted by a chart (Table 2-1) or a figure (Figure 2-1). So is the stable state machine s of (Table 2-2, Figure 2-2). Table 2-1. Transition table of the machine a b c Y x1 x1 x4 {x2, x3} 0 x2 x4 x1 x2 1 x3 x4 x3 1 x4 x1 x4 2 x3 c a x1 x2 x4 c b b a b a c a c Figure 2-1. State flow diagram of the machine Table 2-2. Transition table of the machine s a b c Y x1 x1 x4 {x2, x3} 0 x2 x1 x4 x2 1 x3 x1 x3 1 x4 x1 x4 2

PAGE 18

18 x3 c a x1 x2 x4 c a b b b a c a c Figure 2-2. State flow diagram of the machine s Let Xr = {x1, x2, x3}, then U = {a, c}. Given u = a, the next stable states set is s[Xr, a] = {x1}. The burst set is (Xr, u) = { 2} = {0, 020} and the two burst equivalent subsets of s[Xr, a] are: S1 = {x1} and S2 = {x1}. The state in S1 can be reached via burst 1=0 and the state in S2 can be reached via burst 2=020, so S1 and S2 are two burst equivalent sets. From the above example, we notice that thos e states in a burst equivalent set of an asynchronous machine cannot be distinguished from each other by an external observer. So, we need a new method to deal with this kind of situation. Definition 2-9 Let Xr := {xi(1), ..., xi(m)} be a set of states of the machine assume they have a non-empty set U of comm on input characters, and let u U be a character. The asynchronous machine = (A, Y, X, x0, f, h) is detectable at the set pair (Xr, u) if it is possible to determine from input/output data whether all outcomes s[Xr, u] have reached their next stable state; if so, the set of transitions from (Xr, u) to s[Xr, u] is called a stable and detectable transition set.

PAGE 19

19 It was shown in Geng and Hammer (2005) that a stable transition is detectable if and only if its burst switches output characters in its last step. When dealing with de tectability of sets of states, the situation is somewhat more complicat ed. The outcomes of a st ate-set-input pair (Xr, u) form a set of states s[Xr, u] and all bursts from the set Xr to s[Xr,u] form a set of bursts B(Xr, u). Even if every burst in B(Xr, u) is detectable individually, it is still possible that one cannot determine whether the machine has reached its next stable state. For instance, consider two bursts in (Xr, u): (x1, Xr, u) and (x2, Xr, u). The burst (x1, Xr, u) is a strict prefix of the burst (x2, Xr, u), say (x1, Xr, u) = y1y2y3 and (x2, Xr, u) = y1y2y3y4y5y3. Clearly, then, at the point where the burst (x1, Xr, u) ends, it is not possible to te ll whether the machine has reached its next stable combination, as the machine might actually be on its way to the state x2. This discussion leads us to the following statement. Proposition 2-10 Let Xr := {xi(1), ..., xi(m)} be a set of states of the machine and assume they have a non-empty set U of co mmon input characters. For an element u U, let s[Xr, u] be the set of all possible next stable states, where s is the stable transition function of the machine Let B(Xr, u) be the set of all possible bursts generated by the pair (Xr, u). The asynchronous machine is detectable at the set pair (Xr, u) if and only if the following conditions are satisfied: (a) -1 for all B(Xr, u); (b) is not a strict prefix of for any (Xr, u). Proof The first condition has been proved in Geng and Hammer (2005). Let us examine the second condition. The first condition guarantees the detectability of the end of each burst in B(Xr, u), so the only confusion is fr om other bursts in the set B(Xr, u). Consider two bursts i, j

PAGE 20

20 B(Xr, u), where i leads to the state xi, while j leads to the state xj. Assume first that is detectable at the pair (Xr, u). By contradiction, assume that i is a strict prefix of j, i.e., i = y1y2yk-1yk and j = y1y2yk-1ykyk+1y where, yk yk-1 and y y-1. Once the change from yk-1 to yk is observed, it is not possible to determine whether the machine has reached the next stable state xi or whether it is still in the transition to next stable state xj. Thus the machine cannot be detectable at (Xr, u), a contradiction. This shows that condition (b) must be valid whenever is detectible at (Xr, u). Conversely, assume that conditions (a ) and (b) are both valid, and let (Xr, u) be a burst, and let X s[Xr, u] be the set of all st ates to which the burst leads. Now, since is not a strict prefix of any other burst in B(Xr, u), it follows that, at the end of the burst the machine must be at one of the states of the set X say the state x (i.e., cannot be on its way to other states). Furthermore, since the end of the burst can be determined, and whence it can be determined that has reached a stable comb ination with a state of X (note that it cannot be determined from the burst which state of X has been reached). This completes our proof. For example, consider the machine with transition tabl e of Table 2-1, let Xr = {x1, x2}, then U = {a, b, c}. Let us check the detectability of the combination (Xr, a). The next stable states set s[Xr, a] = {x4}. The burst from the state x1 to the state x4 is 1 = 02 and the burst from the state x2 to the state x4 is 2 = 102. The burst set x4, Xr, a) = { 1, 2}. Since the burst 1 is not a strict prefix of 2, and vice versa, the transition from (Xr, a) to x4 is detectable.

PAGE 21

21 2.2 Generalized Machines, States and Functions The next notion is central to our discussion. It is sometimes convenient to consider certain sets of states of a machine as one quantity. This is c onvenient, for example, in cases where the available data at a certain point in time does not permit us to distinguis h between these states. This leads us to the following notion of a generalized machine. Definition 2-11 Let be a machine with the state se t X and input set A, let S( ) be a burst equivalent set with respect to u of the machine containing more than one state, and let be a set disjoint from X, and let : P(X) be a function. Associate with S( ) the element xb := (S( )); we call xb a burst state. The set is then called the set of potential burst states and is called the burst state assignment f unction. Let A be the set of all common input characters of the states in S( ). Then, the set of a ll valid pairs of xb is given by {( xb, a) : a A}. The set A is also called the valid input set of the burst state xb. Let Xb be the set of all burst states of the machine The generalized state set X of is the union X Xb. The burst equivalent set S( ) represented by a burst state xb is also recorded as S(xb). Let |s = (A, Y, X, x0, s, h) be the stable state machine of an asynchronous machine Let Xr := {xi(1), ..., xi(m)} X be a set of states of the machine and assume they have a nonempty set U of common input characters. For an element u U, let s[Xr, u] be the set of all possible next stable states. Let (Xr, u) { 1, 2, } be the set of all possible bursts generated by the transition (Xr, u) s[Xr, u], and let S( 1), S( 2), S( ) be the burst equivalent sets in s[Xr, u]. For each i = 1, 2, ..., we distinguish between two cases: 1) The set S( i) contains a single state x X. Then, we identify S( i) with the state x.

PAGE 22

22 2) The set S( i) contains more than one stat e. Then, we associate with S( i) a burst state, which represents the fact that these stat es are indistinguishabl e in this transition. For the second case, let Ai be the set of all common input characters of S( i), i = 1, 2, Note that Ai cannot be empty, since at least Ai contains the element u. Definition 2-12 Let = (A, Y, X, x0, f, h) be an asynchronous machine with a generalized state set X = Xb X, where X is the regular state set of and Xb is the burst state set of the machine We build now a generalized stable transition function sg : X A P( X) as follows: 1) For all states x X and all input characters u A, set sg(x, u) : s(x, u). 2) For a burst state x Xb, let U(x) A be the set of all input characters that form valid pairs with x. Let S(x) be the burst equivalent set represented by the burst state x. For an input character a U(x), let 1, 2, m be the set of all burst equivale nt subsets of s[S(x), a]. If i contains more than one state, then let xi be the burst state associated with the set i; otherwise i is represented by its only state xi, i = 1, ..., m. Then, sg(x, a) : {x1, ..., xm}. Note that the next stable states of a mach ine can be a combination of burst states and regular states. In the next discussion, I will give a more speci fic algorithm to build th e generalized stable transition function. As a practical process, th e algorithm should avoid getting involved into infinite loops. Thus, before the construction we need to make sure about two issues: a) the process of building the generalized stable transiti on function includes finite steps; b) there is no infinite cycles created in the construction. Since ever y burst equivalent set S( ) is a subset of the state set X, for an asynchronous machine with n regular stat es, the maximum number of

PAGE 23

23 subsets in X is 2n. Hence, the number of burst equiva lent sets is equal or less than 2n. Namely, the number of burst stat es generated in the machine is finite. Then the first requirement is guaranteed. In the previous di scussion, we have excluded asynchronous machine with infinite cycles. So, any transition starting from a regular state of a machine in this paper ends at the next stable states. Similarly, unde r the definitions of the generalized state and generalized stable transition function, for each vali d state-input pair there is one or more next stable states. Hence, each transi tion starting from a generalized st ate ends at the next stable states, i.e., no infinite cycles will be created in the process of defining the generalized stable transition function sg. Consider an asynchronous machine (A, Y, X, x0, f, h) with stable state machine |s = (A, Y, X, x0, s, h). Let X = Xb X be the generalized state set and let Xb : { 1, 2, t} be the burst state set of For every burst state c Xb, let Ab : {a1, a2, ag(c)} be the valid input set of c. For every valid pair ( a), Xb and a Ab, let S( ) be the set of regular states represented by and let s[S( a) be the set of all possibl e next stable st ates of [S( ), a]. Assume that |s have critical races (r1, v1), (r2, v2), (r, v), and let T(ri, vi) := {r1 i, r2 i, rm(i) i} X be the set of all outcom es of the critical race (ri, vi), i =1,, We build the generalized stable transition function sg with the following algorithm. Algorithm 2-13 Consider an asynchronous machine (A, Y, X, x0, f, h) with stable state machine |s = (A, Y, X, x0, s, h). Let X = Xb X be the generalized state set, where Xb is the burst state set and X is the regular state set. Assume that |s has critical races (r1, v1), (r2, v2), (r, v), and let T(ri, vi) := {r1 i, r2 i, of the rm(i) i} X be the set of all outcomes

PAGE 24

24 critical race (ri, vi), i =1,, For every state x X and u A, if s(x, u) is a single state, then set sg(x, u) : s(x, u). Set Xb := and let (r1, v1), (r2, v2), (r, v) be the set of all cr itical race pairs of the machine Set i := 1 and run the following steps: Step 1 : a) Consider the i-th element (ri, vi) of the set K. If i then let Xi := {r1 i, r2 i, rm(i) i} be the outcomes of the critical race (ri, vi). b) If i > then the i-th element (ri, vi) of the set K is a burst -state-input pair created in Step 3 of a previous cycle of the algorithm. Let S(ri) be the state set associated with the burst state ri. Let Xi := s[S(ri), vi] be the set of all possible next stab le states of the set of states S(ri) with the input character vi. Step 2 : Set j = 0. Partition the set Xi into its burst eq uivalent subsets T1, T2, Tt with respect to the input character vi, and denote by T := {T1, T2, Tt} the corresponding class of subsets. Let Z be the set cons isting of all subsets Tj that contain a single st ate; if there are no such subsets in T, then set Z := Denote by Si := T \ Z the corresponding difference set. If Si = then set k := 0 and go to Step 4. Otherwise, Let Si 1, Si 2, Si k be the members of Si. Step 3 : Set j:= j+1 and check the set Si j as follows. Let be the set of poten tial burst states and let : P(X) be the burst state assignment function. If (Si j) Xb, then proceed as follows; otherwise, go to b).

PAGE 25

25 Add the burst state xi j := (Si j) to Xb, i.e., set Xb := Xb xi j. Let Ac : {u1, u2, ug(i,j)} be the valid input set of the burst state xi j. Let := #K be the number of elements of the set K. Add to K the elements (r, v) := (xi j, u), = 1, ..., g(i,j). Add the burst state (Si j) to Z. If j < k, then go back to Step 3. Step 4 Set sg(xi, ui) : Z. Step 5. If i < #K, then set i = i + 1 and go back to step 1. Otherwise, terminate the algorithm. The set X : X Xb is the generalized st ate set of the machine The generalized stable transition function is sg : X A P( X). According to definition of the burst of a string the last character of a burst is the output value of the system for the corres ponding state. Consequently, all st ates in a burst equivalent set have the same output value. This implies that the following is true. Lemma 2-14 The output value of a burst state x is the output value of any state in the corresponding burst equivalent set S(x). Definition 2-15 Let = (A, Y, X, x0, f, h) be an asynchronous machine with a generalized state set X = Xb X, where X is the regular state set of and Xb is the burst state set of the machine Let x be a generalized state of the machine The generalized output function hg : X A Y of is defined as follows: 1) For all states x X, set hg(x) h(x);

PAGE 26

26 2) For all burst state x Xb, let S(x) be the burst equivalent set that is associated with the burst state x. Set hg(x) h(x ), x S(x). For example, consider the machine with transition table of Table 2-1, which has one critical race s(x1, c) = {x2, x3}. Using Algorithm 2-13, we can get the burst state set Xb = {x5} and x5 represents the subset {x2, x3}. The generalized stable recursion function sg and the generalized output function hg of the machine can also be defined (Table 2-3). Table 2-3. Stable transition table of the generalized a b c Y x1 x1 x4 x5 0 x2 x1 x4 x2 1 x3 x1 x3 1 x4 x1 x4 2 x5 x1 x5 1 Definition 2-16 Let = (A, Y, X, x0, f, h) be an asynchronou s machine with the stable state machine |s = (A, Y, X, x0, s, h). Then, g = (A, Y, X, x0, sg, hg) is the generalized machine associated with where X is the generalized state set, sg is the generalized stable recursion function, and hg is the generalized output function of the machine When an asynchronous machine is enhanced into a generalized machine, it still keeps some properties. We address two prope rties of the generalized machine in these two statements. Lemma 2-17 Given an asynchronous machine with a state set X, which contains finite number of states. Then the a ssociated generalized machine g also has a generalized state set X with finite number of states.

PAGE 27

27 Proof Let us suppose the machine has a state set X = {x1, x2, xn} and the generalized machine g has a generalized state set X = {x1, x2, xn+t} From the definition of burst equivalent set, a ny burst equivalent set S( ) is a subset of the state set X. Then, the maximum number of burst equivalent sets cannot be larger than the number of subsets of X, i.e., 2n, and hence is finite. Lemma 2-18 If the machine has no infinite cycles, neither does the machine g. Proof. Assume the machine has no infinite cycles but the generalized machine g, which is derived from the machine has one infinite cycle of length i, where i > 1. Suppose that i generalized states x1, x2, ..., xi are involved in this infinite cycle The states x1, x2, ..., xi may be regular states or burst states. Let us consider the followi ng two cases: i) If all these i states are regular states. Then it implies that the machine has at least one infinite cycle And the infinite cycle invol ves the i states x1, x2, ..., xi of the machine t conflicts with the assumption that the machine has no infinite cycles. ii) If in the i states x1, x2, ..., xi there is at least one burst state xp, where 1 p i. Suppose that the underling regular states of the burst state xp are x1 p, ..., xk p. Then the infinite cycle actually involves the following regular states: x1, ..., xp-1, xj p, xp+1 ..., xi, where 1 j k. Hence there is an infinite cycle that involves i regular states of the machine t conflicts with the assumption that the machine has no infinite cycles. This completes the proof. 2.3 Observer As depicted in Figure 1-1, we build an output feedback loop w ith a controller C, which is also an asynchronous machine. Specifically, this controller C is composed of two asynchronous machine: an observer B and a state-feedback control unit F (Figure 2-3).

PAGE 28

28 Figure 2-3. Control configurati on for the closed-loop system c Here, the observer B estimates the uncer tainty caused by crit ical races with the input/output information of and generates estimate state of to feed F. With the external input of the whole system and the estimate state of the control unit F generates a sequence of input to drive to match the model. We denote the controller C with (F, B). We use the observer in a way that is similar as it is used in other branches of control theory. Specifically, the observer here is an asynchronous input/state machine, which has two functions: a) check if the asynchronous machine has reached its next stable state; b) use the input/output information to estimate the current state of Let g = (A, Y, X, x0, sg, hg) be the generalized machine derived from Similarly as in Geng and Hammer (2005), we can build an observer that reproduces all st able and detectable transitions of the machine g The observer for g is an input/state machine B = (A Y, X, Z, z0, I) with two inputs: the input character u A of g and the output burst Y of g the state set Z is identical to the generalized state set X and the initial condition is identical to that of g i.e., z0 =x0. The recursion function A Y Z of B is u y v F B x C o n t r o l l e r C

PAGE 29

29 constructed as follows. First, using the generalized stable recursion function sg, define the function A {0, 1} Z by setting (z, u, a) sg z, u) if a = 1; z if a = 0. (2-2) Now, assume that the machine g is in a stable combination (x, ui-1), when the input character changes to ui, where (x, ui) is also a detectable pair. The change of the input character may give rise to a chain of transitions of g. Let k i be a step during this chain of transitions, let k be the burst of g from step i to step k, and let uk be the input character of g at step k. Since fundamental mode operatio n requires that the input charac ter be kept constant during a chain of transitions, we have uk =ui. Define (x, uk, k) s x, uk) if k = (x, uk); x otherwise. (2-3) Let zk be the state of the observe r B at the step k, while k be the output of B. The observer B is then an input/sta te machine defined by the recursion B zk+1 = (zk, uk, k) k =zk (2-4) The observer B is a stable state machine. To describe the operation of the observer, assume that the observer switched to the generalized state x immediately after g has reached the stable combination (x, ui-1). Let p i be the step at which the ch ain of transitions from (x, ui) to the next stable state x = sg(x, ui) terminates; then, p = (x, ui). As the pair (x, ui) is detectable, it follo ws by the definition of that the output of the observer B switches to the state x at the step p+1.

PAGE 30

30 We can now summarize the implications of our recent observations on the control configuration Figure 1-1. Fundamental mode operation requires the output of the controller C to remain constant while the system g is in transition. In order to fulfill this requirement, it must be possible for the controller C to detect the point at which g has completed its transition process. As discussed above, the out put of the observer B switche s to the state that represents the next generalized stable state of g immediately after g has reached that stat e; this signifies the end of the transition process and indi cates the most recent stable state of g. In this way, the observer B helps create an envi ronment in which the machine g can be controlled in fundamental mode operation.

PAGE 31

31 CHAPTER 3 REACHABILITY OF A GENERALIZED MACHINE The occurrence of critical ra ces in an input/output asynchronous machine causes the lacks of information about the exact state of the machin e. We use the concept of generalized states to deal with this uncertainty and keep a machine op erate in fundamental mode. In this chapter, we use generalized states to characterize the re achability properties of an asynchronous machine with critical races. First, let me introduce some important concepts that will be used in latter part of this chapter. 3.1 Generalized Reachability Matrix Definition 3-1 Let = (A, Y, X, x0, f, h) be an asynchronous machine with the state set X = {x1, xn} and let g = (A, Y, X, x0, sg, hg) be the generalized machine associated with where X = { x1, xn, xn+1, xn+t} is the generalized state set. The generalized one-step reachability matrix R g is defined as a (n+t) (n+t) matrix with entry Rij, where Rij is the set of all characters a A for which xj sg(xi, a) and for which the transition xi xj is a detectable transition. If there is no such character a, then set Rij N, where N is a character not in the alphabet A. Note that when the generalized machine g is equal to the machine (i.e., when there are no burst states), then the ge neralized one-step reachability ma trix reduces to the one-step reachability matrix R In view of the earlier disc ussion in Geng and Hammer (2005) only transitions that are both stable and detectable can be used when constructing a controller. The stability of the transition is guarantied by the ge neralized stable recursion func tion of the controlled machine

PAGE 32

32 However, the detectability of each transition needs to be checked according to proposition 2-10 in the construction of the genera lized one-step reachability matri x. Therefore, each entry of the generalized one-step reachability matr ix characterizes if the machine g can go from one generalized state to another through a stable and detectable transition. Let = (A, Y, X, x0, f, h) be an asynchronous m achine with the state set X = {x1, xn} and let g = (A, Y, X, x0, sg, hg) be the generalized m achine associated with where X = { x1, xn, xn+1, xn+t} is the generalized state set and Xb = { xn+1, xn+t } X is the burst state set. According to Definition 3-1, we can obtain the one-step reachability matrix R of the machine For the generalized machine g, the construction the generalized one-step reachability matrix R g contains two tasks: 1) Determine the necessary burst states; and 2) Add to the reachability matrix rows and columns corresponding to the burst states. Then, we can divide R( g) into 4 blocks R( g ) = R 11 | R 12 _ _R 21 | R 22, where, R11 is n n; R12 is n t, R21 is t n, and R22 is t t. The matrix R11 describes one-step deterministic transiti ons among regular states of while R22 describes one-step transitions among burst states. The submatrix R12 represents one-step transitions from regular states to burst states, while R21 represents one-step tr ansitions from burst stat es to regular states. Example 3-2 Consider the machine with transition table of Table 2-1, which has the input alphabet A = {a, b, c}, the output al phabet Y = {0, 1, 2}, and the state set X = {x1, x2, x3, x4, x5}. There is a critical race pair (x1, c) in the machine

PAGE 33

33 The generalized machine g derived from the has a generalized state set X = {x1, ..., x5}, and it can be depicted as follows. Table 3-1. Stable state transition table of the machine g x1 x5 x2 x4 b c c a c b c x3 a a a a b Figure 3-1. State flow diagram of the machine g According to Definition 3-1, the one-step reach ability matrix of the original machine is R( ) = accb acNb aNcN aNNb a b c Y x1 x1 x4 x5 0 x2 x1 x4 x2 1 x3 x1 x3 1 x4 x1 x4 2 x5 x1 x5 1

PAGE 34

34 and the generalized one-step reachab ility matrix of the machine g is R( g) = aNNbc acNbN aNcNN aNNbN aNNNc The submatrix R22 = [c] in the matrix R( g) describes the stable and detectable transitions inside the burst state set Xb. After obtaining the generalized stable recursion function sg we can get the generalized one-step reachability matrix R( g) as above. Similar to the one-step transition matrix in Venkatraman and Hammer (2004), we define so me operations on the generalized one-step reachability matrix R( g). Based on these operations we can obt ain the overall vi ew of reachable states in the generalized machine g and the information about how to approach the destination of any transition. The latter information is very us eful in the construction of the controller of the closed loop system. Definition 3-3 Let A be the set of all stri ngs of characters of the alphabet A and let wi be a subset of A or the character N, i = 1, 2. The operation of unison is defined by w1 w2 := w1 w2 if w1 w2 Aw1 if w1 A and w2 = N w2 if w1 = N and w2 AN if w1 = w2 = N. (3-1)

PAGE 35

35 The unison C : A B of two n n matrices A and B, whose entries are either subsets of A or the character N, is defined entrywise by Cij : Aij Bij, i, j = 1, ..., n. Note that N takes the role of zero. For example, given two 3 3 matrices A = abN bNN aac and B = NbN cNN abb the unison of A and B is C : A B abN {bc}NN a{ab}{bc} Definition 3-4 Let A be the set of all stri ngs of characters of the alphabet A and let w1, w2 be two subsets of A or the character N. C oncatenation of elements w1, w2 A N is defined by conc(w1,w2) := w2w1 if w1 w2 AN if w1 = N or w2 = N. (3-2) Let W = {w1, w2, wq} and V = {v1, v2, vr} be two subsets, whose elements are either subsets of A or the character N. Define conc(W, V) := i = 1 q j = 1 r conc(wi,vj) (3-3) For instance, consider two subsets W = {a,N,{bc}} and V = {N,a,{ab}}. The concatenation of W and V is conc(W, V) = {a,aa,{aa, ba},N,{a,b},{b,c},{ab,ac},{ab,bb,ac,bc}}. Definition 3-5 Let C and D be two n n matrices whose entries are either subsets of A or the character N. Let Cij and Dij be the (i,j) entries of th e corresponding matrices. Then, the product Z : CD is an n n matrix, whose (i,j) entries Zij is given by

PAGE 36

36 Z ij : n k=1 conc(Cik,Dkj), i,j = 1, ..., n. (3-4) For example, consider two 3 3 matrices A = abN bNN aac and B = NbN cNN abb Then the product of A and B is Z = AB = cbbaN NbbN {acca}{babc}bc Using the operation of product, we can de fine powers of the generalized one-step reachability matrix by setting Rq( g) : Rq-1( g)R( g), q = 2, 3, ... (3-5) Proposition 3-6 All transitions of the matrix Rq( g) are stable and detectable transitions. Proof According to the definition of the gene ralized one-step reachability matrix, each non-zero entry of the matrix refers to a stable and detectable transition. After the operation of product, every non-zero entry of a generalized multi-step reacha bility matrix refers to a combination of multi-step stable and detectable transitions. This operation does not change either the stability or the detectability of the transitions. Thus, for every entry of the matrix Rq( g), if it is not N, it stands for a stable and detectable transition. Based on Proposition 3-6, for an integer q 1, the matrix Rq( g) describe if the machine can reach one state from another st ate through exact q stable and detectable transitions. If the (i,j) entry of the matrix Rq( g) is not N, then it is the set of all input strings that can takes the machine g from the state xi to the state xj via a q-step stable and de tectable transition. If the (i,j) entry is N, then it is impossible to reach the state xj from the state xi in exact q stable and detectable transitions. Though, it might be possible to reach from xi to xj in stable and

PAGE 37

37 detectable transitions, where < q or > q. Since we are also interested in if the machine can reach one state from another in fewer transi tions, it is needed to construct a multi-step reachability matrix. Definition 3-7 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine and let R( g) be the generalized one-step reach ability matrix of the machine g. The generalized qstep reachability matrix is defined by R(q)( g) : r = 1, ..., qRr( g q = 2, 3, ... (3-6) Note that the (i,j) entry of R(q)( g) contains the reachability information from the state xi to the state xj. If the (i,j) entry is no t N, it consists all strings that may take the machine g from xi xj through stable and detectable transitions in q or fewer steps. It leads to the following statement and its proof is si milar to Murphy, Geng and Hammer (2003). Lemma 3-8 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine with n states and t burst states, and let R( g) be the generalized reachability matrix of the machine g. Then the following two statements are equivalent: (i) The generalized state xj is stably reachable through a detectable transition from the generalized state xi. (ii) The (i,j) entry of R(n+t)( g) is not N. Proof. Let A be the set of all strings of characters of the alphabet A. If the first statement is true, namely, the state xj is stably reachable from xi, then there is an input string u : uk-1 u1u0, which satisfies xj = sg(xi, u) and the transition from xi to xj is

PAGE 38

38 detectable Here, u A and k : |u |. If |u | (n t 1), then take u : u Thus, the (i,j) entry of R(n+t)( g) is uk-1 u1u0. If |u | (n t 1), then we need to show that a shorter string u in the string u still satisfies xj = sg(xi, u) and |u| (n t 1). Define recursivel y a string of states x0, x1, ..., xk, by setting x0 : xi and xm+1 : sg(xm, um), for m = 0, 1, ..., k-1. This implies xk = xj. The length of the string x0, ..., xk, k +1 is greater or equal to (n t). However, there are totally only (n t) distinct generalized states of the machine g. So, at least one generalized state must be repeated in the string x0, ..., xk. Suppose xp = xq, for 0 p q k. Remove from u the string v, which satisfies xq = sg(xp, v). Afterwards the s hortened input string u : u0u1 up-1uq uk-1 uk-1 uqup-1 u1u0 (or u : uk-1 uq when p = 0 ). This shortened u still satisfies xj = sg(xi, u ). Keep shortening the input string until an input string u of length |u| (n t 1) still satisfying xj = sg(xi, u). Conversely, if the second statemen t is true, then it implies that there is an input string u A of length |u| (n t 1). Suppose the (i,j) entry of R(n+t)( g) is the string u : uk-1 u1u0. There are k input characters in the string u and those characters satisfy the following equation: setting x0 : xi and xm+1 : sg(xm, um), for m = 0, 1, ..., k-1. Then we have xk = xj. According to the definitions of the generali zed stable recursion function, the machine g is only involved into stable transitions here. Meanwh ile, in the construction of the generalized reachability matrix R( g), all undetectable transitions are el iminated. Thus, the generalized (n t

PAGE 39

39 1) step reachability matrix R(n+t)( g) only contains detectable tr ansitions. So, the generalized state xj is stably reachable from the generalized state xi. Therefore, all possible stable and det ectable transitions for the machine g can be found in the matrix R(n+t)( g), i.e., the generalized (n t 1) step reachability matrix characterizes the reachability property of the machine g with n states an d t burst states. Definition 3-9 Let R( g) be the generalized one-step reachability matrix of the machine g, which has n t generalized states. The generalized st able reachability matr ix of the machine g is ( g) : R(n+t)( g). Example 3-10 Consider the machine and the generalized machine g of Example 3-2. g has a generalized state set X = {x1, x2, x3, x4, x5} and (n t 1) = 4. Raise the power of the R( g) as follows: R2( g) = {aabaabbbac}NNac{cacbcc} ba{ccca}N{acaa}N {aabaac}NccNca {abbbba}{ccca}N{acaa}cb {aabaac}caN{aaac}{cacc} After a stable transition, repeat applying the same input charac ter will not change the state of the machine. Thus, all same consecutive input character can be replace d by one character. For instance, the input string aa can be replaced by a and it will not affect the stable transitions of the machine. Hence, we obtain

PAGE 40

40 R2( g) = {abbaabac}NNac{c cacb} ba{cca}N{aac}N {abaac}NcNca {babba}{cca}N{aac}cb {abaac}caN{aac}{cca} Continue raising the power of the R( g) until the (n t 1) = 4. Then we have R4( g) = aabacabaaca abababacacabacac NN bbababbac bababaca ccacabcac cabacaca aabacabaabc acaabababac cN bbabcbabbac babababcbaca cacabcaccaba cabccaca aacabaaca abacacac N c{babcbacbacababa}{}cacaccabacaca aababaaca ababacab NN{}bbababbababaca {}cacabcabacaca aacabaaca abacacac NN {}babacbababaca{} ccacaccabacaca According to Definition 3-7 and Definiti on 3-9, we obtain the generalized stable reachability matrix g) of the machine g as follow:

PAGE 41

41 ( g ) = aabacabaaca abababacacabacac NN bbababbac bababaca ccacabcac cabacaca aabacabaabc acaabababac cN bbabcbabbac babababcbaca cacabcaccaba cabccaca aacabaaca abacacac N c{babcbacbacababa}{}cacaccabacaca aababaaca ababacab NN{}bbababbababaca {}cacabcabacaca aacabaaca abacacac NN {}babacbababaca{} ccacaccabacaca. 3.2 Common-output Generalized States As we have mentioned before, if the outcomes of a critical race (r, v) can be divided into more than one burst equivalent set, then sg(r, v) consists of more than one generalized state. This situation is shown in the genera lized one-step reachability matr ix as one input string appears more than once in different entries of a single row. Consider both this fact and the Lemma 3-8, we have the statement below. Proposition 3-11 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine with n states and t burst states, and let ( g) be the generalized stab le reachability matrix of the machine g. Then the following two statements are equivalent for all input strings u A+ and for all j = 1, ..., n t. (i) Applying u at the generalized state xi generates a critical race. (ii) The string u appears in more than one entry of row i of the matrix ( g). Note that the above conclusion is similar w ith the Proposition 4-16 in Venkatraman and Hammer (2004).

PAGE 42

42 After using burst states to repr esent subsets of states which have the same output value and same burst, we can see there are still critical ra ces in the machine on the generalized state base. Some input strings may be repeated in more than one entries of a row of the generalized stable reachability matrix (Example 3-10). That is caused by the existence of critical races. In the present discussion, the machine ( g) is an input/output machine. Thus, what matters to the user are the output value but not the state of the ma chine itself. Next we check if the machine can be led from different outcomes of th e critical races to the same output value. In Venkatraman and Hammer (2004), if the machine can be led from differ ent outcomes of the critical races to the same state, then it means the existence of a feedback trajectory. Here, we can loose the restriction to a subset of states which have the same output value. They can be also called common-output generalized states. Definition 3-12 Let g = (A, Y, X, x0, sg, hg) be a generalized asynchronous machine with a generalized state set X = Xb X. Assume that the machine g have critical races (r1, v1), (r2, v2), (r, v), and let T(ri, vi) := {r1 i, r2 i, rm(i) i} X be the set of all outcomes of the critical race (ri, vi), i =1,, Divide T(ri, vi) into subsets C1 i, C2 i, Cm(i) i according to the output value of r1 i, r2 i, rm(i) i. These subsets C1 i, C2 i, Cm(i) i can be represented by x1, x2, ..., xc, which are called the common-out put states of the machine g. Set m = n t c, then the generalized state set increases to X = {x1, ..., xm}. Note that the outcomes of the critical race s may be a combination of burst states and regular states. Moreover, if two subsets contain the same states, then they are represented by the same common-output state.

PAGE 43

43 After introducing the common-out put state of the machine g, we should update the generalized one-step reachability matrix R( g) and the generalized reachability matrix ( g). The transitions from one generalized state to a subset of states, which have the same output value, will be replaced by the single transi tion from the starting state to a newly defined common-output state. Example 3-13 Consider a machine with the input alphabet A = {a, b, c}, the output alphabet Y = {0, 1, 2}, and the state set X = {x1, x2, x3, x4, x5}. There is a critical race pair (x1, c) in the machine (Table 3-2). Table 3-2. Transition table of the machine a b c Y x1 x1 x4 {x4, x5} 0 x2 x2 x1 x2 1 x3 x1 x5 x3 1 x4 x1 x4 x2 2 x5 x2 x5 x3 2 The stable state machine of is s (Table 3-3). Table 3-3. Transition table of the machine s a b c Y x1 x1 x4 {x2, x3} 0 x2 x2 x4 x2 1 x3 x1 x5 x3 1 x4 x1 x4 x2 2 x5 x2 x5 x3 2 Using Algorithm 2-13, we get the genera lized stable recu rsion function sg of the machine g. Associate a burst state x6 with the subset {x2, x3}. Then the generalized machine g has a generalized state set X = {x1, ..., x6}. Assign a common-output state x7 to represent the subset

PAGE 44

44 {x4, x5}. Now the generalized machine g has a generalized state set X = {x1, ..., xm} and m 7. The generalized one-step reachability matrix is R( g) = aNNbNcN N {ac} N b N N N aNcNbNN acNbNNN NacNbNN aaNNNcb aaNNNcb Definition 3-14 Let |s be a generalized stable state machine with the generalized stable recursion function sg, and let u be an input string of |s. The transition induced by u from a generalized state x is a de terministic transition if sg(x, u) consists of a single state. The machine g is a deterministic machine if all transitions of |s are deterministic. 3.3 Output Feedback Trajectory From the definition of the critical race, we know a transition from a critical race pair to the outcomes is not a deterministic transition. So, or iginally, an asynchronous machine with critical races is not a deterministic machine. If we can transform the machine with critical races into a deterministic machine on a specific basis, then we actually get rid of the e ffect of the critical races to the machine. The following procedure helps us to transform a machin e with critical races into a deterministic machine. Consider a generalized machine g with the generalized state set {x1, x2, ..., xm} and input set A. Assume the m achine has a critical race (xj, v) with the outcomes {xp, xq} and p

PAGE 45

45 q. If the h(xp) = h(xq), then we can define a burst state or a common-output state to make the transition from xj to the subset {xp, xq} a deterministic transition. So, we only need to focus on the situation that the outcomes have different output values, i.e., h(xp) h(xq). In another word, we cannot make the generalized machine g transform into a deterministic one simply with a generalized state set. When h(xp) h(xq), if there exist input string s which can take the machine g from these two states (also two output values) to a single ge neralized state xs through deterministic transitions, then the effect of the critical race (xj, v) can be eliminated. Assume there exist input strings u1, u2 A, where u1 takes the machine from xp to xs deterministically and u2 takes the machine from xq to xs deterministically. That means sg(xp, u1) = sg(xq, u2) = xs. Then we can generate a deterministic transition from xj to xs with introducing an output feedback controller to the machine g as follows: After applying the input v at the state xj, check the outcomes. If the outcome is xp, then apply u1 to the machine. If the outcome is xq, then apply u2 to the machine. Hence, based on the generalized state set of a generalized machine g, we can turn the machine g into a deterministic machine with an output feedback controller. This co ntroller sets up a standard pr ojection on the generalized state set X, which can be denoted by x : X A X : x(x, u) = x. Definition 3-15 Let g be an asynchronous machine w ith the generalized state set X = {x1, ..., xm}, the input alphabet A, and the gene ralized stable recursion function sg. An output feedback trajectory from the generalized state xj to the common-output state xi is a list {S0, S1, ..., Sp} of sets of valid pairs of |s with the following properties: (i) sg (x, u) is a detectable transition for all (x,u) Uj=0,...,p Sj,

PAGE 46

46 (ii) S0 = {(xj, u0)}, (iii) sg [S] x[S], = 0, ..., p 1, (iv) sg [Sp] = {xi}. For example, consider the machine g in Example 3-13. The out put feedback trajectory from the generalized state x6 to the generalized state x4 is: S0 = {(x6, a)}, S1 ={(x1, b), (x2, b)}. Proposition 3-16 Let g be a generalized machine and let xj and xi be two generalized states of g. The following two statements are equivalent. (a) There exists an output feedback controller C that drives g through a deterministic transition from xj to xi. (b) There is an output feedback trajectory from xj to xi. Proof. Suppose that the part (b) is valid, and let { S0, S1, Sp} be an output feedback trajectory from xj to xi. We construct an output feedback cont roller C that takes the machine g from xj to xi through a string of deterministic transiti ons. This output feedba ck controller C has two inputs: one is the output burst Y of g, and the other is the external input v A, which is also the command input of the cont roller C. Given a set of characters W A, we need to construct a controller C(xj, xi, W). This controller takes the machine g from generalized state xj to xi through deterministic transitions as th e response to an input character w W. The controller C(xj, xi, W) is a combination of an obser ver B and a control unit F as shown in Figure 2-3. Where, the observer is an input/state machine B = (A Y, X, Z, z0, I) with two inputs: the input character u A of g and the output burst Y of g the state set Z is identical to the generalized state set X and the initial condition is identical to that of

PAGE 47

47 g i.e., z0 =x0. And the function A Y Z is the stable recurs ion function of B. Let zk be the state of the observer B at the step k, while k be the output of B. The observer B is an input/state machine defined by the recursion (Eq. 2-4) The control unit F is also an i nput/state asynchronous machine F = (A X, A, 0, ) with two inputs: th e external input v A and the output X of the observer B. To complete the construction of the controller C, we need to derive the recursion function and the output function of the unit F. According to Figure 2-3, as long as v W, the controller C stays in its initial state (z0, 0) and the input character u of the machine g equals to the external input character v. After the machine g arrives a stable combination of state xj, if the external input v changes to a character of W, then the cont roller C starts working. The obse rver B collects both the input character u and the output burst xj of the machine g and feeds the contro l unit F with the state of the machine g. The control unit F generates a string of characters u1u2ur and apply it to the machine g. This input string u1u2ur will drive the machine g from the state xj to xi through a string of detectable and stable deterministic transitions. Recalling that the control unit is an i nput/state asynchronous machine F = (A X, A, 0, ). The recursion function of F is a function X and the output function of F is denoted by X A. Referring to Figure 2-3, the output X of the observer B is one of the inputs of F, and the ot her input is the external input v W. Then the control unit F generate the string u A to feed the controlled machine g. Note that the cont rol unit F must

PAGE 48

48 operates in a fundamental mode, so the whole sy stem must have reached a stable combination before the F generates the next input character for g. Assume that F will generate r input characters u1u2...ur to feed g, then it needs r states 1(xj, w), 2(xj, w), ..., r(xj, w). Denote this set by xj, w : { 1(xj, w), 2(xj, w), ..., r(xj, w)}. We define the recursion function and output function of the F as follows. (i) Let U(xj) A be the set of all input characters that form stable combination with the generalized state xj, and let z0 be the initial state of B and 0 be the initial state of F. Set ( 0, (z, t)) : 0 for all (z, t) X A\xj U(xj), ( 0, (xj, v)) : 1(xj) for all v U(xj). Where 1(xj) is the state of F, when observer B detects a stable combination with xj. When both B and F are at initial states, the controller C(xj, xi, W) directly applies the external input v to g, thus set ( 0, (z, v)) : v for all (z, v) X A. (ii) When the observer B det ects a stable combination of g with the generalized state xj, suppose the external input switches to a character w W. We choose a character uj U(xj) and set ( ( xj), (xj, t)) : uj for all t U(xj). In this way, the machine g lingers in the state xj when the external input switches to a character of W. Hence, the fundamental mode operation of the machine is guaranteed. Then the control unit F will generate an input string u=u1u2...ur to drive the machine g to the

PAGE 49

49 generalized state xi. Since we have a output feedback trajectory {S0, S1, ..., Sp}, we need P new states for F, where P = # xS0 + # xS1 # xSp Denote the state of F as k(xj, w, x), where x xSk and k = 1, ..., p. When the input character switches to w, the c ontrol unit F moves to the state 0(xj, w, xj) and it begins to generate the first input character u0 to feed g, where u0 A is an character that satisfies (xj, u0) S0. To implement this, we set ( 1(xj), xj, w) : 0(xj, w, xj) for all w W; ( 1(xj), xj, v) : 1(xj) for all v U(xj) \ W; ( 1(xj), xj, v) : 0 for all v U(xj) W; ( 0(xj, w, xj), x, v) : u0 for all (x, v) X A. After u0 is applied to g, the machine will move to a gene ralized stable combination with a generalized state x1xS1. After the observer B detects th is transition, the control unit F moves to the next state 1(xj, w, x1) and generates the ne xt input character u1 to the machine g. The process continues similarly until xi is reached. Then at the step k {1, 2, ..., p} the function and must be defined as follows ( k-1(xj, w, xk-1), xk, w) : k(xj, w, xk), ( k(xj, w, xk), x, v) : uk for all (x, v) X A. At the k=p step, the machine g reaches a state xpxSp. Set sg(xp, up) : xi, where up is an character satisfies (xp, up) Sp. This is accomp lished by setting ( p(xj, w, xi), xk, w) : p+1(xj, w, xi),

PAGE 50

50 ( p+1(xj, w, xi), z, t) : for all (z, t) X A\W. ( p+1(xj, w, xi), x, v) : up for all (x, v) X A. As long as the external input remains as a ch aracter in set W, th e machine will linger in the stable combination (xi, up). If the external input is no long er belongs to W, the controller returns to the initial state We build the controller as well as prove that statement (b) implies statement (a) as above. Conversely, assume part (a) is valid. Let 0 be the initial state of the controller C and let C( x, u) be the output value produ ced by the controller C when it is at the next stable state corresponding to its state g is at the state x and the ex ternal input is u. By assumption, there is an external input value w that induces the controller C to ge nerate an input string u0u1...up for the machine g from the generalized state xj to the generalized state xi via deterministic transition. The first char acter of this input string is u0 = C( xj, u). Define the set S0 : {(xj, u0)}. Let sg be the generalized stable recursion function of g. when the input from the controller to g changes to u0, g moves to a generalized stable combination with one of the states of the set s(xj, u0) s[S0]. When this state is reached by g the controller C detects the new state and controller moves to its own next stable state. Let (x, u0) be the next stable state of the controlle r and let u1 C( (x, u0), x, w) A be the output character generated by the controller once C reaches (x, u0). Define the set S1 : {(x, C( (x, u0), x, w)) : x s(S0)}. Continue operating like that until the set Sk, k > 0, is defined. Bu ild a new set by setting

PAGE 51

51 Sk+1 : {(x C( (x uk), x w)) : x s(Sk)}. By assumption, the controller C drives g to the state xi through deterministic transitions. Consequently, there exists an integer p such that s(Sp) xi. Then, the list S0, S1, ..., Sp forms a output feedback trajectory. So, th e existence of a output feedback controller C that drive g from xj to xi through deterministic transitions, implie s the existence of a output feedback trajectory S0, S1, ..., Sp from xj to xi. Namely, part (a) implies part (b). This completes the proof. 3.4 Preliminary Generalized Skeleton Matrix Using the algorithm in the above proof of Proposition 3-16, we can check the basic connection between any two genera lized states of the machine g, namely, the existence of the output feedback trajectory between any pair of generalized states. If we focus on the stable and detectable reachability properties, then we dont n eed to record all the input strings. Instead, we can use a numerical matrix, which has only entrie s of one and zero, to re present this one-step stable and detectable reachabil ity properties. This numerical matrix can be called preliminary generalized skeleton matrix of the machine g. Afterwards, it is easier to calculate the power of it and obtain the overall preliminary genera lized skeleton matrix. For the machine g with m generalized states, the overall preliminary genera lized skeleton matrix characters all the stable and detectable transitions among the generalized stat es of the machine within m steps. We can use the following algorithm to gradually transfor m the generalized one-step reachability matrix into the preliminary one-step generalized sk eleton matrix. Meanwhile, the machine g is transformed into a deterministic machine on the ge neralized state basis with an output feedback controller C.

PAGE 52

52 An operation involving strings of A+ and zero and 1 should be defined before giving the algorithm. Definition 3-17 Let be a character not included in A. The meet operation between two strings of A+ and zero and 1 is defined as follow: 0 0 : 0, 0 1 1 0 : 0, 1 1 : 1, 0 a a 0 : 0, 1 a a 1 : for all a A+. The meet of two vectors with r 1 components is defined entr ywise as the vector of the meets of the corresponding components. Algorithm 3-18 Let g be an asynchronous machine w ith the generalized state set X = {x1, ..., xm} and let ( g) be the generalized stable reachability matrix of the generalized machine g. Step 1: Transpose the matrix ( g) and denote the resulting matrix by ( g). Step 2: Replace all entries of N in the matrix ( g) by the number 0; denote the resulting matrix by K1. Step 3: Perform (a) below for each i,j = 1, ..., m; then continue to (b): (a) If K1 ij includes a string of A+ that does not appear in any other entry of the same column j, then replace entry K1 ij by the number 1. Otherwise, let the entry K1 ij remain. (b) Set k : 1 and denote the resulting matrix by K(k). Step 4: If all entries of row k of the matrix K(k) are 1 or 0, then set K(k+1) : K(k) and set k : k+1. Step 5: If k = m + 1, then set K( g : K(k) and terminate the algorithm. Otherwise, go to step 6.

PAGE 53

53 Step 6: Perform the following operations: (a)If there is a character u A that appears in row k of K(k), then let j1, ..., jq be the columns of row k of K(k) that includ e u. Denote by J(u) the meet of rows j1, ..., jq of the matrix K(k). (b) If J(u) has no entries other than 0 or 1, then delete u from all entries of row k of the matrix K(k); set all em pty entries, if any, to the value 0. Continue to (c). (c) If J(u) has no entries of 1, then retu rn to Step 3. Otherwise, continue to (d). (d) If J(u) has entries of 1, then let j1, ..., jr be the entries of J(u) having the value 1. Let S(k) be the set of rows of K(k) that consists of row k and of every row that has the number 1 in row k. In the matrix K(k), perform the following opera tions on every row of S(k): Delete from the column all occurrences of input characters that appear in columns j1, j2, ..., jr of the row. Replace rows j1, j2, ..., jr of the column by the number 1. If any entries of K(k) remain empty, then replace them by the number 0. Return to Step 4. The final resulting matrix K1( g is called the preliminary gene ralized skeleton matrix of the machine g. Definition 3-19 The outcome K1( g) of Algorithm 3.23 is defined as the preliminary generalized skeleton matrix of th e generalized asynchronous machine g.

PAGE 54

54 Note that this preliminary generalized skeleton matrix K1( g) of the generalized machine g is similar to the one-step fused skeleton matrix ( ) of an asynchronous machine in Geng and Hammer (2005). Example 3-20 Consider the machine and the generalized machine g of Example 310. The generalized stable reachability matrix g) of the machine g is ( g ) = aabacabaaca abababacacabacac NN bbababbac bababaca ccacabcac cabacaca aabacabaabc acaabababac cN bbabcbabbac babababcbaca cacabcaccaba cabccaca aacabaaca abacacac N c{babcbacbacababa}{}cacaccabacaca aababaaca ababacab NN{}bbababbababaca {}cacabcabacaca aacabaaca abacacac NN {}babacbababaca{} ccacaccabacaca. Applying the Algorithm 3-18 to the matrix ( g), we can obtain the preliminary generalized skeleton matrix K1( g of the machine g is K1( g) = 10011 11011 10111 10011 10011

PAGE 55

55 Proposition 3-21 Let g be a generalized machine w ith the preliminary generalized skeleton matrix K1( g and let xi and xj be two generalized states of g. Then the following two statements are equivalent. (a) There exists an output feedback trajectory from xj to xi. (b) The (i, j) entry of K1( g is 1.

PAGE 56

56 CHAPTER 4 MODEL MATCHING FOR INPUT/OUTPUT ASYNCHRONOUS MACHINES WITH RACES In the present chapter we start to address the model-matching problem for input/output asynchronous machines with critical races. In la st chapter the reachabil ity properties of an input/output asynchronous machine with critical races has been discussed and corresponding generalized machine has been derived. The newl y defined generalized machine with related generalized state set and genera lized functions of the machin e could be controlled as a deterministic machine without critical races. Th e control of this kind of asynchronous machines has been discussed in Geng and Hammer (2005). T hus, the controller will be designed to correct the input/output machine under th e configuration of Fig. 2-3, so that the closed-loop system possesses an equivalent input/output behavi or as that of a prescribed model. Since we are discussing the input/output mach ines, we first study the equivalent list of the generalized machine g, with respect to the model Then we work on the sufficient and necessary conditions of the existe nce of the output feedback contro llers so as to solve the model matching problem. When such a controller exis ts, we provide an algorithm to construct the controller. Finally, an example is presented to illustrate how the control system operates. 4.1 Model Matching Problem As we mentioned before, the desi gn of a controller to eliminat e the effects of critical races of an existing asynchronous machine is calle d the Model-Matching Pr oblem. Specifically, the formal statement of the model matc hing problem is as follows. Let be a machine that exhibits undesirable behavior. Assume that the desirabl e behavior is specifi ed by an asynchronous machine The machine is called the model. Our objective is to design a controller C for which the behavior of the closed loop system c simulates the behavior of the model It is

PAGE 57

57 indicated in Kohavi (1970) th at the practical performance of an asynchronous machine is determined by its stable-state behavior. Thus, the stable-state behavior of c need to be equivalent to the stable-state behavior of Let us first introduce th e classical notions of equivalence. Definition 4-1 Let = (A, Y, X, x0, f, h) and = A, Y, X f h be two machines having the same input and the same output sets, and let |s and |s be the stable state machines induced by and respectively. Two states x X and X are stably equivalent (x ) if the following conditions are true: When |s starts from the state x and |s starts from the state then (i) |s and |s have the same permissi ble input strings; (ii) |s and |s generate the same output string for every permi ssible input string. The two machines and are stably equivalent if their initial stat es are stably equivalent, i.e., if x0 Note that two machines = (A, Y, X, x0, f, h) and = A, Y, X f h that are stably equivalent appear identical to a user. Definition 4-2 Given a machine and find necessary and sufficient conditions for the existence of a controller C such that c is stably equivalent to and operates in fundamental mode. If such a controller C exis ts, derive an algorithm for its design. In this dissertation, the model matching probl em concentrates on matching the stable input/output behavior of the model. The model can be taken as a st ably minimal machine. Let g be a generalized machine with the generalized state set {x1, x2, ..., xm} which is induced from the machine Our objective is then to match the i nput/output behavior of the generalized machine g and the model

PAGE 58

58 Next, let us introduce a notion which underlies the solution of the model matching problem for asynchronous machines. Given two sets S1 and S2 and a function g : S1 S2, denote by gI the inverse set function of g; i.e., for an element s S2, the value gI (s) is the set of all elements S1 that satisfies g( ) = s. Definition 4-3 Let = (A, Y, X, s, h) and = A, Y, X f h be two machines having the same input and the same output sets. Let g = (A, Y, X, sg, hg) be a generalized machine induced from the machine The state set X of consist of the q state 1, ..., q Define the subsets Ei : hg Ih ( i) X, i = 1, ..., q. Then, E( g, ) : {E1, ..., Eq} is the output equivalence list of g with respect to An equivalence list is characterized by th e following property: the value of the output function hg of g at any state of the set Ei is equal to the value of the output function h of at the state i. The members of an output equivalence list are not necessarily disjoint sets. Definition 4-4 Let g be a generalized machine with generalized state set X = {x1, ..., xm}, and let and be two nonempty subsets of X. The reachability indicator r( g, ) is defined as 1 if every element of can reach an element of through a chain of stable and detectable transitions; otherwise, r( g, ) = 0. Example 4-5 Let g be a generalized machine with generalized state set X = {x1, x2, x3} and the preliminary generalized skeleton matrix is K1( g

PAGE 59

59 K1( g = 111 111 001 Let = {x1, x2} and = {x2, x3} be two state subsets. Then r( g, ) = 1. Definition 4-6 Let g be a generalized machine with generalized state set X = {x1, ..., xm}, and let ..., q be a list of m 1 nonempty subsets of X. The fused skeleton matrix ( g, ) of is an q q matrix whose (i,j) entry is ij( g, ) = r( g, i, j). Example 4-7 Consider the machine g and the two state subsets and in the Example 4-5. Let be a list of subsets of X. Then the fused skeleton matrix ( g, ) of is ( g, ). ( g, ) = 11 01 Definition 4-8 Let ..., q and W={W1, ..., Wq} be two lists of subsets of X. The length of the list is the number q of its members. Th e list W is a subor dinate list of the list denoted as W if it has the same length q as the list and if Wi i for all i=1, ..., m. A list is deficient if it includes the empty set as one of its members.

PAGE 60

60 4.2 Existence of Controllers Next, we give the condition of the exis tence of a controlle r C for which c is stably equivalent to a specified model Given two p q numerical matrices A and B, the expression A B indicates that every entry of the ma trix A is not less than the corresponding entry of the matrix B, i.e., Aij Bij for all i = 1,..., p a nd for all j = 1, ..., q. Lemma 4-9 Let g=(A, Y, X, x0, sg, hg) and =(A, Y, X s h ) be asynchronous machines, where is stably minimal. Let X = { 1, ..., q} be the state set of where the initial condition of is 0 = d. Assume that there is a controller C for which c is stably equivalent to and operates in fundamental mode. The n, there is a non-def icient subordinate list of the output equivalence list E( g, ) for which ( g, ) K( ) and x0 d. The proof of the above Lemma 4-9 is similar to the proof of the Lemma 4.11 in Geng and Hammer (2005). The difference is that a generalized machine appears here instead of a regular machine Recall that all the underlying states of a burst state or a common output state in the generalized machine g are the same states in the original machine and those underlying states have the same output value. Thus, when applying a real input character u to the generalized machine g at a generalized state x it is the same to apply this input character u to the real machine at any underlying state of that generalized state x The real machine will generates the same output value as the generalized machine g does. The condition of Lemma 4-9 is not only a necessary condition, but also a sufficient condition for the existence of a controller to so lve the model matching problem. The inequality ( g, ) K( ) guarantees that the corr esponding output values of the two machines match. If the model has a stable transition from a state i to state j, then the machine g has a

PAGE 61

61 stable and detectable trans ition from every state in i to a state in j. Thus, we only need to construct a controller C which ge nerates the input string that takes g from a state in i to a state in j. This controller should be a combinati on of an observer a nd a control unit as described in Figure 2-3. Theorem 4-10 Let g=(A, Y, X, x0, sg, hg) and =(A, Y, X s h ) be stably reachable asynchronous machines, where is stably minimal. Let X = { 1, ..., q} be the state set of where the initial condition of is 0 = d. Then the following two statements are equivalent. (i) There is a controller C for which c = where c operates in fundamental mode and is well posed. (ii) There is a non-defici ent subordinate list of the output equivalence list E( g, ) such that ( g, ) K( ) and x0 d. Moreover, when (ii) holds, th e controller C can be desi gned as a combination of an observer B and a control unit F as depicted in Figure 2-3 and the obser ver is given by Equation 2-4. Proof The generalized machine g has a generalized state set X = {x1, x2, ..., xt}. All the underlying states of the generalized states {x1, x2, ..., xt} in this set X are the same states in the set X of the original machine Since all the real states incl uded in a burst state or in a common output state will work with the same input value, the same input value can be used on the real machine. Furthermore, the output of a bu rst state or a common output state is the same as that of the underlying states. Hen ce, the operation of the real machine is as same as before the

PAGE 62

62 introducing of the generalized machine. Thus, we can use the same method in Geng and Hammer (2005) on the generalized machine, i.e., to find a controller for g. The Lemma 4-9 indicates that statement (i) impl ies statement (ii). Now let us assume that (ii) is valid. Let ={ ..., q} be a subordinate list of E( g, ) satisfying ( g, ) K( ) and x0 d. Using we build a controller C for which the closed loop system c of 1.1 is stably equivalent to the model is well posed, and operates in fundamental mode. The controller C is a combination of an observer B and a control unit F as depicted in Figure 2-3. The observer B is given by Proposition 3-16, so we complete the proof by constructing the control unit F. Recall that the control unit F is an asynchronous machine F = (A X, A, 0, ) with two inputs: the external input v A and the output X of the observer B. To complete the construction of the controller C, we need to derive the recursion function and the output function of the unit F. Assume that is at the stable state i and that g is at a stable state i. Note that i is either the initial condition x0d of or the outcome of a dete ctable stable transition; is either the ini tial condition x0d of g or the outcome of a detectable stable transition. Assume the external input character switche s to the character w. Then the model moves to its next stable state s ( i, w)= j. Recall that sg is the generalized stab le recursion function of g. The inequality ( g, ) K( ) implies that there is an input string u=u1u2...ur such that the stable combinations ( u1), (sg( u1), u2), (sg( u1u2 ur-1), ur) are all detectable, and such that the state xr : sg( u) belongs to j. Define the intermediate states X1 : sg( u1), x2 : sg(x1, u2), xr = sg(xr-1, ur). (4-1)

PAGE 63

63 As the combinations (xi, ui), i= 1, r, are all stable and de tectable combinations, the states x1, xr appear as output values of the obs erver B immediately after having been reached by g. The situation can be depicted as follows. : i j g: i xr j Figure 4-1. Equivalence of two asynchronous machines and g The objective of the control unit F is to generate the string u = u1u2 ur and apply it as input to the real machine This action achieves model matchi ng for the present transition for the following reason. The string u drives the system g to the stable state xr, which then becomes the next stable state of the closed loop system c. Then, since h(xr) = h[ j] = h ( j), the next stable state of c produces the same output value as the model to match the models response. Note that the control unit F must operates in a fundamental mode, so the whole system must have reached a stable combination before th e F generates the next input character for g. Then, we construct a recursion function for F to implement the above behavior. Keeping in mind the requirement of fundamental mode operation of the machines, we need to make sure that the control unit F generates the string u one character at a time and at each step that the composite system has reached a stable combinati on before generating the next character. As the string u has r characters, the control unit F needs r states to accomplish this: 1( i, w), r( i, w). The resulting set of states w u1u2 ur

PAGE 64

64 i, w) : { 1( i, w), r( i, w)} is associated with the state i of the state of and the external input character w. To account for all possible such combinations, the control unit F needs the state set : 0 { i-1, i w i, }, where 0 is the initial state of F. We shall use the following notation. For a state x of the machine g, let U(x) : {a A : sg(x, a) = x} be the set of all input characters that form stable combinations with x. Similarly, for a state of the machine let U ( ) : {a A : s ( a) = } be the set of all input characters that form stable combinations with Recalling that the control unit is an i nput/state asynchronous machine F = (A X, A, 0, ). The recursion function of F is a function X and the output function of F is denoted by X A. Referring to the confi guration (2.24), the output X of the observer B is one of the inputs of F, a nd the other input is th e external input v W. Then, and are defined as follows. (i) Let the closed loop system c be at a stable combination, where g is at the state namely, the real machine is at one of the underlying st ates of the generalized state The observer B has he output value = and control unit F is at a state Select an element c U( and define ( ,( ,b)) : for all b U ( i),

PAGE 65

65 ( ,( ,a)) : c for all a A. This guaranties that the closed loop system c and the model operate in fundamental mode. (ii) Suppose that the external input switc hes to a character w satisfying s ( i, w) = j. Then, the control unit F needs to generate the input string u = u1u2 ur, to take g through the chain of states x1, xr to the state xr j. Meanwhile the output of the observer B will track the state sequence x1, xr. Thus, the recursion function is defined as follows. w)) : 1( i, w), k( i, w), xk, w)) : k+1( i, w), k = 1, 2, r-1, k( i, w), z, b)) : uk, for any (z,b) X k = 1, 2, r. (iii) In response to the last input character ur produced by F, the machine g reaches the desired stable state xr, which implies the real machine reaches one of the underlying states of the generalized stable state xr. The machine g needs to remain at the state xr until the external input switches from w to another character. Then, choose an element v U(xr) and assign r( i, w), xr, w)) : r( i, w), r( i, w), z, b)) : v, for all (z,b) X This completes the construction of the control unit F. Note that whenever the machine g is at a generalized stat e x, the real machine is at an corresponding underlying state x of this generalized state x and hg(x) = h(x ). This construction achieves model matching of the generalized machine g to the model with fundamental model operation as well. This concludes the proof.

PAGE 66

66 The proof of Theorem 4-10 includes an algorith m for the construction of a controller C solving the model matching problem. Then, we use the Algorithm 4.14 in Geng and Hammer (2005) to build a list that satisfies condition (ii) of th is theorem whenever such a list exists. This algorithm and Theorem 4-10 give a comprehe nsive and constructive solution of the model matching problem. A recursive process is used in the algorithm to build a decreasing chain of subordinate lists. The last list in this chain, if not deficient, sati sfies condition (ii) of Theorem 410; if the last list of the chain is deficient, then there is no controller that solves the requisite model matching problem. Let g=(A, Y, X, x0, sg, hg) and =(A, Y, X s h ) be the machines of Theorem 4.8, let E( g, ) = {E1, ..., Eq} be their output equiva lence list, and let K( ) be the skeleton matrix of The following steps yield a decreasing chain (0) (1) ... (r) of subordinate lists of E( g, ). The members of the list (i) are denoted by 1(i), ..., q(i); they are subsets of the state set X of g. Algorithm 4-11 Let g=(A, Y, X, x0, sg, hg) and =(A, Y, X s h ) be the machines of Theorem 4-10, let E( g, ) = {E1, ..., Eq} be their output equi valence list, and let K( ) be the skeleton matrix of The following steps yield a decreasing chain (0) (1) ... (r) of subordinate lists of E( g, ). The members of the list (i) are denoted by 1(i), ..., q(i); they are subsets of the state set X of g. Start Step: Set (0) := E( g, ). Recursion Step: Assume th at a subordinate list (k) = { 1(k), ..., q(k)} of E( g, ) has been constructed for some integer k 0. For each pair of integers i,j {1, ..., q}, let Sij(k) be

PAGE 67

67 the set of all states x i(k) for which the (i,j) element of ( g, j(k)) is 0; i.e., Sij(k) consists of all states x i(k) for which there is no chain of stable and detectable transi tions to a state of j(k). Note that Sij(k) may be empty. Then set T ij (k):= S ij (k) if K ij ( )=1; if K ij ( )=0. Now, using \ to denote set difference, define the subsets Vi(k) := j=1,...,qTij(k), i = 1, ..., q i(k+1) := i(k)\Vi(k), i = 1, ..., q Then, the next subordinate list in our decreasing chain is given by (k+1) := { 1(k+1), ..., q(k+1)}. Test Step: the algorithm terminates if the list (k+1) is deficient or if (k+1) = (k); otherwise, repeat the Recursi on Step, replacing k by k+1. 4.3 A Comprehensive Exampl e of Controller Design Consider an asynchronous machine = (A, Y, X, x0, f, h) with the input alphabet A={a, b, c}, the output alphabet Y={0, 1, 2}, and the state set X={x1, x2, x3, x4}. There is a critical race pair (x1, c) in the machine (Tables 2-1, Figure 2-1) Let another machine = (A, Y, X 0, f h ) be the desired model (Table 4-1, Figure 4-2). The initial state of is x0 = x1 and the initial state of is 0 = 1. After introducing a burst state x5 = {x2, x3}, we have the generalized machine g of able 4-2).

PAGE 68

68 Table 4-1. Transition table of the machine 3 c 1 2 b a b a a c Figure 4-2. State flow diagram of the machine Table 4-2. Stable state transition table of the machine g a b c Y x1 x1 x4 x5 0 x2 x1 x4 x2 1 x3 x1 x3 1 x4 x1 x4 2 x5 x1 x5 1 The initial state of g is x0 = x1. From Table 2-1 and Table 42., the output equivalence list is E( g, ) ={E1, E2, E3}, where E1={x1}, E2={x2, x3, x5}, E3={x4}. The preliminary generalized skeleton matrix of the generalized machine is K1( g) and the skeleton matrix of the model is K( ). a b c Y 2 1 2 1 3 3 3 2

PAGE 69

69 K1( g) = 10011 11011 10111 10011 10011 K( ) = 111 111 001 The subordinate list of the output equivalence list E( g, ) is x1 x2, x3, x5 x4 The fused skeleton matrix is ( g, ) that satisfies ( g, ) = 111 111 111 111 111 001 = K( ) Thus, there exists a controller C to turn the machine into a deterministic machine that matches the model We have a generalized machine g = (A, Y, X, x0, sg, hg) with the state set X ={x1, x5} and a subordinate list that satisfies ( g, ) K( ) and x1 According to the process of c onstruction of the controller C that is described before, we derive the control unit F and combine it with the observer B of Equation 2-4. Then, we have the corrective controller C as shown in Figure 2-3.

PAGE 70

70 Recall that the initial state of g is x0 = x1 and the initial state of is 0 = 1. Maintain the external input character as a to keep at the state 1 and maintain the external input character as a to keep g at the state x1. Now we construct F as follows. Set the initial state of F to 0. Denote the states of the observer B by {x1, x2, x3, x4, x5} and set the initial state of B to x1. Thus, we have U(x1) = {a} and U ( 1) = {a} and F: ( 0, (x1, a)) : 0, ( 0, (x1, a)) : a. B: x1, (a, x1 for all Y. Assume then the external input character sw itches from a to b. For the machine s ( 1, b) = 2 and h ( 1) = 0 and h ( 2) = 1, so this transition is detect able. In order to simulate this transition, the system g has to move to a state in 2 = x2, x3, x5 Since sg(x1, c)= x5. For the real machine it needs to move to either state x2 or state x3 and it does not matter in which state the really stays. In either case the control unit F needs to generate the character c to serve as input for so that F: ( 0, (x1, b)) (x1, 1, b), ( (x1, 1, b), (x1, b)) c. B: ( x1, (c, ) x 5 for = 01; x 1 otherwise. F: ( (x1, 1, b), (x5, b)) (x1, 1, b), ( (x1, 1, b), (x5, b)) c. B: x5, (c, x5 for all Y.

PAGE 71

71 Now consider the other option: the machine g is at a stable combination with the state x1 1 and is at a stable combination with the state 1, when the external input character switches from a to c. For the machine s ( 1, c) = 3 and h ( 1) = 0 and h ( 3) = 2. Thus this transition is detectable as well. To simulate this transition, the machine g needs to move to a state in 3={x4}, i.e. to x4 So does the real machine Since s(x1, b) = x4, the control unit F needs to generate the character b and this leads to the following F: ( 0, (x1, c)) (x1, 1, c), ( (x1, 1, c), (x1, c)) b. g: s(x1, b) = x4, (x1, b) = h(x1)h(x4) = 02 B: (x1, (b, ) x 4 for = 02; x 1 otherwise. Then, assume the machine stays at a stable combination with the state x 2 and the model is at a stable comb ination with the state 2, when the external input character switches to a. The models response is s ( 2, a) = 1 so F needs to generate an input character a to drive to a state in 1 ={x1}. So we have F: ( (x1, 1, b), (x2, a)) (x2, 2, a), ( (x2, 2, a), (x2, a)) a. g: s(x2, a) = x1, (x2, a) = h(x2)h(x1) = 10 B: (x2, (a, ) x 1 for = 10; x 2 otherwise.

PAGE 72

72 Another possibility is that is in a stable combination with the state x 2 and the model is at a stable comb ination with the state 2, when the external input character switches from b to a. The models response is s ( 2, a) = 1 so F needs to generate an input character a to drive to a state in 1 ={x1}. Then F: ( (x1, 1, b), (x3, a)) (x3, 2, a), ( (x3, 2, a), (x3, a)) a. g: s(x3, a) = x1, (x3, a) = h(x3)h(x1) = 10 B: (x3, (a, ) x1 for = 10; x3 otherwise. Assume further that g is in a stable combination with the state x 2 and the model is at a stable combination with the state 2, when the external input char acter switches from b to a. This case is a combination of the above two cases. Thus, F will ge nerate an input a to drive to a state in 1 ={x1}. F: ( (x1, 1, b), (x5, a)) (x5, 2, a), ( (x5, 2, a), (x5, a)) a. g: s(x5, a) = x1, (x5, a) = h(x3)h(x1) = 10 B: (x5, (a, ) x1 for = 10; x5 otherwise. This completes the construction of the corr ective controller C for the model matching problem. The state set of the control unit F is = { 0, (x1, 1, b), (x1, 1, c), (x2, 2, a), (x3, 2, a), (x5, 2, a)}.

PAGE 73

73 The above state set can be reduced to three stat es and F can be depi cted by Figure 4-3 (the notation near the arrows indicates the informati on of (output of the observer B, input of c)/output of F). 2 1 0 (x1, a)/a (x1, c)/b (x5, a)/a (x3, a)/a (x2, a)/a (x1, b)/c Figure 4-3. State transitions diagram of control unit F The observer B = (A Y, X, Z, z0, I) is defined according to Equation 2-4 and described by Figure 4-4. The controller is the comb ination of F and B according to Figure 2-3. x3 x2 x1 x4 (a,0) x5 (c,1) (b,2) (c,1) (c,1) (a,120) (a,120) (b,102) (c,01) (b,02) (a,20) (a,120) Figure 4-4. State transitions diagram of observer B

PAGE 74

74 CHAPTER 5 SUMMARY AND FUTURE WORK In the present work, the feedback controllers are introduced to correct the faulty behavior of asynchronous machines. When critical races af flict the asynchronous machine, the existence of the controllers offer a solution to eliminate th e effects of the critical races while controlling the machine to match a desirable race-free m odel. We call the problems as Model-Matching Problems. This approach disclose s an interesting and constructive field in which many related topics are worth investigating. The solutions have been obtained to th e Model-Matching Problem for asynchronous input/output machines. The concept of generalized state has been used to describe a persistent state of the machine about which only partial information is available. The generalized state allows us to use the partial inform ation available about the state of to continue controlling the machine as best as possible toward the goal of achieving model matching, while taking best advantage of the available information about The results of the Model-Matching Problem include necessary and sufficient c onditions for the existence of the controller, and algorithms for its construction whenever a controller exists. The following list is the possible topics for future research: (i) The algorithm for transforming the generalized stable reachability matrix into skeleton matrix has been proposed in chapter 3. However, be fore that we need to raise the power of the generalized one-step reachability matrix, whic h requires a large amount of computation. When the state set of the machine is large, this issue is more significant. If we can obtain a likely onestep skeleton matrix from the one-step reachability matrix and raise the power of this numerical skeleton matrix instead, then the calculation is mu ch simpler. But we need spend time to keep all the information that we need in the transforming and computation. (ii) The introduction of generali zed state transforms an async hronous machine with critical races into a deterministic machine. However, the state space is enlarged depending on the number of critical races. If we can minimize th e state space, then it will increase the speed of computation significantly too.

PAGE 75

75 (iii) Although we can construct an output fee dback controller for the closed loop system to eliminate the effects of critical race whenever a controller exists this controller may not be minimal. We can also work on this issue to fi nd out a good strategy to minimize the controller. (iv) The present discussion excludes the exis tence of infinite cycles in the existing machine. We shall deal with the situation when both critical races a nd infinite cycles occur in the defective machine. The controller constructed in the present work ensures that the closed-loop system in Figure 1-1 and Figure 2-3 operates in fundamental mode. The input changes were only allowed during stable combinations. This requires the re striction of the contro lled machine to those without any unstable cycles; otherwise the contro ller cant do anything to correct the machine once the machine enters a cycle.

PAGE 76

76 LIST OF REFERENCES Alpan, G. and Jafari, M.A., Synthesis of a closed-loop combin ed plant and controller model, IEEE Trans. on Systems, Man and Cybernetics vol. 32, no. 2, 2002, pp. 163-175. Barrett, G., and Lafortune, S., Bisimulation, the supervisory control problem, and strong model matching for finite state machines, Journal of Discrete Event Dynamic Systems Volume 8, number 4, 1998, pages 377-429. Chu, T., Synthesis of hazard-free co ntrol circuits from asynchronous finite state machines specifications, Journal of VLSI Signal Processing vol.7, no.1-2, 1994, p. 61-84. Datta, P.K., Bandyopadhyay, S.K. and Choudhury, A.K., "A graph theoretic approach for state assignment of asynchronous sequential machines International Journal of Electronics vol.65, no.6, 1988, p. 1067-75. Davis, A., Coates, B. and Stevens, K., The post office experien ce: designing a large asynchronous chip, Proceeding of the Twenty-Sixth Hawaii International Conference on System Sciences vol.1, pp. 409-418. Dibenedetto, M.D., Nonlinear strong model matching, IEEE Trans. Automatic Control vol. 39, 1994, pp. 1351-1355. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., Model matching for finite state machines, Proceedings of the IEEE C onf. on Decision and Control vol. 3, 1994, pp. 3117-3124. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., Strong model matching for finite state machines with nondeterministic reference model, Proceedings of the IEEE Conf. on Decision and Control vol. 1, 1995, pp. 422-426. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., Strong model matching for finite state machines Proceedings of European Control Conference vol. 3, 1995, pp. 2027-2034. Dibenedetto, M.D., Sangiovanni-Vincentelli, A., and Villa, T., Model matching for finite-state machines, IEEE Transactions on Automatic Control vol. 46, no. 11, 2001, pp. 17261743. Eilenberg, S., Automata, Languages, and Machines, Academic Press, NY, 1994. Furber, S.B., Breaking step the return of asynchronous logic, IEE Review 1993, pp. 159-162. Fisher, P.D., and Wu S. F., Race-free state assignments for synthesizing large-scale asynchronous sequential logic circuits, IEEE Transactions on Computers vol. 42, no. 9, 1993, pp. 1025-1034.

PAGE 77

77 Geng, X., Model matching for asynchronous sequential machines, Ph.D. Dissertation, Department of Electrical and Computer Engin eering, University of Fl orida, Gainesville, FL 32611, USA, 2003 Geng, X., Hammer, J., Input/output control of async hronous sequential machines, IEEE Trans. on Automatic Control Vol. 50, No. 12, pp 1956-1970. Hammer, J., On some control problems in molecular biology, Proceedings of the IEEE Conference on Decision and Control Vol. 4, 1994, pp. 4098-4103. Hammer, J., On the modeling and control of biological signaling chains, Proceedings of the IEEE Conference on Decision and Control Vol. 4, 1995, pp. 3747-3752. Hammer, J., On corrective control of sequential machines, International Journal of Control Vol. 65, No. 65, 1996, pp. 249-276. Hammer, J., On the control of incompletely described sequential machines, International Journal of Control Vol. 63, No. 6, 1996, pp. 1005-1028. Hauck, S., Asynchronous design methodologies: an overview, Proceedings of the IEEE vol. 83, no. 1, 1995, pp. 69-93. Higham, L. and Schenk, E., The parallel asynchronous recursion model, Proceedings of the IEEE Symposium on Parallel and Distributed Processing 1992, 310. Holcombe, W.M.L, Algebraic Automata Theory, Cambridge University Press New York, 1982. Hubbard, P. and Caines, P.E., Dynamical consistency in hierarchical supervisory control, IEEE Trans. on Automatic Control vol. 47, no. 1, 2002, pp. 37-52. Huffman, D.A., [1954a] The synthesis of sequen tial switching circuits, J. Franklin Inst. vol. 257, pp. 161-190. Huffman, D.A., The synthesis of sequen tial switching circuits, J. Franklin Inst ., vol. 257, 1954, pp. 275-303. Huffman, D.A., The design and use of hazard-free switching networks, Journal of the Association of Computing Machinery vol. 4, no. 1, 1957, pp. 47-62. Isidori, A., The matching of a prescribed linear input -output behavior in a nonlinear system, IEEE Trans. Automatic Control vol. AC-30, 1985, pp. 258-265. Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., Synthesis of FSMs : Functional Optimization, Boston, MA: Kluwer, 1997.

PAGE 78

78 Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., Implicit computation of compatible sets for state minimization of ISFSMs, IEEE Transactions on Computer Aided Design vol. 16, 1997, pp. 657-676. Kam, T., Villa, T., Brayton, R., and Sangiovanni-Vincentelli, A., Theory and algorithms for state minimization of nondeterministic FSMs, IEEE Transactions on Computer Aided Design vol. 16, 1997, pp. 1311-1322. Kohavi, Z., 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., Supervisory control of hybrid systems, Proceedings of the IEEE vol. 88, no. 7, 2000, pp. 1026-1049. Lavagno, L., Keutzer, K., and Sangicivanni-Vincentelli, A., Algorithms for synthesis of hazardfree asynchronous circuits, Proceedings of the 28th ACM/IEEE Conference on Design Automation 1991, pp. 302. Lavagno, L., Moon, C. W., and Sangiovanni-Vincentelli, A., Efficient heuristic procedure for solving the state assignment proble m for event-based specifications, IEEE Transactions on Computer-Aided Design of In tegrated Circuits and Systems Vol. 14, 1994, pp 45-60. Lin, B. and Devadas, S., Synthesis of hazard-free multilevel logic under multiple-input changes from binary decision diagrams, IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems vol. 14, no. 8, 1995, pp. 974-985. Lin, F., Robust and adaptive supervisory cont rol of discrete event systems, IEEE Transactions on Automatic Control vol. 38, n0. 12, 1993, pp. 1848-1852. Maki, G., and Tracey, J., A state assignment procedure for asynchronous sequential circuits, IEEE Transactions on Computers vol. 20, 1971, pp. 666-668. Marshall, A., Coates, B. and Siegel, F., Designing an asynchronous communications chip, IEEE Design & Test of Computers Vol. 11, no. 2, 1994, pp. 8-21. Mealy, G.H., A method for synthesizi ng sequential circuits, Bell System Tech. J ., vol. 34, 1955, pp. 1045-1079. Moon, C.W., Stephan, P.R., and Brayton, R.K., Synthesis of hazard-free asynchronous circuits from graphical specifications, IEEE International Confer ence on Computer-Aided Design 1991, pp. 322 Moore, B. and Silverman, L., Model matching by state feedback and dynamic compensation, IEEE Trans. Automatic Control vol. 17, 1972, pp. 491-497. Moore, E.F., Gedanken-experiments on sequential machines, Automata Studies, Annals of Mathematical Studies no. 34, Princeton University Press, N.J., 1956.

PAGE 79

79 Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D. and Robinson, P., Self-calibrating clocks for globally asynchronous locally synchronous systems, Proceedings of Inter. Confer. on Computer Design 2000, pp. 73-78. Morse, A.S., Structure and design of linear model following systems IEEE Trans. Automatic Control vol. 18, 1973, pp. 346-354. Murphy T.E., Geng X., and Hammer J., Controlling races in asynchronous sequential machines, Proceeding of the IFAC World Congress Barcelona, July 2002.. Murphy T.E., Geng X., and Hammer J., On the control of asynchronous machines with races, IEEE Transactions on Automatic Control vol. 48, no. 6, pp. 1073-1081. Murphy, T.E., On the control of asynchronous sequential machines with races, Ph.D. Dissertation, Department of El ectrical and Computer Engineering, University of Florida, Gainesville, FL 32611, USA, 1996. Nishimura, N., Efficient asynchronous simulation of a class of synchronous parallel algorithms, Journal of Computer and System Sciences vol. 50, no. 1, 1995, pp. 98-113. Nowick, S.M., Automatic synthesis of burst -mode asynchronous controllers, Ph.D. Dissertation, Stanford University, 1993. Nowick, S.M., and Coates, B., UCLOCK: automated design of high-performance unclocked state machines, ICCD '94. Proceedings., IEEE Inter national Conference on Computer Design 1994, pp. 434. Nowick, S.M., Dean, M.E., Dill, D.L. and Horowitz, M., The design of a high-performance cache controller: a case study in asynchronous synthesis, Proceedings of the 26th Hawaii International Conference on System Sciences 1993, pp. 419. Nowick, S.M. and Dill, D.L., Synthesis of asynchronous state machines using a local clock, IEEE International Conference on Computer Design 1991, pp. 192-197. Oliveira, D.L., Strum, M., Wang, J.C. and Cunha, W.C., Synthesis of high performance extended burst mode asynchronous state machines, Proceedings. 13th Symposium on Integrated Circuits and Systems Design 2000, pp. 41-46 Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., Stability and stabilizability of discrete event systems, J. ACM Vol. 38, 1991, pp. 730-752. Park, S.-J. and Lim, J.-T., Robust and nonblocking supervisor y control of nondeterministic discrete event systems using trajectory models IEEE Trans. on Automatic Control vol. 47, no. 4, 2002, pp. 655-658. Peterson, J.L., Petri Net Theory and The Modeling of Systems, Prentice-Hall, NJ, 1981.

PAGE 80

80 Ramadge, P.J.G., and Wonham, W.M., supervisory control of a class of discrete event processes, SIAM Journal of Control and Optimization vol. 25, no. 1, 1987, pp. 206. Ramadge, P.J.G., and Wonham, W.M., The control of discrete event systems, Proceedings of IEEE vol. 77, no. 1, 1989, pp. 81-98. Cole, R. and Zajicek, O., The expected advantage of asynchrony, Journal of Computer and System Science vol. 51, no. 2, pp. 286-300. Shields, M.W., An Introduction to Automata Theory, Blackwell Scientific Publications, Boston, 1987. Thistle, J. G. and Wonham, W.M., Control of infinite behavior of finite automata, SIAM Journal on Control and Optimization vol. 32, no. 4, 1994, pp 1075-1097. Unger, S. H., Asynchronous Sequential Switching Circuits, Wiley-Interscience, New York, NY, 1969. Unger, S. H., Self-synchronizing circuits and non-fundamental mode operation, IEEE Trans. Computers vol. 26, no. 3, 1977, pp. 278-281. Unger, S. H., Hazards, critical races, and metastability, IEEE Trans. on Computers vol. 44, no. 6, 1995, pp 754-768. Venkatraman, N., On the control of asynchronous sequent ial machines with infinite cycles, Ph.D. Dissertation, Department of Electrical and Computer Engineer ing, University of Florida, Gainesville, FL 32611, USA, 2004 Venkatraman, N., On the control of asynchronous sequent ial machines with infinite cycles, International Journal of Control Vol. 79, No. 07, 2006, pp. 764-785. Yu, M.L. and Subrahmanyam, P.A., A path-oriented approach for reducing hazards in asynchronous designs, Proceedings of Design Automation Conference 29th ACM/IEEE 1992, pp. 239

PAGE 81

81 BIOGRAPHICAL SKETCH Jun Peng was born in Wuhan, Hubei Province, China. She received her bachelors degree in automatic control and masters degree in control theory and cont rol engineering from Shanghai Jiao Tong University, Shanghai, China, in July 2000 and in April 2003, respectively. She began her Ph.D. program in the Department of Electrical and Computer Engineering at University of Florida, Gainesville, FL in August 2003. Her resear ch interests include asynchronous sequential circuits, application of asynchronous seque ntial systems in computer architecture, artificial intelligence and biological systems, control theory, control systems, and applications of control theory in computer co mmunication networks. She received her Ph.D. in August 2007.