Citation
Model Matching for Asynchronous Sequential Machines

Material Information

Title:
Model Matching for Asynchronous Sequential Machines
Creator:
GENG, XIAOJUN ( Author, Primary )
Copyright Date:
2008

Subjects

Subjects / Keywords:
Closed loop systems ( jstor )
Control units ( jstor )
Hammers ( jstor )
Input output ( jstor )
Integers ( jstor )
Machinery ( jstor )
Matrices ( jstor )
Recursive functions ( jstor )
Skeleton ( jstor )
Sufficient conditions ( jstor )

Record Information

Source Institution:
University of Florida
Holding Location:
University of Florida
Rights Management:
Copyright Xiaojun Geng. 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.
Embargo Date:
8/1/2008
Resource Identifier:
53208054 ( OCLC )

Downloads

This item is only available as the following downloads:


Full Text

PAGE 1

MODEL MATCHING FOR ASYNCHRONOUS SEQUENTIAL MACHINES By XIAOJUN GENG 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 2003

PAGE 2

Copyright 2003 by Xiaojun Geng

PAGE 3

To Jun, my loving husband

PAGE 4

ACKNOWLEDGMENTS I would like to gratefully acknowledge the excellent, professional supervision of my advisor, Dr. Jacob Hammer, during my four years at the University of Florida. I thank Dr. John Schueller, Dr. Haniph Latchman, and Dr. Tan Wong, for serving on my Ph.D. supervisory committee and for their continuous help and advice. I am grateful to Dr. Yuguang Fang, who treats me as his colleague, for his friendly advice and assistance. I extend special thanks to my officemate, Niranjan Venkatraman, for interesting and joyful discussions. Last, but not least, I would like to thank my parents, my parents-in-law, and my husband for their understanding and love; and I am grateful to all of my friends for their care and friendship. iv

PAGE 5

TABLE OF CONTENTS Page ACKNOWLEDGMENTS.................................................................................................iv LIST OF TABLES............................................................................................................vii LIST OF FIGURES.........................................................................................................viii ABSTRACT.......................................................................................................................ix CHAPTER 1 INTRODUCTION........................................................................................................1 2 TERMINOLOGY AND BACKGROUND..................................................................8 2.1 Asynchronous Machines and Fundamental Mode..................................................8 2.2 Machine Equivalence and Quotient Machines.....................................................11 2.3 Races and Race Machine Families......................................................................14 2.4 Stable Transition Matrices and Skeleton Matrices...............................................18 3 MODEL MATCHING FOR INPUT/STATE ASYNCHRONOUS MACHINES.....22 3.1 Control Configuration and Model Matching........................................................22 3.2 Basic Considerations on Feedback Controllers....................................................25 3.3 Model Matching for Input/State Machines...........................................................31 3.3.1 Model Matching for a Single Machine.......................................................31 3.3.2 Controlling Races.......................................................................................33 3.4 Example................................................................................................................47 4 MODEL MATCHING FOR INPUT/OUTPUT DETERMINISTIC MACHINES....51 4.1 Detectability and Observers..................................................................................52 4.2 Controller Design and Existence Condition.........................................................60 4.2.1 Extended Skeleton Matrices.......................................................................60 4.2.2 Existence Conditions for Controllers........................................................62 4.3 Constructing Subordinate Lists............................................................................79 4.4 An Example of Controller Design........................................................................86 v

PAGE 6

5 MODEL MATCHING FOR INPUT/OUTPUT ASYNCHRONOUS MACHINES WITH CRITICAL RACES.........................................................................................93 5.1 Characterizations of Observers.............................................................................94 5.1.1 Detectability at Uncertainty Sets................................................................94 5.1.2 Observability for Critical Race Machines..................................................99 5.1.3 Observer Structure....................................................................................103 5.2 Reachability Trees and Skeleton Matrices.........................................................105 5.2.1 Reachability Trees for Machines with Critical Races..............................105 5.2.2 Fine Subtrees and Fine Sets.....................................................................111 5.3 Solutions to Race Control Problems..................................................................118 5.4 Constructing Suitable Lists.................................................................................135 5.5 Analyses of the Theorem and the Algorithm......................................................139 5.6 Examples.............................................................................................................147 6 SUMMARY AND FUTURE RESEARCH..............................................................153 LIST OF REFERENCES.................................................................................................156 BIOGRAPHICAL SKETCH...........................................................................................162 vi

PAGE 7

LIST OF TABLES Table page 3-1. Stable transition table for the machine .................................................................47 3-2. Stable transition table for the machine 1................................................................48 3-3. Stable transition table for the machine 2..............................................................48 4-1. Transition table of the machine .............................................................................87 4-2. Transition table of the machine ............................................................................87 5-1. State transition function and output function of the Machine ............................108 5-2. Transition Table of the machine in Example 5.34............................................147 5-3. Transition Table of the machine in Example 5.35............................................149 5-4. Transition Table of the machine in Example 5.35...........................................149 5-5. Transition Table of the machine in Example 5.36............................................151 5-6. Transition Table of the machine in Example 5.36...........................................151 vii

PAGE 8

LIST OF FIGURES Figure page 1-1. Control configuration for asynchronous sequential machine .................................2 1-2. Control configuration for input/output asynchronous machine .............................3 5-1. Part of the reachability tree of that shows the transitions after the race............109 5-2. These are two spanned trees of the set {a}............................................................112 5-3. Race tree of the machine in Example 5.35........................................................150 5-4. Race tree of the machine in Example 5.36........................................................152 viii

PAGE 9

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 MODEL MATCHING FOR ASYNCHRONOUS SEQUENTIAL MACHINES By Xiaojun Geng August 2003 Chair: Jacob Hammer Major Department: Electrical and Computer Engineering The presence of critical races causes an asynchronous sequential machine to produce unpredicted and undesired behavior. This has been a major problem since the early development of asynchronous sequential machines. Although many methods are available for the design of race free machines, the literature seems to contain no techniques for eliminating the negative effects of races in existing machines. We investigated the problem of eliminating the effects of critical races on asynchronous sequential machines by using feedback controllers. In addition to eliminating the effects of races, these controllers also transform the system to match the behavior of a prescribed model. Our study addressed machines in which the state is provided as output (input/state machines) as well as machines whose state is not provided as output (input/output machines). In the case of asynchronous input/state machines, the controller works as a state-feedback controller. For asynchronous input/output machines, the controller decomposes into two units: an observer and a state-feedback control unit. The observer ix

PAGE 10

estimates the state of the system and provides this information to the control unit, which uses it to correct the behavior of the controlled machine. This decomposition of the controller into an observer and a state feedback control unit generalizes the well-known separation principle of linear control theory to the case of asynchronous machines. The model matching problem is resolved for both deterministic machines and machines affected by a critical race. For asynchronous machines affected by races, the proposed solution of the model matching problem yields a machine whose input/output behavior is deterministic and simulates the behavior of a prescribed desirable model. This strategy overcomes the uncertainty induced by the race and corrects other undesirable aspects of the machine's behavior. The results presented in the dissertation include necessary and sufficient conditions for the existence of controllers as well as algorithms for their construction (whenever the controllers exist). The necessary and sufficient conditions are presented in terms of certain matrix inequalities. x

PAGE 11

CHAPTER 1 INTRODUCTION Asynchronous sequential machines are digital logic circuits in which state changes are not governed by a clock. In different scenarios, they are also referred to as discrete event systems, self-timing logic systems, or asynchronous finite state machines (AFSMs). The design of asynchronous machines has been an active area of research since at least the mid 1950s (Huffman 1954a, 1957), because of the advantages of asynchronous machines over their synchronous counterparts: they tend to be faster and smaller, dissipate less power, lack clock skew problems, are more robust in respect to temperature variations and electromagnetic interactions (Cole and Zajicek 1990, Fisher and Wu 1993, Furber 1993, Hauck 1995, Lavagno et al. 1991, Moon et al. 1991, Nowick 1993, Nowick and Coates 1994, Yu and Subrahmanyam 1992). Moreover, asynchrony is an inherent ingredient in parallel computation systems (Bruschi et al. 1994, Nishimura 1990). Asynchronous design techniques must be used in order to achieve maximum efficiency in parallel computation (Cole and Zajicek 1990, Higham and Schenk 1992, Nishimura 1995). The use of asynchronous machines requires one to address specific design issues, related to potential inconsistencies in the timing of pulses that propagate through the system. These potential timing difficulties are often referred to as "critical races" or "hazards" (Kohavi 1970 and Unger 1995). A critical race is a flaw in the operation of an asynchronous sequential machine; it causes the machine to exhibit unpredictable behavior. Usually, we would consider critical 1

PAGE 12

2 races as being design defects, but they can also occur as a result of system malfunctions or implementation flaws. When a critical race occurs, common practice is to replace the machine with a new one, built from a race-free design. This work proposes a different, and possibly more efficient, alternative: develop feedback control strategies to overcome the effects of the race. A feedback controller C is connected to the faulty machine , with the objective of eliminating the indeterminacy induced by the critical race. This approach is especially valuable in situations where replacement or internal modification of the machine are not possible or not economically favorable. The closed-loop configuration is shown in Figure 1-1. v u y C Figure 1-1. Control configuration for asynchronous sequential machine The goal is to design a controller C so that the external behavior of the closed-loop system c matches that of a prescribed model (i.e., to find a controller C such that c = ). This is, of course, an instance of the Model-matching problem. In the case where exhibits unpredictable behavior due to a critical race, the controller transforms the closed loop system into a deterministic system equivalent to the model . In this sense, the controller corrects the faulty behavior of the machine caused by the critical race. In the case when is an input/state machine ( i.e., when the output of is the state of , the controller C becomes a state-feedback controller. For the more general case of input/output machines (i.e., when the output of is not necessarily the state), it

PAGE 13

3 has been shown that a separation principle is valid for the controller C: it decomposes into an observer and a state feedback control unit , as shown in Figure 1-2. This separation is analogous to the separation encountered in the linear pole assignment problem (Kailath 1980, Chapter 4). The observer estimates the state of the machine from the input/output data of . This estimate of the state is used by the control unit to generate the input sequence of . The combination of and forms a controller, which we denote by C = (,). Both and are asynchronous sequential machines. Our aim is to obtain necessary and sufficient conditions for the existence of a controller C that solves the model-matching problem, and to provide an algorithm for its design. v u y x Controller C Figure 1-2. Control configuration for input/output asynchronous machine The controller C performs two important functions: It eliminates the uncertainty caused by the race, and it assigns to the closed loop system the behavior of a specified model . To explain how the controller corrects the effects of a critical race, we have to mention the two kinds of states that an asynchronous machine can have: stable states – states at which the machine lingers until an input change occurs; and unstable states – states through which the machine passes rapidly, ideally in zero time. When moving from one stable state to another, an asynchronous machine may pass in rapid succession

PAGE 14

4 through several unstable states. Only the outputs generated at the stable states are noticeable to the user, since the machine lingers at them. The controller C then functions by transforming all undesirable stable states of into unstable states of the closed loop system. In this way, the unwanted outputs become unnoticeable, and the machine exhibits the desirable external behavior. The present discussion of the model-matching problem is a continuation of the work of Hammer 1994,1995, 1996a and b; and Murphy 1996. There is a body of work regarding model matching of finite state machines (i.e., synchronous sequential machines) (Dibenedetto et al. 1994, 1995a, 1995b, and Dibenedetto et al. 2001; Barrett and Lafortune 1998). The latter papers, being related to the operation of synchronous machines, do not take into consideration specialized issues involved with the function of asynchronous machines, like the notions of stable states, unstable states, and fundamental mode operation (Chapter 2). It seems that this work is the first to explore the model-matching problem for asynchronous sequential machines and to develop control theoretic methods for the elimination of the undesirable effects of critical races. Besides the elimination of the effects of critical races, at least two additional situations are of interest in model matching for asynchronous sequential machines (Dibenedetto et al. 2001). First, large digital systems are often designed as many subsystems. Later in the design phase, if an error is detected in the behavior of an asynchronous sequential machine, the cost of redoing the entire design is generally prohibitive. A possible solution is an engineering change where design error is remedied by using model matching (Fujita 1993). Second, the controller which will be designed can be deployed before any flaw

PAGE 15

5 develops in the system, to guard against a potential malfunction; it only takes effect when the system starts to produce undesired outcomes. Other than that, the controller is simply transparent. The resulting closed loop system will function properly both before and after a malfunction occurs, contributing to a substantial improvement in reliability. This approach provides a new design option for asynchronous machines in applications where high reliability is a critical requirement. Existing technical literature on the subject of critical races deals mostly with the development of techniques for the design of race free machines. Race free designs can be achieved through appropriate state assignments. The classical techniques for race free state assignments (Huffman 1954a and 1954b) are reviewed in most textbooks on digital circuit design (Kohavi 1970). More recent studies on the subject were done by Chu 1994, Datta et al. 1988, Fisher and Wu 1993, Lavagno et al. 1994, Lin and Devadas 1995, Maki and Tracey 1971, Nowick and Coates 1994, and Nowick and Dill 1991. Methods for evading the race problem by using locally generated clock pulses were introduced by Moore el at. 2000, Nowick and Dill 1991, and Unger 1977. Another approach for optimal state assignment is provided by Fuhrer et al. 1995, who studied the optimal state assignment for avoiding critical races in terms of an input encoding problem. As mentioned earlier, all of these methods refer to the initial design of race-free asynchronous machines, and are applicable only before the machine is constructed; none of them helps overcome the effects of a critical race in an existing asynchronous machine. In most applications of asynchronous machines, it is assumed that the environment operates in fundamental mode (Unger 1969), that is, that the environment generates a single input change, and waits for the machine to stabilize before it generates the next

PAGE 16

6 input change. Some recent work in asynchronous sequential circuits allows simultaneous change in several input variables. Such mode of operation is referred to as burst-mode (Davis et al. 1993a, Nowick 1993, Oliveira et al. 2000, and Yun 1994). Special restrictions have to be imposed in this approach to guaranty deterministic behavior of the machines. Other applications of control theory to the design of automata and asynchronous machines can be found in the literature on discrete event systems. One example is supervisory control (Ramadge and Wonham 1987, 1989) that is based on formal language theory. In this work, it is assumed that certain events in the system can be enabled or disabled. The control of the system is achieved by choice of control inputs that enable or disable these events. There is an extensive literature on discrete event systems; this topic was discussed by Alpan and Jafari 2002, Hubbard and Caines 2002, Koutsoukos el at. 2000, Lin 1993, Ozveren et al. 1991, Park and Lim 2002. The separation principle, which is shown applicable to the model-matching problem for asynchronous machines, is also discussed in the centralized supervisory control problem for discrete-event systems (Barrett and Lafortune 2000), where the estimated information sets could be independent of the supervisor’s control policy. Issues related to observers and observability in discrete-event systems are investigated by Bose et al. 1994, Caines and Wang 1989, Caines et al. 1988, Ozveren and Willsky 1990. The present work uses the finite state machine model since it can be advantageous versus the use of language theory to investigate discrete-event control problems, and a detailed discussion is provided by Dibenedetto et al. 2001. Asynchronous machines are heavily used in industry, as they yield fast and

PAGE 17

7 economical digital systems. Here are some examples of asynchronous machines in industrial use: an adaptive routing chip (Davis et al. 1993b), a cache controller (Nowick et al. 1993), and an infrared communications chip (Marshall et al. 1994). The dissertation is organized as follows. Terminology and background are presented in Chapter 2. Chapter 3 deals with the model-matching problem for asynchronous input/state machines; the chapter presents necessary and sufficient conditions for the existence of a solution to the model-matching problem, as well as algorithms for the implementation of appropriate controllers. The discussion of input/output machines starts in Chapter 4, where the model-matching problem for deterministic input/output machines is solved. Chapter 5 addresses the model-matching problem for input/output machines with critical races. Both Chapters 4 and 5 include necessary and sufficient conditions for the existence of controllers, as well as algorithms for the design of such controllers. Finally, conclusions and possible directions of future research are presented in Chapter 6.

PAGE 18

CHAPTER 2 TERMINOLOGY AND BACKGROUND 2.1 Asynchronous Machines and Fundamental Mode An asynchronous sequential machine is a quintuple (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. The initial state of the machine is x0 X, and f : AX X and h : AX Y are partial functions, namely, functions defined only on part of their domain. We name f the state transition function (or recursion function) and h the output function. When the output function h does not depend on the input character (i.e., when h : X Y), the machine is called a Moore machine (Moore 1956). It can be shown in general (Kohavi 1970 and Mealy 1955) that every asynchronous machine can be represented as a Moore machine. In view of this fact, the present work deals with only Moore machines (without loss of generality), namely, with asynchronous machines that can be represented in Equation 2-1, xk+1 = f(xk,uk)yk = h(xk) k = 012... (2-1) Here, u0, u1, u2, ... is the input sequence of the machine; y0, y1, y2, ... is the output sequence of the machine; and x0, x1, x2, ... is the state sequence of the machine; the state x0 is the prescribed initial condition. The integer k represents the "step counter" of the sequential machine . The step counter k advances by at every state transition and at every change in the input value. The system is an input/state machine when the output 8

PAGE 19

9 is the state. That is, when xk+1 = f(xk,uk)yk = xk k = 012... (2-2) A pair (x,u) is a stable combination if x = f(x,u). For a pair (x,u) which is not a stable combination, the system engages in a chain of transitions x1 = f(x,u), x2 = f(x1,u), ... (2-3) If there is an integer i 0 such that (xi, u) is a stable combination, then xi is called the next stable state of x. If there is no integer i for which (xi, u) is a stable combination, then the system contains an infinite cycle. The present discussion assumes that none of the machines under considerations have infinite cycles. Ideally, for an asynchronous machine with no infinite cycles, it takes zero time to reach the next stable combination, irrespective of the number of intermediate transitions involved. From a user’s point of view, only stable combinations and their corresponding output values are noticeable, since the machine may linger only at stable combinations. Using the concept of next stable state, we can induce a new transition function s of defined as follows. Let x be the next stable state for the pair (x, u); then, set s(x,u) := x. In other words, s generates the next stable state of any pair (x, u). We refer to s as the stable transition function of the system . The operation of is best described by the stable state transition function s, since, as mentioned earlier, only stable combinations are meaningful to the user. Nonetheless, unstable states are important to the present discussion, since the controllers developed in the present work function by transforming certain undesirable stable states of into unstable states of the closed loop system. We refer to the quintuple (A,Y,X,x0,s,h) as the stable-state machine induced by

PAGE 20

10 . An important restriction on an asynchronous sequential machine is that only a single variable of the machine is allowed to change its value at a time. A machine that satisfies this requirement is said to operate in fundamental mode. In fundamental mode operation, an input variable of the machine can change its value only after the machine has reached a stable combination. This guarantees that the state value is fixed when the input value changes. Of course, if the machine has more than one input variable, then only one input variable may change its value at any instant of time. In the ensuing discussion, all asynchronous machines, as well as all combinations of asynchronous machines, operate in fundamental mode. When the state-input pair (x,u) is not a stable combination, the machine will continue from this pair through a chain of state transitions, reaching the next stable state s(x,u) in the end. In fundamental mode operation, the input value u must be kept fixed while this chain of transitions is in progress. Note that an infinite cycle cannot be terminated in fundamental mode operation, since one cannot change the input value while the cycle is in progress. As the present work is restricted to fundamental mode operation, we have to exclude from consideration machines with infinite cycles. Thus, for every asynchronous machine discussed here, a valid pair (x,u) of always has a next stable state. Now, consider the situation where an input string t = u0u1um-1 is applied to the system at the initial state x0. In accordance with fundamental mode operation, the first input value u0 remains fixed until reaches the next stable state x1 := s(x0,u0). After that, the input value switches to u1 and stays constant until the next stable state x2 :=

PAGE 21

11 (s(s(x0,u0),u1) is reached. This process continues until the last stable state xm := s(...s(s(s(x0,u0),u1),u2)...,um-1) is reached. Let us use the shorthand notation s(x0,t) := s(...s(s(s(x0,u0),u1),u2)...,um) = xm; (2-4) the multiple-step stable transitions can also be represented by (x0,t) xm. It is said that the state x is stably reachable from the state x if there is an input string t for which s(x,t) = x. The corresponding output string of the machine is defined as h(x0)h(x1)h(xm), that is, the output values contributed by the stable states. As before, only output values associated with stable combinations are meaningful to users. 2.2 Machine Equivalence and Quotient Machines This section introduces minimal machines and quotient machines which are associated with the concept of machine equivalence. The following is some notation. For the input set A, denote by A* the set of all finite strings of characters of A. Also, given a function f with domain X and a subset X1 of X, denote by f[X1] the image of the subset X1 through the function f (i.e., f[X1] = x X1 f(x)). We need the following definition. Definition 2.1 Let = (A,Y,X,x0,s,h) and = (A,Y,X,0,s,h) be two stable-state machines having the same input and output sets. Let x X and X be two states in the corresponding state spaces. The states x and are stably equivalent if the following is true: When starts from the state x and starts from the state , then (i) and have the same permissible input strings, and (ii) and generate the same output string for every permissible input string. We shall indicate stable equivalence of the states x and by writing x .

PAGE 22

12 Definition 2.2 Two machines and with initial states x0 and 0, respectively, are stably equivalent if x0 0. To indicate that two machines and are stably equivalent, we write = . If = , then it must hold that h(x0) = h(0). In practical terms, stably equivalent machines cannot be distinguished from each other through their input/output behavior. The present dissertation only talks about the stable equivalency of asynchronous machines. Definition 2.3 A machine is reduced if it has no two states that are stably equivalent. Recall that the state x is stably reachable from the state if there is an input string that takes the machine from the state x to the stable state . Note that it is possible for a machine to have states that are not stably reachable from any other states. In this regard, let us introduce the following definitions (Holcombe 1982 and Shields 1987). Definition 2.4 A stable-state machine is stably reachable if every state of the machine is stably reachable from its initial state; it is called strongly stably reachable if every two states of the machine are stably reachable from each other. Definition 2.5 An asynchronous sequential machine is stably minimal if it is stably reduced and stably reachable. It can be seen that by removing the states which are not stably reachable from the initial state, the remaining part of the machine is stably reachable and possesses the same input/output behavior as the original machine. Therefore, the later discussion simply focuses on stably reachable machines without losing generality.

PAGE 23

13 Given a set X, a partition of X is a set whose members are disjoint subsets of X and whose union is X. The members of a partition are called blocks of . The following definitions adapt certain classical concepts of automata theory to the present context (compare to Eilenberg 1974 and Nelson 1968). Definition 2.6 Let = (A,Y,X,x0,s,h) be a stable-state machine, and let be a partition of the set of all stably reachable states in X. Then, the partition is transition consistent if, for every block P and every input character u A, there exists a block Q such that s[P,u] Q. Definition 2.7 Let = (A,Y,X,x0,s,h) be a stable-state machine, and let be a partition of the set of all reachable states in X. Then, the partition is output consistent if for every block Q , and any element q1,q2 Q, it holds that h(q1) = h(q2). A partition that is both transition consistent and output consistent is called a stably equivalence partition. Definition 2.8 Given an asynchronous stable-state machine = (A,Y,X,x0,s,h), let be a partition of the set of all stably reachable states of X, and assume that is a stably equivalence partition. Then, the stably quotient machine / is the machine (A,Y,,0,s,h) that satisfies the following conditions: For any blocks i, j of and any input character u A, it holds that (i) The stable transition function s is defined by s(i,u) := j if s[i,u] j, for all i, j . (ii) h(i) := h[i] for all i . (iii) 0 is the block of containing x0.

PAGE 24

14 Given a machine and one of its stably equivalence partitions, say , we can construct the stably quotient machine / by substituting each state with a corresponding block of the partition , and it holds that = /. The following is a modified statement of a well-known result in automata theory. Proposition 2.9 Let = (A,Y,X,x0,s,h) be a stable-state machine, and let be an stable equivalence partition of X. Then, = /. The following definition and proposition follow along well-established lines of automata theory (Eilenberg 1974). Definition 2.10 Given two machines 1 = (A1,Y1,X1,x10,f1,h1) and 2 = (A2,Y2,X2, x20,f2,h2), with the stable recursion functions s1 and s2, respectively. We say that 1 and 2 are stably isomorphic if there exist bijective functions, , , and , where : X1 X2, : A1 A2, and : Y1 Y2, such that, for all x X1, u A1, (i) (s1(x,u)) = s2((x),(u)), (ii) h1(x,u) = [h2((x),(u))], (iii) x20 = (x10). Proposition 2.11 Let 1 and 2 be stably equivalent machines. If 2 is stably minimal, then there exists a stable equivalence partition for 1 such that the stably quotient machine 1/ is stably isomorphic to 2. 2.3 Races and Race Machine Families A race is a situation in an asynchronous sequential machine when two or more variables try to change their values simultaneously (Kohavi 1970 and Unger 1995). As simultaneous change of independent variables is unlikely, a sequential change of the

PAGE 25

15 variables occurs instead. The order in which the values of the variables change is, however, unpredictable, since it depends on irregular delays and on other random conditions within the hardware. A critical race is a race in which the response of the machine depends on the order in which the race variables change their values. Since this order is unpredictable, a critical race causes the response of the machine to be unpredictable at the race. In this way, a critical race manifests itself through a state-input pair whose next stable state is unpredictable. 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. Asynchronous sequential machines are always designed with the objective of incurring no critical races. Nevertheless, a critical race may appear in a machine anyway, as a result of a component malfunction, an implementation fault, or a design error. Consider an asynchronous machine having a single critical race pair (r,v). When is at the state r and receives the input value v, the next stable state of the machine can be one of several options, say r1, ..., r. The states r1, ..., r are called the outcomes of the race. To represent the race, we build a family M = {1, ..., } of sequential machines as follows. All machines of M have the same input set, the same output set, the same state set, and the same output function as the race afflicted machine . For each i = 1, ..., , the recursion function fi of i is the same as the recursion function f of at all points except at the critical race pair (r,v), at which fi(r,v) := i, i = 1, ..., . As mentioned earlier, a race (as the term indicates) is created by a "simultaneous" change of the values of two or more variables of the machine. Since our machine has a

PAGE 26

16 single input variable, it is not possible for the race state r to remain unchanged during the race. This implies that i r for all i = 1, ..., , and the recursion function fi of i satisfies fi(x,u) = f(x,u) for all (x,u) (r,v); i for (x,u) = (r,v) where i r (2-5) i = 1, ..., . Let us denote by ri the next stable state reached with the input value v from the state i, i = 1, ..., . Note that, here too, it is necessary to have ri r for all i = 1, ..., to prevent an infinite cycle. To summarize, each member of a critical race family M is a machine with no critical races; it represents the behavior of the machine for one possible outcome of the race. Let us call the family M a critical race family. Of course, a sequential machine may have more than one critical race, and a family of sequential machines can be built to represent such multiple critical races. The presentation in this dissertation, however, concentrates on the study of critical race families that model the effects of a single critical race. Machines with multiple critical races can be handled by similar methods. Next is a basic technical property of critical race families which is important to the present discussion. First, some notation. Consider an asynchronous machine operated in fundamental mode. Let f be the recursion function of . Assume starts from a state x0, and is driven by an input string w = u0u1 ... um–1 that takes the machine to its next stable combination. On its way, the machine will pass through a string of states x0, ..., xm, where xi+1 = f(xi,ui), i = 0, ..., m, (2-6)

PAGE 27

17 ending with the combination (xm,um–1). Fundamental mode operation implies that ui = ui+1 whenever (xi,ui) is not a stable combination, i = 0, ..., m – 2. (2-7) Definition 2.12 Let w = u0u1 ... um–1 be an input string of the asynchronous machine . In the notation of Eq. 2-6 and Eq. 2-7, the transient path P(,x0,w) is the list of pairs P(,x0,w) := {(x0,u0), (x1,u1), ..., (xm–1,um–1), (xm,um–1)}. (2-8) Note that a transient path is always generated by the recursion function of the machine, not by its stable recursion function. In these terms, a critical race family has the following property, which follows directly from Eq. 2-5. Proposition 2.13 Let M = {1, ..., } be a critical race family induced by the asynchronous machine with the single critical race pair (r,v). Let x be a state of and let w be an input string. If there is an integer i {1, ..., } for which (r,v) P(i,x,w), then all transient paths are equal: P(j,x,w) = P(i,x,w) for all j = 1, ..., . Condition in Eq. 2-7 requires each input value to be “repeated” until the next stable combination is reached. In reality, the input value is not repeated; it is just held constant until the next stable combination. As all our machines are operated in fundamental mode, Eq. 2-7 is valid for all input strings mentioned in the present discussion. To simplify the notation for input strings, it will be convenient to adopt the convention that only one representative is listed for each sub-string of consecutive “repeating” input values. For example, an input string w = u0u0u1u2u2u2 will be listed simply as w = u0u1u2. Under this convention, it is understood that each input value is “repeated” consecutively as many times as necessary to satisfy Eq. 2-7. Note that this shortened notation signifies, in fact, the corresponding input string for the stable

PAGE 28

18 recursion function. Thus, under this convention, the input string of the recursion function and the corresponding input string of the stable recursion function are denoted by the same symbols. 2.4 Stable Transition Matrices and Skeleton Matrices As usual, reachability characterizes the states a sequential machine can reach from a given initial condition in response to various input strings. In the following we introduce two types of matrices to characterize the reachability of asynchronous machines, namely, transition matrices and skeleton matrices. A complete characterization of these matrices for input/state asynchronous machines can be found in Murphy et al. 2002, 2003. The following discussion won’t specify the initial states of machines when the initial states are not relevant to the issue under investigation. Let = (A,X,X,s,h) be an input/state stable-state machine with state set X = {x1, , xn}. For an integer m 1, The matrix R(m)() of m-step stable transition matrix is an nn matrix whose (i,j) entry R(m)ij() is the set of all input strings that take xi to xj in at most m stable transitions; the entry is written as N otherwise. It can be shown that the matrix R(m)() can be easily calculated from the matrix R(1)() (Murphy et al. 2003). Let n be the number of states of the machine . Then, it can be shown that, if an entry of R(n-1)() is N, then the corresponding entry of R(m)() is also N for all m 1 (Murphy, Geng, and Hammer 2003). Proposition 2.14 Let be an asynchronous machine having n 1 states, and let i, j {1, 2, ..., n} be a pair of integers. Then, for all m 1, the entry R(m)ij() = N if and only if the entry R(n)ij() = N.

PAGE 29

19 In view of Proposition 2.14, the matrix R(n)() completely characterizes all pairs of states (xi, xj) of the machine for which xj is stably reachable from xi. This leads us to the next. Definition 2.15 Let be an asynchronous machine with n states. Then, R(n)() is called the matrix of stable transitions of . Note that the entries of R(n)() consist of input strings (if any) that take from one state to another through a succession of stable transitions. These input strings are important for the construction of corrective controllers later in this dissertation. However, the existence of such controllers can be verified from the simpler matrix introduced next. Let be the input/state machine with the one-step stable transition matrix R(1)(). The one-step skeleton matrix S(1)() of is an nn matrix whose (i,j) entry S(1)ij() is given by S(1)ij() := 0if R(1)ij() = N;1if R(1)ij() N (2-9) for all i, j {1, ..., n}. As we can see, the matrix S(1)() is a matrix of zeros and ones. The (i,j) entry of the S(1)() indicates whether or not there exists a one-step stable transition that takes from the state xi to the state xj. Similarly, we can get the m-step skeleton matrix S(m)() of from R(m)(), whose (i,j) entry is one if and only if it is possible to reach the state xj from the state xi through m stable transitions or fewer. The following is a special operation for skeleton matrices, which will lead us to the relationship between the skeleton matrices defined above.

PAGE 30

20 Definition 2.16 Let A, B be two nn matrices of zeros and ones. The combination AB of A and B is again an nn matrix of zeros and ones, whose (i,j) entry is (AB)ij := max {AikBkj : k = 1, ..., n} (2-10) for all i, j = 1, ..., n. Note that the operation of matrix combination bears a formal similarity to matrix multiplication, with the operation of taking the maximum replacing the addition of standard matrix multiplication. Using combination, it can be shown (Murphy, Geng, and Hammer 2002, 2003) that the relationship between the m-step skeleton matrix and the one-step skeleton matrix in given by S(m)() = S(m)()S(1)(), m = 2, 3, ... (2-11) It can also be shown that a state xj is stably reachable from a state xi if and only if S(n-1)ij() = 1 (Murphy, Geng, and Hammer 2002, 2003). The same reference also contains a proof of the fact that S(p)() = S(n)() for all p n. These observations indicate that the matrix S(n)() contains substantial structural information about the system . This matrix is critical to the ensuing discussion, and so it is defined formally next. Definition 2.17 Let be an input/state asynchronous machine with the one-step skeleton matrix S(1)(). The matrix S(n)() is the skeleton matrix of , and it is denoted by K(): K() := S(n)(). (2-12) Note that K() has at least n non-zero entries, since, according to the previous assumptions, every state must have at least one stable combination. Sometimes there is a need to compare two nn skeleton matrices K, K. We shall

PAGE 31

21 write K K whenever Kij Kij for all i, j = 1,,n, that is, element by element comparison. The (i,j) entry Kij() of the matrix K() is sometimes written as K(,xi,xj). The following is then true. Proposition 2.18 Let A, B, C and D be nn skeleton matrices. If A B and C D, then, under matrix combination, AC BD. Proof. Denote by (AC)ij and (BD)ij the (i,j) entries of the matrices AC and BD, respectively. Using Eq. 2-10 and the relations A B and C D, we obtain (AC)ij := max {AikCkj : k = 1, ..., n} max {BikDkj : k = 1, ..., n} = (BD)ij (2-13) for all i, j = 1, ..., n. Therefore, AC BD. For race families of input/state asynchronous machines, we have the following definition of skeleton matrices. Definition 2.19 Let M = {1, ..., } be a critical race family of asynchronous machines with the state space X = {x1, ..., xn}. Let K(k) be the skeleton matrix of the machine k, k = 1, ..., . The skeleton matrix K(M) of the family M is an nn matrix whose (i,j) entry Kij(M) is given by Kij(M) := min {Kij(k) : k = 1, ..., }, i, j = 1, ..., n. (2-14) It follows that the skeleton matrix K(M) of a critical race family M is a matrix of zeros and ones. The (i,j) entry of K(M) is 1 if and only if the state xj is stably reachable from the state xi for each one of the members of M.

PAGE 32

CHAPTER 3 MODEL MATCHING FOR INPUT/STATE ASYNCHRONOUS MACHINES This chapter presents solutions to the model matching problem for input/state asynchronous machines with critical races, which are represented as critical race families. We start with the description of the model matching problem and the control system in Figure 1-1. Then, we study the basic characteristics and functions of the controllers for deterministic machines. In the end, we present solutions to the model matching problem for both deterministic machines and critical race families. In both cases, the results include necessary and sufficient conditions for the existence of solutions, and algorithms to construct such solutions as well. 3.1 Control Configuration and Model Matching Let = (A,X,X,f,h) and = (A,X,X,f,h) be two input/state asynchronous machines, where denotes the machine in the control configuration of Figure 1-1 and servers as a prescribed model. Note that initial conditions are not specified in these two machines. Consider the closed loop configuration of Figure 1-1. The controller C is also an asynchronous machine, and it has two input variables: the external reference input v, and the feedback variable y. To simplify notation, it is convenient to assume that the set of possible values of v is the input set A of . Recalling that the output set of is X (the state set of ), we obtain that the input set of the controller C is the cross product set AX. 22

PAGE 33

23 Clearly, the output values of C must be contained in A, since the output of C serves as the input of . Let be the state set of C, let being its recursion function, and let being its output function. Then, C is represented by the quintuple (AX,A,,,). The closed loop system c of Figure 1-1, being the combination of the machines and C, has a state set given by the cross product X. A direct observation of Figure 1-1 indicates that the output set X of the input/state system is also the output set of c since the output of c is the output of . Consequently, the output function of c is a partial function hc : (X)A X, satisfying hc((x,),v) = x for all states and all valid pairs (x,v) XA of . Letting sc denote the stable transition function of c, we conclude that c can be represented by the quintuple (A,X,X,sc,hc). Several preliminary issues arise when the control loop is closed around the system of Eq. 2-2. The first issue is the need to guarantee that the closed loop system of Figure 1-1 is well posed, namely, that all signals within the loop are uniquely and causally determined by the external reference signal v. This condition is satisfied in the present setup, since the input/state machine of Eq. 2-2 is a strictly causal system (Hammer 1996a). Another important issue is the requirement that no new critical races arise from the closure of the control loop in Figure 1-1. To satisfy this requirement, we shall guarantee that the controller C, as well as the entire composite system c, operate in fundamental mode. To attain fundamental mode operation, the controller C is designed to satisfy the following conditions.

PAGE 34

24 Starting from a stable combination, and in response to a change in the external input variable v, the output value of the controller does not change until the controller reaches its next stable state. In response to changes in the output value y of , the controller C does not commence any state transitions until reaches its next stable state. When these conditions are met, the systems and C do not simultaneously engage in state transitions. Furthermore, while one of the systems or C is in the process of state transitions, its input values remain fixed. And, finally, for C, not more than one input variable can change at a time. Of course, c must be operated so that the time span between consecutive changes of the external variable v is long enough, to allow the closed loop system to reach its next stable state before an input change occurs. This is a standard restriction on the operation of asynchronous sequential machines. Consider the case where is an input/state machine possessing a critical race, then, represent the machine as M = {1, ..., }, a critical race family of input/state asynchronous machines. For a member i of M, let icbe the stable-state machine of the closed loop system obtained when is replaced by i in Figure 1-1. In these terms, the main topic of the present discussion can be phrased as follows. Problem 3.1 Let M = {1, ..., } be a critical race family of input/state asynchronous machines, and let be a race-free stable-state machine. Assume that has the same input set and the same output set as the members of the family M. Find necessary and sufficient conditions for the existence of a controller C such that ic is equivalent to (i.e., ic = ) for all i = 1, ..., . When such a controller exists, provide an algorithm for its design.

PAGE 35

25 When it exists, the controller C of Problem 3.1 eliminates the effects of the race. It assigns to the closed loop system the desirable behavior of the stable-state machine , irrespective of the outcome of the race. A demonstration of the model matching problem and its solution is provided in the example of Section 3.4 below. There, the family M consists of two members whose recursion functions are given (in table form) by Table 3-1 and Table 3-2. The objective is to design a controller C for which the closed loop system always behaves according to a prescribed model, irrespective of the race outcome. Clearly, such a controller removes the indeterminacy about the systems response, and assigns to the closed loop system a preferred behavior. The method used in the example to calculate the controllers recursion function is developed in Sections 3.2 and 3.3. The model matching problem considered here bears similarity to the model matching problems investigated for synchronous sequential machines in Hammer 1994,1995,1996a, and 1996b. However, the case of asynchronous machines considered here has much more flexibility, since one only needs to match a specified stable state behavior (rather than a full behavior). Consequently, the methods used here are different, as are the derived results. The presentation is for the case of a machine afflicted by a single critical race, but the results can be generalized to machines with multiple races. 3.2 Basic Considerations on Feedback Controllers The present section examines some of the basic characteristics of controllers for input/state asynchronous machines. Specifically, it concentrates on the characteristics of controllers that modify the stable transition function of an asynchronous machine. Understanding these characteristics will help in the next section, where we derive

PAGE 36

26 necessary and sufficient conditions for the existence of controllers that overcome the effects of a critical race. Consider the configuration of Figure 1-1 with the input/state machine = (A,X,X,f,h) and the controller C = (AX,A,,,). The stable-state machine c that results from the combination of and C is then described by a quintuple of the form (A,X,X,sc,hc). As is an input/state machine, we have h(x,u) = x. Letting x : X X : (x,) x be the standard projection, and noting that in Figure 1-1 the output of c is the output of , we obtain hc = x. (3-1) Now, let = (A,X,X,s,h) be a stable-state input/state machine, having the same input set and the same state set as the machine . Consider the existence of a controller C for which c = ; (3-2) Eq. 3-2 represents the Model Matching Problem 3.1 for the case of a race free machine. Let sc : XA X : (x,,v) sc(x,,v) be the recursion function of c. Recalling that the output of c is the state of , it follows by Definition 2.1 that Eq. 3-2 is equivalent to the following. For every valid pair (x,v) of , there is a state for which ((x,),v) is a valid pair of c, where, in view of Eq. 3-1, x sc(x,,v) = s(x,v). (3-3) The next statement forms the first step in the process of constructing controllers. It shows how a controller can change the stable recursion function of an asynchronous machine. Given two sets , , we denote by \ the difference set (i.e., the set of all

PAGE 37

27 elements of that are not in . Theorem 3.2 Let = (A,X,X,f,h) be an input/state machine with s being its stable transition function. For an integer k 1, let x1U1, x2U2, ..., xkUk XA be disjoint sets whose members are valid pairs of . For each i {1, ..., k}, let xi X be a state stably reachable by from the state xi. Then, there is a controller C for which c is equivalent to a stable-state machine = (A,X,X,s,h), whose recursion function s satisfies (i) s[xiUi] = xi for all i = 1,,k, and (ii) s(z,t) = s(z,t) for all (z,t) XA \ (i=1, ..., k xiUi). Furthermore, the closed loop system c is well posed and operates in fundamental mode. The controller C of Theorem 3.2 allows one to assign desirable values to the stable recursion function of the closed loop system. An algorithm for the construction C is provided in the proof below. Proof (of Theorem 3.2). Recall that s is the stable recursion function of . In view of the fact that xi is stably reachable from xi, there is an input string wi A+ for which s(xi,wi) = xi, i = 1, ..., k. Let m(i) := |wi| be the length of the string and let v0i, v1i, vm(i)-1i be its characters, so that wi := v0iv1ivm(i)-1i for all i = 1, ..., k. With this input string, the stable recursion function s generates the following string of states x1i := s(xi,v0i), x2i := s(x1i,v1i), , xm(i)-1i := s(xm(i)-2i,vm(i)-2i) xi := s(xm(i)-1i, vm(i)-1i), i = 1, , k. (3-4) Let U(xi) A be the set of all input characters that form stable combinations with

PAGE 38

28 the state xi, i = 1, ..., k. Define the sets S := i = 1 ... k xiU(xi), (3-5) V := i = 1 ... k xiUi. (3-6) A controller C = (AX,A,,,) that satisfies the requirements of Theorem 3.2 can then be constructed as follows. (i) The state set of C has 2 + ki=1 m(i) states denoted by = { 0, 1, 1 1 , 21, ..., m(1)1, 12, ..., m(2)2, ..., 1k, ..., m(k)k }. (3-7) (ii) The initial state of the controller C is 0. The controller moves to the state 1 upon detection of a stable combination with one of the states x1, ... xk. To this end, the recursion function of C is defined at the point 0 as follows. (0,(z,t)) := 0 for all (z,t) XA \ S, (3-8) (0,(x,u)) := 1 for all (x,u) S. (3-9) Due to fundamental mode operation, no changes in the output of C may occur before C reaches the state 1. Consequently, the output function of C is defined at 0 by (0,(z,t)) := t for all (z,t) XA, (3-10) that is, at 0 the controller applies to the external input value. To define the output function at the state 1, choose a character ui U(xi), and set (1,(xi,t)) := ui for all t A, i = 1, ..., k, (3-11) so that the input of is set to be ui when the controller reaches the state 1. This preserves fundamental mode operation, since the system was in a stable combination when the controller moved to the state 1.

PAGE 39

29 (iii) Assume that an input value u Ui appears at the input of the closed loop system while is in a stable combination with the state xi, where i {1, ..., k}. The controller C starts then to generate the input string wi that drives to the state xi. To guarantee fundamental mode operation, the string wi is generated by C one character at a time, where a new character is generated only after has reached a stable combination. The first step in this process is the detection of the input u, signified by the state 1i of C as follows. (1,(xi,u)) := 1i for all u Ui, i = 1, ..., k; (1,(xi,u)) := 1 for all u U(xi) \ Ui, i = 1, ..., k; (1,(z,t)) := 0 for all pairs (z,t) XA \ (S V). (3-12) Upon reaching the state 1i, the controller generates the first character of the input string wi for : (1i,(z,t)) = v0i for all (z,t) XA, i = 1, ..., k. (3-13) This input character causes to move to the state x1i; recall that (x1i,v0i) is a stable combination of . (iv) In a similar fashion, the following definitions of the recursion function and the output function prompt C to continue to generate the input string wi for . (ji,(xji,u) := j+1i for all u Ui, (ji,(z,t)) := ji for all (z,t) XA \ xjiUi, (3-14) for j = 1, ..., m(i) and i = 1, ..., k. The state j+1i of the controller signifies that has reached the stable combination (xji,vj-1i). In compliance with fundamental mode operation, the system is now ready for the next input character vji of the string wi. Consequently, for j = 1, 2, ..., m(i), set

PAGE 40

30 (j+1i,(z,t)) := vji for all (z,t) XA, i = 1, ..., k. (3-15) (v) Finally, for j = m(i), assign (m(i)i,(xi,u)) := m(i)i for u Ui, (m(i)i,(z,t)) := 0 for all (z,t) XA \ S, i = 1, ..., k. (m(i)i,(z,t)) := 1 for (z,t) S. (3-16) The fact that the sets x1U1, x2U2, ..., xkUk are disjoint guaranties that there is no inconsistency in the definition of the recursion function . A careful review of the above construction shows that the stable recursion function sc of the closed loop system c satisfies: sc(xi,0,u) = (s(xi,u),1) for all u U(xi); sc(z,0,t) = (s(z,t),0) for all (z,t) XA \ S; sc(xi,1,ui) = (xi,m(i)i) for all ui Ui; sc(xi,1,u) = (xi,1) for all u U(xi); sc(xi,1,t) = (xi,0) for all t A \ (U(xi) Ui); sc(xi,m(i)i,u) := (xi,m(i)i) for u Ui; sc(z, m(i)i,t) := (s(z,t),0) for all (z,t) XA \ xiUi; (3-17) for all i = 1, ..., k. This shows that Eq. 3-3 is valid. Finally, as detailed during the construction, fundamental mode operation is obeyed. Also, being an input/state system, is strictly causal, and consequently the closed loop system c is well posed (Hammer 1996a). This concludes the proof. The controller C of Theorem 3.2 is a state feedback controller that assigns desirable behavior to the closed loop system c. It functions by generating an input string that takes the machine from the state xi to the state xi through a string of stable transitions of . The intermediate steps of this transition become unstable states of the closed loop system c, so that, for the closed loop, xi becomes the next stable state of xi

PAGE 41

31 with any input character of the set Ui. The proof of the theorem contains an algorithm for the construction of C. Once the controller C is constructed by this algorithm, standard machine reduction techniques can be used to reduce its number of states. Finally, an examination of the proof of Theorem 3.2 indicates that, for fundamental mode operation of the closed loop system, it is necessary for the state xi to be stably reachable from the state xi for all i = 1, ..., k. This shows that the scope of Theorem 3.2 includes all cases in which an appropriate controller C exists. 3.3 Model Matching for Input/State Machines This section presents a solution of the Model Matching Problem 3.1 for a critical race family M of input/state asynchronous machines. It starts with the simpler case where the family M consists of a single member. This case is also of interest on its own merit. 3.3.1 Model Matching for a Single Machine The following statement provides a necessary and sufficient condition for the existence of a state feedback controller that assigns a prescribed stable recursion function to a deterministic asynchronous machine . Theorem 3.3 Let = (A,X,X,f,h) be an input/state machine, and let = (A,X,X,s,h) be a stable-state input/state machine. The following two statements are equivalent. (i) There exists a controller C for which c = , where c is well posed stable-state machine and operates in fundamental mode. (ii) The skeleton matrices of the machines and satisfy K() K(). Proof. Let s and s be the stable recursion functions of and of , respectively,

PAGE 42

32 and following the previous notation, denote by c = (A,X,X,sc,hc) the stable-state composite machine. Then, sc is the stable recursion function of c. Define := xsc, and let X = {x1, ..., xn} be the state set of . Assume first that condition (i) of the theorem is valid, namely, that there is a controller C for which c = . Then, for every valid pair (x,u) XA of , there is a state such that (x,,u) = s(x,u). Now, x and (x,,u) are states of , say x = xi X and (x,,u) = s(x,u) = xk X. This means that we can write xk = (xi,,u) = s(xi,u). Letting S() be the one-step skeleton matrix of , the equality xk = s(xi,u) implies that Sik() = 1. Further, since the controller C accesses only through the input of , the equality xk = (xi,,u) means that there is an input string w A+ such that xk = s(xi,w). By the definition of the skeleton matrix K() of , the last equality implies that Kik() = 1. Thus, it concludes that Kik() = 1 if Sik() = 1. In symbolic form, that means that K() S(). Multiplying each side of this inequality by itself n times, we obtain by Proposition 2.18 that K(n)() S(n)() = K(). Applying Proposition 2.17, we conclude that K() K(). This shows that condition (i) implies condition (ii). Conversely, assume that condition (ii) of the theorem is valid (i.e., K() K()). Now, by the definition of skeleton matrix, one always has K() S(). Combining the last two inequalities, it follows that K() S(). This implies that, for every valid pair (x,u) of , the state s(x,u) is stably reachable from x by . Theorem 3.2 guaranties then the existence of a controller C for which c = . Thus, condition (ii) implies condition (i), and the proof concludes.

PAGE 43

33 In view of the last paragraph of the above proof, the proof of Theorem 3.2 provides an algorithm for the construction of a controller C that satisfies Theorem 3.3. We turn now to the issue of controlling a critical race family of machines. 3.3.2 Controlling Races The following statement provides necessary and sufficient conditions for the existence of a solution to the Model Matching Problem 3.1. It is one of the main results of the present chapter. Theorem 3.4 Let M = {1, ..., } be a critical race family of input/state asynchronous machines with state set X and input set A, and let be a stable-state input/state machine having the same state set X and input set A. Let K(M) be the skeleton matrix of the family M, and let K() be the skeleton matrix of . Then, the following two statements are equivalent. (i) There is a controller C for which ic = for all i = 1, ..., , where the closed loop systems 1c2c c are all well posed and all operate in fundamental mode. (ii) The skeleton matrices satisfy K(M) K(). In crude terms, the controller C functions by transforming into unstable combinations the undesirable outcomes of the race, and driving all members of the critical race family to the same stable combination after the race. In this way, the controller equalizes the stable state response of the closed loop system for all members of the family M. More specifically, the controller C detects the stable combination (ri,v) reached by the member i of the family M after the race. It then applies an input string that drives i to a stable combination that is common to all members of M. This has the

PAGE 44

34 effect of making (ri,v) into an unstable combination of the closed loop system, and equalizing the stable state response of the closed loop system for all members of M. The proof of Theorem 3.4 (provided later in this section) includes an algorithm for the construction of an appropriate controller C. This construction guaranties fundamental mode operation of the closed loop system. An example of the construction of C can be found in Section 3.4 below. Recall from Section 2.4 that the skeleton matrix K(M) of a critical race family M cannot be a zero matrix, since each state must be part of a stable combination. Consequently, one can always build a stable-state machine whose skeleton matrix is equal to K(M). Taking this into account, Theorem 3.4 implies that every critical race can be eliminated through state feedback control. The remaining part of this section deals with technical issues related to the proof of Theorem 3.4. In preparation for the proof of Theorem 3.4, several auxiliary results are needed. First, using the notation of Theorem 3.4, the following argument is a consequence of the definition of the skeleton matrix K(M). If K(M) / K(), then there is a machine i M for which K(i) / K(). In view of Theorem 3.3, this implies that there is no controller C for which ic = . This proves the next statement. Lemma 3.5 Let M = {1, ..., } be a critical race family of input/state asynchronous machines with state set X and input set A, and let be a stable-state input/state machine with the same state set X and input set A. Let K(M) be the skeleton matrix of the family M, and let K() be the skeleton matrix of . If K(M) / K(), then there is no controller C satisfying ic = for all i = 1, ..., . Consider now the case where the skeleton matrix K(M) of the critical race family

PAGE 45

35 M = {1, ..., } does satisfy the condition K(M) K(). Then, by Definition 2.19, we have K(i) K(M) for all i = 1, ..., . Consequently, K(i) K() for all i = 1, ..., . Theorem 3.3 implies then that, for each i {1, ..., }, there is a controller C(i) such that ic(i) = . The present objective in the remaining part of this section is to show that the controllers C(1), ..., C() can be chosen all equal to the same controller C. This will then yield a single controller C that satisfies condition (i) of Theorem 3.4. To this end, consider a member i of M. Let si be the stable recursion function of i, and let s be the stable recursion function of . Build the set D(i,) = {(x,u) XA : (x,u) is a valid pair of and si(x,u) s(x,u)}; (3-18) this is the set of all valid pairs of for which the next stable state of is different from the next stable state of i. We shall refer to D(i,) as the discrepancy set of the machine i. The discrepancy set indicates the points where controller action is required in order to match the desired stable state response. Note that the term "discrepancy" here refers to single input characters. The condition K(i) K() implies that, for each element (x,u) D(i,), there is an input string w A* satisfying si(x,w) = s(x,u). Let Si(x,u) A* be the set of all such input strings w. Next, consider a pair (x,u) D(i,) and an input string w Si(x,u). Let P(i,x,w) be the corresponding path of the machine i, and recall that (r,v) is the critical race pair of the family M. For each i {1, ..., }, build a subset DN(i,) D(i,) by setting

PAGE 46

36 DN(i,) := {(x,u) D(i,) : (r,v) P(i,x,w) for at least one string w Si(x,u)}. (3-19) In other words, DN(i,) is the set of all pairs (x,u) where the stable state response of i can match the response of without passing through the critical race (r,v). By Proposition 2.13, a path P(i,x,w) that does not contain (r,v) is common to all members of M. In other words, if the stable state response of one member of M can match the response of without passing through the race, then so can the stable state responses of all members of M. The argument of this paragraph yields the following. Lemma 3.6 Let M = {1, ..., } be a critical race family of input/state asynchronous machines having the skeleton matrix K(M), the state set X, and the input set A. Let be a stable-state input/state machine with the skeleton matrix K() and the same state set X and input set A. Assume that K(M) K(), and let DN(i,) be the set of Eq. 3-19. Then, DN(i,) = DN(j,) for all j = 1, ..., . In view of Lemma 3.6, we use the notation DN(M,) := DN(i,), i = 1, ..., . (3-20) Considering the paragraph following Eq. 3-19, we conclude that in the process of matching the response of for elements of DN(M,), the controller can apply the same input string to all members of M. It is, therefore, relatively simple to control the family M over the set DN(M,). Let us direct now our attention to the other members of the discrepancy set, namely, to the members of the difference set DR(i,) := D(i,) \ DN(M,). (3-21) The set DR(i,) consists of all valid pairs of at which the response of cannot be

PAGE 47

37 matched by i without passing through the critical race pair (r,v). As a result, there must be an input string w that takes each pair of DR(i,) to (r,v). Consider the path of the machine i induced by w up to (but not beyond) (r,v). It follows by Proposition 2.13 that this path is identical for all members of M. This leads to the following. Lemma 3.7 Let M = {1, ..., } be a family of input/state machines induced by the critical race (r,v) of an asynchronous machine with state set X and input set A. Let be a stable-state input/state machine with the same state set X and input set A. Assume that K(M) K(). Then, in the notation of Eq. 3-21, the following are true. (i) For every element (x,u) DR(i,), there is an input string w that takes i from (x,u) to the race pair (r,v), encountering the race pair (r,v) only in the last step of w. (ii) The input string w of (i) takes every member of M from (x,u) to the race pair (r,v). In view of Lemma 3.7, the process of matching the performance of for pairs of the set DR(i,) can be split into two parts: the part before the race and the part after the race. The part before the race can be the same for all members of M. Specifically, for a pair (x,u) DR(i,), suppose s(x,u) = x. Then, the controller C functions as follows. First, it generates an input string that takes the active machine from the pair (x,u) to the race pair (r,v). By part (ii) of Lemma 3.7, this input string can be the same for all members of M, and therefore, during this part, the controller does not need to identify which member of M is active, since the outcome of the race has not occurred yet. Next, the controller drives the machine from the outcome of the race to the state x. Here, the string that the controller needs to generate may vary from one member of M to

PAGE 48

38 another, as it may depend on the outcome of the race. The outcome of the race is the first stable combination of this segment. Upon reaching this combination, the controller identifies the outcome of the race and determines which member of M is active. Based on this identification, the controller generates an input string that drives the active system from the outcome of the race to the state x. The existence of such a string is guaranteed by condition (ii) of Theorem 3.4, as shown in the proof below. This action of the controller has the effect of making the outcome of the race into an unstable combination of the closed loop system (if the outcome is not at the state x). To summarize, for each member i M, we have induced a disjoint partition of the discrepancy set D(i,) D(i,) = DN(M,) DR(i,). (3-22) Based on this partition, the controller C operates in two modes. For pairs belonging to DN(M,), it generates the same input string for all members of M. For pairs belonging to DR(i,), it first generates a common input string that drives all members of M to the race pair (r,v). Thereafter, based on the outcome of the race, it generates an input string that drives the active member of M to the corresponding response of the machine . This is the basic principle guiding the construction of the controller C in the proof of Theorem 3.4 below. Proof (of Theorem 3.4). In view of Lemma 3.5, condition (i) of Theorem 3.4 implies condition (ii). Thus, to complete the proof, it only remains to show that condition (ii) implies condition (i). To this end, assume that condition (ii) of Theorem 3.4 is satisfied. Let be the asynchronous machine whose critical race (r,v) gives rise to the critical race family M = {1, ..., }. Let si be the stable recursion function of the

PAGE 49

39 member i of M, and let s be the stable recursion function of . Finally, let (ri,v) be the stable combination following the critical race pair (r,v) for the machine i, and recall from Section 2.3 (the paragraph following Eq. 2-5) that ri r, i = 1, ..., . The below exhibits the construction of a controller C that satisfies condition (i) of Theorem 3.4. For each member i M, build the set D(i,) of Eq. 3-18. Of course, if D(i,) is empty for all i = 1, ..., , then each member of M matches the response of , and there is no need for a controller. Assume then that D(i,) for at least one i {1, ..., }. We denote by xD(i,) the projection of D(i,) onto the state set X; then, xD(i,) is the set of all states x for which there is an input value u such that (x,u) D(i,). For a state x X, let Ui(x) be the set of all input characters that form stable combinations with the state x of the machine i M. In view of Eq. 2-5, the only pair at which the members of the critical race family M differ from each other is the race pair (r,v). Furthermore, in view of Eq. 2-5 and the paragraph subsequent to Eq. 2-5, the pair (r,v) cannot be a stable combination of a member of M. Consequently, the set Ui(x) is the same for all members i M. Denoting this set by U(x), we have Ui(x) = U(x), i = 1, ..., . (3-23) The set Vi := {xU(x) : x xD(i,)} (3-24) describes then the set of all stable combinations with states in the set xD(i,). The union of all such stable combinations is denoted by

PAGE 50

40 V := i = 1 ... Vi. (3-25) For each i {1, ..., }, partition the set D(i,) into the disjoint union D(i,) = DN(M,) DR(i,) of Eq. 3-22, where DN(M,) is defined in Eq. 3-20 and DR(i,) is defined in Eq. 3-21. We also define the set DR(M,) := i=1,..., DR(i,). (3-26) Finally, let D := i=1, ..., D(i,), (3-27) and denote by D(x) the set of all input characters u A for which (x,u) D. Consider first the case where DN(M,) . As explained near Eq. 3-20, points of DN(M,) can be handled without passing through the race (r,v). On paths not passing through the race, all recursion functions of the members of M are equal. To indicate this fact, we use the symbol s to denote the equal restrictions of the stable recursion functions s1, ..., s to such paths. For each pair (x,u) DN(M,), let w(x,u) be a shortest input string that satisfies the conditions s(x,w(x,u)) = s(x,u) and (r,v) P(,x,w(x,u)). The input string w(x,u) exists by the definition of the set DN(M,). Letting m(x,u) := |w(x,u)|, and denoting by v0(x,u), v1(x,u), ..., vm(x,u)(x,u) the characters of this string, we have w(x,u) := v0(x,u) ... vm(x,u)(x,u). (3-28) The stable states through which w(x,u) takes the machine are denoted by x1(x,u) := s(x,v0(x,u)), x2(x,u) := s(x1(x,u),v1(x,u)), , xm(x,u)(x,u) := s(xm(x,u)(x,u),vm(x,u)(x,u)), and s(x,u) := s(xm(x,u)–1(x,u),vm(x,u)–1(x,u)). (3-29)

PAGE 51

41 Let n(N) := #DN(M,) and, assuming the set is nonempty, let (x1,u1), ..., (xn(N),un(N)) be the elements of the set DN(M,). The following set of elements will be used later as states of the controller C. N := {(1(x1,u1), ..., m(x1,u1)(x1,u1), ..., 1(xn(N),un(N)), ..., m(xn(N),un(N) ) (xn(N),un(N))}. (3-30) In case DN(M,) = , set N := . Next, denote n(R) := #DR(M,), (3-31) and, assuming the set is nonempty, let (x1,u1), ..., (xn(R),un(R)) be the elements of DR(M,). For an integer i {1, ..., }, consider the case where DR(i,) . By the construction of the set DR(i,), there is, for each pair (x,u) DR(i,), an input string w(x,u) such that si(x,w(x,u)) = s(x,u); select a shortest such string w(x,u). By the definition of DR(i,), the path P(i,x,w(x,u)) contains the race pair (r,v) of . Because cycles are not allowed, P(i,x,w(x,u)) contains (r,v) exactly once. Divide the path P(i,x,w(x,u)) into two parts P1,i(x,u) and P2,i(x,u), as follows. The part P1,i(x,u) contains the race pair (r,v) and ends with the stable combination (ri,v) immediately following (r,v). The part P2,i(x,u) consists of the remaining segment of the path P(i,x,w(x,u)), starting with the pair immediately following (ri,v). Now, referring to the common part of the path considered in Lemma 3.7, let w0(x,u) be a shortest common input string that takes the machine from the state x to the race pair (r,v), and set m(x,u) := |w0(x,u)|. Name the characters of this input string v0(x,u), v1(x,u), ..., vm(x,u)–1(x,u). Note that vm(x,u)–1(x,u) = v, the race input character, since this part

PAGE 52

42 of the path ends at the race pair. Then, w0(x,u) := v0(x,u) ... vm(x,u)–1(x,u). (3-32) Let P(i,x,w0(x,u)) be the path of the machine i starting at (x,u), driven by the input string w0(x,u), and ending with the stable combination (ri,v) which follows the race for i. Recalling Lemma 3.7, let us replace the path P1,i(x,u) by the path P(i,x,w0(x,u)) for all i = 1, ..., . Then, the concatenated path P(i,x,w0(x,u))P2,i(x,u) still takes the machine i from the combination (x,u) to the desired state s(x,u). Let wi(x,u) be the input string that generates the path P2,i(x,u). Let m(x,u,i) := |wi(x,u)|, and write this input string in terms of its individual characters as wi(x,u) := v0(x,u,i) ... vm(x,u,i)(x,u,i). (3-33) By construction, the machine i is at the state ri when the input string wi(x,u) starts, where ri is the stable outcome of the race. The state ri is reached at the end of the path P(i,x,w0(x,u)). Using notation analogous to Eq. 3-29, we have then ri = si(xm(x,u)–1(x,u),vm(x,u)–1(x,u)). (3-34) At this point, the input string wi(x,u) starts, driving the machine i through the following states: x1(x,u,i) := si(ri,v0(x,u,i)), x2(x,u,i) := si(x1(x,u,i),v1(x,u,i)), , s(x,u) := si(xm(x,u,i)(x,u,i),vm(x,u,i)(x,u,i)), (3-35) for all (x,u) DR(i,) and all i = 1, ..., . The following sets of elements will be used later as states of the controller C: R := {(1(x1,u1), ..., m(x1,u1)(x1,u1), ..., 1(xn(R),un(R)), ..., m(xn(R),un(R))(xn(R),un(R))}, (3-36)

PAGE 53

43 i := {(1,i(x1,u1), ..., m(x1,u1,i),i(x1,u1), ..., 1,i(xn(R),un(R)), ..., m(xn(R),un(R),i),i(xn(R),un(R))}, i = 1, ..., . (3-37) The various elements are selected so that N, R, 1, ..., are disjoint sets. If DR(i,) = for some i {1, ..., }, then set i := ; if DR(M,) = , then set R := and i := for all i = 1, ..., . Finally, define the following set of two new elements, also to be used later as states of the controller C 0 := {0, 1}. (3-38) Now, we are ready to start the construction of the controller C. First, the state set of C is given by := 0 N R 1 ... . (3-39) In the construction outlined below, the state subset 0 is used by the controller to record certain stable combinations of , to ensure fundamental mode operation. The state subsets N and R are used by the controller to generate input strings of along path segments that are common to all members of M. Finally, the state subset i is used by the controller to generate the input string of after the machine has passed through the race with the outcome ri. The recursion function and the output function of the controller C are constructed in the following steps. The construction is described for the case where the sets N, R, 1, ..., are all nonempty; appropriate adjustments can be made for cases where one or more of these sets is empty. (i) The initial state of the controller C is 0. Without a change in its output, C moves to the state 1 upon detection of a stable combination in the set V of Eq. 3-25. This

PAGE 54

44 assures that is in a stable combination before its input is changed by the controller, as required for fundamental mode operation. Accordingly, the recursion function of C is defined as follows. (0,(z,t)) := 0 for all (z,t) XA \ V, (0,(x,u)) := 1 for all (x,u) V. (3-40) While in the state 0, the controller is inactive; it is transparent, applying to its own external input. Accordingly, the output function of the controller is defined at this state by (0,(z,t)) := t for all (z,t) XA. (3-41) To define at the state 1, choose a character u* U(x), and set (1,(z,t)) := u* for all (z,t) XA. (3-42) In this way, remains in a stable combination with the state x as long as the controller is in the state 1. Note that the system is in a stable combination when its input is (possibly) changed to u*, so fundamental mode operation is retained. (ii) Recalling the set D of Eq. 3-27, assume that is in a stable combination with a state x xD and an input value u appears for which (x,u) D. Then, C gets ready to generate for an input string which will take to the state s(x,u) to match the model . This process is similar to the one used in the proof of Theorem 3.2. First, the controller moves to a state 1(x,u) to signify the encounter of the pair (x,u) (required for fundamental mode operation). (1,(x,u)) := 1(x,u) for (x,u) D; (1,(x,u)) := 1 for all u U(x) \ D(x); and (1,(z,t)) := 0 for all pairs (z,t) XA \ (V D). (3-43)

PAGE 55

45 Upon reaching the state 1(x,u), the controller starts to generate for the input string w(x,u) or the input string w0(x,u), as the case may be. In view of Eq. 3-28 or Eq. 3-32, as appropriate, this is accomplished by setting (1(x,u),(z,t)) = v0(x,u) for all (z,t) XA. (3-44) Note that is in a stable combination when this change in its input value occurs. According to Eq. 3-29, the input value v0(x,u) causes to move to the state x1(x,u). The pair (x1(x,u),v0(x,u)) is again a stable combination; it is the next step of the stable recursion function s. From here on, the controller continues to generate the input string w(x,u) (or w0(x,u), depending on the case) as input for , according to the following scheme. (iv) For 1 j m(x,u) and for all (x,u) D, (j(x,u),(xj(x,u),u)) := j+1(x,u), (j(x,u),(z,t)) := j(x,u) for all (z,t) (xj(x,u),u), (j+1(x,u),(z,t)) := vj(x,u) for all (z,t) XA, (3-45) where vj(x,u) is from Eq. 3-28 or Eq. 3-32, as the case may be. (v) For j = m(x,u), consider two cases: (a) For the case (x,u) DN(M,), assign (m(x,u)(x,u),(s(x,u),u))) := m(x,u)(x,u), (m(x,u)(x,u),(z,t)) := 0 for all (z,t) (s(x,u),u). (3-46) This terminates the action of the controller C for this case, since the state s(x,u) of has been reached. (b) When (x,u) DR(i,) for some i {1, ... }, set

PAGE 56

46 (m(x,u)(x,u),(ri,u)) := 1,i(x,u), (m(x,u)(x,u),(z,t)) := m(x,u)(x,u) for all (z,t) (ri,u), (1,i(x,u),(z,t)) := v0(x,u,i) for all (z,t) XA, (3-47) where v0(x,u,i) is the first input value in Eq. 3-33. The controller C then continues to generate the input string in Eq. 3-33, following the string of stable combinations of i described in Eq. 3-35. (j,i(x,u),(xj(x,u,i),u)) := j+1,i(x,u), (j,i(x,u),(z,t)) := j,i(x,u) for all (z,t) (xj(x,u,i),u)), (j+1,i(x,u),(z,t)) := vj(x,u,i) for all (z,t) XA, (3-48) where j = 1, ..., m(x,u,i). The end of the input string in Eq. 3-33 is reached at j = m(x,u,i); by Eq. 3-35, the system i reaches then the desired state s(x,u), and then assign (m(x,u,i)(x,u),(s(x,u),u)) := m(x,u,i)(x,u), (m(x,u,i)(x,u),(z,t)) := 0 for all (z,t) (s(x,u),u). (3-49) This completes the construction of the controller C. An argument similar to the one used in the proof of Theorem 3.2 shows that this construction yields a controller for which the closed loop system is well posed and operates in fundamental mode. Theorem 3.4 presents the solution to the model matching problem for machines without specified initial conditions. Considering the situation where the machine and the model have a preset initial state, we obtain the following statement. Corollary 3.8 Given the same machines and the notation in Theorem 3.4, let x0 X to be the preset initial state of both and . Then, the two statements (i) and (ii) in Theorem 3.4 are equivalent. Proof. The results could be derived directly from Theorem 3.4.

PAGE 57

47 We comment that the construction of the controller C in the proof of Theorem 3.4 does not attempt to minimize the number of controller states. Once C has been determined through the construction described in the proof, the number of its states can be reduced by using standard state reduction techniques for asynchronous machines (KOHAVI 1970). In cases where the input strings needed to control the machine are not uniquely determined, careful selection of the strings generated by the controller can help further reduce the number of controller states. 3.4 Example This section demonstrates the construction of a controller C that fulfills the requirements of Theorem 3.4. Consider an input/state asynchronous machine having the input set A = {a,b,c} and the state set X = {x1,x2,x3}. Assume the machine has a critical race at the pair (x1,c), with two possible outcomes: x2 and x3. The recursion function f of is described by Table 3-1 of transitions. Table 3-1. Stable transition table for the machine a b c x1 x1 x2 {x2, x3} x2 x3 x2 x2 x3 x3 x2 x3 The machine induces a critical race family M = {1, 2} with two stable-state member machines whose stable recursion functions s1 and s2 are described in Table 3-2 and Table 3-3, respectively. Using the tables, we obtain the one-step stable transition matrices: R(1) = {a}{bc}NN{bc}{a}N{b}{ac}, R(2) = {a}{b}{c}N{bc}{a}N{b}{ac} (3-50)

PAGE 58

48 Using the corresponding matrix operations in Murphy, Geng, and Hammer 2003, the resulting matrices of stable transitions are given by R(2)(1) = {aaa}{bcabacbbbccbcc}{baca}N{bcbbbccbccab}{abacaaaac}N{bbbbcabcb}{acbaaaaccacc} (3-51) R(2)(2) = {aaa}{babbbbccb}{cacbacacc}N{bcbbbccbccab}{abacaaaac}N{bbbbcabcb}{acbaaaaccacc} (3-52) Table 3-2. Stable transition table for the machine 1 a b c x1 x1 x2 x2 x2 x3 x2 x2 x3 x3 x2 x3 Table 3-3. Stable transition table for the machine 2 a b c x1 x1 x2 x3 x2 x3 x2 x2 x3 x3 x2 x3 Next, the one-step skeleton matrices are S(1) = 110011011, S(2) = 111011011, (3-53) The skeleton matrices are then calculated by Eq. 2-9 as K(1) = 111011011, K(2) = 111011011. (3-54)

PAGE 59

49 The skeleton matrix of the family M is found by Eq. 2-12 to be K(M) = 111011011. (3-55) Choose the stable-state machine := 2 (3-56) as the desired model to match (this is an arbitrary choice). Apply now the construction described in the proof of Theorem 3.4 to obtain a controller C. In view of Eq. 3-18 and Table 3-2 and 3-3, a slight reflection shows that the discrepancy sets satisfy D(1,) = {(x1,c)}, and D(2,) = , (3-57) where the last equality originates from the fact that = 2.The set of input values which form stable combinations with the state x1 is U(x1) = {a}, and the set V of Eq. 3-25 is given by V = {(x1,a)}. (3-58) Letting s be the recursion function of and recalling that = 2, it follows from Table 3-3 that s(x1,c) = x3. By Table 3-2, the set of input strings that take 1 from (x1,c) to s(x1,c) = x3 is, in the notation following Eq. 3-18, given by S1(x1,c) = {ca}. (3-59) By Table 3-3, the set of input strings that take 2 from (x1,c) to s(x1,c) is S2(x1,c) = {c}. (3-60) The paths of each system are then given by

PAGE 60

50 P(1,x1,ca) = {(x1,c), (x2,c), (x2,a), (x3,a)}, (3-61) P(2,x1,c) = {(x1,c), (x3,c)}. (3-62) As we can see, both paths contain the race pair (x1,c), so that in this case we have DN(M,) = , DR(1,) = D(1,) = {(x1,c)}. (3-63) Referring next to Eq. 3-30, Eq. 3-36, and Eq. 3-37, it follows that N = , R = {1(x1,c)}, 1 = {1,1(x1,c)}, and 2 = . By Eq. 3-39, the controller C has the state set = {0, 1, 1(x1,c), 1,1(x1,c)}, (3-64) consisting of 4 states in this case. Following the construction described in the proof of Theorem 3.4, the recursion function and the output function of the controller C are as follows. (0,(z,u)) := 0 for all (z,u) XA \ (x1,a); (0,(x1,a)) := 1; (0,(z,u)) := u for all (z,u) XA; (1,(x1,c)) := 1(x1,c); (1,(x1,a)) := 1; (1,(z,t)) := 0 for all pairs (z,t) {(x1,a), (x1,c)}; (1,(z,u)) := a for all (z,u) XA; (1(x1,c),(x2,c)) := 1,1(x1,c); (1(x1,c),(z,t)) := 1(x1,c) for all pairs (z,t) {(x2,c), (x3,c)}; (1(x1,c),(x3,c)) := 0; (1(x1,c),(z,u)) := c for all (z,u) XA; (1,1(x1,c),(x3,c)) := 1,1(x1,c), (1,1(x1,c),(z,t)) := 0 for all (z,t) (x3,c); (1,1(x1,c),(z,u)) := a for all (z,u) XA. (3-65) This completes the example.

PAGE 61

CHAPTER 4 MODEL MATCHING FOR INPUT/OUTPUT DETERMINISTIC MACHINES Chapter 3 has seen how to design state feedback controllers that correct undesirable properties of input/state asynchronous machines. The present chapter deals with a similar problem for a more general class of asynchronous machines: the class of input/output machines (i.e., machines whose output is not necessarily their state). The goal is to design an output feedback controller C for which the input/output behavior of the closed-loop system c matches that of a prescribed model . This is, again, an instance of the model matching problem. Among other topics, we prove in this chapter the validity of a separation principle, whereby every solvable model matching problem can be solved by a controller C that consists of two asynchronous machines: an observer and a state-feedback control unit , as depicted in Figure 1-2. The observer estimates the state of the machine from the input/output data of , and feeds the estimated information to the control unit . The latter generates a sequence that drives along a desirable path. To exhibit such decomposition, we write C = (). In the present chapter, necessary and sufficient conditions are obtained for the existence of a solution for the model matching problem. Also an algorithm is provided for the design of an appropriate controller C, whenever one exists. The present chapter is organized as follows. Section 4.1 focuses on asynchronous observers and related issues. The main results about the model matching problem are 51

PAGE 62

52 presented in Section 4.2, which includes necessary and sufficient conditions for the existence of solutions, as well as methods for the implementation of solutions, whenever solutions exist. An algorithm to check the existence of a solution to the model matching problem is presented in Section 4.3. The chapter concludes with Section 4.4, which contains an example of the calculation of a model matching controller. 4.1 Detectability and Observers In order for the control configuration of Figure 1-1 (or Figure 1-2) to operate in fundamental mode, the input value of must remain constant while undergoes state transitions. This requires that, after every change, the output value of the controller C must remain constant until reaches a stable combination. Accordingly, it must be possible for the controller to detect when reaches its next stable combination. As the controller has no access to the state of , this detection can only be based on input/output data of , namely, on its input string and on its output string. The following concept is crucial in this context. Definition 4.1 An asynchronous machine = (A,Y,X,x0,f,h) is detectable at a valid pair (x,u) if it is possible to determine from input/output data whether has reached the next stable combination of (x,u). To examine the situation more closely, let = (A,Y,X,x0,f,h) be an asynchronous machine with stable recursion function s. Assume that is in a stable combination (x1,v) when the input character changes to u. Let x1, x2, ..., xm be the string of states generated by this input change, where xm = s(x1,u) is the next stable state of , and, if m > 1, the other states satisfy xi+1 = f(xi,u), i = 1, ..., m – 1. The corresponding output string is then h(x1)h(x2)h(xm). When m = 1, the machine remains in a stable

PAGE 63

53 combination, so the issue of detecting arrival at the next stable state becomes mute. However, when m > 1, a careful examination is required, since the output values h(x1), h(x2), , h(xm) generated during this transition may not be all distinct. In an asynchronous environment, it is impossible to distinguish between consecutive equal values of a string, since there is nothing to mark the start of a new step. Accordingly, constant segments of the output string appear as a single element. The presence of constant segments in the output string, say, when h(xi) = h(xi+1) for some i {1, ..., m–1}, may produce a difficulty: it would make it impossible to determine from input/output data when the transition from xi to xi+1 has occurred. Note that the input data does not help in this regard, since the input is fixed at u during this entire string of transitions. Before discussing these issues further, it is convenient to introduce the following notion. Definition 4.2 Let y = y0y0y1y1ykyk be a string of elements of a set Y, where yj yj+1 for all j = 0, , k-1. The string burst(y) := y0y1yk is named the burst string or the burst of y. The burst is obtained by replacing each segment of repeating characters by a single occurrence of the same character. For example, the output string abbcccaa has the burst burst(abbcccaa) = abca. Clearly, the burst is the only discernible entity of an asynchronous output string. When referring to the output string generated by the machine from the valid pair (x1,u), we use the shorter notation burst(x1,u) := burst(h(x1)h(x2)h(xm–1)h(xm)). (4-1) To determine from input/output data whether has reached the stable combination (xm,u), we need to find out whether the output string h(x1)h(x2)h(xm) has reached its end. This, however, is not always feasible. Consider, for example, the case

PAGE 64

54 where m = 3, and h(x1) = a, h(x2) = b, h(x3) = b. Here, it is not possible to determine from the output whether the machine has reached the stable combination (x3,u), since the output switches to b at the state x2 and remains unchanged during the transition from x2 to x3. The difficulty originates from the fact that one observes only the burst of a string, not the string itself. Consequently, the end of the output string can be determined if and only if it is signified by a difference in the burst, that is to say, if and only if burst(h(x1)h(x2)h(xm–1)) burst(h(x1)h(x2)h(xm–1)h(xm)). The last condition is equivalent to h(xm–1) h(xm). This provides a practical test for detectability and justifies the next statement. It will be convenient to use the notation burst(x1,u) := burst(h(x1)h(x2)h(xm–1)) for m > 1 for m = 1. (4-2) The following is a necessary and sufficient condition for the detectability. Proposition 4.3 An asynchronous machine = (A,Y,X,x0,f,h) is detectable at a valid pair (x,u) if and only if burst(x,u) burstx,u). In general, of course, an asynchronous machine may or may not be detectable at any one of its valid pairs. However, for input/state machines, the situation is different. Proposition 4.4 An asynchronous input/state machine is detectable at all its valid pairs. Proof. The following uses the notation of the previous paragraphs regarding the valid pair (x1,u). When m = 1, one always has burst(x1,u) burst(x1,u), since burst–1(x1,u) = and burst(x1,u) = xm in this case. Next, assume that m > 1. Then, since xm is the next stable state, the states x1, x2, ..., xm must all be distinct. Indeed, a repeating state in this list would either create a stable combination before xm is reached, or it

PAGE 65

55 would cause an infinite loop. But then, burst(x1,u) = x1x2 ... xm–1, while burst(x1,u) = x1x2 ... xm, so burst(x1,u) burst(x1,u) in all cases. Critical to the present discussion is the following notion (Murphy, Geng, and Hammer 2002 and 2003). Let = (A,Y,X,x0,f,h) be an asynchronous machine with state set X = {x1, , xn}, and let s be its stable recursion function. The one-step skeleton matrix S() is an nn matrix of zeros and ones whose (i,j) entry is Sij() = 1 if there is a character u A such that is detectable at (xi,u) and xj = s(xi,u); Sij() = 0 otherwise. In the special case when the machine is detectable (e.g., when is an input/state machine), the present definition reduces to the one used in Murphy, Geng, and Hammer 2002 and 2003. Using the combination operation for matrices described in Definition 2.16, let us consider the k-th power Sk() of the one-step skeleton matrix, k = 1, 2, ... Let Skij() be the (i,j) entry of Sk(). Define the matrix S(m)() by setting its (i,j) entry to be S(m)ij():= maxk = 1, ..., m Skij(), m = 1, 2, (4-3) Then, S(m)() is also a matrix of zeros and ones, and S(1)() = S(). The following terminology is convenient at this point. Definition 4.5 Let xi and xj be two states of the asynchronous machine = (A,Y,X,x0,f,h). A chain of detectable stable transitions from the state xi to the state xj is a string of detectable pairs (xi,u1), (x2,u2), ..., (xm–1,um), where u1, u2, ..., um A are input characters, and x2 := s(xi,u1), x3 := s(x2,u2), ..., xm := s(xm–1,u) = xj are stable states.

PAGE 66

56 Returning to the matrix S(m)(), a slight reflection shows that the entry S(m)ij() = 1 if and only if the state xj can be reached from the state xi through a chain of detectable stable transitions. The case m = n, where n is the number of states of , is of particular importance. Definition 4.6 Let S() be the nn one-step skeleton matrix of . The skeleton matrix of is K() := S(n)(). In view of Proposition 4.4, it follows that, in the case of asynchronous input/state machines, the present definition of the skeleton matrix reduces to the definition of Murphy, Geng, and Hammer 2002 and 2003. A discussion analogous to the same reference yields the next result. Proposition 4.7 Let xi and xj be two states of the asynchronous machine = (A,Y,X,x0,f,h), and let K() be the skeleton matrix of . Then, the following two statements are equivalent. (i) There is a chain of detectable stable transitions from the state xi to the state xj. (ii) Kij() = 1. As mentioned earlier, fundamental mode operation implies that the controller C in Figure 1-2 can guide the system only along paths that are chains of detectable stable transitions. When this fact is combined with Proposition 4.7, it gives rise to the expectation that the skeleton matrix K() would be critical in determining control capabilities. The forthcoming sections bear out this expectation. The next turns to a discussion of observers for asynchronous machines. The notion of observer is employed here in a role similar to its use in other branches of control theory. Briefly, an observer is an asynchronous input/state machine whose purpose is to

PAGE 67

57 calculate the current state of another asynchronous machine, using input/output data of that machine. One can attempt to obtain an observer for a machine = (A,Y,X,x0,f,h) by using the input/state part of , namely Bf = (A,X,X,x0,f,I), where I indicates the identity output function. The machine Bf would, of course, reproduce the transitions of the input/state part of , except that the transitions would not be synchronized among the two machines. Indeed, if, in response to an input string, the machine Bf passes a state x, then the machine must also pass the state x in response to the same input string. However, since the machines are asynchronous, may reach the state x either before, or during, or after the time x is reached by Bf. In other words, Bf is not an observer, since it is not synchronized with . Furthermore, this argument indicates that it would never be possible to build an observer for transient states of ; as the machines (ideally) spend zero time in a transient state, there is no opportunity to synchronize them. Thus, the most one can hope is to build an observer for stable combinations of . To deal with stable combinations, the following discussion restricts to the stable recursion function s of , and whence we use the stable input/state machine Bs = (A,X,X,x0,s,I) as the basis of the ensuing discussion. The next statement will help us show that Bs can be augmented in a simple way to yield an "observer" by utilizing the notion of detectability introduced earlier in this section. Lemma 4.8 Given an asynchronous machine = (A,Y,X,x0,f,h), let (x1,u) be a valid pair, and let xm be the next stable state of (x1,u) through the transient state chain x1, x2, , xm. Let j be the burst of moving from x1 to xj. Then the following two

PAGE 68

58 statements are equivalent. (i) The machine is detectable at the pair (x1,u). (ii) There is a function (x1,u,) : Y* {0,1} such that (x1,u,j) = 1 if and only if j = m. Proof. First, assume that (ii) is valid. Then, it must be true that (x1,u,burst(x1,u)) (x1,u,burst(x1,u)), which implies that burst(x1,u) burst(x1,u), and part (i) follows by Proposition 3.3. Conversely, assume that (i) is valid. Then, using again Proposition 3.3, we get burst (x1,u) burst(x1,u). The latter implies that the function (x1,u,) : Y* {0,1} defined by (x,u,burst(x1,u)) := 1 and (x1,u,y) := 0 for all y burst(x1,u) satisfies condition (ii). This completes the proof. As discussed earlier, the observer has to be designed in such a way that the entire composite system c operates in fundamental mode, that is, the controller needs to remain unchanged until the machine reaches a stable combination. According to Lemma 4.8, the detectability of at the pair (x1,u) ensures that the observer can determine the state status of from the output data (i.e., the transition burst burst(x1,u)). The observer then indicates the point at which the controller can start to change. One of the input ports of the observer is connected to the output of the machine (see Figure 1-2); the burst of can then be recorded on a shift register. The register is initially empty, and it accumulates the output data until the machine has reached a stable combination; then, it clears the memory and starts afresh for the next stable transition of . Let

PAGE 69

59 := {burst(x,u), (x,u) is a valid and detectable pair of } (4-4) be the set of all transition bursts of the machine ; denote by the set of all prefixes of the elements of . Then, the output string recorded by the above shift register at any moment is an element of , and the register resets its memory when the recorded string is an element of . Clearly, as the length of the transition bursts in is finite, the above register can be finite. Then, the observer is an input/state machine = (A,X,X,x0,,I), where is the recursion function and I is the output function. We can build now an observer that will reproduce all transitions of that are both stable and detectable. To define the operation of the observer, consider the situation where the machine is in a stable combination (x,uk) it has reached from a detectable pair. Assume that, at the step k, the input character changes from uk to uk, where (x,uk) is also a detectable pair. For the machine , let x = s(x,uk) be the next stable state of x with the input uk, and let burst(x,uk) be the burst of this transition. Then, the inputs of the observer are the input character uk of and the output burst y* from . Letting k and k be, respectively, the state and the output of at a step k, we set : k+1 = (k,(uk,y*)) = s(k,uk) if y* = burst(k,uk)k otherwise; (4-5) k = k. The observer functions then recursively, as follows. Assume is initially at x0 and moves to the next stable state x1 in response to the input u0. Starting from the initial state 0 = x0, the observer keeps staying at 0 until one of its inputs turns to burst(0,u0). At that point, the machine has reached the next stable state x1; then, the

PAGE 70

60 observer moves to 1 = s(0,u0) = x1 and outputs 1 = x1, indicating the new state of . Consider a step k when is in the stable combination (x,uk-1) and the output of the observer is equal to the state x. As a result of a new input uk, the machine moves to its next stable state x = s(x,uk), generating burst(x,uk) along the way. During this process, the output of stays at x until the entire string burst(x,uk) is received from , at which point the state of the observer changes to x and outputs k+1 = x. In such a fashion, the output of the observer always indicates the most recent stable state the machine has reached via a detectable transition. The observer can be used to read the state of after a detectable stable transition; by Lemma 4.8, it is not possible to infer the state of under any other circumstances. Note that the observer is a stable state input/state machine. 4.2 Controller Design and Existence Condition This section presents a solution of the model matching problem. Specifically, the work includes necessary and sufficient conditions for the existence of a solution, and it shows that, when a solution exists, a model matching controller can be taken as a combination of an observer and a control unit, as depicted in Figure 1-2. The structure of the observer was described earlier in Eq. 4-5; an algorithm for the construction of the control unit is included later in this section. We start with a technical notion that is critical to the ensuing discussion. 4.2.1 Extended Skeleton Matrices Given a set X, let Z = {Z1, ..., Zm} be a list of subsets of X. The integer m is the length of the list Z. Given a list Z = {Z1, ..., Zm}, another list Z = {Z1, ..., Zm} of the

PAGE 71

61 same length m is a subordinate list of Z if Zi Zi for each i = 1, ..., m. To indicate that Z is a subordinate list of Z, we write Z Z. If a list contains the empty set as one of its members, then we say that it is deficient. Definition 4.9 Let be an asynchronous sequential machine with the state set X. Let Z1, Z2 be two lists of elements of X. The reachability indicator of with Z1 and Z2, denoted by d(,Z1,Z2), is 1 if every element of Z1 can stably reach at least one element of Z2; otherwise, d(,Z1,Z2) := 0. Given the skeleton matrix K() and two lists of elements of X, Z1 and Z2, we are able to obtain the reachability indicator d(,Z1,Z2) from K() by the definition. For example, suppose that we have the machine with the state set X = {x1,x2,x3} and the skeleton matrix K() = 111011011. (4-6) Let Z1 = { x1,x2} and Z2 = {x1,x3} be two lists of elements of X. We get the reachability indicator d(,Z1,Z2) = 1 since both x1 and x2 in Z1 can stably reach x3 in Z2 at least. Definition 4.10 Given a machine with the state set X and the skeleton matrix K(), let Z = {Z1, ..., Zm} be a list of subsets of the state set X. The extended skeleton matrix K(,Z) is an mm matrix, whose (i,j) entry is Kij(,Z) := d(,Zi,Zj) Following the preceding example, let Z = {Z1,Z2} be a list of subsets of X, where Z1 and Z2 are given as before. We can obtain that the extended skeleton matrix of with respect to Z by calculating each of its entries. The entry K11(,Z) = d(,Z1,Z1) = 1 and the entry K22(,Z) = d(,Z2,Z2) = 1 since each element of Z1 and Z2 can stably

PAGE 72

62 reach itself; K12(,Z) = d(,Z1,Z2) = 1 as calculated before; and K21(,Z) = d(,Z2,Z1) = 1 since both x1 and x3 in Z2 can stably reach x2 in Z2 at least. Therefore, the extended skeleton matrix K(,Z) is the 22 matrix K(,Z) = 1111. (4-7) Finally, let = (A,Y,X,x0,s,h) and = (A,Y,X,0,s,h) be two stable-state machines, and let X = {1, , q} be the state set of . For a point y Y, denote by hI(y) the subset of all states x X satisfying h(x) = y, where hI(y) = , the empty set, when y is not in the image of h. Clearly, hI simply denotes the inverse function of h. Given the output set Y = {y1, , y}, we define the counter-image list of as {hI(y1), , hI(y)}. (4-8) We define the equivalence list B(,) of with respect to B(,) := {hIh(1), , hIh(q)} (4-9) as a list of the q subsets of X. Clearly, B(,) is a special list of members of the counter-image list of . 4.2.2 Existence Conditions for Controllers In this section we derive necessary and sufficient conditions for the existence of controllers that solve the model matching problem for asynchronous machines. We show that the model matching problem can always be solved by a controller that is decomposed into a control unit and an observer, as depicted in Figure 1-2. The principles of constructing the control unit are outlined as well. Recall that the structure of the observer was described earlier in Eq. 4-5. First we set some notation for the control system. Let A be the input set of the

PAGE 73

63 machine , and let be the set that contains all prefixes of the transition bursts of , as defined in Section 4.1. In view of Figure 1-1, the input set of C is then the cross product A; the output set of C is simply the set A. We can describe C as the sextuple (A,A,,0,,), where is the state set, is the recursion function, is the output function, and 0 is the initial state of C. Being a combination of the machines C and the closed-loop system c has the state set X. Denote by G the set of reachable stable states of , then G X. The input and output of c are A and Y, respectively. Denote by sc the stable transition function of c, and denote by hc the output function. Then, we can describe the closed-loop system c by (A,Y,G,(0,x0),sc,hc). Also notice that the output of c is the output of , so the output function of c is a partial function hc : GA Y satisfying hc((,x),v) = h(x) for any state (,x) X and any input v A. We turn now to a formal statement of the model matching problem. Let be the machine that needs to be controlled. Assume that it is necessary to change the behavior of the machine so that it becomes equal to the behavior of a specified asynchronous machine . We refer to the machine as the model. Clearly, as only the input/output behavior of is relevant, the model can always be taken as a stably minimal machine -reduction to stably minimal form does not alter the input/output behavior. The problem is then to find a controller C such that the closed loop system in Figure 1-1 satisfies c = . Lemma 4.11 Let = (A,Y,X,x0,f,h) and = (A,Y,X,0,s,h) be two asynchronous machine, where is stably minimal and satisfies h(x0) = h(0). Assume

PAGE 74

64 there is a controller C for which c is stably equivalent to . Then, there is a nondeficient subordinate list Z of the equivalence list B(,) for which the extended skeleton matrix satisfies K(,Z) K(). Proof: Given a controller C = (A,A,,0,,) for which c = , we will derive the inequality K(,Z) K() in the following by constructing an equivalence partition and a quotient machine of c. Following the earlier notation, the state set of is X ={1, , q}. The machine c is stably equivalent to the stably minimal machine , then, by Proposition 2.11, there exists an equivalence partition of the state set G of c such that the quotient machine c/ is isomorphic to . Denote the partition by {1, , q} where its blocks are disjoint subsets of G. For the quotient machine c/, we use to represent its state set, then each block of stands for a state of the machine c/. Since c/ is stably equivalent to , we are able to set i i, i = 1, , q. The initial state of c/ is denoted by 0, so we have (0,x0) 0. Denote by sc and s the stable recursion functions of c and c/, respectively. Denote the block i of by {(i,1,xi,1), , (i,m(i),xi,m(i))}, where i,1, , i,m(i) and xi,1, , xi,m(i) X for i = 1, , q. From the properties of the equivalence partition, namely, transition consistency and output consistency, it follows that (i) hc((i,1,xi,1),u) = = hc((i,m(i),xi,m(i)),u), for any u A; (ii) s(i,u) = j in c/ if and only if for each m = 1, , m(i), there exists an index n {1, , m(j)} such that the transition sc((i,m,xi,m),u) = (j,n,xj,n)

PAGE 75

65 holds in c. Since the output function hc((,x),u) = h(x) and the states i i, we get from (i) and (ii) that (iii) h(xi,1) = = h(xi,m(i)) = h(i); (iv) s(i,u) = j in if and only if for each m = 1, , m(i), there exists n {1, , m(j)} such that sc((i,m,xi,m),u) = (j,n,xj,n) exists in c. In view of the closed-loop configuration in Figure 1-1, the controller has access to the machine only through the input of , so, the statement (iv) implies that (v) s(i,u) = j in then for each m = 1,m(i), there exists an integer n {1, , m(j)} and t A* such that s(xi,m,t) = xj,n in . Now, collect the second variables of i, which are xi,1, xi,2, , xi,m(i), and denote as Zi; and then Zi is a subset of X. We define further Z = {Zi X, i = 1, , q}. Evidently, Z is a subordinate list of B(,). Now, we verify the skeleton matrix inequality in the theorem. In view of statement (v), s(i,u) = j implies that Kij() = 1. The second-half part of (v) implies that each element of Zi has access to an element of Zj, which follows that the extended reachability indicator d(,Zi,Zj) = 1. The above holds for any element Zi and Zj in Z, so we have Kij(,Z) = 1 from the definition of the extended skeleton matrix K(,Z). We conclude that if Kij() = 1, then Kij(,Z) = 1 from the statement (v). In other words, K(,Z) K() holds, which completes the proof. The above lemma presents a necessary condition for the existence of solutions to the model matching problem with the model given as a stably minimal machine. The next

PAGE 76

66 statement will tell us that the same kind of condition holds when the model is not stably minimal. Assume here the model is stably reachable; if not, again, it is always easy to get a stably equivalent machine which is stably reachable, by removing the states that are not stably reachable. Lemma 4.12 Let and be as described in Lemma 4.11, and assume that is a stably reachable machine. If there is a controller C such that c = , then there exist a subordinate list of B(,), denoted by Z, such that K(,Z) K(). Proof. The result will be derived by examining the relations between the skeleton matrix of and that of its stably equivalent machine which is stably minimal. First, if the machine is not stably minimal, it is always possible to find an equivalence partition to construct a quotient machine of , denoted by / = {A,Y,,0,sm,hm}, which is a stably minimal machine. It is evident that the machine / is stably equivalent to . For the machines and /, denote their state set by X = {1, , q} and = {1, , p}, respectively, and then build a homomorphism : X with (i) = j, where j is the block of containing i, and i (i). Then, by the definition of quotient machines, we have h(i) = hm((i)) and (0) = 0. Next, we shall show the following argument is true: There exists a subordinate list Z = {z1, , zq} of B(,) such that K(,Z) K() if there exists a subordinate list Z = {z1, , zp} of B(,/) such that K(,Z) K(/). The state set of machine is given by X = {1, , q}. Using the homomorphism , we build another set by [X] := {(1), , (q)} where (i)

PAGE 77

67 for i = 1, , q. Since = {1, , p}, we can write [X] as {i(1), ,i(q)} where i(j) and i(1), , i(q) {1, , p}. In the notation of the indices i(1), , i(q), we define Z in terms of elements of Z as follow, Z = {zi(1), , zi(q)} := {z1, , zq} where zij Z for j = 1, , q. (4-10) We show that this Z is a subordinate list of B(,). We have h(zj) = {hm(j)} since Z is a subordinate list of B(,/), and also it holds that i(j) = (j) from the preceding discussion, thus, h[zj] = h[zij] = hm(i(j)) = hm((j)). (4-11) Applying Eq. 4-10 into Eq. 4-11, we get h[zj] = h(j) for each j. Hence, Z is a subordinate list of B(,). Now, we will show that the list Z we define above satisfies K(,Z) K() if K(,Z) K(/) holds. First, we have Kjk(,Z) = Ki(j),i(k)(,Z) by the relation between Z and Z; then, Ki(j),i(k)(/) = Kjk() holds in terms of the relation between [X] and X. Hence, we conclude that Kjk(,Z) Kjk() for j, k = 1, , q, namely, K(,Z) K(). So, the argument is valid. In view of Lemma 4.11, if there exists a controller C such that the closed-loop system c is stably equivalent to the stably minimal machine /, then there is a subordinate list Z of B(,/) such that K(,Z) K(/). Applying the result of the above statement, it follows that there exists a subordinate list Z of B(,), such that K(,Z) K(). Next, we shall derive a necessary and sufficient condition for the existence of solutions to the model matching problem. This derivation includes the design of a

PAGE 78

68 controller C = (,) that decomposes into a control unit and an observer . The observer := (A,X,X,x0,,I) is described in Section 4.1. As to the control unit , we denote by := (AX,A,,0,,). Note that the input set AX indicates that it has two inputs -the system input and the output of . Being a combination of the machines ,, , the system c has the state set G := XX = {(,x,), , x X, X}. Theorem 4.13 Let = (A,Y,X,x0,f,h) be an asynchronous machine, and let = (A,Y,X,0,s,h) be a stable-state machine satisfying h(x0) = h(0), where both machines are stably reachable. Then the following two statements are equivalent. (a) There is a controller C = (,) such that the closed-loop system c is stably equivalent to , where c operates in fundamental mode. (b) There is a subordinate list Z of B(,) for which the skeleton matrix inequality K(,Z) K() holds. Proof: Regarding the verification that (a) implies (b), it has been given in the above lemmas. For the converse direction, assume that Z = {Zi X, i = 1, , q} is a subordinate list of B(,) that satisfies K(,Z) K(). Using the list Z, we shall build a controller C for which the input/output behavior of the closed-loop system c matches that of the machine . Incidentally, we will also show that C can be decomposed into a control unit and an observer , as connected in the Figure 1-2. First, suppose the initial states of and satisfy 0 := e X and x0 := xd X, respectively. We construct a new list W = {Wi X, i = 1, , q} by adding the initial state x0 of to the member Ze of Z (if it is not already there), while leaving all other

PAGE 79

69 members of Z unchanged. In other words, We = Ze {x0} and Wj = Zj for j e. We show next that the list W is still a subordinate list of B(,) satisfying K(,W) K(). Indeed, since h(x0) = h(0) by the assumption of the theorem and h[Ze] = h(e) = h(0) by definition, it follows that h[We] = h[Ze {x0}] = h[Ze] h[x0] = h(Ze). In addition, since Wi = Zi for i = 1, , q and i e, we get h[Wi] = h[Zi] = h(i) for i = 1, 2, , q and i e. Thus, the list W is still a subordinate list of B(,). Next, since every state of is stably reachable from the initial state x0, we have K(,x0,xi) = 1 for all xi X. Combining the equality We = Ze {x0} with Definition 4.9, we get d(,We,Wi) = d(,Ze,Zi) for all i = 1, , q, (4-12) d(,Wi,We) d(,Zi,Ze) for all i = 1, , q. (4-13) Together with d(,Wi,Wj) = d(,Zi,Zj) for all i, j = 1, , q and i, j e, we have K(,W) K(,Z) K(). Recall that for each member of W, say, Wi, its elements generate the same output value as the state i of does. In the following, we shall design the controller so that any member Wi of W corresponds to one state, i.e., i, of the model, i = 1, , q. That is to say, whenever the machine stays at a state x Wi, the controller will work in such a way that the closed-loop machine c has the same input/output behavior as the model does at the state i. From the definition of the list W, it is possible that different members of W contain the same state of X. For instance, x Wi and x Wj for x X. If this

PAGE 80

70 happens, we need to know which member of W the state x currently belongs to, Wi or Wj, since the controller action will depend on whether x is treated as a member of Wi or of Wj at that instant. This is done by assigning different states of the control unit . Remember that the state space of the closed-loop machine c is contained in the cross-product XX, where is the state set of the control unit . To be simple, we assign the state of to be i if the machine is at the state x Wi. Denote by Gi := {(i,x,x) : x Wi}, i = 1, , q; clearly the elements of the sets G1, ..., Gq are stable states of the composite machine c. The controller C is designed below so that, starting from a state in Gi, the closed-loop machine c generates the same input/output behavior as the model does at its state i, i = 1, , q. Note that x0 We, so we have (e,x0,x0) Ge from the above assignment. Now, let us construct a controller to achieve the above objective. The controller decomposes into two machines: an observer whose output is the current stable state of , and a control unit which serves as a "state-feedback" controller. The observer := (A,X,X,x0,,I) is described in Eq. 4-5, so we only need to build the control unit . The control unit has the inputs x and u, where x is the output of the observer (equal to the state of ) and u is the external input of the composite system. The elements 1, ..., q mentioned earlier will be part of states of the control unit . Denote by = {1, ..., q} which is a subset of the state set of . The state transition function of the control unit is built so that has the following property. Whenever there is a stable state transition s(i,u) = j in and the system is at a state x Wi, the control unit generates an input string for

PAGE 81

71 that takes to a state Wj. The existence of such an input string is guaranteed by the inequality K(,W) K(). The special construction of the sets W1, ..., Wq guarantees that the output of the closed loop system c will mimic the output of the model by the above transitions. The states 1, ..., q of the controller are used to help identify the relevant member of W, since the same state x may belong to several members of W. Let us start now to design the transition function of the control unit . Assume that the control unit is currently in a stable combination with the state i and that is in a stable combination at the state x Wi. By construction, the observer will then also be in a stable combination with the state x, so the composite system c is at the stable state (i,x,x). This is necessary in order to ensure fundamental mode operation, in which the system must be in a stable combination before the controller initiates its action. We will now design the control unit so that it generates an input string t that drives the machine from the state x Wi to the state Wj. At the end of this process, the composite machine c will settle down at the state (j,,). Note that this process is associated with the state-input pair ((i,x,x),u) (or the triple (i,x,u) for short). Suppose that the string t consists of characters t = t1t2 ... t. Due to the requirement of fundamental mode operation, the control unit must generate the string t one character at a time, making sure at each step that the composite system has reached a stable combination before generating the next character. To this end, the control unit needs states which we shall denote later by 1, 2, -1, , and denote by (i,x,u) := {1, 2, -1, }. Input string t will take the system through stable combinations, say (x1,t1), (x2,t2), ..., (x,t), where x = . The outputs of the observer

PAGE 82

72 recognize these states as passes through them, so x1, ..., x can be regarded as the corresponding observer output values. Let s be the stable state transition function of , and denote by U(x) := {u A : s(x,u) = x}, the set of all input characters that form stable combinations with the state x. Similarly, U() := {u A : s(,u) = }. We can next specify the transition function and the output function of step by step. (i) Suppose the system c is initially in a stable combination with the state (i,x,x), as we discussed above. Accordingly, the operations of are defined as follows. Select an element u* U(x). (i,(x,w)) := i, for all w U(i), (i,(x,w)) = u*, for all w A. (4-14) (ii) An external input value u appears for which the model possesses s(i,u) = j. The control unit starts to apply to the input string t = t1t2 ... t which will bring to the state Wj. This process is accomplished by the following settings. (i,(x,u)) := 1, (1,(z,w)) := t1 for all (z,w) XA. (4-15) For 2 j , (j-1,(xj-1,u)) := j, (j,(z,w)) := tj for any (z,w) XA. (4-16) (iii) As a result of the last input character t that the control unit produces, the machine reaches the stable state . Then we choose an element v* U() and assign the following. (,(,u)) := j, (j,(,u)) := j, (j,(,w)) = v*, for all w A. (4-17)

PAGE 83

73 This step guarantees the composite machine c stays in a stable state combination at the state (j,,) before the external input changes. This terminates the action of the controller for the process to imitate the stable transition s(i,u) = j providing that the machine c is at the stable state (i,x,x). The above assignments implement the one-step stable transition of c, which can be described by using the stable transition function sc as sc((i,x,x),u) = (j,,), where u A for which s(i,u) = j. (4-18) Similarly, for any state x Wi, there is a corresponding state Wj so that we can construct the operations of the control unit to implement the transition sc((i,x,x),u) = (j,,), in order to match the output behavior of the one-step transition s(i,u) = j of . Also denote by (i,Wi,u) := x Wi (i,x,u) the total states of we need in order to implement the above transitions. Furthermore, we do the similar design for all the one-step transitions of . Gathering the union of all the transient states and the stable states of appearing above, we obtain the state space of , denoted by i = 1q u A (i,Wi,u)} . This completes the design of the controller, and it can be shown that the composite system operates in fundamental mode from its construction. Finally, we show that the controller we build is a solution for the model-matching problem such that c = . Consider the partition of G denoted by := {G1, , Gq}. In view of the operations we built above, for any element of the block Gi and every permissible input symbol u A, there is a block, say Gj, such that (Gi,u) Gj.

PAGE 84

74 Therefore, the partition is transition consistent. Furthermore, the output value of c is equal to that of , that is, hc[Gi,u] = h(Wi) = h(i), i = 1, , q, which explains that is output consistent. Besides, the initial state of c, denoted by (0,x0) := (e,x0), is contained in Ge ; we name Ge = G0 the initial state of the composite machine c. So, is an equivalence partition, and the quotient machine c/ with the state set := {G1, , Gq} and the initial state G0, is stably equivalent to c. Now consider the machine c/ and . For each state i in , there is a one-one and onto correspondent state Gi in c/ for i = 1, , q, such that (1) s(i,u) = j if and only if sc(Gi,u) = Gj; (2) h(i) = h[Gi] for i = 1, , q; (3) G0 := Ge is the initial state of c while e is the initial state of . By the definition, c/ and are isomorphic. Therefore, the above yields c = c/ = . The proof of the theorem is complete. Theorem 4.13 states a necessary and sufficient condition for the existence of controllers to the model matching problem; its proof includes an algorithm for constructing an appropriate controller. Note that this controller, as constructed in the proof, decomposes into an observer and a control unit. This fact implies that a separation principle is valid here: we can always build the controller C as a combination of an observer and a feedback control unit , as connected in Figure 1-2, whenever model matching is possible. This separation is analogous to the separation encountered for linear systems. The observer detects the state of the machine from the input/output data of the machine , and provides this information to the control unit . The observer depends only on the system , and is independent of the model ; the control unit depends both on and on .

PAGE 85

75 The machine in the theorem is assumed to be a stably reachable machine, but the result in the above theorem is still valid if is not stably reachable. Theorem 4.14 Theorem 4.13 remains true when the machine is not stably reachable. Proof: Again, the proof that (a) implies (b) has been given in the lemmas. Now assume Z be a subordinate list of B(,) for which K(,Z) K(), as given in the theorem. Without losing generality, we assume the initial state x0 contains in the element Ze of Z. If it is false, we can always build such a new list from the given list Z that the new list satisfies the above condition and the condition in (b). If is stably reachable, the results have been proven in the preceding theorem. If is not stably reachable, denote by X the set which contains all the stably reachable states from x0, then we can construct a reachable machine which is stably equivalent to , by removing the non-reachable states in X\ X and their associated operations. We denote by = (A,Y, X ,x0, f , h ). Notice that X is the state set of , and the functions f and h are identical to the functions f and h but only defined on the state subset X . Let X = {1, , q} be the state set of , and denote by Z = {Zi X, i = 1, , q}. Define Z = {Zi = Zi X , i = 1, , q}. We shall verify in the following that the list Z is a non-deficient subordinate list of B( ,) satisfying K( ,Z) K(). Following the earlier notation, the initial state of is 0 := e X, where e {1, , q}, and the initial state of is x0 := xd X, where d {1, , n}. First we show Z is not a deficient subordinate list of B( ,). Each element of Z is a subset of the state set X of the reachable machine ; the output function of is

PAGE 86

76 identical to that for defined on the set X . Therefore, the list Z is a subordinate list of B( ,) by the definition. The machine is stably reachable, hence, for any j {1, , q}, the (e,j) entry of the skeleton matrix K(), namely, Kej() = 1. Since the subordinate list Z satisfies K(,Z) K(), we get Kej(,Z) = 1, and it implies that d(,x0,Zj) = 1 from the definition and the fact x0 Ze, which further follows that there exists a state j Zj such that it is stably reachable from x0 for all j. So, Zj = Zj X is not empty for all j. We draw a conclusion that Z is not a deficient subordinate list of B( ,). Next, we show that K( ,Z) K() holds for the above Z. Keep in mind that for any integer k, the set Zk contains the states in Zk that is stably reachable from x0. For any integers i, j such that Kij() = 1, we have d(,Zi,Zj) = 1 because of K(,Z) K(). Then, for any state xi Zi Zi, there must exist a state xj Zj for which K(,xi,xj) = 1, which implies that xj is stably reachable from xi. We know xi is stably reachable from x0 due to xi Zi, thus, the state xj is stably reachable from x0. From the definition of Zj, it yields that xj Zj. In conclusion, given any integers i, j satisfying Kij() = 1, there is a corresponding state xj in Zj for each state xi in Zi such that xi can stably reach xj. In other words, we have d(,Zi,Zj) = 1. Hence, it holds that K( ,Z) K(). Therefore, it is true that there is a subordinate list Z of B( ,) for which K( ,Z) K() provided that there is a subordinate list Z of B(,) satisfying K(,Z) K(). The machine is reachable; by applying Theorem 4.13 to and , there is a controller (,) such that c = , where c is the closed-loop system in Figure 1-1 by

PAGE 87

77 replacing with . Since all the operations of the reachable machine are identical to that of on the set of stable sets, if we substitute for in the closed-loop system c, we end up the system c with the same input/output behavior. So, there is a controller (,) such that c = . The construction of the controller can be built by following the procedures in the proof of Theorem 4.13 and by utilizing the subordinate list Z we built above. The next statement presents a sufficient condition for the existence of solutions to the model matching problems. Given the output set Y = {y1, , y}, recall that the counter-image list of is hI(Y) := {hI(y1), , hI(y)}. Corollary 4.15. Let = (A,Y,X,x0,f,h) be an asynchronous machine and let = (A,Y,X,0,s,h) be a stable-state machine. Assume that the counter image list hI(Y) is not deficient. If every entry of the extended skeleton matrix K(,hI(Y)) is equal to one, then there exists a solution to the model matching problem for and . Proof. Given the output set Y = {y1, , y}, denote by hI(Y) := {hI(y1), , hI(y)}. Since K(,hI(Y)) is an all-one matrix, the reachability indicator d(,hI(yi),hI(yj)) is 1 for any i, j = 1, , . Denote by Z := B(,) the equivalence list of with respect to , and consider the extended skeleton matrix K(,Z). Each entry of K(,Z) is one element of {d(,hI(yi),hI(yj)), i, j = 1, , }, which is 1. Therefore, K(,Z) is an all-one matrix too. The inequality of skeleton matrices in Theorem 4.13 is always satisfied, so, there exists a solution to this model matching problem. The following are more corollaries in which some simplified sufficient conditions are derived for the existence of solutions. We assume the model is stably reachable

PAGE 88

78 without loss of generality. Corollary 4.16 Let the system and the notation be as given in Theorem 4.13. Assume there is a list Z = {x1, , xq} of elements of the state set X of such that h(xi) = h(i), i = 1, q, and K(,Z) K(). Then, there is a controller (,) such that c = . This result is a direct consequence of Theorem 4.13. It refers to the following special situation. For each stable state of the model, there is a corresponding state x of the machine , so that the input/output behavior starting from can be achieved by the transitions of starting from x, via the present control scheme. Collecting the corresponding state for each state of , we then obtain the list Z of the corollary. The next statement is for the case when the machine is strictly stably reachable. The strict reachability indicates that, for any two states of the machine, one is stably reachable from the other and vice versa. Corollary 4.17 Let and be as described in Theorem 4.13, and assume that is strictly stably reachable. There is a controller (,) such that c = if and only if the equivalence list B(,) is not deficient. Proof: In terms of strict reachability, every entry of K() is 1, that is, K() is an all-one matrix. Following the same line of argument, we know that the extended skeleton matrix K(,Z) is also an all-one matrix for any subordinate list Z of the non-deficient list B(,). So, as long as B(,) is not deficient, we can always choose a list of elements of X that satisfies the condition in Theorem 4.13. On the other hand, if B(,) is deficient, there exists a state of such that no state of generates the same

PAGE 89

79 output value. Recall the output of the closed-loop machine c is the output of , thus, there is no state of c stably equivalent to . Namely, there is no controller (,) such that c = if B(,) is deficient. To summarize, if we can find a subordinate list Z of the equivalence list B(,) such that the skeleton matrix inequality of Theorem 4.13 is satisfied, then the model matching problem for and is solvable, and a controller can be constructed by utilizing Z. So, the subordinate list Z is the key to the solution. The next subsection describes the construction of an appropriate subordinate list Z. 4.3 Constructing Subordinate Lists This section presents the procedure of finding a list that satisfies the conditions of Theorem 4.13. We start with the following definition. Definition 4.18 Let be an input/output asynchronous machine with the state set X = {x1, ..., xn} and the skeleton matrix K(). Let Z1, Z2 be two lists of elements of X, where Z1 has m1 members and Z2 has m2 members. The restricted skeleton matrix K(,Z1,Z2) of associated with Z1 and Z2 is an m1 m2 matrix whose (i,j) entry is defined as follows. If xr is the i-th element of Z1, and xs is the j-th element of Z2, then Kij(,Z1,Z2) = Krs(). (4-19) From the definition, the restricted skeleton matrix K(,Z1,Z2) represents the reachability from each element of Z1 to each element of Z2. Recall that the reachability indicator d(,Z1,Z2) indicates whether each element of Z1 has access to at least one element of Z2. Given the restricted skeleton matrix K(Z1,Z2), we can calculate the reachability indicator d(,Z1,Z2) as follows. Build a vector v in which each entry is the

PAGE 90

80 maximum of the corresponding row of the matrix K(,Z1,Z2). Then, the reachability indicator d(,Z1,Z2) is the minimum the entries of v. For example, suppose that we have the state set X = {x1,x2,x3} and the skeleton matrix K() = 111011011. (4-20) Let Z1 = {x1,x2} and Z2 = {x1,x3} be two lists of elements of X. The restricted skeleton matrix K(,Z1,Z2) will be 1101 (4-21) by following the definition. We take maximum operation on each row to get a vector (1,1), then the reachability indicator is d(,Z1,Z2) = 1, the minimum of all elements of this vector. The following algorithm determines if there is a subordinate list Z of B(,) satisfying the inequality K(,Z) K(); whenever such a list exists, the algorithm yields the list. The derivation of the list Z, when combined with Theorem 4.13, completes the solution of the model matching problem for input/output asynchronous machines. Algorithm 4.19 Let = (A,Y,X,x0,f,h) and = (A,Y,X,0,f,h) be two asynchronous machines, where is stably minimal. Let X = {1, , q} be the state set of , let K) be the skeleton matrix of , and let B(,) := {B1, , Bq} be the equivalence list of with respect to . Let zki X, i = 1, , p(k), be the elements of the member Bk of B(,), where p(k) is the cardinality of Bk, k = 1, ..., q. The algorithm uses a recursive process

PAGE 91

81 to build a decreasing chain Z0 Z1 ... Z of subordinate lists of B(,); the integer k = 0, 1, , is used to count the steps in this recursive process. The last subordinate list Z determines whether or not a solution exists to the problem of matching the model . If there is such a solution, then an appropriate controller C can be derived through the construction described in the proof of Theorem 4.13, by taking Z := Z, the last subordinate list. In the process below, the members of the subordinate list Zk are denoted by Zk,1, , Zk,q, k = 0, ..., . Recall that each member Zk,i is a set of states of the machine . Step 1. Set k := 0 and Z0 := B(,), where B(,) is given by Eq. 4-8. Step 2. Consider a pair of integers i, j {1, , q}. Let S(i,j) be the set of all states that correspond to zero rows in the restricted skeleton matrix K(,Zk,i,Zk,j), where S(i,j) = if this matrix contains no zero rows or if Kij() = 0. Set Zk+1,i = Zk,i \j = 1, ..., q S(i,j), i = 1, ..., q, (4-22) and Zk+1 := {Zk+1,1, ..., Zk+1,q}. (4-23) If Zk+1,i = for an integer i, then the present model matching problem has no solution, and the algorithm terminates. Step 3. If Zk+1 = Zk, then Zk determines a solution to the model matching problem, and the algorithm terminates. Otherwise, repeat from Step 2, using the value of k+1 for k. The algorithm generates a decreasing chain Z0 ... Z-1 Z of subordinate lists of B(,). This chain has the following fundamental property.

PAGE 92

82 Proposition 4.20 Let and be two machines as described in Theorem 4.13, and let Z0 ... Z-1 Z be the chain of subordinate lists generated by Algorithm 4.19. Then, any subordinate list Z of B(,) that satisfies the inequality K(,Z) K() is contained in Z. Proof. As in the previous notation, we have Zk = {Zk,1, , Zk,q}, k = 0, ..., Consider the chain of the m-th members in the subordinate lists, that is, Z0,m Z,m. By the construction in Algorithm 4.19, for any element x Zk,m but x Zk+1,m, there is an integer n such that the reachability indicator d(,x,Zk,n) < Km,n(), namely, d(,x,Zk,n) = 0 and Km,n() = 1, where k = 0, , -1. We shall show by induction that the following is true: for any element x removed from Bm during the algorithm, any subordinate list Z = {Z1, , Zq} of B(,) with x Zm cannot satisfy K(,Z ) K(). The induction is taken on the number of steps (or runs) in the recursive process of the algorithm. Recall that Z0 = B(,) :={B1, , Bq}. First, we show the above argument is true for any element x removed in the first run (i.e., in the process to obtain Z1 from Z0). Assume x Z0,m = Bm but x Z1,m, where m {1, , q}. Then, there is an integer n such that the reachability indicator d(,x,Z0,n) < Km,n(). It follows, for any subset Bn of Z0,n = Bn and for any subset Bm of Bm with x Bm, that d(,Bm,Bn) < Km,n(). Thus, no subordinate list Z with x Zm can satisfy K(,Z ) K(). Next, assume the statement is true for any element x removed in the previous k runs of the recursive process, and we shall show it also holds for the previous k+1 runs.

PAGE 93

83 More specifically, for any element Bm but Zk,m, where m {1, , q}, we assume that no subordinate list Z with Zm satisfies K(,Z ) K(). Let us consider the elements removed in the first k+1 runs in order to build the subordinate list Zk+1. Suppose x Bm but x Zk+1,m (x is removed in the first k+1 runs of the algorithm). If x Zk,m, then the statement is true by the induction assumption. If x Zk,m and x Zk+1,m, then there is an integer n such that the reachability indicator d(,x,Zk,n) < Km,n() (that is, d(,x,Zk,n) = 0 and Km,n() = 1). Next, consider the following two cases. (1) Consider a subordinate list Z = {Z1, , Zq} of B(,) with x Zm and Zn Zk,n. By definition, we get the reachability indicator d(,Zm,Zn) = 0 from d(,x,Zk,n) = 0. Since Km,n(,Z) = d(,Zm,Zn) = 0 but Km,n() = 1, it implies that K(,Z) K() is not true. (2) Consider a subordinate list Z = {Z1, , Zq} of B(,) with x Zm but Zn is not a subset of Zk,n. Then, there exists at least one element y Zn Bn and y Zk,n (i.e., y is an element removed during the first k runs). By the induction assumption, the inequality K(,Z) K() cannot be true. Combining the case (1) and (2), we claim that no subordinate list Z with x Zm can satisfy K(,Z ) K(), where x Zk,m and x Zk+1,m, for m {1, , q} and k {0, , }. Together with the previous discussion, we have shown that the argument is true for any element x removed in the first k+1 steps of the recursive process. By induction, we draw a conclusion that for any element x removed from Bm

PAGE 94

84 during the algorithm, any subordinate list Z = {Z1, , Zq} of B(,) with x Zm cannot satisfy K(,Z) K(). In other words, any subordinate list Z of B(,) satisfying the inequality K(,Z) K() is contained in the Z, and so is in Zi, i = 0, ..., . The next statement shows that there exists a solution to the model matching problem if and only if Z = Z-1 (i.e., if and only if Z is not deficient); more specifically, we show the non-deficient list Z is a subordinate list of B(,) that satisfies the inequality K(,Z) K(). Proposition 4.21 Let and be two machines as described in Theorem 4.13, and let Z0 ... Z-1 Z be the chain of subordinate lists generated by Algorithm 4.19. Then, the following two statements are equivalent: (i) There is a subordinate list Z of B(,) satisfying K(,Z) K(). (ii) Z is not deficient. When (ii) holds, then K(,Z) K(). Proof: Assume first that (ii) is valid, namely, that Z = Z-1. We shall show that Kij(,Z) = 1 whenever Kij() = 1. Indeed, by contradiction, assume that Kij() = 1 and Kij(,Z) = 0. Then, from its definition, the reachability indicator satisfies d[,Z-1,i,Z-1,j] = d[,Z,i,Z,j] = Kij(,Z) = 0. The fact that d[,Z-1,i,Z-1,j] = 0 implies, as a result of construction, that there must be a zero row in the restricted skeleton matrix K(,Z-1,i,Z-1,j). In such case, Step 2 of Algorithm 4.19 will yield Z,i Z-1,i, violating the previous assumption that Z = Z. Therefore, we conclude that Kij(,Z) = 1 whenever

PAGE 95

85 Kij() = 1 for all i, j {1, ..., q}; it implies that K(,Z) K(), so (i) holds with Z = Z. Conversely, assume Z Z-1 in the string Z0, , Z-1, Z obtained from Algorithm 4.19. Then, the algorithm terminates because there is an integer i {1, , q} such that Z,i = in Step 2 of the algorithm. By Proposition 4.20, any subordinate list Z = {Z1, , Zq} of B(,) satisfying K(,Z) K() is contained in Z. However, any subordinate list of Z is deficient since Z is deficient. Thus, there is no non-deficient subordinate list Z of B(,) satisfying K(,Z) K(). By combining Proposition 4.21 with Theorem 4.13, we obtain Corollary 4.22. Let and be two machines as described in Theorem 4.13, and let Z0 ... Z-1 Z be the chain of subordinate lists generated by Algorithm 4.19. Then, there exists a solution to the model matching problem for and if and only if Z is not deficient. Next, let us take a deeper look at how Algorithm 4.19 produces the solution. Let be the set of subordinate lists of B(,). Given any two lists Z1 = {Z11, , Z1q} and Z2 = {Z21, , Z2q }, define the meet Z1 Z2 of Z1 and Z2 as Z1 Z2 := {Z11 Z21, , Z1q Z2q }, (4-24) and define the join Z1 Z2 of Z1 and Z2 as Z1 Z2 = {Z11 Z21, , Z1q Z2q }. (4-25) By definition of the equivalence list B(,), we have Z1 Z2 and Z1 Z2 if Z1 and Z2 . Therefore, is a lattice since any two elements of have both a

PAGE 96

86 meet and a join in . Clearly, the lattice has the universal maximal element B(,). By the property of the decreasing chain Z0 ... Z-1 Z given in Proposition 4.20, it can be seen that the subordinate list Z is the meet or the maximal element of any subordinate lists satisfying the skeleton matrix inequality in the theorem. As a result of the construction in Algorithm 4.19, the decreasing chain satisfies Z0 ... Z-1 Z. So, Algorithm 4.19 operates in such a way that it searches along a downward chain of the lattice from the universal maximum B(,) till the maximal solution Z that satisfies the inequality K(,Z) K(). Consequently, the sub-lattice of with the universal maximal element Z contains all subordinate lists that satisfy this inequality. Considering the complexity of Algorithm 4.19, we have the following statement. Proposition 4.23 Algorithm 4.19 has polynomial complexity. Proof. Denote by X and X the state set of and , respectively. Let n := |X| and q :=|X|. Then, the total number of elements of X in B(,) is less than qn. Since Z0 ... Z-1 Z is strictly decreasing except the last step, the maximal number of runs of the recursive process is qn-q = q(n-1). For each run, we evaluate its complexity by the number of times of checking zero rows. The total rows that we need to check are less than qn. In all, the number of times of checking zero rows is less than q2n2. So, Algorithm 4.19 has polynomial complexity and is practical to implement. 4.4 An Example of Controller Design Let = (A,Y,X,x0,f,h) and = (A,Y,X,0,f,h) be two input/output asynchronous machines. The objective is to control the so as to match the model . Let A = {a,b,c} be the input set of the machines and , and let Y = {0,1,2} be their

PAGE 97

87 output set. The state set of is X = {x1, , x6} with the initial state x0 = x1, and the state set of is X = {1, , 4} with the initial state 0 = 1. Tables 4-1 and 4-2 define the stable state transition functions and the output functions of and , respectively. Table 4-1. Transition table of the machine a b c Y x1 x2 x3 x1 0 x2 x2 x2 x4 1 x3 x3 x5 x3 2 x4 x4 x6 x6 0 x5 x5 x5 x5 0 x6 x6 x6 x6 1 Table 4-2. Transition table of the machine a b c Y 1 1 2 3 0 2 2 4 2 1 3 4 3 4 2 4 4 4 4 0 Utilizing the tables, we can directly calculate the stable transition matrix R(5)() for the input/output machine . The following matrix R() contains only the shortest strings within the entries of R(5)(), R() = cabacbbacc{ab}c cc {ac}b a {bc}{abc}{abc}. (4-26)

PAGE 98

88 The skeleton matrices of and are then obtained from R() by inspection: K() = 111111010101001010000101000010000001, K() = 1111010100110001. (4-27) Next, to determine whether the posed model matching problem has a solution, we employ Algorithm 4.19 to check whether there is a subordinate list Z satisfying condition (ii) of Theorem 4.13. In the present case, since the state set of consists of 4 elements, this subordinate list, if it exists, consists of 4 members as Z = {Z1,Z2,Z3,Z4}. To perform the initial step of Algorithm 4.19, we calculate B(,) = {B1,B2,B3,B4} = {(x1,x4,x5),(x2,x6),(x3),(x1,x4,x5)}. Proceeding with the Algorithm yields the final result Z = {x1,x2,x3,(x1,x4,x5)}, a subordinate list of B(,) that satisfies K(,Z) K(). As this list is not deficient, it concludes that there is a solution of the model matching problem. A controller can then be derived from the list Z by following the steps of the proof of Theorem 4.13. In some cases it is possible to simplify the controller by eliminating from Z states that are redundant. The elimination is performed by searching for a subordinate list Z of Z that satisfies the inequality K(,Z) K(). An examination shows that the subordinate list Z = {x1,x2,x3,(x4,x5)} satisfies these requirements. By trying the various options, it can be seen that this is the minimal subordinate list that satisfies the requirements. Regarding the states x4 and x5 of the last member of Z, no matter which one we remove, the resulting list does not satisfy the skeleton matrix inequality any more.

PAGE 99

89 Consequently, these two states in have to work together in order to implement the behavior of . A direct calculation leads to K(,Z) = 1111010100110001 = K(). (4-28) The following discusses the observer. By definition, the (i,j) entry of the skeleton matrix is 1 if and only if the state xj is stably reachable from the state xi through a chain of detectable and stable transitions. Hence, there is always an observer for these transitions of the machine; we can construct the observer = (AY,X,X,x0,,I) as described by Eq. 4-5. Next, we set the stable states of the composite system c to be {(1,x1,x1), (2,x2,x2), (3,x3,x3), (4,x4,x4), (4,x5,x5)}, and we design the controller C so that the following equivalence relations hold between the states of the composite machine c and the states 1, 2, 3, and 4 of the model (1,x1,x1) 1, (2,x2,x2) 2, (3,x3,x3) 3, and (4,x4,x4) (4,x5,x5) 4. For each state and each transition of the model in Table 4-2, we create corresponding transitions for the equivalent states of c. First, for the transition s(1,a) = 1 of , the corresponding operation for c will be assigned as sc((1,x1,x1),a) = (1,x1,x1). From the transition matrix R(), we know there is a transition s(x1,c) = x1 for the machine . Then, the operations of the controller (,) and the corresponding system transitions are described by the following.

PAGE 100

90 (1,(x1,a)) = 1, (1,(x1,a)) = c; (4-29) For the transition s(1,b) = 2 of , the corresponding transition of c is sc((1,x1,x1),b) = (2,x2,x2). From the transition matrix R() in Eq. 4-26, we have s(x1,a) = x2 for . Then, the transitions of the control unit are: (1,(x1,b)) = 1(x1,1,b), (1(x1,1,b),(z,w)) = a (to take from x1 to x2), for all (z,w) XA, (1(x1,1,b),(x2,b)) = 2, (2,(x2,b)) = a (to keep staying at x2). (4-30) Here, the state 1(x1,1,b) of is associated with variables x1, 1, and b, at which outputs the input symbol a to control the machine . Once the machine reaches x2, the state of switches to 2 to help stay at x2. Similarly, for the transition s(1,c) = 3 of , we assign (1,(x1,c)) = 1(x1,1,c), (1(x1,1,c),(z,w)) = b, for all (z,w) XA, (1(x1,1,c),(x3,c)) = 3, (3,(x3,c)) = b. (4-31) For the transition of starting from the state 2 (i.e., is in a stable combination at the state x2 Z2), we have the next assignment: (2,(x2,a)) = 2, (2,(x2,a)) = a; (2,(x2,c)) = 2, (2,(x2,c)) = a; (2,(x2,b)) = 1(x2,2,b), (1(x2,2,b),(z,w)) = c, for all (z,w) XA, (1(x2,2,b),(x4,b)) = 4, (4,(x4,b)) = c. (4-32) Considering the transitions s(3,a) = 4 and s(3,c) = 4 of , the states

PAGE 101

91 (4,x4,x4) and (4,x5,x5) are both stably equivalent to 4, so the corresponding transition of c can be chosen as either sc((3,x3,x3),v) = (4,x4,x4) or sc((3,x3,x3),v) = (4,x5,x5), where v = a, c. By observing R(), the state x4 is not stably reachable from x3, but x5 is stably reachable from x3 under the input b, therefore, we use the latter transition for the design of . Regarding the transition s(3,b) = 3, we assign sc((3,x3,x3),b) = (3,x3,x3) by using the input a or c. The corresponding transitions of are (3,(x3,b)) = 3, (3,(x3,b)) = a; (3,(x3,v)) = 1(x3,3,v), for v {a,c}, (1(x3,3,v),(z,w)) = b, for all (z,w) XA and v {a,c}, (1(x3,3,v),(x5,v)) = 4, for v {a,c}, (4,(x5,v)) = v, for v {a,c}. (4-33) For the transition s(4,v) = 4 of where v = {a,b,c}, we get the transitions s(x4,a) = x4 and s(x5,a) = x5 by examining the matrix of stable transitions R(). Accordingly, the transitions sc((4,x4,x4),a) = (4,x4,x4) and sc((4,x5,x5),a) = (4,x5,x5) for the composite machine c can be generated as follows. (4,(x4,w)) = 4, for w {a,b,c}, (4,(x4,w)) = a, for w {a,b,c}, (4,(x5,w)) = 4, for w {a,b,c}, (4,(x5,w)) = a, for w {a,b,c}. (4-34) So far, for each possible one-step stable transition of , we have designed the corresponding operations for the control unit . Together with the function of the observer described in Eq. 4-5, the controller (,) drives the machine to match the behavior of the model . In view of the example, it is clear that the length of input strings in the transition

PAGE 102

92 matrix we use for constructing the operations of the system determines the order of the controller (i.e. the number of states). Also we can see that the construction above doesn’t attempt to minimize the number of states. Once the controller is designed through the procedure described in the proof of Theorem, we can reduce the number of its states by using available state reduction techniques for asynchronous machines (Fisher and Wu 1993, and Kohavi 1970).

PAGE 103

CHAPTER 5 MODEL MATCHING FOR INPUT/OUTPUT ASYNCHRONOUS MACHINES WITH CRITICAL RACES Chapter 3 and Chapter 4 have introduced feedback controllers to drive an asynchronous machine so that the composite system performs a prescribed behavior. Chapter 3 considers input/state machines and chapter 4 focuses on input/output deterministic machines. The present discussion deals with the model matching problem for input/output machines whose behaviors suffer from the effects of critical races. The goal is to design an output-feedback controller C so that the input/output behavior of the composite system c matches a prescribed model . Whenever such a controller exists, it removes the indeterminacy of the system’s behavior, and assigns to the composite system a preferred behavior. It is also shown that every solvable model matching problem can be solved by a controller C that consists of two asynchronous machines: an observer and a state-feedback control unit , as depicted in Figure 1-2. The present chapter is organized in the following way. Section 5.1 concentrates on the observer part of the controller and its associated concepts. In Section 5.2, we define extended skeleton matrices for input/output machines with critical races. The concept here is a generalization of the extended skeleton matrices presented in Chapter 4. The main results about the model matching problem are presented in Section 5.3, which includes a necessary and sufficient condition for the existence of solutions, as well as methods for the implementation of solutions, whenever solutions exist. Section 5.4 93

PAGE 104

94 presents an algorithm to check the above condition, and Section 5.5 makes some extended discussion on the preceding results. In the end, examples are given in Section 5.6 for the implementation of these results. 5.1 Characterizations of Observers This section views observers for nondeterministic asynchronous machines and discuss some special issues associated with the inputs/outputs of machines. In the present work, the function of observers is to detect as much as possible of the information of machines from their input/output data. Similar to observers for deterministic asynchronous machines, the observers here need to fulfill two tasks; one is to inform if the machine is in a stable combination, and the other is to estimate the states based on input/output data of the machine. Consequently, we separate the function of the observer as two kinds in the following: One is associated with detectability and the other is related to observability. Unlike the deterministic case, it is possible that the observer only provides a state uncertainty set in which the machine might be, instead of an accurate state value. Therefore, the present discussion will be involved with state uncertainty sets. 5.1.1 Detectability at Uncertainty Sets Let us first define the concept of detectability at state uncertainty sets. Consider an input/output asynchronous machine = (A,Y,X,x0,f,h). Let s be its stable state transition function. Given a subset Z = {z1, , zn} of X and an input u let the successor of (Z,u) be the set Z = {z1,,zn} := s[Z,u] where zi = s(zi,u) for i = 1, , n. Similarly, define the successor of (Z,t), where t A* is an input string. Suppose the machine is in a stable combination at a state x1 Z, and it moves to the next stable

PAGE 105

95 state xm = s(x1,u) under the input u, by going through a chain of transient states x1, x2 ,, xm. Denote by y*(j) = h(x1)h(xj) for j = 1 m;h(x1)h(xm) for j = m+1 (5-1) the corresponding transient output string at moment j, and denote the burst of y*(j) by b(j) := burst(y*(j)), (5-2) Recall the definition of transition burst, the burst b(m) is the transition burst of (x1,u), and denoted by b(m) = burst(x1,u). Recall a burst takes only the symbol changes into account, and it is the type of data that is measurable from an asynchronous machine. Next, following the notation described in Eq. 5-1 and Eq. 5-2 for any one-step stable transition of , we define the detectability at uncertainty sets for asynchronous machines. Definition 5.1 Let be an asynchronous machine with the state set X and an input symbol u. Denote by Z a subset of X and denote by Z the successor of (Z,u). Then, is detectable at the set (Z,u) if there is a function : Y* {0, 1} for j = 1, 2, such that (b(j)) = 1 if xj Z; 0 otherwise. (5-3) According to the definition, if the machine starts from an arbitrary pair in (Z,u) and is detectable at (Z,u), then there is a one-one mapping from the step number j to {Z, X\Z}, where Z is the successor of (Z,u). Next is an argument about the detectability. Proposition 5.2 Let be detectable at the set (Z,u) of state-input pairs. If

PAGE 106

96 starts from an arbitrary state in Z with the input u, at any moment, we can tell whether the machine is in a stable combination from the current output burst. Proof. Denote by Y1 := burst[Z,u] the set of the transition bursts, which includes all the transition bursts generated by the machine from any initial state in Z; denote by Y2 the set of the bursts from an initial state till the moment the machine is still at transient states (i.e., before entering a stable combination). By the definition of detectability, there is a function : Y* {0, 1} such that [Y1] = 1 and [Y2] = 0. The existence of the function guarantees that Y1 Y2 = (empty set). Following the earlier notation, denote by b(j) the current output burst of , then we can tell whether the machine is in a stable combination by checking b(j) Y1 or b(j) Y2. The following statement shows that the detectability defined in Section 4.1 for single input-state pairs is a special case of the one defined above for sets of pairs. Proposition 5.3 If is detectable at (Z,u) X A, where X is the state set and A is the input set of , then is detectable at any input-state pair (x,u) (Z,u). A necessary and sufficient condition for the detectability is given as follows. It provides us an easy way to verify the detectability of a machine. We use prefix() for the prefix relation, and use s_prefix() for the strict prefix relation (not including the string itself). Proposition 5.4 Let = (A,Y,X,x0,f,h) be an asynchronous machine, and follow the notation in Definition 5.1. The machine is detectable at (Z,u) if and only if (i) is detectable at all pairs (x,u) (Z,u), and (ii) For any two transition bursts y1, y2 burst[Z,u] of , it holds that y1 is not a prefix of y2.

PAGE 107

97 Proof. Assume first is detectable at (Z,u), then (i) is valid from the proposition 5.3. Suppose that there exist two bursts y1, y2 burst[Z,u], and y1 = prefix(y2). Since y1 y2, it is evident that y1 = s_prefix(y2). Suppose generates a transition burst y1 with the initial state being x1 Z, and it generates y2 with the initial state being x2 Z. Let starts from an arbitrary state in Z. At a certain moment, the machine produces a burst y1 in its output port. Two different situations might occur at this instant: (a) The machine reaches the next stable state if the initial state is x1; (b) It is not yet in a stable combination if the machine is initially from x2. Following Definition 5.1 of detectability, there is a function for which (y1) = 1 (from case (a)) and (y1) = 0 (from case (b)). A contradiction occurs, which yields that y1 is not a prefix of y2. Since y1, y2 are picked up arbitrarily in burst[Z,u], it concludes that there is no prefix relation for any two elements in burst[Z,u] if is detectable at (Z,u). On the other hand, assuming that the detectability of at any individual state-input pair holds (i.e., condition (i)), and that no prefix relation exists between any two elements of burst[Z,u] (i.e., condition (ii)), we shall show is detectable at (Z,u). Construct the set Yp(Z,u) = {s_prefix(burst(x,u)) : x Z} which includes the strict prefix strings of all transition bursts in burst(Z,u). Following the previous notation, suppose the machine is initially in a stable combination at x1 Z, and suppose moves to the next stable state xm through a chain of transient states x1x2xm-1xm as the result of an input u. Denote by b(j) the output burst of at transient step j and let y1 := b(m) = burst(x1,u). Cleary, the string y1 burst[Z,u]. Let y2 burst[Z,u] be

PAGE 108

98 another transition burst. Then, we have the string y2 s_prefix(y1) due to the condition (ii). For the burst b(j) of at transient step j, it holds that b(j) = s_prefix(y1) for j = 1, m-1, from the condition (i). Thus, it yields that y2 b(j) Yp(Z,u) for j = 1, m-1. So, for any string y* burst(Z,u), we have s_prefix(y*) burst(Z,u), that is, burst[Z,u] Yp(Z,u) = . Hence, there exists a function such that (b(j)) = 1 if b(j) Y*(Z,u)0 if b(j) Yp(Z,u). (5-4) If b(j) burst(Z,u), the machine is in the next stable state, and it is not, otherwise. So, the machine is detectable at (Z,u) by the definition. Proposition 5.4 provides a convenient way to verify the detectability of the machine. Intuitively, if there exists two output burst strings y1, y2 burst[Z,u] such that y1 = prefix(y2). The moment outputs the entire string of y1, it is impossible to tell if reaches the next stable state because it might continue to generate more symbols and eventually the output burst turns out to be y2. Therefore, we cannot determine whether has reached the next stable state when we observer the output burst y1, that is to say, is not detectable at (Z,u). The following gives a property of the detectability. Proposition 5.5 Let = (A,Y,X,x0,f,h) be an asynchronous machine. Let Z1, Z2 be two subsets of X where Z1 Z2. Then, the machine is detectable at (Z1,u) if it is detectable at (Z2,u), where u A is an input character. Proof. From the necessary and sufficient condition in Proposition 5.4, the fact that is detectable at (Z2,u) implies that (i) is detectable at (x,u) where x Z2, and (ii) for any two bursts y1, y2 burst[Z2,u], the burst y1 is not a prefix of the burst y2. It

PAGE 109

99 follows from (i) that is detectable at (x,u) where x Z1 Z2, and from (ii) that for any two strings in burst[Z1,u] burst[Z2,u], one is not a prefix of the other. Applying again the condition in Proposition 5.4, the machine is detectable at (Z1,u). 5.1.2 Observability for Critical Race Machines The present section studys the observability issue, namely, the ability of observers to identify the value of stable states of a machine. There are known to be at least two types of observing (or identification) problems, the initial-state observing problem and the terminal-state observing problem (Booth 1967 and Kohavi 1970 for sequential machines). The following statements adapt original definition of automata theory to our present context of asynchronous machines. The initial-state observing issue deals with the problem of determining the unknown initial state of the machine from its subsequent input/output data. For asynchronous machines, the available data are input strings and their resulting output bursts. Let = (A,Y,X,x0,f,h) be an asynchronous machine, where the initial state x0 is unknown but contains in the uncertainty set Z X. In response to an input symbol u A, the machine moves from any initial state x Z to the next stable state of (x,u) and produces a transition burst burst(x,u). Different initial states may or may not result in different transition bursts. If two states in Z correspond to a same transition burst, then it is impossible to identify the initial states based on the output. The function of the observer is to detect from the output burst the smallest uncertainty set which the initial state x0 might be in. Regarding the terminal-state observing problem, we assume again the machine is initially at an unknown state in Z. Apply an input string and measure the ensuing output

PAGE 110

100 burst. Then, on the basis of this observation, we try to specify the terminal (i.e., current) state of the machine. This type of problem is what we will face in the present discussion on model matching. Now, we define the burst matrix of asynchronous machines as follows. Given the asynchronous machine , let the state set be X = {x1, , xn} and let the input set be A = (u1, , u), its burst matrix is an n matrix denoted by W, whose (i,j) entry is equal to burst(xi,uj), the transition burst generated from for the one-step stable transition at (xi,uj). The burst matrix is convenient to get from the transition matrices of the machine. We use the above burst matrix as a tool to help check the observability of the machine. Utilizing the burst matrix W of the machine , we will show below how to solve the observability problems. Suppose the state uncertainty set is initially at Z0 X. The input symbol u0 is applied to the machine and the transition burst y* is then observed. By checking the entries of W which are associated with the pair in (Z0,u0), we can simply reduce the uncertainty Z0 to the states whose corresponding entries match y*. In other words, denoting the refined set by Z0 Z0, we have Z0 = {x: burst(x,u) = y*, x Z0}. Furthermore, let s be the stable transition function of , and the current state uncertainty will simply be the successor Z1 := s(Z0,u0). If more symbols are applied, say, u1 is applied after u0, we can further reduce the uncertainty based on the burst as a result of the input u1. The following example illustrates how to refine the uncertainties. Let the state space of be X = {x1,x2,x3} with h(x1) = y0 and h(x2) = h(x3) = y1. Suppose the one-step stable transition matrix for the machine is

PAGE 111

101 bNaNbabNa, where each entry gives the possible input characters for the corresponding row and column, and symbol ‘N’ indicates that there is no such a character. Then, the burst matrix can be built as W = y1y0y1y0y0y0y0y1. (5-5) Assume the machine is detectable at any uncertainty pair, so that the detectability issue is of no concern to our present discussion. If the machine is initially in a stable combination at uncertainty set Z = {x1,x2,x3} when the input turns to a. By examining the related entries in W, we can reduce the initial uncertainty to be either {x1} or {x2,x3}, depending on which output burst it actually produces, y1y0 or y0. Given the stable transition function s, we can further obtain the uncertainty of the current state to be {s(x1,a)} or {s(x2,a), s(x3,a)}. In such a way, the observer we will construct later estimates the smallest uncertainty of the current stable state, so as to refine the state uncertainty along the transitions. In the situation where the input/output machine is afflicted by a critical race, we can represent the machine by a critical race family M which contains several member machines; each member machine is a deterministic machine and corresponds to one outcome of the race. Suppose there are outcomes of the race, then we denote by M = {1, , }. For each member machine i, we can build its burst matrix Wi which will be used next to observe the state uncertainty. Proposition 5.6 Given a critical race family M = {1, , }, denote by si and

PAGE 112

102 Wi the stable state transition function and the burst matrix of i, i = 1, , . Starting from an initial uncertainty set Z0, the machine generates a transition burst y* in response to an input u. Then, the minimal uncertainty set of the current stable state is Z1 := i = 1, , si(Zi,u), where Zi = {x: y* = burst(x,u), x Z0} is obtained directly from the burst matrix Wi, i = 1, , . Proof. During the one-step stable transition under the input u, if the machine does not encounter the critical race, then the corresponding entries burst(x,u) = y* are the same in each burst matrix Wi, i = 1, , , namely, Zi = Zj for all i, j = 1, , . Therefore, the uncertainty set of the current stable state Z1 = si(Zi,u) where i {1, , }, which is the same result as in the case of a single deterministic machine. If a critical race occurs in the one-step stable transition, different outcomes of the race cause different next stable states. The set Zi contains the possible initial states in Z0 for the member machine i, and then si(Zi,u) are the stable states of Zi resulting from the input u. Which member machine takes effect is random after the race, so, the uncertainty set of the current stable state will be the union of Zi, i = 1, , . In some situations, we only have knowledge that the actual machine is one of a general machine family, in which each member machine is deterministic and distinct. Again the machine can be represented as a machine family, say, M = {1, , }. The difference on the transitions of a general family from that of a race family is that the same member machine is operating at any time; however, in a race family, the member might be different when the machine hits the race at different times. Given the same one-step transition and the same initial uncertainty as discussed previous, we can utilize the burst

PAGE 113

103 matrix to identify the uncertainty of the stable states as follows. The uncertainty is stored in a list of subsets of the state space, denoted by Z1 := {s1(Z1,u), , s(Z ,u)} where Zi = {x: y* = burst(x,u), x Z0} is obtained from the burst matrix Wi of i, i = 1, , . If a member si(Zi,u) of the list Z1 is empty set , it indicates that the member machine i has been out of the consideration hereafter. 5.1.3 Observer Structure We have discussed detectability and observability issues for input/output asynchronous machines. Given the asynchronous machine = (A,Y,X,x0,f,h) and its stable transition function s, now, let us construct the observer . The observer is such an asynchronous machine that its initial state is identical to x0 (the preset initial state of ) and that its output signifies the minimum uncertainty for the most recent stable state of . The minimum means, that might be at any state in the minimum uncertainty set, and that the state of must be in this uncertainty set. We choose the observer as an input/state asynchronous machine without losing generality. First of all, let us take a view of how the observer functions. Suppose the machine is currently at a state uncertainty set Z0 (in the later discussion, the set Z0 will be assigned as the current state of the observer ). As a result of the input character u, the machine starts moving and generating output characters. The observer has to be designed in such a way that the whole system operates in fundamental mode, that is, the observer remains unchanged until the machine has reached a stable combination. Similar to the concept in Chapter 4 for deterministic machines, we use a shift register of finite memory to store the output data of one-step stable transition of the machine; the register

PAGE 114

104 clears its memory once launches the next stable transition in response to a new input. Consider the example in Section 5.1.2, where we assume is detectable at the set (Z0,u). The detectability ensures that we can determine if the machine has reached a stable combination by examining if the output burst of is equal to y* burst(Z0,u). Then, required by the fundamental mode, the observer can make a move only if y* burst(Z0,u). Utilizing the observing procedure described in Section 5.1.2, we could obtain the refined state uncertainty Z1, which contains the possible stable states of as a result of the input u. The observer then outputs Z1 which is a function of Z0 and the input-burst pair (u,y*); next, this relation is described by the recursion function of the observer. Note that the stable state of the observer carries the information of state uncertainty of the machine ; we will simply symbolize the states of by subsets of X. Denote by F the state set of , then each element of F is a subset of X. If the set X contains n elements (i.e., |X| = n), then the maximal size of F will be 2n. To reduce the number of variables, each state of can be implemented as an n-tuple variable, say, (a1, , an), where ai = 1 if xi X is included in the uncertainty set represented by the state of , and ai = 0 otherwise. By this means, the exponential size of state space can be easily put into practice by n variables. Denote by 0 the initial state of the observer, which is assigned to be the initial state x0 of the machine . Denote by the set of all prefixes of transition bursts of . Then, the output string y* recorded in the register at any moment contains in , and y* serves as one input of the observer. To conclude, the observer can represented as

PAGE 115

105 the stable transition machine = (A,F,F,x0,,I), where the output function I stands for the ‘identity’. Assume that, at the step k, the state of is k (i.e., the uncertainty of stable state of at the same moment). As an input uk appears, the machine moves to its next stable state and generates a transition burst contained in burst(k,uk). The state of at the step k+1 is denoted by k+1 which represents the subset of X that satisfies burst(k,u) = y* s(k,u) = k+1. (5-6) The procedure to calculate k+1 is explained in the preceding section by utilizing the burst matrix. Note that it is necessary that is detectable at (k,uk) in order to guarantee the combination of the observer and the machine operates in fundamental mode. The observer keeps unchanged until it has received a transition burst in burst(k,u) to guarantee the machine has reached a stable combination. More specifically, we have the following transition for the operation of the observer: K+1 = (k,(uk,y*)) = s(k,uk) if y* burst(k,uk)k otherwise (5-7) where k ={x k : burst(x,u) = y*}. 5.2 Reachability Trees and Skeleton Matrices 5.2.1 Reachability Trees for Machines with Critical Races For input/output asynchronous machine, the occurrence of critical races results in the following situation: from the available input/output data, we may not be able to identify which individual state the machine is at; instead, we can only get a state uncertainty set. In order to investigate the model matching problem for input/output

PAGE 116

106 machines, in this section, we introduce the concept of stable transitions between two uncertainty sets. The reachability tree is a tool to produce and store these possible transitions. The reachability tree, which is similar to the successor tree (Kohavi 1970), displays the uncertainties of the successor for all permissible inputs starting from a specified initial uncertainty set. It is composed of branches arranged in successive levels, numbered 0, 1, .., j, There are several branches in the j th level, each corresponding to and labeled with one permissible input symbol of the machine. Each node of the reachability tree is associated with a state uncertainty set. Each branch emanates from one node in a level, and forms one or more nodes in its successive level. If there are two or more successive nodes for one branch, these nodes are called siblings to each other; they distinguish themselves by different transition bursts of the one-step stable transition associated with this branch. The fact that the siblings exist indicates that the uncertainty associated with one node get refined based on the information of this one-step stable transition. For two or more branches emanating from a common node, while labeled with different input symbols, the successive nodes generated from one branch are cousins to those from other branches. A sequence of branches, starting from node i and terminating at node j, is referred to as a path from node i to node j. Each branch is labeled as an input character, so each path is associated with an input string which is composed of all the input characters of its branch in the downward order. The length of a path is the number of levels going through, or the number of input characters in the string. The initial node (at level 0) of the reachability tree is associated with the initial uncertainty of the machine; in the present discussion the initial state is specified by x0

PAGE 117

107 X. Denote by N0 an arbitrary node (i.e., an uncertainty set), and label a branch emanating from N0 by the input symbol u. If the successive nodes of this branch are nodes N1, , Nk (they are siblings), then there exist k disjoint sets A1, , Ak N0 with N0 = i = 1, , k Ai such that the following transitions occur: s(A1,u) = N1, , s(Ak,u) = Nk. For the transitions of s(Ai,u) = Ni := {s(x,u) = Ni : x Ai}, their bursts are the same; however, the transition burst of s(Ai,u) = Ni is different for different i’s. So, given a node, each of its successive node Ni can be identified as a pair (u,y*) of input and transition burst, where y* = burst(Ni,u). The successive nodes N1, , Nk can be easily obtained from the burst matrix of the machine we defined in Section 5.1.2 (see Proposition 5.6). Following the construction of the reachability tree, given any node A and any permissible input u, the existence of successive nodes of (A,u) requires that the machine is detectable at (A,u). So, there will be no branch emanating from the node A if any input symbol u cannot satisfy the detectability condition. If it happens, this node becomes terminal. A node in the tree becomes terminal whenever any of the following occurs: The node is associated with an uncertainty that is also associated with some node in a preceding level. The node is associated with an uncertainty such that no permissible input symbol exists. The following is an example of constructing reachability trees. Consider the machine with the stable transitions shown in Table 5-1. Its state set is X = {x1,x2,x3} with the initial state x0 := x1, its input set is A = {a,b,c}, and its output set is Y = {0,1}.

PAGE 118

108 The state-input pair (x1,c) is a critical race pair, so we could build a race family = {1,2} with two deterministic member machines, where 1 and 2 have everything the same except the next states at the critical race pair. Table 5-1. State transition function and output function of the Machine a b c y x1 x1 x2 {x1, x2} 0 x2 x3 x2 x2 0 x3 x3 x2 x3 1 By definition, it is easy to obtain the burst matrices for 1, 2, which are W1 = W2 = 00001001101 (5-8) Checking the entries in each column, there are not two entries of a column for which one is the prefix of the other. Hence, is detectable at any uncertainty combination (Z,u) where Z X and u A. We construct the reachability tree of the machine with the initial state x1 (i.e., the 0th-level node of the tree) as follows. There are totally three branches emanating from x1 associated with three inputs a, b, c, respectively. Figure 5-1 shows only the successive nodes of the branch labeled with the input c; we omit those of the other two branches since they are just regular branches as defined in a successor tree (Kohavi 1970). As we can see from Figure 5-1, the race occurs in the first level, and it generates an uncertainty set (x1,x2). By definition, the nodes x1 and x3 in the terminal level are siblings, but x1 and x2 are cousins. Now, collect as a set X^ all the state uncertainty sets of associated with the nodes in the reachability tree, and denote by X := X^ X, which we call the observing

PAGE 119

109 set of . For the above example, we have the observing set X := {x1,x2,x3,x4} = {x1,x2,x3,(x1,x2)}. Let N1 and N2 be two elements of X, then, we say that N2 is stably reachable from N1 if there is a path from N1 to N2 in the reachability tree, and is k-step stably reachable if the path has length k or less. Similar to the concept for deterministic machines, we are able to define k-step stable transition matrices and k-step skeleton matrices of with the observing set X, denoted by R(k)(,X) and S(k)(,X), respectively. We omit their details. Likewise, skeleton matrices are matrices of zeros and ones. Supposing |X| = , similarly, the skeleton matrix of with the observing set X, denoted by K(,X), is defined as K(,X) := S(-1)(,X). (5-9) (x1,x2) (x1,x2) x2 x1 x1 x3 c a b c Figure 5-1. Part of the reachability tree of that shows the transitions after the race. We name K(,X) as the skeleton matrix for the input/output machine with critical races. It stores the information of reachability between any two nodes in the reachability tree (i.e., any two elements in X) . If the machine is an input/output deterministic machine, its observing set is X = X, and then the transition matrices and skeleton matrices defined above are identical to

PAGE 120

110 the corresponding matrices defined for input/output deterministic machines in Section 4.2.1. Thus, the definition of these matrices in the present discussion for the machines with critical races is an extension of the definition for deterministic machines, which we state in the following proposition. Proposition 5.7 Let be an input/output deterministic machine, and let X be its observing set. Then, the skeleton matrix K(,X) defined for machines having critical races is identical to the skeleton matrix K() for deterministic machines in Section 4.2.1. Proof. It is a fact that the observing set X for the deterministic machine is identical to its state set X. From the construction of the reachability tree, for each node N1 and a branch emanating from N1 with label u, it holds that is detectable at the set (N1,u). Since any node N1 is an element of X for the deterministic machine , the machine is detectable at the state-input pair (N1,u). By the definition of one-step skeleton matrices for deterministic input/output machines, we get S(1)(,X) = S(1)(,X) = S(1)(). The skeleton matrices K(,X) and K() are computed in the analogous way from S(1)(,X) and S(1)(), respectively, which implies that K(,X) = K(). For the previous example, the one-step transition matrix R(1)(,X) is described as R(1)(,X) = {a}{b}NcN{bc}{a}NN{b}{ac}Nabac, (5-10) where the input characters in its (i,j) entry could take the machine from the node xi to the node xj, and the entry with the value ‘N’ indicates that xj is not stably reachable

PAGE 121

111 from xi. The skeleton matrix K(,X) with the observing set X can be calculated from R(1)(,X) to be K(,X) = 1111011001101111. (5-11) The (i,j) entry with value 1 in K(,X) indicates that there is a path from the node xi to the node xj in the reachability tree, where xi, xj X. For instance, the (4,1) entry is 1 if there is a path from the uncertainty (x1x2) to the state x1. 5.2.2 Fine Subtrees and Fine Sets In the present section, we will introduce the concept of fine subtrees and fine sets on the basis of the reachability tree. Following the earlier notation, the state set of is X, and the set of nodes in the reachability tree, named as the observing set of , is X. The elements of X are subsets of X. We introduce subtrees and fine subtrees as follows. Definition 5.8 A subtree of the reachability tree is composed of the nodes and branches that include in the reachability tree. A fine subtree of a reachability tree is such that, if a node of the reachability tree is contained in the subtree, so are its siblings. The next is some notation. Given two sets X1, X2 X (X1 and X2 contain subsets of X), we say X1 X2 (or X2 X1) if there is a corresponding element 2 X2 for each 1 X1 such that 1 2. And we say that X2 is a closed set of X1 if X2 contains all the subsets of the elements of X1, that is to say, X2 := {2 : 2 1 for any 1 X1}. For example, the set {(a,b),a,b} is a closed set of {(a,b)}, and {(a,b),a,b}

PAGE 122

112 {(a,b)}. x3 a a x1 a x1 (x1,x2) (x1,x2) (A) (B) Figure 5-2. These are two spanned trees of the set {a}. (A) is a fine subtree for the triple (,(x1,x2),{(x1),(x3)}), but (B) is not a fine subtree for the triple (,(x1,x2),{(x1),(x3)}) Given a reachability tree, its node 1 X and a set of nodes, X2 X, we define the spanned subtree (or spanned tree) of a string set T for the triple [,1,X2] as follows. It is a subtree with the initial node being 1 and the terminal nodes contained in the closed set of X2; each path of the spanned tree from 1 to a node in the closed set of X2 is associated with an input string in T. We call the set T of strings a fine set for the triple [,1,X2] if the subtree spanned by T is a fine subtree. In the previous example, the string set {a} does not span a fine subtree for the triple [,(x1,x2),{(x1)}], but it does for the triple (,(x1,x2),{(x1),(x3)}). The subtree for the former case is shown in (A) of Figure 5-2, and for the latter case is in (B). Following the previous notation, let 1 be a node of the reachability tree of the machine , and let X2 be a set of nodes. Denote by T the set of all the possible input strings that can drive from the node 1 to nodes in the closed set of X2. The following describes an algorithm to detect if there is a fine subtree within the spanned tree of the string set T. From the existence of a fine subtree, we can conclude that T is a

PAGE 123

113 fine set for the triple (,1,X2). In practice, the reachability tree can be stored in the computer with a form of date structure. Algorithm 5.9 Step 1. Going through all the paths in the reachability tree which originate from the node 1 and terminate at the nodes in the closed set of X2, we mark the nodes along the paths which are associated with the strings in T. Step 2. Remove the mark of a node if one of its siblings has no mark; and remove the mark of a node if all its successive nodes have no mark. Step 3. In the end, check if the initial node 1 is marked. If yes, then T is a fine set for the triple (,1,X2). Moreover, the paths running through the remaining nodes with marks on comprise a fine subtree, and the input strings associated with these paths form a fine set too. Proposition 5.10 The set T of strings is a fine set for (,1,X2) if and only if the initial node 1 is marked after Algorithm 5.9, and if so, the input strings associated with the remaining paths also form a fine set for (,1,X2). Proof. Assume first that the initial node 1 remains marked. It implies there is at least one of its successive nodes having mark, otherwise, the mark of 1 needs to be removed by Step 2. Similarly, this successive node of 1 also has at least one marked successive node, and so on and so forth, until we reach the terminal nodes of the paths. Thus, there is at least a path from 1 to a node in the closed set of X2, along which all nodes are marked. Also the siblings of these nodes have marks due to the operation in Step 2. Therefore, the remaining paths from the initial node to the terminal nodes build

PAGE 124

114 up a fine subtree, and the input string associated with those paths constitute a fine set for the triple (,1,X2). Conversely, assume that T is a fine set for (,1,X2) but the initial node 1 has no mark after the algorithm. This fine set T constructs a fine subtree from 1 to nodes in the closed set of X2. For each node in this subtree, at least one of its successive nodes has mark, and all of its siblings have mark. So, after applying Algorithm 5.9, all the nodes in this subtree still have marks, which is conflicted with the assumption that 1 has no mark. This completes the proof. Proposition 5.11 Let the system and the notation be as described in Proposition 5.10. Let T be a set of input strings that spans a fine subtree for (,1,X2), and let 2 be a node in this subtree. Then, there is a fine set for the triple (,2,X2). Proof. Consider all the paths in the spanned subtree of T for the triple (,1,X2). If we only look at the segments of these paths starting from the node 2, then these segments form a fine subtree for (,2,X2) by the definition. Therefore, there is always a fine set for (,2,X2). Comparing to Definition 4.9 in Section 4.2.1, we give the following notation. Definition 5.12 Given an input/output nondeterministic machine , let X be its observing set. Denote by Z1 and Z2 two subsets of X. Then, the reachability indicator d[,Z1,Z2] of is 1 if there is a fine set for the triple (,1,Z2) for every 1 Z1; d[,Z1,Z2] = 0 otherwise. If d[,Z1,Z2] = 1, we say there is a fine set for the triple (,Z1,Z2).

PAGE 125

115 The reachability indicator possesses the following properties. Proposition 5.13 Let the system and the notation be as given in Definition 5.12. Given another subset of X, denoted by Z2, for which Z2 Z2, we have d(,Z1,Z2) d(,Z1,Z2). Proof. It implies from Z2 Z2 that for any node Z2, there is a node Z2 such that (, are nodes in the reachability tree of , i.e., subsets of X). If a set T of input strings spans a fine subtree for (,Z1,Z2), then it is also a fine subtree for (,Z1,Z2) by definition. Therefore, if d(,Z1,Z2) = 1, then d(,Z1,Z2) = 1, namely, d(,Z1,Z2) d(,Z1,Z2). Proposition 5.14 Let the system and the notation be as given in Definition 5.12. Given another subset of X, denoted by Z1, for which Z1 Z1, we have d(,Z1,Z2) d(,Z1,Z2). Proof. It implies from Z1 Z1 that for any node Z1, there is a node Z1 such that (, are subsets of X). The equality d(,Z1,Z2) = 1 implies that for each node Z1, there is a fine set T of input strings that spans a fine subtree, denoted by Tr1, for the triple (,,Z2). The next discussion is within the subtree Tr1. Denote by u the label of an arbitrary branch emanating from the node of Tr1, then, the machine is detectable at (,u). Considering a node Z1 for which , we know the machine is detectable at (,u) by Proposition 5.5. Denote by 1 a successive node of (,u), then there is a successive node 1 of (,u) for which 1 1. This is true for all the successive node

PAGE 126

116 of (,u) which are siblings of the node 1. Now, if we substitute 1, 1 for , respectively, in the above discussion, we can obtain the similar statement as addressed above. The process could continue until the successive nodes reach the terminal nodes of Tr1. We shall build a tree Tr2 with an initial node as follows. First, replace the initial node by , and then replace any successive node 1 of by the successive node 1 if a corresponding 1 is available. So on and so forth, till hitting the terminal nodes in the closed set of Z2. From the preceding discussion, all the siblings of the nodes in Tr2 are also included in Tr1. We conclude that there is a fine tree for (,,Z2), where is an arbitrary node in Z1. Therefore, we have the reachability indicator d(,Z1,Z2) = 1 given that d(,Z1,Z2) = 1, which implies d(,Z1,Z2) d(,Z1,Z2). In terms of reachbility indicator, we define next the extended skeleton matrix for input/output machines with critical races. Definition 5.15 Following the above notation, let Z be a list whose members are subsets of X, denoted by Z = {Z1, , Zm}, where Zi X for all i. The extended skeleton matrix K(,Z) of with respect to the list Z is an mm matrix, whose (i,j) entry is Kij(,Z) = d(,Zi,Zj). Let be an input/state machine with a critical race. Given the state set of as X = {x1, , xn}, let Z = {Z1, , Zn} be a list described in definition 4.19, where each member Zi contains only one element xi X X, namely, Z = X. Then, we have the following argument on the extended skeleton matrix K(,Z).

PAGE 127

117 Proposition 5.16 Given an input/state asynchronous machine with a critical race, we represent it as a critical race family M and let Z be the list defined above so that Z = X. Denote by K(M) the skeleton matrix of M defined in (3.19), and denote by K(,Z) the extended skeleton matrix given in Definition 5.15. Then, it holds that K(,Z) = K(M). Proof. We show first K(M) = 1 given that K(,Z) = 1. By Definition 5.15 of the skeleton matrix K(,Z), its (i,j) entry Kij(,Z) = 1 if the reachability indicator d(,Zi,Zj) = 1. Since each member Zk contains only one element which is xk X for k = 1, , n, there exists a fine subtree in the reachability tree for the triple (,xi,xj) if Kij(,Z) = 1. Two situations might appear. If there is a path in the fine subtree from the node xi to xj without passing through the critical race, then each node in this path has no siblings (no uncertainty occurs). It yields that Kij(M) = 1. Otherwise, all paths in the fine subtree go through the race. Note that the nodes that can have siblings are only the successive nodes of the critical race pair (i.e., the outcomes of the race). The existence of a fine tree for (,xi,xj) guarantees that there are paths from all these siblings to the node xj. It indicates that there is a path from xi to xj for each member machine of M, namely, Kij(M) = 1. Conversely, we shall verify K(,Z) = 1 by assuming K(M) = 1. Suppose Kij(M) = 1. And again, there are two possible cases here. (1) There is a string taking from xi to xj without encountering races. Then, there is a corresponding path in the reachability tree of , and the nodes on the path have

PAGE 128

118 no sibling. Clearly, this path builds a fine subtree for (,xi,xj), which follows that Kij(,Z) = 1. (2) All the stings from xi to xj have to go through the critical race. Denote the race family by M = {1, , }, then there is a set of input strings T = {ttk, k = 1, , } such that the input string t takes all the member machines from xi to the state right before the race, and tk then continues to drive the member machine k from one outcome of the race to xj. In view of the reachability tree, the set T forms a fine subtree for (,xi,xj) such that siblings of each node are included. Therefore, we have Kij(,Z) = 1 from Kij(M) = 1. It completes the proof. 5.3 Solutions to Race Control Problems In the present section, we shall investigate the model matching problem for input/output asynchronous machines which are nondeterministic due to critical races. The objective is to obtain a necessary and sufficient condition for the existence of solutions, and to provide an algorithm for constructing a solution as well. To this end, we first present some lemmas for auxiliary results, as a preparation of the theorem. The following are descriptions of the feedback loop system in Figure 1-1 provided that is an input/output machine with a critical race. Given = (A,Y,X,x0,f,h), let be the set that contains all prefixes of transition bursts of , as defined in Section 5.1.3. In view of Figure 1-1, the input set of C is the cross product A; the output set of C is the set A. Let be the state set, the recursion function, the output function and 0 the initial state. Then, we can depict C by a sextuple (A,A,,0,,). Being a combination of the machines C and the closed-loop system c is represented as

PAGE 129

119 (A,Y,G,(0,x0),sc,hc), where G X is the set of reachable stable states, sc is the stable transition function, and hc is the output function. The following two lemmas show some basic characteristics of the system in Figure 1-1 for input/output asynchronous machines with a critical race. The lemmas help us to have a good understanding of the theorem presented later. Lemma 5.17 Given = {A,Y,X,x0,f,h} as an input/output asynchronous machine with a critical race, let X be its observing set, and let Zi X and Zj X. The current state of is at an arbitrary member of Zi. The symbol ‘-‘ substitutes the variables that are allowed to take any values. If there exists a controller C such that the closed-loop system c in the Figure 1-1 satisfies sc[(-,Zi),u] (-,Zj) for u A, then, we have the reachability indicator d(,Zi,Zj) = 1. Proof. Initially, the machine is in a stable combination at an arbitrary state in the set Zi. Denote by 0 the initial sate of the controller C. Then, the initial state of the composite machine c will be in the set (0,Zi). After applying the input symbol u A to the machine c, the machine settles down at an element of Zj by the assumption; assume the controller is at 0 at the same moment, then the composite machine c reaches a stable combination in the set (0,Zj) as a result of u. For the above operation of c, we can represent it as the following one-step stable transitions: Sc((0,Zi),u) (0,Zj) (5-12) In view of Figure 1-1, the controller has access to the machine only through the input of , so, Eq. 5-12 implies that the controller C generates an input string t A*

PAGE 130

120 to drive the machine from an arbitrary state in Zi to a state in Zj. Denote by t = u1um. To guarantee the fundamental mode operation, the string t is generated by C one character at a time, where a new character is generated only after has reached a stable combination. So, the controller C has to be able to detect the state status of by reading the output burst generated from , which requires the detectability of at certain conditions. Denote by y1*y2*ym* the chain of bursts of in response to u1u2um, then, the input character uk+1 depends on the input/output data (u1,y1*), , (uk,yk*) and the initial uncertainty Zi, k = 1, , m-1. Due to the uncertainty of the initial state and the race outcomes, each burst of y1*, y2*, , and ym* may not be fixed but randomly varied, which might result in different input strings for u1u2um. That is, for each possible chain of the bursts of , there is a corresponding input string to fulfill the task. Counting all the possibilities, we obtain a set of input strings, denoted by T. Now, Let m be the maximal length of input strings in T, and we shall show by induction on the number m that the set T spans a fine tree for the triple (,Zi,Zj). A trivial case is when m = 0, where there is no need for any operation of the controller since the initial uncertainty satisfies Zi Zj. When m = 1, the controller C can drive from Zi to a state in Zj by applying one input symbol, say, u1, which is dependent on Zi. Then, consider the following subtree. The initial node is Zi, and a branch emanating from Zi is labeled with u1. Clearly, the successive nodes of (Zi,u1) are siblings to each other, which represent all the possible uncertainties of the next stable state of . The existence of controllers guarantees that these nodes are contained in Zj. Therefore, this two-level

PAGE 131

121 subtree is a fine tree for (,Zi,Zj). Here is an assumption: if a set T of input strings with maximal length k drives the machine from Zi to a state in Zj, then T spans a fine tree for (,Zi,Zj). We shall show in the following the argument is true for T with length k+1. Again, consider the following subtree with the initial node Zi. Suppose u1 is the first input symbol that the controller C generates and applies to . Consider the branch emanating from the node Zi with label u1, and denote by Z1 the set of the successive nodes of (Zi,u1). Each node in Z1 is a possible uncertainty set which the next stable state of is in after applied u1 . The existence of the controller C ensures that there are input strings that drive from each node of Z1 to a state contained in Zj; and clearly, these input strings have length less than or equal to k. Let be an arbitrary node in Z1, and consider as the initial node. By assumption, there is an input string set, denoted by T(), that spans a fine tree for (,,Zj). Let a, b be two strings, and we use the notation con(a,b) to represent their concatenation. By the definition of fine trees, the input string set T = {con[u1,T()] : Z1} spans a fine tree for (,Zi,Zj), where the maximal length of strings in T is k+1. From the above induction, we claim that the existence of the controller guarantees that there is a set of input strings that spans a fine tree for (,Zi,Zj), that is, the reachability indicator d(,Zi,Zj) = 1. Lemma 5.17 presents a necessary condition for the existence of a controller to fulfill a simple task (i.e., to drive the machine from an initial uncertainty set to a state in another set. Next, we shall derive a sufficient condition for its existence by constructing such a controller.

PAGE 132

122 The feedback controller C we design next will be decomposed into a control unit and an observer , for which we use notation C := (,). The observer := (A,F,F,x0,,I) has the same notation and the same function as given in Section 5.1.3. As to the control unit , we denote by := (AX,A,,0,,). Note that the input set AX indicates that has two inputs which are the external input and the output of . As showed in Figure 1-2, being a combination of the machines ,, and , the system c has the state set G := XF = {(,x,), , x X, F}. Lemma 5.18 Given = {A,Y,X,x0,f,h} as an input/output asynchronous machine with a critical race, let X be the observing set of , and let Zi X and Zj X. The state of is currently in the uncertainty set Zi. If the reachability indicator d(,Zi,Zj) = 1, then there exists a controller C = (,) such that the closed-loop system c in Figure 1-2 satisfies Sc((-,x,Zi),u) {(-,,): , Zj} (5-13) for any x Zi and any given u A. Proof. We shall construct a controller C that satisfyies the given requirement. The following explains the idea of how our controller works. From the condition that the reachability indicator d(,Zi,Zj) = 1, we know there is a set T of input strings that spans a fine tree for the triple (,Zi,Zj). Pick up an arbitrary branch emanating from the node Zi in the spanned fine tree, and denote its label by u1. The control unit applies u1 to , and consequently, the machine produces an output burst denoted by y1*. In the reachability tree, we know that there is one successive node of Zi which is associated

PAGE 133

123 with the input-burst pair (u1,y1*). Suppose this node is 1 X, and then the observer produces and delivers this information to the control unit . Next, pick up an arbitrary branch emanating from the node 1 and label it by u2. Then, the control unit generates and applies u2 to the machine . So on and so forth, the process continues until the input-burst pair (um,ym*) corresponds to a node m, where m is contained in the closed set of Zj. In brief, the control unit drives the machine from the initial uncertainty Zi to some states in Zj along a path of the fine tree spanned by T. The input string which labels this path is denoted by u1um, and the output bursts associated with the nodes along the path are denoted by the chain y1*ym*, where yk* (the set of transition bursts of ), k = 1, , m. During the process, set the initial state of the control unit to be 0; and set the initial state of the observer to be the node 0 := Zi, indicating that the initial uncertainty of is Zi. To complete the operations along the path, the state chain of is denoted by 012m0, and the state chain of is 01m in which each character represents a node on the path. Let s be the stable transition function of , and denote by U(x) := {u A : s(x,u) = x}, the set of all input characters that form stable combinations with the state x. The following are transitions for the control unit and the observer so that the behavior of the composite system c satisfies the given requirement. (i) The system c is initially in a stable combination with the state (0,x,0), where 0 = Zi and x Zi, as discussed above. Accordingly, the operations of the

PAGE 134

124 controller are defined as follows. Select an element u* U(0). : (0,(0,w)) := 0 for all w A\u; (0,(0,w)) := u* where u* U(0) and w A\u. : (0,(u*,-)) = 0 (5-14) (ii) After an external input value u appears, the control unit starts to apply to the input symbols of t = u1um which will bring to an uncertainty set contained in the closed set of Zj. Again, to guarantee fundamental mode operation, the string t is generated by one character at a time, where a new character is generated only after the observer provides the information that has reached a stable combination. Recall that yk* is the transition burst of in response to the input character uk, k = 1, , m. This process is accomplished by the following settings. : (0,(0,u)) := 1 for u A, (1,(z,w)) = u1 for all (z,w) XA; : (0,(u1,y1*)) = 1. (5-15) For 2 j m, : (j-1,(j-1,u)) := j, (j,(z,w)) := uj for any (z,w) XA; : ( j-1,(uj,yj*)) = j. (5-16) (iii) Finally, the observer sends m Zj to the control unit to show that has reached a stable combination at a state in m. Then, the control unit moves to the state 0, and at the same time, outputs an element v* U(m), which helps c remain in a stable state combination before the next external input appears. We assign the following. : (m,(m,u)) := 0 for u A, (0,(m,u)) := v* where v* U(0) and u A; : (m,(v*,-)) = m. (5-17)

PAGE 135

125 It is easy to justify that, applying the controller we design above, the composite system c performs as an asynchronous machine which starts from a stable state in {(0,x,0) : x Zi} and enters a stable state in {(0,,m) : m, m Zj} in response to an external input u A. During the process, the definition of fine set guarantees that the machine is detectable at any state-input pairs in (k,uk), k = 1, , m. By receiving two input variables, uk and yk*, the observer knows that the is in a stable combination and starts to output a state estimation (i.e., uncertainty set). Then, the control unit updates its state values as a response to this state information. Therefore, we draw a conclusion that the control system designed above works in fundamental mode and fulfills the task stated in the lemma. Lemma 5.17 and 5.18 present together a necessary and sufficient condition for the existence of the controller C such that the composite system c satisfies a given one-step stable transition. The proof also implies that a separation principle is valid here: we can always build the controller C as a combination of an observer and a feedback control unit , as connected in Figure 1-2, whenever model matching problem is solvable. When a critical race occurs during transitions of the machine , uncertainties of the outcomes of the race are examined and refined on the basis of input/output data of . Effects of the critical race are taken into consideration while different inputs are generated based on different outcomes (i.e., output bursts) of . Based on the design idea in Lemma 5.17 and 5.18, next, we shall derive a complete solution to the problem of model matching. Recall that B(,) denotes the equivalence list of machine with respect to machine . Without losing generality, we assume the

PAGE 136

126 machine is stably reachable and the mode is minimal. Lemma 5.19 Let = (A,Y,X,x0,f,h) be an input/output asynchronous machine with a critical race. Let = (A,Y,X,0,s,h) be a deterministic stable-state machine with h(x0) = h(0). Denote by B(,) = {B1, , Bq} where q = |X|. If there is a controller C such that c = , then there exists a list Z = {Z1, , Zq} whose member Zi contains subsets of Bi, i = 1, , q, such that K(,Z) K(). Proof. Following the earlier notation, let C = (A,A,,0,,) be a controller such that c = . The closed-loop machine c = (A,Y,(X),(0,x0),sc,hc) is deterministic and stably equivalent to the minimal machine . In terms of machine equivalence, there exists an stable equivalence partition of the states of c such that the stably quotient machine c/ is isomorphic to . Let X = {1, , q} and denote by := {1, , q} with i := {(i,1,xi,1), , (i,m(i),xi,m(i))}, where i,j and xi,j X for j = 1, , m(i), i = 1, , q. It holds that i i for i = 1, , q. From the properties of the stable equivalence partition, namely, transition consistency and output consistency, it follows that (i) hc((i,1,xi,1),u) = = hc((i,m(i),xi,m(i)),u), for any u A; (ii) s(i,u) = j in c/ if and only if for each m = 1, , m(i), there exists an index n {1, , m(j)} such that the transition sc((i,m,xi,m),u) = (j,n,xj,n) holds for c. Due to the output function hc((,x),u) = h(x) and the states i i, we get from (i) that (iii) h(xi,1) = = h(xi,m(i)) = h(i); it also implies that the condition in (ii), s(i,u) = j, is equivalent to s(i,u) = j in . In

PAGE 137

127 view of the closed-loop configuration in Figure 1-2, the controller has access to the machine only through the input of , so, the statement (ii) implies that (iv) s(i,u) = j in then for each m = 1,m(i), there exists n {1, , m(j)} and t A* such that s(xi,m,t) = xj,n in . Let Zi = {xi,1, xi,2, , xi,m(i)} for i = 1, , q. Clearly we have Zi Bi for i = 1, , q from the statement (iii). The statement (iv) indicates that the composite system c satisfies sc((-,xi,m),u) (-,Zj) for all m = 1, , m(i). Applying the results in Lemma 5.17, it follows that the reachability indicator d(,xi,m,Zj) = 1 (5-18) for m = 1, , m(i). That is, there is a fine set for the triple (,xi,m,Zj) that spans a fine tree with the initial node xi,m and the terminal nodes in the closed set of Zj. We denote this fine set by T(xi,m,Zj), and denote the set of all its terminal nodes by Xf(xi,m,Zj), for each m = 1, , m(i). When the closed-loop system c reaches a stable combination after the transition in (iv) in order to match s(i,u) = j, the machine lies at a node in Xf(xi,m,Zj). Due to the existence of a critical race, the machine settles down at different nodes in response to different outcomes of the race, and also each terminal node might be a state uncertainty set. Therefore, each member of Xf(xi,m,Zj) is a subset of Zj and Bj (Zj Bj). So, in order to match the transition s(i,u) = j of the model, all the possible terminal nodes that the machine reaches are contained in the union of Xf(xi,1,Zj), Xf(xi,2,Zj), , and Xf(xi,m(i),Zj). Consider all the transitions of the model terminating at the state j (i.e., s(,u) = j for any state X and u A), then we define

PAGE 138

128 X1f(Zj) := i = 1, , q {m = 1, , m(i) Xf(xi,m,Zj) (5-19) for j = 1, , q. The set X1f(Zj) consists of all the possible state uncertainties in Zj at which settles down after the composite machine c mimics the behavior of any one-step stable transition of the model; here, initially stays at an individual state. Suppose the state of c is currently in an uncertainty set X1 X1f(Zj). An external input u is applied for which the model responds with s(j,u) = n. Correspondingly, the machine needs to be transformed to a state in Zn = {xn,1, , xn,m(n)} so that the one-step stable transition of c is formulated as sc((-,X1),u) = (-,Zn). Applying the result in Lemma 5.17, we get the reachability indicator d(,X1,Zn) = 1 (5-20) for any X1 X1f(Zj). Again, the above transition induces a new set of terminal state uncertainties for the machine after the composite system c enters a stable combination with the input u; we denote this new set by Xf(X1,Zn), where X1 X1f(Zj). Hence, in order to match s(j,u) = n of the model, the machine may settle down at any state uncertainty in the union of Xf(X1,Zn) for all X1 X1f(Zj). Consider all the possible one-step transitions of the model ending at n, namely, the transition s(j,u) = n for any j X and u A, j = 1, , 1, then, we obtain X2f(Zn) = j = 1, , q {Xf(X1,Zn) : X1 X1f(Zj)} (5-21) for n = 1, , q. The set X2f(Zn) includes all the possible state uncertainties where may terminate starting from any uncertainty set contained in X1f(Zj), j = 1, , q, so as to match an arbitrary one-step transition of the model with the ending state xn.

PAGE 139

129 Do the similar procedure on X2f(Zj) as we did on X1f(Zj), we can obtain X3f(Zj) for all j = 1, , q. So on and so forth. Note that Xfk(Zj) contains subsets of Zj for any integer k, so the above process terminates in finite steps. Finally, define the following Xf(Zj) = k =1, 2, Xkf(Zj), (5-22) where j = 1, , q. For any uncertainty Xi Xf(Zi), it follows from the above discussion that d(,Xi,Zj) = 1 if there is a transition from i to j in the model , that is, Kij() = 1. In other words, there is a fine set T for (,Xi,Zj) such that all the possible terminal state uncertainties are contained in Xf(Zj), which is true for all the set Xi Xf(Zi), where i, j = 1, , q. Define the list Z = {Xf(Z1), , Xf(Zq)}. Clearly, each member Zj of Z contains subsets of Bj. We then claim in terms of the skeleton matrix for the list Z that K[,Xf(Zi),Xf(Zj)] = 1 (5-23) given that Kij() = 1 for i, j = 1, , q, which follows that K(,Z) K(). The above Lemma presents a necessary condition for the existence of solutions to the model matching problem. Next, we shall show that it is also a sufficient condition by constructing such a controller (consisting of a control unit and an observer) that the closed-loop system is stably equivalent to the model. Again in the following, the machine is stably reachable and the model is minimal. Theorem 5.20 Let = (A,Y,X,x0,f,h) be an input/output asynchronous machine with a critical race. Let = (A,Y,X,0,s,h) be a deterministic stable-state machine with |X| = q and h(x0) = h(0). Denote by B(,) = {B1,,Bq}. Then, the following two statements are equivalent.

PAGE 140

130 (a) There is a controller C = (,) such that the closed-loop system c = , where c operates in fundamental mode; (b) There exists a list Z := {Z1, , Zq} of which each member Zi contains subsets of Bi, i = 1, , q, such that K(,Z) K(). Proof: Regarding the part that (a) implies (b), it has been shown in Lemma 5.19. For the converse direction, assume that Z = {Z1, , Zq} is a list that satisfies the conditions in (b). Denote the state set of by X = {x1, , xn} and its initial state x0 := xd; and denote the state set of by X = {1, , q} and its initial state 0 := e. From the given condition, we get h(x0) = h(0) = h(e). We assume that the initial state x0 appears in Ze without losing generality; the reason is that we can always add x0 into Ze so that Z is still a list that satisfies (b) owing to the fact that is stably reachable and h(x0) = h(e). Utilizing the list Z, we shall build a controller C for which the input/output behavior of the composite system c matches that of the model . Incidentally, we will also show that C can always be decomposed into a control unit and an observer , as shown in the Figure 1-2. From the definition of the equivalence list, the condition in (b) implies that all the states of appearing in Zi generate the same output value as the state i does. We shall design the controller so that each member Zi of Z corresponds to the state i of the model , i = 1, , q. We denote by Zi = {Zi,1, , Zi,n(i)}, where Zi,j Bi for j =1, , n(i), i = 1, , q. Each element of Zi represents a possible state uncertainty, and will serve as a state (or output) of the observer . Define the set F := qi = 1 Zi = {Z1,1, ,

PAGE 141

131 Z1,n(1), , Zq,1, , Zq,n(q)}, which will be the stable state set of the observer , that is, all the possible state uncertainty of the machine that can be observed from its input/output data. By the definition of equivalence list B(,), its member is given by Bk := {x X: h(x) = h(k), k X}, so two members of B(,), say Bi and Bj, will be the same if the two states i and j of the model generate the same output, namely, h(i) = h(j). The member Zi of the list Z contains subsets of Bi, so, the two members Zi and Zj may contain a same subset. If this happens, we would like to know which member, Zi or Zj, this subset belongs to, since the controller action depends on whether the subset is treated as an element of Zi or of Zj at that instant. This is done by assigning different states of the control unit . For simplicity, we assign the state of to be i if the state uncertainty of is considered to be an element of Zi. Then, for Zi = {Zi,1, , Zi,n(i)}, we build a set of pairs as { (i,Zi,1), , (i,Zi,n(i))}, i = 1, , q. The first variables in the pairs are states of the control unit and the second are states of the observer . The state of the observer serves to report the estimated information on the state status of the machine . For instance, the fact that the state of is Zi,j indicates that the current stable state of is an arbitrary element in the set Zi,j. Recall that the closed-loop system c, as a composite machine of , , and , has the state set G := XF = {(,x,), , x X, F}. For each pair (i,Zi,j) F we build above, we generate a set Ai,j := {(i,x,Zi,j), x Zi,j} XF, (5-24)

PAGE 142

132 where j = 1, , n(i), and i = 1, , m(i). We do it for each element Zi,j of Zi, and then we define Gi := n(i)j = 1 Ai,j = {(i,x,Zi,j) : x Zi,j, j = 1, , n(i)}, (5-25) i = 1, , q. The stable state set of the system c is then defined as G = qi = 1 Gi. So, for each state of c, say (i,x,Zi,j), the variable Zi,j is the state (or output) of the observer to present an estimated information about where the state of might be, the variable i is the state of the control unit to indicate that the uncertainty set Zi,j is treated as a member of Zi, and the variable x is simply the current state of , where x Zi,j. The controller C is designed below so that, starting from a state in the set Gi, the closed-loop machine c generates the same input/output behavior as the model does starting from its state i, i = 1, , q. More specifically, for each transition s(i,u) = j in , we shall build operations of and so that the system c goes through the corresponding transition sc(Gi,u) = Gj, namely, the transition s (Ai,k,u) {Aj,1, , Aj,n(j)} for any k = 1, , n(i). From the inequality K(,Z) K(), the reachability indicator d(,Zi,k,Zj) = 1 for k = 1, , n(i) if Kij() = 1. Applying the result of Lemma 5.18, we know that there exists a controller C = (,) such that c runs the following transition: Sc((-,x,Zik),u) {(-,,): , Zj}, (5-26) where x Zik. Following the procedure in the proof of Lemma 5.18, we can design the operations of a controller Sc((i,x,Zik),u) {(j,,): , Zj} (5-27)

PAGE 143

133 for any x Zik. Note that here the initial state of the control unit will be i and the state in the end of this process will be j, instead of 0 and 0, respectively, in the proof of Lemma 5.18. During this process, the machine initially stays at an arbitrary state in the uncertainty set Zik, and terminates at a state in an uncertainty set of Zj, where k = 1, , n(i). Different initial state in Zik might result in different terminal uncertainty in Zj; even the same initial state in Zik might have different terminal uncertainties due to the random outcomes of the race. In other words, the controller transforms the machine from each state uncertainty Ai,k into another uncertainty in {Aj,1, , Aj,n(j)}, for k = 1, , n(i), which follows that sc(Gi,u) = Gj for the composite system c. For each possible transition s(i,u) = j of the model, we can design the corresponding operations for the controller in the similar way due to the condition K(,Z) K(). Let us look at how the composite machine c operates. Note that x0 Ze, so we have (0,x0,x0) Ge according to the assignment in Eq. 5-24 and Eq. 5-25. The initial state of c is (0,x0,x0). When an external input u appears for which (0,u) := s(e,u) = i holds for the model, the machine c runs through the process as designed above to enter a state in Gi; the machine c may enter different states in Gi due to the uncertainties caused by the critical race. Suppose the next input u comes in for which the model runs the transition s(i,u) = j, then c will transform from the state in Gi to a state in Gj. Again, it might reach different states of Gj due to the uncertainty. So on and so forth. The operations of each step are designed in such a way that they have no interference with each other, which guaranties that there is no inconsistency in the definition of the functions, and ensures that the system operates in fundamental mode.

PAGE 144

134 Let := {G1, , Gq} be a partition of the state space G. It can be seen that is an stable equivalence partition from the previous definition of G and the above operations on G, therefore, the quotient machine c/ is stably equivalent to c. Also from the above design, we have that c is isomorphic to , which follows that c is stably equivalent to the model . This completes the proof. Theorem 5.20 presents a necessary and sufficient condition for the existence of controllers to the model matching problem; its proof also supplies an algorithm to obtain the structure of the controller which decomposes into an observer and a control unit. Again, similar to the result in Section 4.2.2, a separation principle is valid here, that is, we can always build a controller C to be the combination of an observer and a control unit , as connected in Figure 1-2, whenever the model matching problem is solvable. Consider the situation where is deterministic in the above discussion. Then, the reachability tree of will collapse to a regular successor tree, except the requirement in the present work that only detectable transitions be considered in the tree. In other words, each node of the tree represents a state of the machine, there are no siblings for any node, and each transition is detectable. Therefore, the observing set X will be identical to the state set X, and the list Z in Theorem 5.20 will be a list of subsets of X. It then follows that the necessary and sufficient condition in Theorem 5.20 becomes the same as that of the theorem in Section 4.2.2 for input/output deterministic machines. Corollary 5.21 The necessary and sufficient condition for the model matching problem presented in Theorem 5.20 is an extension to the result in Section 4.2.2 for input/output deterministic machines.

PAGE 145

135 Consider the case when the machine is an input/state machine with a critical race. In such a situation, the machine and the model share the same state space X (refer to Chapter 3), all the nodes in the reachability tree of are individual states, and siblings only happen to the successive nodes of the race condition. Thus, the observing set of is X, and there is only one candidate for non-deficient lists Z in Theorem 5.20, which is Z = X. Letting M be the race family representing the machine , we have K(,Z) = K(M) from Proposition 5.16. So, the condition in Theorem 5.20 turns to the verity of the inequality K(M) K(), which is exactly the result for input/state machines in Section 3.3.2. Corollary 5.22 The necessary and sufficient condition for the model matching problem presented in Theorem 5.20 is an extension to the result in Section 3.2.2 for input/state machines with criical races. 5.4 Constructing Suitable Lists By Theorem 5.20, once there is a list Z satisfying the conditions in the theorem, we can conclude the existence of the solution to the model matching problem; and moreover, we are able to design a controller by utilizing the list Z. In this present section, we shall present an algorithm to check if such a list Z exists, and furthermore, to find one suitable list Z if it exists. First, some notation. Let the state set of the model be X = {1, , q}, and let the equivalence list be B(,) = {B1, , Bq}. Assume Z = {Z1, , Zq} is a list that satisfies the condition in Theorem 5.20, where Zi := {zi,1 , zi,n(i)} consists of subsets of Bi, for i = 1, , q. From the construction of controllers in the preceding section, all those subsets in Zi, for i = 1, , q, are possible states of the observer (i.e., nodes in the

PAGE 146

136 reachability tree). The procedure to calculate such a list Z will be somewhat similar to the one in the deterministic situation, but have its specialty. Given the observing set X, the matrix K(,X) is defined to be the skeleton matrix for the input/output nondeterministic machine (refer to Section 5.2.1); on the basis of K(,X), the following is a definition of restricted skeleton matrices of , which is a counterpart of the same notation for deterministic machines. Definition 5.23 Let K(,X) be the skeleton matrix of the machine with its observing set X. Let Z1, Z2 be two lists of elements of X, where Z1 has m1 elements and Z2 has m2 elements. The restricted skeleton matrix K(,Z1,Z2) of associated with Z1 and Z2 is an m1m2 matrix whose (i,j) entry is defined as follows. If xr is the i-th element of Z1, and xs is the j-th element of Z2, then Kij(,Z1,Z2) = Krs(X). (5-28) The following algorithm uses a recursive process to build a decreasing chain Z0 Z1 ... Z of lists; the integer k = 0, 1, , is used to count the steps in this recursive process. The initial list Z0 is such as each element Z0,i contains all subsets of Bi which are nodes in the reachability tree, i = 1, , q. The last list Z determines whether or not there is a solution to the problem of matching the model . Following our earlier notation, the members of the list Zk are Zk,1, , Zk,q, k = 0, ..., , and each member contains some nodes of the reachability tree. Algorithm 5.24

PAGE 147

137 Step 1. Set k := 0 and Z0 := {Z0,1, , Z0,q} with Z0,i := {x Bi : x X}, where Bi is i-th member of the equivalence list B(,), i = 1, , q. Step 2. Consider a pair of integers i, j {1, , q}. Let S(i,j) be the set of any node x in Zk,i that satisfies the reachability indicator d(,x,Zk,j) = 0 (by Algorithm 5.9), where S(i,j) = if no such a node exists, or if Kij() = 0. Set Zk+1,i = Zk,i \j = 1, ..., q S(i,j), i = 1, ..., q; (5-29) and set Zk+1 := {Zk+1,1, ..., Zk+1,q}. (5-30) If Zk+1,i = for an integer i, then the present model matching problem has no solution, and the algorithm terminates. Step 3. If Zk+1 = Zk, then Zk determines a solution to the model matching problem, and the algorithm terminates. Otherwise, repeat from Step 2, using the value of k+1 for k. We name Z0 the list of equivalent nodes of with respect to the model , and denote by P(,) := Z0. After the algorithm ends, we obtain a decreasing chain Z0 ... Z-1 Z of lists whose members are subsets of nodes in the reachability tree. This chain has the following fundamental property. Proposition 5.25 Let and be two machines as described in Theorem 5.20, and let Z0, , Z-1, Z be the string of lists generated by Algorithm 5.24. Then, any list Z := {Z1, , Zq} satisfying Z Z0 and K(,Z) K(), is less than or equal to Zi, i = 0, ..., .

PAGE 148

138 Proof. We know Z0 := {Z0,1, , Z0,q} with Z0,i := {x : x Bi and x X} from the algorithm. The argument in the proposition is true if we show by induction that the following is true: for any element x removed from Z0,m during the algorithm, any list Z := {Z1, , Zq} Z0 with x Zm cannot satisfy K(,Z ) K(). The induction is taken on the number m of steps (or runs) in the recursive process of the algorithm. The procedure will be similar to the proof of Proposition 4.20 and the details are omitted. We claim next that there exists a solution to the model matching problem if and only if Z = Z-1, or Z is not deficient; more specifically, we show the non-deficient list Z obtained from the algorithm is a list satisfying the condition in the theorem and the inequality K(,Z) K(). Proposition 5.26 Let and be two machines as described in Theorem 5.20, and let Z0, , Z-1, Z be the string of lists generated by Algorithm 5.24. Denote by P(,) the list of equivalent nodes of with respect to . Then, the following two statements are equivalent: (i) There is a list Z P(,) satisfying K(,Z) K(). (ii) Z = Z-1 (or Z is not deficient). When (ii) holds, then K(,Z) K(). Proof: The idea is similar to that of the proof for Proposition 4.21 in the deterministic situation, and the detail of the proof is omitted. Combining Proposition 5.26 with Theorem 5.20, we obtain Corollary 5.27 Let and be two machines as described in Theorem 5.20, and let Z0, , Z-1, Z be the string of lists generated from Algorithm 5.24. Then, there exists

PAGE 149

139 a solution to the model matching problem for and if and only if Z Z-1 (or Z is not deficient). 5.5 Analyses of the Theorem and the Algorithm The solution to the model matching problem in Theorem 5.20 can be obtained if there is a list Z with Z P(,) for which the inequality K(,Z) K() holds, where P(,) is the list of equivalent nodes of with respect to . Algorithm 5.24 provides a general means to check this condition and to calculate such a list if the condition can be satisfied by utilizing the reachability tree. In this section, we shall discuss solutions to the model matching problem under certain conditions, and in the meantime, to analyze the complexity of the algorithm. In practice, it is not necessary sometims to build up an entire reachability tree of the machine as introduced in Section 5.2.1. In some scenarios, we only need to get part of the reachability tree which initially starts from the critical race pair. In the following circumstances, we even do not need the reachability tree at all. Following the previous notation, let = {A,Y,X,x0,f,h} be an asynchronous machine with a critical race pair (r,v) and the state set X = {x1, , xn}. Denote by s the stable transition function with s(r,v) = {r1, , r}. Let Xr := {x : s(x,v) = s(r,v)}, namely, the set of states whose next stable states with input v are the outcomes of the race (r,v). In other words, (Xr,v) consists of all the critical race pairs in the stable-state machine induced from . As depicted earlier, we could always represent as a race family M = {1, , } of which each member machine is deterministic and corresponds to one outcome of the race. The following are definitions of two special types of skeleton matrices of .

PAGE 150

140 Definition 5.28 Let be as given above, the race-free skeleton matrix of , denoted by Kd(), is such that its (i,j) entry Kijd() := 1 if xj is stably reachable from xi without going through the race 0 otherwise (5-31) where i, j = 1, , n. It is very easy to get the race-free skeleton matrix from the transition function f: first remove the transition at the critical race pair (r,v), then calculate the one-step stable transition matrix, and further get the skeleton matrix by following the procedure provided by Murphy (1996, Chapter 4). The skeleton matrix we obtain will be the race-free skeleton matrix. Definition 5.29 Given an input/output machine and it race family M, the skeleton matrix K(), is an nn matrix of zeors and ones, whose (i,j) entry is Kij() := 1 if Kij(k) = 1 for k = 1 0 otherwise (5-32) for i, j = 1, , n. The above definition of skeleton matrices for input/output race families is congruent to the definition in Section 2.4 for input/state machines. In order to have Kijd() = 1, not only need we have Kij(k) = 1 for all k, but also there is a string that can drive the race machine from the state xi to xj without entering the race. Therefore, the condition for the race-free skeleton matrix Kd() is stronger than the skeleton matrix K(M), that is, Kd() K(). Given a sublist Z of elements of X, we can define the corresponding extended skeleton matrices Kd(,Z) and K(M,Z) with respect to Z

PAGE 151

141 analogous to the previous definition of extended skeleton matrices. Next, in terms of these skeleton matrices, we present results to the model matching problem regarding to some special cases. Proposition 5.30 Let M be a race family of input/output machines, let be an input/output machine, and let Z be a sublist of B(,) such that Kd(,Z) K(). Then, there exists a solution to the model matching problem. Proof. It is a direct result from the definition of the race-free skeleton matrix and Theorem 5.20. The algorithm of checking the existence of such a list Z in Proposition 5.30 and obtaining one whenever it exists is the same as the algorithm in Section 4.3 for deterministic machines. The algorithm has polynomial complexity. Recall that the set Xr is the set of states from which the machine will run through the race (r,v) after the input symbol v is applied, for which we have s(Xr,v) = s(r,v) = {r1, , r}. By different output values the outcomes of the race generate, we could partition them into different blocks, denote by Rp := (R1, , R). We name it as the race partition of the critical race (r,v). Clearly, |R1| + + |R| . For any state Xr, let Xs() be the set of stably reachable states from without going through the race. Considering the situation when there is at least one common state in Rp and Xs() for any Xr, we have the next result about the model matching problem. Corollary 5.31 Let the system and the notation be as given above. If s(r,v) Xs() for any Xr, then a necessary and sufficient condition for the existence of

PAGE 152

142 solutions to the model matching problem is: there is a sublist Z of B(,) such that Kd(,Z) K(). Proof. Suppose first there is a solution to the model matching problem. From Theorem 5.20, there is a list Z = {Z1, , Zq} P(,) such that K(M,Z) K(), where P(,) is the list of equivalent nodes. Following the algorithm in the proof of the theorem, we could build a controller C such that the machine could transform into Zj from any node of Zi in order to match the transition s(i,u) = j of the model, where i, j X and u A, and i, j = 1, , q. Supposing Kij() =1, we consider the transition of that transform into a node in Zj from any node in Zi. Assume that we know is currently at an individual state in Zj, say, x. Then, there is a fine tree for (,x,Zj) and the reachability indicator d(,x,Zj) = 1 from Kij(,Z) = 1. If no race appears in the fine tree, the terminal node of will be an individual state in Zj, say, z X. Hence, the entry of the race-free skeleton matrix Kd() indexed by x and z, that is, Kd(,x,z) = 1. Given that the critical race occurs during the above transformation, we consider the first time when the race occurs. Before the race, the machine is at a state Xr; and after the race, reaches a state in s(r,v) randomly. Since s(r,v) Xs() for any Xr, there is a state s(r,v) Xs(), namely, the machine can reach from without passing the race. Next, consider the last time the race appears in the fine tree for (,x,Zj). Surely, the state is contained in one of the successive nodes of the race pair. By the property of

PAGE 153

143 fine trees and skeleton indices, we have d(,,Zj) = 1 for any state s(r,v) Xs(), and there is a fine tree for (,,Zj) without encountering the race. Connect the path from x Zi to Rr before the first-time race, the path from to s(r,v) Xs() without being through the race, and the path from to a node z Zj after the last-time race. since all the paths are not involved with the race, the node z is an individual state and the entire path from x Zi to z Zj does not pass the race. It concludes that Kd(,x,z) = 1. So, if Kij() = 1, we have Kd(,x,z) = 1 for any state x Xi and an arbitrary state z Zj. The machine starts initially from an individual state x0; along the way to match the model, goes from one individual state to another and never runs into the race. Therefore, there is a sublist Z of B(,) such that Kd(,Z) K() from the result for deterministic situations. Conversely, assume that there is a sublist Z = {Z1, , Zq} of B(,) such that Kd(,Z) K(). Treat each state in Zi as a node in the reachability tree, then, the list Z also satisfies the condition in Theorem 5.20. Therefore, there is a solution for the model matching problem, which completes the proof. Again, when the condition, s(r,v) Xs() for any Xr, is satisfied, the algorithm of finding such a list Z is analogous to the algorithm in Section 4.4 for deterministic machines. The algorithm has polynomial complexity. Corollary 5.32 Following the previous notation, if each block of the race partition is an individual state, then a necessary and sufficient condition of the existence of solutions to the model matching problem is as follows: there is a sublist Z of B(,)

PAGE 154

144 such that K(M,Z) K(). Proof. Suppose first there is a controller C to solve the model matching problem. From Theorem 5.20, there is a list Z = {Z1, , Zq} P(,), where P(,) is the list of equivalent nodes, such that K(,Z) K(). Since starts initially from the initial state x0 and all the successive nodes of the race pair are individual states, all the nodes in the reachability tree are individual states. Then the list Z in Theorem 5.20 simply reduces to a sublist of B(,). Supposing Kij(,Z) = 1, for any states x Zi and Zj, we have a fine tree for (,x,) and the reachability indicator d(,x,) = 1. If no race is in the fine tree, it implies K(M,x,) = 1. If the race does occur and the race partition Rp = (r1, , r), we have K(M,rk,) =1 for k = 1, , , which implies that K(M,x,) = 1. Therefore, the list Z satisfies K(M,Z) K(). For the converse part, assuming there is a sublist Z such that K(M,Z) K(), we could build a controller by following the similar procedure in the proof of Theorem 5.20 to solve the model matching problem. Again, for machines satisfying the condition in Corollary 5.32, the algorithm of constructing controllers has polynomial complexity. Suppose the state set X has n elements, and consider an arbitrary transition that transforms from x Zi to Zj. If no race is encountered, the maximal number of steps takes by going from x till will be n-1; if a race is necessary, the race only needs to happen once, and then the maximal number of steps will be 2(n-1) (i.e., n-1 before the race and n-1 after the race).Moreover, it means also that the maximal number of levels of the reachability tree

PAGE 155

145 will be 2n-1. The next argument gives the bounds to the number of levels (or the height) of the reachability tree for certain situations. In those scenarios, the race needs only to happen once in the reachability tree. This is to say, instead of storing the information of the whole reachability tree, we need only to build one of its subtrees, called a race tree, as follows. Its initial node is Rr and the only branch emanating from Rr is labeled by v. Then, the nodes on the second level will be the blocks in the race partition Rp. The subsequent levels will follow the same rules as a reachability tree. Except the first level, no race is allowed to happen in the race tree. Evidently, combining the race tree together with the one-step transition matrix that characterizes the deterministic transitions between individual states, we have full information of the original machine. Proposition 5.33 Let the system and the notation be as given above with |X| = n and B(,) = {B1, , Bq}. Given the race partition Rp := (R1, , R), let max{|R1|, , |R|} = m. In the following two situations, the height of the reachability tree is less than n(n-1)2 (m-1)+(n-1), and the race needs only happening once in the transitions of in response to any input symbol. (a) For any state z hIh(x), where x Xr, we have s(z,v) s(r,v). (b) For any node that Xr in the race tree, there is a fine subtree for the triple (,,Rp). Proof. We view the condition (a) first. The race tree stores the possible transitions after the first-time race and before the second-time race. Suppose the machine is currently at an arbitrary node of the race tree, for which there is a state x Xr.

PAGE 156

146 Then, the critical race will occur if the input v is applied when is at . Since h[] = h(x), we have that hIh(x). Owing to s[hIh(x),v] s(r,v) from the condition (a), the successive nodes of (,v) will still be the blocks of the race partition Rp, which repeats the nodes in the second level of the race tree. Therefore, the race is not necessary to happen more than once to complete a one-step stable transition of the composite machine c; the maximal step size of the controller to respond to an external input will be (n-1) before the race plus n(n-1)2 (m-1) after the race. Next, we study the situation in (b). Again, consider an arbitrary node in the race tree. Let Z be a set of subsets of X, and assume there is a fine set for the triple (,,Z) and the race occurs in the spanned tree of this fine set. Denote by the node at which the last-time race appears, then we must have Xr . The successive nodes of (,v) are denoted by N1, , Nm. It can be seen that for any block Rk of the race partition Rp, there is a node Ni such that Rk Ni, where i {1, , m}, for k = 1, , . By the property of fine sets, there are fine sets for the triples (,Ni,Z) without passing races, i = 1, , m, which further follows that there are fine sets for (,Rk,Z) without going through races, k = 1, , . From the condition in (b), there is a fine set for the triple (,,Rp) without encountering races. Connecting the two processes together, we get that there is a fine set for the triple (,,Z) and no race is necessary to appear in between. This is true for any node in the race tree. Therefore, it is enough for the machine to run the transitions in the race tree plus the deterministic transitions. And again, the maximal step size of the controller to respond to an external input is the same as the one for the situation (a).

PAGE 157

147 For all the situations discussed above, it suffices to consider the transitions in the race tree for uncertainty subsets, in company with the deterministic transitions between individual states. In many situations, such information is enough to determine the existence of the solution. For general situations, it is possible to have multiple occurrence of the race during the transitions of the machine in response to an external input; the number of occurrence is limited by blocks of the race partition Rp and the members of the equivalence list B(,). 5.6 Examples Example 5.34 Given an asynchronous machine = (A,Y,X,x0,f,h), its initial state x0 := x1 and its transition function f and output function h are given in the Table 5-2 (the same machine as shown in Table 5-1). Let = (A,Y,X,0,s,h) be an asynchronous stable-state machine satisfying h(x0) = h(0). Table 5-2. Transition Table of the machine in Example 5.34 a b c Y x1 x1 x2 {x1, x2} 0 x2 x4 x2 x2 0 x4 x4 x2 x4 1 From the table, we have the input set A = {a,b,c}, the output set Y = {0,1}, and the state set X = {x1,x2,x4}. Clearly, the state-input pair (x1,c) is a critical race pair. The race tree of the machine has been shown in Figure 5-1 in the previous discussion. We observe the observing set of as X := {x1,x2,x3,x4} = {x1,x2,x4,(x1,x2)} which includes the nodes in the race tree and the individual states in X. The skeleton matrix K(,X) of is calculated as

PAGE 158

148 K(,X) = 1111011001101111. (5-33) Let us investigate the existence of solutions to this model matching problem. First, we check the race-free skeleton matrix Kd() of . Following the definition, we remove the one-step transition at the race pair (x1,c), and then obtain Kd() = 111011011. (5-34) From h(x1) = h(x2) = 0 and h(x4) = 1, we get the counter-image list hI(Y) = {(x1,x2),x4}. The extended skeleton matrix of Kd() with respect to the list hI(Y) is then obtained as Kd(,hI(Y)) = 1111. (5-35) Given the list Z = B(,), each member of Z is an element of hI(Y). In terms of the definition of extended skeleton matrices, each entry of Kd(,Z) is an entry of Kd(), which is equal to 1. Thus, the skeleton matrix Kd(,Z) is an all-one matrix, and it holds that Kd(,Z) K() for any model . From Proposition 5.14, it follows that this model matching problem is always solvable. The construction of a solution (i.e., a controller) can be designed by following the procedure in the proof of the theorem. The above discussion only involves the race-free skeleton matrix which demonstrates the characteristics of the deterministic part of the machine. In other words, in order to match the input/output behavior of any deterministic model, it suffices to run the machine without triggering any critical race.

PAGE 159

149 Example 5.35 The machines and have the same the input set A = {a,b,c} and the output set Y = {0,1,2}. The state set of is X = {x1, , x5} and its initial state x0 := x1; the state set of is X = {1, , 4} and its initial state 0 := 1. The following flow tables, Table 5-3 and Table 5-4, depict the stable state transition function and the output function for and , respectively. Table 5-3. Transition Table of the machine in Example 5.35 a b c Y x1 x2 x3 x1 0 x2 x2 x2 {x1,x4} 1 x3 x5 x3 x5 2 x4 x4 x2 x4 0 x5 x4 x5 x5 0 Table 5-4. Transition Table of the machine in Example 5.35 a b c Y 1 2 3 1 0 2 2 4 2 1 3 3 3 4 2 4 2 4 4 0 Utilizing the table, we can easily calculate the race-free skeleton matrix Kd() of and the skeleton matrix K() of the model as follows; Kd() = 11111 01000 00111 01010 01011, K() = 1111010101110101. (5-36) The counter-image list of the output function h for the machine is given by hI(Y) := {(x1,x4,x5),x2,x3}, and the equivalence list is calculated to be B(,) = {(x1,x4,x5),x2,x3,(x1,x4,x5)}. Applying Algorithm 4.19, we conclude that there does not

PAGE 160

150 exist a sublist Z of B(,) such that Kd(,Z) K(). It indicates that there is no solution to the model matching problem without taking the race into account. Therefore, we need take a further look at the race tree of which is shown as follows. x4 x2 x2 b x3 (x1,x4) (x1,x4) x2 c a c Figure 5-3. Race tree of machine in Example 5.35 Observing the race tree in Figure 5-3, we notice that there is no new uncertainty subset except outcomes of the race (x1,x4). Therefore, the race only occurs at most once in the transitions of in response to an external input. We have the observing set is X := {x1,x2,x3,x4,x5,(x1,x4)}, and denote by Z := {Z1, , Z4} the list that satisfies the condition in the Theorem. Then, we have Z1, Z4 {x1,x4,x5,(x1,x4)}, Z2 = {x2}, and Z3 = {x3}. Following Algorithm 5.24, check each entry of the extended skeleton matrix (,Z), then we get K(,Z) K(). Therefore, the model matching problem is solvable. Moreover, the machine might enter the critical race during the operation, but the critical race appears only once during the system’s transition to respond to one external input. We omit the detailed construction of the controller (see the proof of the theorem). Example 5.36 The machines and have the same the input set A = {a,b,c} and the output set Y = {0,1,2}. The state set of is X = {x1, , x5}, and the state set of is X = {1, , 3}. The initial state of is x0 := x1 and the initial state of is

PAGE 161

151 0 := 1. Table 5-5 and Table 5-6 show the stable state transition function and the output function for and , respectively. Table 5-5. Transition Table of the machine in Example 5.36 a b c Y x1 x2 x3 x1 0 x2 x2 x2 {x1,x4} 1 x3 x3 x3 x3 2 x4 x5 x3 x4 0 x5 x5 x5 x4 1 Table 5-6. Transition Table of the machine in Example 5.36 a b c Y 1 2 1 3 0 2 2 1 3 1 3 3 3 3 2 Utilizing the table, we can easily calculate the race-free skeleton matrix Kd() of and the skeleton matrix K() of as follows; Kd() = 11111 01010 01000 01010 01011, K() = 111111001. (5-37) The counter-image list of the output function h for the machine is given by hI(Y) := {(x1,x4),(x2,x5),x3}, and the equivalence list is B(,) = {(x1,x4),(x2,x5),x3}. Again we can verify that there does not exist a sublist Z of B(,) such that Kd(,Z) K(), which implies that the race has to appear in the transitions of the machine in order for the composite machine c to match the model. The race tree of is shown in Figure 5-4.

PAGE 162

152 x3 b (x1,x4) (x1,x4) (x2,x5) c a (x2,x5) (x1,x4) a,b c x2 a Figure 5-4. Race tree of machine in Example 5.36 The race tree initially starts from the race pair (x2,a), whose successive node is a state uncertainty subset (x1,x4). Notice that the race pair (x2,a) occurs again when is at the uncertainty set (x2,x5). Since (hIh(x2),a) = ({x2,x5},a) {x1,x4}, by Proposition 5.33, the race needs only happening once in order to match the behavior of a one-step transition of the model. Following the algorithm, we obtain a list Z = {Z1,Z2,Z3}, where Z1 = {x1,(x1,x4)}, Z2 = {x2,(x2,x5)}, and Z3 = {x3}, for which the skeleton matrix inequality K(,Z) K(). Utilizing the list Z and following the procedure in the proof of Theorem 5.20, we can design the controller to solve the model matching problem. The detailed construction for the controller is omitted.

PAGE 163

CHAPTER 6 SUMMARY AND FUTURE RESEARCH In the present work, feedback controllers have been introduced to correct undesirable behavior of asynchronous sequential machines. Specifically, controllers can eliminate the indeterminacy caused by critical races, while driving the machine to match the desirable behavior of a race-free model. This approach opens an interesting and constructive field in which many open problems remain to be investigated. In earlier chapters of this dissertation, solutions have been presented to the model matching problem for both input/state machines and input/output machines, as well as for deterministic machines and machines with critical races. The results include necessary and sufficient conditions for the existence of controllers and algorithms for their construction, whenever the controllers exist. In the case of input/output machines, we have proved that a separation principle is valid: if model matching is possible, a controller, which decomposed into an observer and a state feedback control unit, always exists, as depicted in Figure 1-2. This separation property is analogous to the separation encountered for certain classes of linear controllers. We have shown in Chapter 5 that the necessary and sufficient condition derived for input/output machines with critical races is very general, and can be extended and applied to many other situations. One possible generalization is to permit an uncertainty about the initial state of the machine. Another possible generalization is to consider the model matching problem for a general family of asynchronous machines, rather than a race family. 153

PAGE 164

154 To summarize, here are several topics for future research: (i) In Chapter 5, we have presented a solution of the model matching problem for critical race families of asynchronous machines which include both cases of input/state machines and input/output machines. In the case of input/state machines, the solution of the model matching problems for general families is quite similar to its solution for critical race families. In the case of input/output machines, the solution of the model matching problem for general families is somewhat different from its solution for critical race families. It would be interesting to formulate the solution to the problem of model matching for general families of asynchronous machines. (ii) The present dissertation uses asynchronous finite state machines (FSMs) to model asynchronous machines (i.e., discrete-event dynamical systems (DEDS)). In the domain of DEDS control problems, supervisory control problems have earned a lot of attention, and they use the generator-acceptor model and are based on language theory. Dibenedetto et. al (2001) have mentioned some connections between the model matching problems using FSM model and the supervisory control problems based on language theory. It would be meaningful to investigate further the relation between the model matching problems of asynchronous FSMs (the topics in the present work) and the supervisory control problems; the relation would help us apply the present techniques and results to solving the corresponding supervisory control problems.

PAGE 165

155 (iii) Asynchronous sequential machines can be used to model and simulate parallel and distributed systems due to their event-driven nature. For instance, stochastic automata networks have been proposed to model complex parallel systems. The use of feedback has the promise to improve the performance of parallel computing systems, and it is possible to apply the methods developed in the present work. In addition, as distributed systems are becoming increasingly popular, it would be a practical and valuable direction to explore hierarchical control and distributed control for distributed multi-plants, instead of centralized control as we consider in the present dissertation.

PAGE 166

LIST OF REFERENCES Alpan, G. and Jafari, M.A., [2002] “Synthesis of a closed-loop combined plant and controller model,” IEEE Trans. on Systems, Man and Cybernetics, Vol. 32, No. 2, pp. 163-175. Barrett, G. and Lafortune, S., [2000] “On the separation of estimation and control in discrete-event systems,” in Proceedings of the 39th IEEE Conference on Decision and Control, pp. 2258-2259. Barrett, G., and Lafortune, S., [1998] “Bisimulation, the supervisory control problem, and strong model matching for finite state machines,” Journal of Discrete Event Dynamic Systems, Volume 8, number 4, pp. 377-429. Bose, S., Patra, A., and Mukhopadhyay, S., [1994] “On observability with delay: antitheses and syntheses,” IEEE Transaction on Automatic Control, Vol. 39, No. 4, pp. 803-806. Bruschi, D., Pighizzini, G., and Sabadini, N., [1994] “On the existence of minimum asynchronous automata and on the equivalence problem for unambiguous regular trace languages,” Information and Computation, Vol. 108, No. 2, pp. 262-285. Caines, P. E., Greiner, R., and Wang, S., [1988] “Dynamical logic observers for finite automata,” in Proceedings of the IEEE Conference on Decision and Control, pp. 226-233. Caines, P. E. and Wang, S., [1989] “Classical and logic based regulator design and its complexity for partially observed automata,” in Proceedings of the IEEE Conference on Decision and Control, pp. 132-137. Chu, T., [1994] “Synthesis of hazard-free control circuits from asynchronous finite state machines specifications,” Journal of VLSI Signal Processing, Vol.7, No.1-2, pp. 61-84. Cole, R. and Zajicek, O., [1990] “The expected advantage of asynchrony,” in Proceedings of the second annual ACM symposium on Parallel algorithms and architectures, pp. 85-94. Datta, P.K., Bandyopadhyay, S.K. and Choudhury, A.K., [1988] “A graph theoretic approach for state assignment of asynchronous sequential machines,” International Journal of Electronics, Vol.65, No.6, pp. 1067-75. 156

PAGE 167

157 Davis, A., Coates, B. and Stevens, K., [1993a] “Automatic synthesis of fast compact asynchronous control circuits,” in S. Furber and M. Edwards, editors, Asynchronous Design Methodologies, volume A-28 of IFIP Transactions, Elsevier Science Publishers, pp. 193-207. Davis, A., Coates, B. and Stevens, K., [1993b] “The post office experience: designing a large asynchronous chip,” in Proceeding of the Twenty-Sixth Hawaii International Conference on System Sciences, Vol.1, pp. 409-418. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., [1994] “Model matching for finite state machines,” in Proceedings of the IEEE Conf. on Decision and Control, Vol. 3, pp. 3117-3124. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., [1995a] “Strong model matching for finite state machines with nondeterministic reference model,” in Proceedings of the IEEE Conf. on Decision and Control, Vol. 1, pp. 422-426. Dibenedetto, M.D., Saldanha, A., and Sangiovanni-Vincentelli, A., [1995b] “Strong model matching for finite state machines,” in Proceedings of European Control Conference, Vol. 3, pp. 2027-2034. Dibenedetto, M.D., Sangiovanni-Vincentelli, A., and Villa, T., [2001] “Model matching for finite-state machines,” IEEE Transactions on Automatic Control, Vol. 46, No. 11, pp. 1726-1743. Eilenberg, S., [1994] “Automata, languages, and machines,” Academic Press, NY. Fisher, P.D., and Wu S. F., [1993] “Race-free state assignments for synthesizing large-scale asynchronous sequential logic circuits,” IEEE Transactions on Computers, Vol. 42, No. 9, pp. 1025-1034. Fujita, M., [1993] “Methods for automatic design error correction in sequential circuits,” in Proceedings of the European Conference on Design Automation with the European Event in ASIC Design, pp. 76-80. Furber, S.B., [1993] “Breaking step the return of asynchronous logic,” IEE Review, pp. 159-162. Hammer, J., [1994] “On some control problems in molecular biology,” in Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 4098-4103. Hammer, J., [1995] “On the modeling and control of biological signaling chains,” in Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 3747-3752. Hammer, J., [1996a] “On corrective control of sequential machines,” International Journal of Control, Vol. 65, No. 65, pp. 249-276.

PAGE 168

158 Hammer, J., [1996b] “On the control of incompletely described sequential machines,” International Journal of Control, Vol. 63, No. 6, pp. 1005-1028. Hauck, S., [1995] “Asynchronous design methodologies: an overview,” Proceedings of the IEEE, Vol. 83, No. 1, pp. 69-93. Higham, L. and Schenk, E., [1992] “The parallel asynchronous recursion model,” in Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp. 310. Holcombe, W.M.L, [1982] “Algebraic automata theory,” Cambridge University Press, New York. Hubbard, P. and Caines, P.E., [2002] “Dynamical consistency in hierarchical supervisory control,” IEEE Trans. on Automatic Control, Vol. 47, No. 1, pp. 37-52. Huffman, D.A., [1954a] “The synthesis of sequential switching circuits,” J. Franklin Inst., Vol. 257, pp. 161-190. Huffman, D.A., [1954b] “The synthesis of sequential switching circuits,” J. Franklin Inst., Vol. 257, pp. 275-303. Huffman, D.A., [1957] “The Design and Use of Hazard-Free Switching Networks,” Journal of the Association of Computing Machinery, Vol. 4, No. 1, pp. 47-62. Kailath, T., [1980] “Linear Systems,” Prentice Hall Inc., pp. 268-272. Kohavi, Z., [1970] “Switching and finite automata theory,” McGraw-Hill Book Company, New York. Koutsoukos, X.D., Antsaklis, P.J., Stiver, J.A. and Lemmon, M.D., [2000] “Supervisory control of hybrid systems,” Proceedings of the IEEE, Vol. 88, No. 7, pp. 1026-1049. Lavagno, L., Keutzer, K., and Sangicivanni-Vincentelli, A., [1991] “Algorithms for synthesis of hazard-free asynchronous circuits ,” in Proceedings of the 28th ACM/IEEE Conference on Design Automation, pp. 302. Lavagno, L., Moon, C. W., and Sangiovanni-Vincentelli, A., [1994] “Efficient heuristic procedure for solving the state assignment problem for event-based specifications,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, Vol. 14, pp 45-60. Lin, B. and Devadas, S., [1995] “Synthesis of hazard-free multilevel logic under multiple-input changes from binary decision diagrams,” IEEE Trans. on Computer-Aided Design of Integrated Circuits and Systems, Vol. 14, No. 8, pp. 974-985. Lin, F., [1993] “Robust and adaptive supervisory control of discrete event systems”, IEEE Transactions on Automatic Control, Vol. 38, No. 12, pp. 1848-1852.

PAGE 169

159 Maki, G., and Tracey, J., [1971] “A State assignment procedure for asynchronous sequential circuits,” IEEE Transactions on Computers, Vol. 20, pp. 666-668. Marshall, A., Coates, B. and Siegel, F., [1994] “Designing an asynchronous communications chip,” IEEE Design & Test of Computers, Vol. 11, No. 2, pp. 8-21. Mealy, G.H., [1955] “A method for synthesizing sequential circuits,” Bell System Tech. J., Vol. 34, pp. 1045-1079. Moon, C.W., Stephan, P.R., and Brayton, R.K., [1991] “Synthesis of hazard-free asynchronous circuits from graphical specifications,” IEEE International Conference on Computer-Aided Design, pp. 322 . Moore, E.F., [1956] “Gedanken-experiments on sequential machines,” Automata Studies, Annals of Mathematical Studies, No. 34, Princeton University Press. pp. 129-153. Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D. and Robinson, P., [2000] “Self calibrating clocks for globally asynchronous locally synchronous systems,” in Proceedings of Inter. Confer. on Computer Design, pp. 73-78. Murphy, T.E., [1996] “On the control of asynchronous sequential machines with races,” Ph.D. Dissertation, Department of Electrical and Computer Engineering, University of Florida, Gainesville, FL. Murphy T.E., Geng X., and Hammer J., [2002] “Controlling races in asynchronous sequential machines,” Proceedings of IFAC World Congress, CDROM. Murphy T.E., Geng X., and Hammer J., [2003] “On the control of asynchronous machines with races,” IEEE Trans. on Automatic Control, Vol. 48, No. 6, pp. 10731081. Nelson, R.J., [1968] “Introduction to Automata,” John Wiley &Sons, Inc.. Nishimura, N., [1990] “Asynchronous shared memory parallel computation,” in the 3rd ACM Symposium on Parallel Algorithms and Architectures SPAA'90, pp. 76-84. Nishimura, N., [1995] “Efficient asynchronous simulation of a class of synchronous parallel algorithms,” Journal of Computer and System Sciences, Vol. 50, No. 1, pp. 98-113. Nowick, S.M., [1993] “Automatic synthesis of burst-mode asynchronous controllers,” Ph.D. Dissertation, Department of Computer Science, Stanford University. Nowick, S.M., and Coates, B, [1994] “UCLOCK: automated design of high-performance unclocked state machines,” in Proceedings of IEEE International Conference on Computer Design (ICCD), pp. 434.

PAGE 170

160 Nowick, S.M., Dean, M.E., Dill, D.L. and Horowitz, M., [1993] “The design of a high-performance cache controller: a case study in asynchronous synthesis,” in Proceedings of the 26th Hawaii International Conference on System Sciences, pp. 419. Nowick, S.M. and Dill, D.L., [1991] “Synthesis of asynchronous state machines using a local clock,” IEEE International Conference on Computer Design, pp. 192-197. Oliveira, D.L., Strum, M.; Wang, J.C. and Cunha, W.C., [2000] “Synthesis of high performance extended burst mode asynchronous state machines,” in Proceedings. 13th Symposium on Integrated Circuits and Systems Design, pp. 41-46. Ozveren, C.M., Willsky, A.S., [1990] “Observability of discrete event dynamic systems,” IEEE Trans. on Automatic Control, Vol. 35, No. 7, pp. 797-806. Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., [1991] “Stability and stabilizability of discrete event systems,” J. ACM, Vol. 38, pp. 730-752. Park, S.-J. and Lim, J.-T., [2002] “Robust and nonblocking supervisory control of nondeterministic discrete event systems using trajectory models,” IEEE Trans. on Automatic Control, Vol. 47, No. 4, pp. 655-658. Ramadge, P.J.G., and Wonham, W.M., [1987] “Supervisory control of a class of discrete event processes,” SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206. Ramadge, P.J.G., and Wonham, W.M., [1989] “The control of discrete event systems,” Proceedings of IEEE, Vol. 77, No. 1, pp. 81-98. Shields, M.W., [1987] “An introduction to automata theory”, Blackwell Scientific Publications, Boston. Unger, S. H., [1969] “Asynchronous Sequential Switching Circuits,” Wiley-Interscience, New York, NY. Unger, S. H., [1977] “Self-synchronizing circuits and non-fundamental mode operation,” IEEE Trans. Computers, Vol. 26, No. 3, pp. 278-281. Unger, S. H., [1995] “Hazards, critical races, and metastability,” IEEE Trans. on Computers, Vol. 44, No. 6, pp 754-768. Watanable, Y. and Brayton, R., [1993] “Computing permissible behaviors of FSM’s,” in Proceedings of the International Conference on Computer-Aided Design, pp. 316-320. Yu, M.L. and Subrahmanyam, P.A., [1992] “A path-oriented approach for reducing hazards in asynchronous designs,” in Proceedings of Design Automation Conference 29th ACM/IEE, pp. 239 .

PAGE 171

161 Yun, K.Y., [1994] “Synthesis of asynchronous controllers for heterogeneous systems,” PhD thesis, Stanford University.

PAGE 172

BIOGRAPHICAL SKETCH Xiaojun Geng was born in Jiangxi Province, China. She received her B.S and M.S. in Electrical Engineering from Northwestern Polytechnical University, Xi’an, China, in July 1993 and April 1996, respectively, and earned a Ph.D. degree in Electrical Engineering from the Institute of Automation of Shanghai Jiao Tong University, Shanghai, China, in July 1999. Since August 1999, she has been a Ph.D. student in the Department of Electrical and Computer Engineering at University of Florida, Gainesville, FL. Her research interests include control theory, control systems, and applications of control theory in asynchronous networks and parallel computation. 162