UFDC Home  myUFDC Home  Help 
PAGE 65
56 the controller states 00(x,u), 0m(0;x,u)(x,u), and the controller's recursion function is defined as follows. (1,(x,u)) := 00(x,u), for (x,u) D, (1,(x,t)) := 1, for all t U(x)\D(x), (0j(x,u),(x0,j(x,u),u)) := 0j+1(x,u), (0j(x,u),(z,t)) := 0j(x,u), for all (z,t) XA, (418) where 0 j m(0;x,u). We can now generate the first m(0;x,u) characters of the substring w0(x,u) by defining the controller output function as follows. (0j(x,u),(z,t)) := w0j(x,u), for all (z,t) XA, (419) where 0 j m(0;x,u). The final character of w0(x,u) is applied while the machine is in the cycle state x0,m(0;x,u)(x,u), and creates a critical race with the outcome x(1,i1), as discussed earlier. Recall that w(x,u) passes through q cycles. The controller continues to generate all the substrings wj(x,u,x(j,i(j))), j = 1, q consecutively. Let the controller states associated with the substring wj(x,u,x(j,i(j))) be j0(x,u), jm(j;x,u,x(j,i(j)))(x,u). The transition function is then given by (jh(x,u),(xj,h(x,u),u)) := jh+1(x,u), (jh(x,u),(z,t)) := jh(x,u), for all (z,t) (xj,h(x,u),u), (420) where h = 0, m(j;x,u,x(j,i(j))), and j = 1, q. The corresponding output values are generated by the controller's output function as follows. (jh(x,u),(z,t)) := wjh(x,u,x(j,i(j))), (z,t) XA, (421) where h = 0, m(j;x,u,x(j,i(j))), and j = 1, q.
PAGE 66
57 The transition from the end of one substring to the first character of the next substring of w(x,u) is accomplished by defining the controller's transition function as follows. (jm(j;x,u,x(j,i(j)))(x,u),(xj,h(x,u),u)) := j+10(x,u), (422) j = 0, q. At the end of the string w(x,u), the machine reaches the state s(x,u), required for matching the model The last character of w(x,u) is, of course, the last character of wq(x,u,x(q,i(q))). After this character is applied, the machine must remain in a stable combination with the state s(x,u) until the external input changes. To implement this requirement, the transition function of the controller is defined by (qm(q;x,u,x(q,i(q)))(x,u),(z,t)) := 1, (z,t) (s(x,u),u). (423) This completes the operation of the controller for the transition from x to s(x,u). Summarizing, the set of all controller states associated with the generation of the string w(x,u) is given by C(w(x,u)) = {00(x,u), 0m(0;x,u)(x,u), q0(x,u), qm(q;x,u,x(q,i(q)))(x,u)}. (424) Note when (x,u) DN(,), then q is taken as zero in the above construction, and w(x,u) consists of only one substring which completes the required transition. To complete the implementation of the controller C, the above construction has to be applied to each input pair (x,u) DC. To describe the state set of the controller, let the elements of DC be given by {(z1,u1), (zn(C),un(C))} and let w(zk,uk) be the string that takes from (xk,uk) to the state s(xk,uk) required to match the model for a
PAGE 67
58 specific sequence of cycle outcomes. Then, in analogy with Equation 424, the controller states associated with the generation of w(xk,uk), for a specific combination of the outcome of the cycles encountered, are C(w(xk,uk)) = {00(xk,uk), 0m(0;xk,uk) (xk,uk), q0(xk,uk), qm(q;xk,uk,x(q,i(q))) (xk,uk)}. (425) The set of all states for all combinations of outcomes of cycles are then given by C(xk,uk) = all possible w(x k ,u k ) C(w(xk,uk)). (426) Thus, the set of controller states for all the elements of DC are C = k = 1, n(C) C(xk,uk) (427) Of course, if DC = then C(xk,uk) = and C = Then the complete state set of the controller is given by = {0,1} N C. (428) By construction, the closed loop system operates in semifundamental mode and is well posed. This completes the construction of the controller C. Note that the states of the controller are not optimized. This can be done by the various state reduction techniques, e.g., KOHAVI [1970]. Further state reductions can be done by careful choice of the corrective string.
PAGE 68
CHAPTER 5 EXAMPLE This chapter demonstrates the construction of a controller C that fulfills the requirements of Theorem 41. Consider the input/state machine having the input set A = {a, b, c, d} and the state set X = {x1, x2, x3, x4}. Consider the recursion function of the machine f to be defined by Table 51 of transitions. Table 51. Transition table for the machine a b c d x1 x1 x3 x1 x1 x2 x3 x2 x4 x3 x3 x4 x4 x4 x3 x4 x2 x4 x3 x4 Applying Algorithm 38 to the above machine, the cycles in the machine can be found. We see that the cycles are 1 = {a;x2, x3, x4} and 2 = {c;x3, x4}. Now, the cycle states corresponding to the cycles 1 and 2 are x5 and x6. The generalized stable state machine s now has the state set X = {x1, x2, x3, x4, x5, x6}, as defined in Equation 38, and the same input set A. The stable recursion function s of the generalized stable state machine s is defined in the Table 52 of transitions. The generalized stable recursion function for the generalized stable state machine is defined in Equation 311. Note that when an input character is applied to a cycle state, it can result in unpredictable outcomes. This is represented as the set of all possible output states. 59
PAGE 69
60 Table 52. Stable transition table for the generalized stable state machine s a b c d x1 x1 x3 x1 x1 x2 x5 x2 x6 x3 x3 x5 x4 x6 x3 x4 x5 x4 x6 x4 x5 x5 {x2,x4} {x4,x6} {x3,x4} x6 x5 x4 x6 {x3,x4} The machine s is now an asynchronous machine with multiple race outcomes. We will now follow the procedure in Chapter 4 to calculate the skeleton matrix of this machine. As defined in Equation 312, the matrix of onestep generalized stable transitions R(s) is shown in Table 53. Table 53. Matrix of onestep generalized stable transitions R(s) x1 x2 x3 x4 x5 x6 x1 a,c,d N N N N N x2 N b N N b N x3 N d d N d d x4 b N b b,d b,d b,d x5 N a a a a a x6 N c c c c c
PAGE 70
61 Using Equation 317 and Equation 318, we construct the matrices R2(s), R3(s), R4(s), and R5(s), and then the matrix R(5)(s). Then, applying Definition 314, the matrix of stable transitions T(s) is constructed. Finally, using Definition 317, the skeleton matrix is derived. The skeleton matrix K() calculated from R(5)() is given by K() = 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 (51) Now to solve the model matching problem, we need the given stable state machine as our model. The stable recursion function for is given in Table 54 of transitions. Table 54. Stable transition function of the given model a b c d x1 x1 x3 x1 x1 x2 x4 x2 x4 x3 x3 x4 x4 x4 x3 x4 x4 x4 x4 x4 Now, the skeleton matrix for the model follows the same procedure as in the generalized stable state machine, except for the absence of the cycle states. This results in a square matrix, given by K0() = 1 0 0 0 0 1 0 0 0 1 1 0 1 1 1 1 (52)
PAGE 71
62 Following Equation 41, the augmented skeleton matrix K() is then constructed as follows. K() = 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 (53) The next step in the construction of the controller is to see if the necessary and sufficient conditions are satisfied. We find that K() K(), thus satisfying Theorem 41. To construct the controller, we need the following matrices, as explained in the proof of Theorem 41. D(,) := {(x2,a),(x3,a),(x4,a),(x2,c),(x3,c),(x4,c)}, D := {(x5,a),(x6,c),(x2,c)}, xD := {x2,x3,x4}, D(x) := {a,c}, U(x2) := {b}, U(x5) := {a}, U(x6) := {c}, DN(,) := DC := {(x2,c),(x5,a),(x6,c)}. (54) For (x2,c) DC(,), w0(x2,c) = d, w1(x2,c,x3) = b. There are two possible strings, d and db; r(x2,c) = 2. The state transitions are: (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x2,c)) := 1 for all (x2,c) V, (1,(x2,c)) := 00(x2,c), for (x2,c) D, (1,(x2,t)) := 1, for all t U(x2)\D(x2), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x2,c),(x0,1(x2,c),d)) := 10(x2,c), (00(x2,c),(z,t)) := 00(x2,c), for all (z,t) (x0,1(x2,c),d), (10(x2,c),(z,t)) := 1, (z,t) (s(x2,c),u). (55)
PAGE 72
63 The output functions are (0,(z,t)) := t for all (z,t) XA, (1,(x2,t)) := b for all (x2,t) XA, (00(x2,c),(z,t)) := w00(x2,c) = d, for all (z,t) XA, (10(x2,c),(z,t)) := w10(x2,c,x3) = b, (z,t) XA. (56) Now, consider the next element (x5,a) DC(,). For this cycle state, w0(x5,a) = d, w1(x5,a,x3) = b; as before, r(x5,a) = 2. The state transitions and output functions are given by (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x5,a)) := 1 for all (x5,a) V, (1,(x5,a)) := 00(x5,a), for (x5,a) D, (1,(x5,t)) := 1, for all t U(x5)\D(x5), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x5,a),(x0,1(x5,a),d)) := 10(x5,a), (00(x5,a),(z,t)) := 00(x5,a), for all (z,t) (x0,1(x5,a),d), (10(x5,a),(z,t)) := 1, (z,t) (s(x5,a),b), (0,(z,t)) := t for all (z,t) XA, (1,(x5,t)) := a for all (x5,t) XA, (00(x5,a),(z,t)) := w00(x5,a) = d, for all (z,t) XA, (10(x5,a),(z,t)) := w10(x5,a,x3) = b, (z,t) XA. (57) Similarly, the transition and output functions for the third element (x6,a) DC(,) are defined below. Here, w0(x6,c) = b; r(x6,a) = 1. (0,(z,t)) := 0 for all (z,t) XA\V, (0,(x6,c)) := 1 for all (x6,c) V, (1,(x6,c)) := 00(x6,c), for (x6,c) D, (1,(x6,t)) := 1, for all t U(x6)\D(x6), (1,(z,t)) := 0, for all pairs (z,t) XA\(VD), (00(x6,c),(z,t)) := 1, (z,t) (s(x6,c),b), (0,(z,t)) := t for all (z,t) XA, (1,(x6,t)) := c for all (x6,t) XA,
PAGE 73
64 (00(x6,c),(z,t)) := w00(x6,c) = b, for all (z,t) XA. (58) This concludes the construction of the feedback controller C such that the closed loop machine cs = The equations (56), (57) and (58) give the state and transition functions of the controller C.
PAGE 74
CHAPTER 6 SUMMARY AND FUTURE WORK The present work shows the use of feedback controllers to correct one of the common hazards in the behavior of asynchronous sequential machines. Specifically, the designed controller not only eliminates the effects of infinite cycles in such a machine, but it can also drive the defective machine to match the behavior of a desired model. This approach opens an interesting arena where many open problems remain to be analyzed. In Chapter 5 of this dissertation, solutions have been presented to the model matching problem of inputstate machines involved in infinite cycles. The necessary and sufficient conditions for the existence of a controller have been stated, and an algorithm for its construction has been included, whenever a controller exists. The control of asynchronous machines is an area of research that is still ripe with possibilities. A straight forward extension of this dissertation is to the construction of a comprehensive state feedback controller that solves the the model matching problem for a machine with multiple hazards, including both races and cycles. The comprehensive controller has elements of both the race problem investigated by Murphy 1996, Murphy, Geng, and Hammer 2002, and Murphy, Geng, and Hammer 2003, as well as the controller for remedying cycles in an asynchronous machine, described in this dissertation. My future research plans include work on extending the results obtained in this dissertation to the comprehensive state feedback controller. The next logical step lies in 65
PAGE 75
66 formulating a more compact representation of the controller. A close examination of the controller structure described in Chapter 3 and Chapter 4 shows that it consists of a number of interconnected similar units. This observation leads us to believe that the controller can be assembled in a modular fashion from a collection of standard units. Formalizing this observation will lead to a simple methodology of controller design, whereby the controller is constructed simply by interconnecting a few standard blocks. Further, investigating the possibility of a comprehensive output feedback controller for a machine with multiple races and cycles is also a future research interest. The present proposal develops a controller that eliminates the negative effects of infinite cycles in asynchronous machines under the assumption that the state of the machine is available for feedback purposes. The problem of overcoming the effects of infinite cycles becomes substantially more complex if the state of the machine is not available, and only an output signal is available. The solution of this problem requires the development of concepts related to the observability of asynchronous machines, to find conditions under which an infinite cycle in state space can be detected from an observation of the output signal. The application of the obtained results to parallel and distributed systems is also an area of interest. Asynchronous sequential systems can be used to model parallel and distributed systems due to their event driven nature. It has been shown by Plateau and Atif 1991 that complex parallel networks can be modeled using stochastic automata networks. Recent work has succeeded in showing that a distributed system can be represented by cellular automata (Zambonelli et al 2003). Feedback control holds
PAGE 76
67 promise for improving the performance and reliability of such parallel and distributed systems, and it is possible to apply the principles developed in this work.
PAGE 77
LIST OF REFERENCES Alpan, G., and Jafari, M.A., 2002, Synthesis of a closedloop combined plant and controller model, IEEE Transactions on Systems, Man and Cybernetics, Vol. 32, No. 2, pp.163175. Arbib, M., 1969, Theories of abstract automata, Prentice Hall Inc., Englewood Cliffs, NJ. Armstrong, D., Friedman A., and Menon P., 1968, Realization of asynchronous sequential circuits without inserted delay elements, IEEE Transactions on Computers, C17, No. 2. Bredeson, J., and Hulina, P., 1971, Generation of a clock pulse for asynchronous sequential machines to eliminate critical races, IEEE Transactions on Computers, C20, pp. 225226. Bruschi, D., Pighizzini, G., and Sabadini, N., 1994, On the existence of minimum asynchronous automata and on the equivalence problem for unambiguous regular trace languages, Information and Computation, Vol. 108, No. 2, pp. 262285. Brzozowski, J.A., and Seger, C., 1987, A characterization of ternary simulation of gate networks, IEEE Transactions on Computers, C36, No. 11, pp. 13181327. Brzozowski, J.A., and Seger, CJ., 1989, A unified framework for race analysis of asynchronous networks, Journal of the Association for Computing Machinery, Vol. 36, No. 1, pp. 2045. Brzozowski, J.A., and Yeoli, M., 1979, On a ternary model of gate networks, IEEE Transactions on Computers, C28, pp.178183. Chiang, J., and Radhakrishnan, D., 1990, Hazardfree design of mixed operating mode asynchronous sequential circuits, International Journal of Electronics, Vol. 68, No. 1, pp. 2337. Chu, T., 1994, Synthesis of hazardfree control circuits from asynchronous finite state machine specifications, Journal of VLSI Signal Processing, Vol. 7, No. 12, pp. 6184. Chu, T., Mani, N., and Leung, C., 1993, An efficient critical racefree state assignment technique for asynchronous finite state machines, Proceedings of the 30th ACM/IEEE Design Automation Conference, Dallas, TX, pp. 25. 68
PAGE 78
69 Cole, R., and Zajicek, O., 1990, The expected advantage of asynchrony, Proceedings of the Second Annual ACM Symposium on Parallel Algorithms and Architectures, pp. 8594. Datta, P.K., Bandyopadhyay, S.K., and Choudhury, A.K., 1988, A graph theoretic approach for state assignment of asynchronous sequential machines, International Jounal of Electronics, Vol. 65, No. 6, pp. 10671075. Davis, A., Coates, B., and Stevens, K., 1993a, Automatic synthesis of fast compact asynchronous control circuits, S. Furber and M. Edwards, editors, Asynchronous Design Methodologies, Volume A28 of IFIP Transactions, Elsevier Science Publishers, pp. 193207. Davis, A., Coates, B., and Stevens, K., 1993b, The post office experience: designing a large asynchronous chip, Proceeding of the 26th Hawaii International Conference on System Sciences, Vol. 1, pp. 409418. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1994, Model matching for finite state machines, Proceedings of the IEEE Conference on Decision and Control, Vol. 3, pp. 31173124. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995a, Strong model matching for finite state machines with nondeterministic reference model, Proceedings of the IEEE conference on Decision and Control, Vol. 1, pp. 422426. Dibenedetto, M.D., Saldanha, A., and SangiovanniVincentelli, A., 1995b, Strong model matching for finite state machines, Proceedings of European Control Conference, Vol. 3, pp. 20272034. Dibenedetto, M.D., SangiovanniVincentelli, A., and Villa, T., 2001, Model matching for finitestate machines, IEEE Transactions on Automatic Control, Vol. 26, No. 11, pp. 17261743. Eichelberger, E.B., 1965, Hazard detection in combinational and sequential switching circuits, IBM Journal of Research and Development, Vol. 9, No. 2, pp. 9099. Eilenberg, S., 1974, Automata, Languages and Machines, Volume A, Academic Press, New York. Evans, J.B., 1988, Structures of discrete event simulation, Halsted Press, New York. Fisher, P., and Wu, S., September 1993, Racefree state assignments for synthesizing largescale asynchronous sequential logic circuits, IEEE Transactions of Computers, Vol. 42, No. 9, pp.10251034. Fujita, M., 1993, Methods for automatic design error correction in sequential circuits, Proceedings of the European Conference on Design Automation with the European Event in ASIC Design, pp. 7680.
PAGE 79
70 Furber, S.B., 1993, Breaking step The return of asynchronous logic, IEEE Review, pp. 159162. Geng, X. J., 2003, Model matching for asynchronous sequential machines, Ph.D. dissertation, Department of Electrical and Computer Engineering, University of Florida, Gainesville, Florida. Geng, X. J., and Hammer, J., 2003, Input/output control of asynchronous sequential machines, submitted for publication. Geng, X. J., and Hammer, J., 2004a, Asynchronous sequential machines: input/output control, Proceedings of the 12th Mediterranean Conference on Control and Automation, Kusadasi, Turkey, June 2004. Geng, X. J., and Hammer, J., 2004b, Output Feedback Control Asynchronous Sequential Machines, Proceedings of the 8th World Multiconference on Systemics, Cybernetics and Informatics (SCI 2004) to be held in Orlando, Florida.(to appear). Hammer, J., 1994, On some control problems in molecular biology, Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 40984103. Hammer, J., 1995, On the modeling and control of biological signaling chains, Proceedings of the IEEE Conference on Decision and Control, Vol. 4, pp. 37473752. Hammer J., 1996a, On the control of incompletely described sequential machines, International Journal of Control, Vol. 63, No. 6, pp. 10051028. Hammer J., 1996b, On the corrective control of sequential machines, International Journal of Control, Vol. 65, No. 6, pp. 249276. Hauck, S., 1995, Asynchronous design methodologies: an overview, Proceedings of the IEEE, Vol. 83, No. 1, pp. 6993. Hazeltine, B., 1965, Encoding of asynchronous sequential circuits, IEEE Transactions on Electronic Computers, EX14, pp.727729. Higham, L., and Schenk, E., 1992, The parallel asynchronous recursion model, Proceedings of the IEEE Symposium on Parallel and Distributed Processing, pp. 310316. Hlavicka, J., 1970, Essential hazard correction without the use of delay elements, IEEE Transactions on Computers, C19, No. 3, pp. 232238. Holcombe, W.M.L., 1982, Algebraic automata theory, Cambridge University Press, New York.
PAGE 80
71 Hubbard, P., and Caines, P.E., 2002, Dynamical consistency in hierarchical supervisory control, IEEE Transactions on Automatic Control, Vol. 47, No. 1, pp. 3752. Huffmann D.A., 1954a, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 161190. Huffmann D.A., 1954b, The synthesis of sequential switching circuits, J. Franklin Inst., Vol. 257, pp. 275303. Huffmann, D.A., 1957, The design and use of hazardfree switching networks, Journal of the Association of Computing Machinery, Vol. 4, No. 1, pp. 4762. Ingerson, T.E., and Buvel, R.L., 1984, Structure in Asynchronous Cellular Automata, Physica D, Vol. 10, pp. 5968. Kailath, T., 1980, Linear systems, Prentice Hall Inc., Englewood Cliffs, New Jersey, 1979, pp. 268272. Kalman, R.E., Falb, P.L., and Arbib, M.A., 1969, Topics in Mathematical Systems Theory, McGrawHill Book Company, New York. Kohavi, Z., 1970, Switching and finite automata theory, McGrawHill Book Company, New York, 1970. Koutsoukos, X.D., Antsaklis, P.J., Stiver, J.A., and Lemmon, M.D., 2000, Supervisory control of hybrid systems, Proceedings of the IEEE, Vol. 88, No. 7, pp. 10261049. Lavagno, L., Keutzer, K., and SangiovanniVincentelli, A., 1991, Algorithms for synthesis of hazardfree asynchronous circuits, Proceedings of the 28th ACM/IEEE Design Automation Conference, San Francisco, CA, pp. 302308. Lavagno, L., Moon, C.W., and SangiovanniVincentelli, A., 1994, Efficient heuristic procedure for solving the state assignment problem for eventbased specifications, IEEE Transactions on ComputerAided Design of Integrated Circuits and Systems, Vol. 14, pp. 4560. Lin, B., and Devadas, S., 1995, Synthesis of hazardfree multilevel logic under multipleinput changes from binary decision diagrams, IEEE Transactions on ComputerAided Design of Integrated Circuits and Systems, Vol. 14, No. 8, pp. 974985. Lin, F., 1993, Robust and adaptive supervisory control of discrete event systems, IEEE Transactions on Automatic Control, Vol. 38, No. 12, pp. 18481852. Lin, F., and Wonham, W.M., 1990, Decentralized control and coordination of discrete event systems with partial observation, IEEE Transactions on Automatic Control, Vol. 35, No. 12, pp. 13301337.
PAGE 81
72 Liu, C., 1963, A state variable assignment procedure for asynchronous sequential switching circuits, Journal of the Association of Computing Machinery, Vol. 10, pp. 209216. MacLane, S., and Birkhoff, G., 1967, Algebra, The Macmillan Company, New York. Mago, G., 1971, Realization of methods for asynchronous sequential circuits, IEEE Transactions on Computers, C20, pp. 290298. Maki, G., and Tracey, J., 1971, A state assignment procedure for asynchronous sequential circuits, IEEE Transactions on Computers, C20, pp. 666668. Marshall, A., Coates, B., and Siegel, F., 1994, Designing an asynchronous communications chip, IEEE Design & Test of Computers, Vol. 11, No. 2, pp. 821. Masuyama, H., and Yoshida, N., 1977, design of failsafe asynchronous sequential machines, Transactions of the Institute of Electronics and Communication, Vol. E60, No. 10, pp. 527532. McCluskey, E.J., 1963, Fundamental mode and pulse mode sequential circuits, Proc. IFIP Congress 1962, International Conference on Information Processing, Munich, August 27September 1, 1962, pp. 725730, Cicely M. Popplewell (ed.), North Holland Publishing Company, Amsterdam. McCluskey, E.J., 1965, Introduction to the theory of switching circuits, McGrawHill Book Company, New York. Mealy, G.H., 1955, A method for synthesizing sequential circuits, Bell Systems Technical Journal, Vol. 34, pp. 10451079. Moon, C.W., Stephan, P.R., and Brayton, R.K., 1991, Synthesis of hazardfree asynchronous circuits from graphical specifications, IEEE International Conference on ComputerAided Design, pp. 322325. Moore, E.F., 1956, Gedankenexperiments on sequential machines, Automata Studies, Annals of Mathematical Studies, No. 34, Princeton University Press, Princeton, NJ. Moore, S.W., Taylor, G.S., Cunningham, P.A., Mullins, R.D., and Robinson, P., 2000, Self calibrating clocks for globally asynchronous locally synchronous systems, Proceedings of the International Conference on Computer Design, pp 7378. Murphy, T.E., 1996, On the control of asynchronous sequential machines with races, Ph.D. Dissertation, Department of Electrical and Computer Engineering, University of Florida, Gainesville, Florida.
PAGE 82
73 Murphy, T.E., Geng, X. J., and Hammer, J., 2002, Controlling races in asynchronous sequential machines, Proceedings of the IFAC World Congress, Barcelona, July 2002. Murphy, T.E., Geng, X. J., and Hammer, J., 2003, On the control of asynchronous machines with races, IEEE Transactions on Automatic Control, Vol. 28, No. 6, pp. 10731081. Nelson, R.J., 1968, Introduction to automata, John Wiley and Sons, Inc., 1979. Nishimura, N., 1990, Asynchronous shared memory parallel computation, The 3rd ACM Symposium on Parallel Algorithms and Architectures SPAA pp. 7684. Nishimura, N., 1995, Efficient asynchronous simulation of a class of synchronous parallel algorithms, Journal of Computer and System Sciences, Vol. 50, No. 1, pp. 98113. Nowick, S.M., 1993, Automatic synthesis of burstmode asynchronous controllers, Ph.D. Dissertation, Department of Computer Science, Stanford University, Stanford, California. Nowick, S.M., and Coates, B., 1994, UCLOCK: Automated design of highperformance unclocked state machines, Proceedings of the IEEE International Conference on Computer Design (ICCD), pp. 434441. Nowick, S.M., Dean, M.E., Dill, D.L., and Horowitz, M., 1993, The design of a highperformance cache controller: A case study in asynchronous synthesis, Proceedings of the 26th Hawaii International Conference on System Sciences, pp. 419427. Nowick, S.M., and Dill, D.L., 1991, Synthesis of asynchronous state machines using a local clock, IEEE International Conference on Computer Design, pp. 192197. Oikonomou, K.N., 1992, Abstractions of finitestate machines and immediatelydetectable output faults, IEEE Transactions on Computers, Vol. 41, No. 3, pp. 325338. Oliviera, D.L., Strum, M., Wang, J.C., and Cunha, W.C., 2000, Synthesis of high performance extended burst mode asynchronous state machines, Proceedings of the 13th Symposium on Integrated Circuits and Systems Design, pp. 4146. Ozveren, C.M., and Willsky, A.S., 1990, Observability of discrete event dynamic systems, IEEE Transactions on Automatic Control, Vol. 35, No. 7, pp. 797806. Ozveren, C.M., Willsky, A.S., and Antsaklis, P.J., 1991, Stability and stabilizability of discrete event dynamics systems, Journal of the Association of Computing Machinery, Vol. 38, No. 3, pp. 730752.
PAGE 83
74 Park, SJ., and Lim, JT., 2002, Robust and nonblocking supervisory control of nondeterministic discrete event systems using trajectory models, IEEE Transactions on Automatic Control, Vol. 47, No. 4, pp. 655658. Patterson, W.W., and Metze, G., 1974, Fail safe asynchronous sequential machine, IEEE Transactions on Computers, Vol. C23, No. 4, pp. 369374. Piguet, C., 1991, Logic synthesis of racefree asynchronous CMOS circuits, IEEE Journal of SolidState Circuits, Vol. 26, No. 3, pp. 371380. Plateau, B., and Atif, K., 1991, Stochastic automata network of modeling parallel systems, IEEE Transactions on Software Engineering, Vol. 17, No. 10, pp. 10931108. Ramadge, P.J., and Wonham, W.M., 1987, Modular feedback logic for discrete event systems, SIAM Journal of Control and Optimization, Vol. 25, pp. 12021218. Ramadge, P.J., and Wonham, W.M., 1989, The control of discrete event systems, Proceedings of the IEEE, Vol. 77, No. 1, pp. 8199. Ramadge, P.J.G., and Wonham, W.M., 1987, Supervisory control of a class of discrete event processes, SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206230. Sen, R.K., 1985, On state assignment of asynchronous sequential machines, Proceedings COMPINT 85: Computer Aided Technologies, pp. 433440. Schnfisch, B., and De Roos, A., 1999, Synchronous and Asynchronous Updating in Cellular Automata, BioSystems, 51(3), pp. 123143. Shields, M.W., 1987, An introduction to automata theory, Blackwell Scientific Publications, Boston, Massachusetts. Thistle, J.G., and Wonham, W.M., 1994, Control of infinite behavior of finite automata, SIAM Journal of Control and Optimization, Vol. 25, No. 1, pp. 206230. Tracey, J.H., 1966, Internal state assignments for asynchronous sequential machines, IEEE Transactions on Electronic Computers, EC15, pp. 551560. Turing, A., 19361937, On computable numbers, with an application to the entscheidungsproblem, Proceedings of the London Mathematical Society, Ser. 242, pp. 230265 with a correction, Ibid, Ser. 243, pp.544546, 19361937. Unger, S.H., 1959, Hazards and delays in asynchronous sequential switching circuits, IRE Transactions on Circuit Theory, Vol. CT6, No. 1, pp.1225.
PAGE 84
75 Unger, S.H., 1969, Asynchronous sequential switching circuits, Wiley Interscience, New York, NY. Unger, S.H., 1977, Selfsynchronizing circuits and nonfundamental mode operation, IEEE Transactions on Computers, Vol. 26, No. 3, pp. 278281. Unger, S.H., 1995, Hazards, critical races and metastability, IEEE Transactions on Computers, Vol. 44, No. 6, pp. 754768. Watanable, Y. and Brayton, R., 1993, Computing permissible behaviors of FSMs, Proceedings of the International Conference on ComputerAided Design, pp. 316320. Whitaker, S., and Maki, G., 1992, Self synchronized asynchronous sequential pass transistor circuits, IEEE Transactions on Computers, Vol. 41, No. 10, pp. 13441348. Wolfram, S., 1994, Cellular automata and complexity, World Scientific Pub Co Inc., 1986. Wonham, W.M., and Ramadge, P.J.G., 1987, On the supremal controllable sublanguage of a given language, SIAM Journal of Control and Optimization, Vol. 25, pp. 637659. Yoeli, M., and Rinon, S., 1964, Application of ternary algebra to the study of static hazards, Journal of the Association of Computing Machinery, Vol. 11, No. 1, pp. 8497. Yu, M.L., and Subrahmanyam, P.A., 1992, A pathoriented approach for reducing hazards in asynchronous design, Proceedings of the Design Automation Conference, 29th ACM/IEE, pp. 239244. Zambonelli, F., Roli, A., and Mamei, M., 2003, Dissipative cellular automata as minimalist distributed systems : A study on emergent behaviors, 11th IEEE EUROMICRO Conference on Parallel, Distributed, and Network Processing, Genova (I), IEEE CS Press, pp. 250257.
PAGE 85
BIOGRAPHICAL SKETCH Niranjan Venkatraman was born in Bangalore, India, and obtained his Bachelor of Engineering (B.E.) degree in Electrical and Electronics Engineering in May 2000 from the College of Engineering, Guindy, Chennai, a part of Anna University. Since August 2000, he has been a Ph.D. student in the Department of Electrical and Computer Engineering at the University of Florida, Gainesville, FL. During the pursuit of his Ph.D., he obtained his M.S. in Electrical and Computer Engineering from the University of Florida in December 2002. His research interests include control theory, control systems, automata theory, and the application of control theory to asynchronous networks and parallel computation. 76



Full Text  
ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES By NIRANJAN VENKATRAMAN A DISSERTATION PRESENTED TO THE GRADUATE SCHOOL OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY UNIVERSITY OF FLORIDA 2004 Copyright 2004 by Niranj an Venkatraman To my parents, who always stood by me. ACKNOWLEDGMENTS First and foremost, I would like to acknowledge the unflagging support and excellent supervision of my advisor, Dr. Jacob Hammer, during my four years at the University of Florida. I thank Dr. Haniph Latchman, Dr. Tan Wong, and Dr. John Schueller for all their efforts and their advice, and for serving on my Ph.D. supervisory committee. I would like to especially thank Xiaojun Geng (my officemate for three years) for our animated and interesting discussions. I also extend special thanks to my current officemates (Jun Peng and Debraj Chakraborty) for making the last year interesting and full of fun. Special thanks are also due to my roommates (Raj, Nand and Arun) for putting up with my eccentric behavior for four years. I would also like to thank all my friends; their unceasing friendship and care has made this work possible. Last but not the least, I would like to thank my parents, my grandmother, my sister, her husband and my other relatives for their unfailing love and support during all the years that I have been away from them. TABLE OF CONTENTS A C K N O W L E D G M E N T S ................................................................................................. iv L IST O F T A B L E S ........ ................................................................................. vi L IST O F FIG U R E S .... ....... ...................... ........................ .... ...... .. ............. vii A B S T R A C T ......... .................................. ................................................... v iii CHAPTER 1 IN T R O D U C T IO N ............................................................................... .............. .. 2 TERMINOLOGY AND BACKGROUND ...........................................................10 2.1 Asynchronous Machines and States ....................................... ............... 10 2.2 M odes of O operation ........................................................... ............... 14 3 IN F IN IT E C Y C L E S .......................................................................... ....................20 3 .1 In tro d u ctio n .................................................................................................. 2 0 3.2 D election of Cycles................. ............ ....................................... .. ... ....22 3.3 Stable State Representations for Machines with Cycles.................................29 3.4 Stable R eachability .............................................. .... .......... .............. .. 32 3.5 Matrix of Stable Transitions and the Skeleton Matrix..................................34 3 .6 C orrectiv e C controllers ........................................ .........................................39 4 THE MODEL MATCHING PROBLEM ........................................................46 5 E X A M P L E ............................................................................................................ 5 9 6 SUMMARY AND FUTURE WORK ................................................... ...............65 L IST O F R E F E R E N C E S ..................................... .................................... ....................68 B IO G R A PH IC A L SK E TCH ...................................................................... ..................76 v LIST OF TABLES Table page 51. Transition table for the m machine ........................................ ....................... 59 52. Stable transition table for the generalized stable state machine ls ........................60 53. Matrix of onestep generalized stable transitions R(ls) ...........................................60 54. Stable transition function of the given model '. .............................................61 LIST OF FIGURES Figure 11. Control configuration for the asynchronous sequential machine ...........................3 page Abstract of Dissertation Presented to the Graduate School of the University of Florida in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy ON THE CONTROL OF ASYNCHRONOUS MACHINES WITH INFINITE CYCLES By Niranj an Venkatraman August 2004 Chair: Jacob Hammer Major Department: Electrical and Computer Engineering My study deals with the problem of eliminating the effects of infinite cycles on asynchronous sequential machines by using state feedback controllers. In addition to eliminating the effects of infinite cycles, the controllers also transform the machine to match the behavior of a prescribed model. My study addresses machines in which the state is provided as the output of the machine (input/state machines). Algorithms are provided for detecting infinite cycles in a given machine, for verifying the existence of controllers that eliminate the effects of infinite cycles, and for constructing the controllers whenever they exist. The feedback controllers developed in my study resolve the model matching problem for machines that are afflicted by infinite cycles. They transform the given machine into a machine whose input/output behavior is deterministic and conforms with the behavior of a prescribed model. Thus, the feedback control strategy overcomes the effects of infinite cycles as well as any other undesirable aspects of the machine's behavior. Results include necessary and sufficient conditions for the existence of controllers, as well as algorithms for their construction whenever they exist. These conditions are presented in terms of a matrix inequality. The occurrence of infinite cycles produces undesirable behavior of afflicted asynchronous sequential machines. The occurrence of hazards has been a major problem since the early development of asynchronous sequential machines. There are many methods to design cyclefree machines; but the literature does not seem to contain any technique for eliminating the negative effects of infinite cycles in case it occurs in existing asynchronous sequential machines. CHAPTER 1 INTRODUCTION Asynchronous sequential machines are digital logic circuits that function without a governing clock. They are also described variously as clockless logic circuits, selftiming logic circuits, and asynchronous finite state machines (AFSMs). Asynchronous operation has long been an active area of research (e.g., Huffman 1954a, 1954b, 1957), because of its inherent advantages over commonly used synchronous machines. One of the more obvious advantages is the complete elimination of clock skew problems, because of the absence of clocks. This implies that skew in synchronization signals can be tolerated. The various components of the machine can also be constructed in a modular fashion, and reused, as there are no difficulties that are associated with synchronizing clocks. Further, the speed of the circuit is allowed to change dynamically to the maximal respond speed of the components. This leads to improved performance of the machine. Asynchronous machines are by nature adaptive to all variations, and only speed up or slow down as necessary (Cole and Zajicek (1990), Lavagno et al. (1991), Moon et al. (1991), Yu and Subrahmanyam (1992), Fisher and Wu (1993), Furber (1993), Nowick (1993), Nowick and Coates (1994), Hauck (1995)). Asynchronous machines also require lower power, because of the absence of clock buffers and clock drivers that are normally required to reduce clock skew. The switching activity within the machine is uncorrelated, leading to a distributed electromagnetic noise spectrum and a lower average peak value. Moreover, asynchronous operation is inherent in parallel computation systems (Nishimura (1990), Plateau and Atif (1991), Bruschi et al. (1994)). Asynchronous design is essential to ensure maximum efficiency in parallel computation (Cole and Zajicek (1990), Higham and Schenk (1992), Nishimura (1995)). Asynchronous machines are driven by changes of the input character, and are self timed. In this context, it is vital to address design issues, especially those that can lead to potential inconsistencies in the pulses that propagate through the machine. These difficulties are referred to as "hazards" (Kohavi (1970), Unger (1995)). A cycle is one such potential hazard in the operation of asynchronous machines. It causes the machine to "hang," as is demonstrated in software applications with coding defects that can cause the program to hang in an infinite loop. A "critical race" is another hazard that causes the machine to exhibit unpredictable behavior. These hazards can occur because of malfunctions, design flaws, or implementation flaws. The common procedure followed when a hazard occurs is to replace the machine with a new one, built with no defects. In our study, we propose to employ control techniques to devise methods that take a machine out of an infinite cycle and endow it with desirable behavior. Thus, we concentrate on the design of controllers that resolve infinite cycles and control the machine so as to achieve specified performance. To explain the mode of action of our controllers, a basic description of the structure of an asynchronous machine needs to be reviewed. An asynchronous machine has two types of states: stable states and unstable states. A stable state is one in which the machine may linger indefinitely, while an unstable state is just transitory, and the machine cannot linger at it. A cycle is a situation where the machine moves indefinitely from one unstable state to another, without encountering a stable state. Cycles can occur often in applications, brought about by errors in design, by errors in implementation, or by malfunctions of components, for example, errors in programming that lead to infinite cycles. The solution currently recommended in the literature for correcting an infinite cycle is to replace the affected machine by a new machine. The solution proposed in our study is, in many cases, more efficient. Moreover, it is the only practical solution in cases where the affected system is out of reach. The controllers we design are feedback controllers connected to the afflicted machine, as depicted in Figure 11. The controller is activated during a cycle. Whenever possible, the controller drives the machine out of the cycle, and leads it to a desirable state. We characterize all cycles from which there is an escape, and present an algorithm for the design of a controller that takes the machine out of any escapable cycle. u C V I Figure 11. Control configuration for the asynchronous sequential machine X Here, X is the asynchronous machine being controlled, and C is another asynchronous machine that serves as a controller. We denote by Yc the closed loop system represented by Figure 11. The controller C eliminates the effects of the cycles of X so that the closed loop system Yc matches a prescribed model X' (i.e., Yc = Y'). The goal is to provide necessary and sufficient conditions for the existence of such a controller C as well as an algorithm for its design. An important property of the controller C is that the closed loop system will function properly whether or not the cycle actually occurs. As a result, the controller C can be used to prevent the effects of cycles before they occur, improving the reliability of the system. It is important to note that during a cycle, the machine moves among unstable states in quick succession, without lingering in any of the cycle states. Consequently, it cannot be arranged for an input change to occur at a specific state of the cycle. Thus, the input changes enforced by the controller occur at random during the cycle, and it is not possible to predetermine the state of the cycle at which the controller acts. As a result, the outcome of the controller action is unpredictable in most cases. This could lead to a critical race condition being generated by the controller, which can then be rectified by known procedures (Murphy (1996); Murphy, Geng and Hammer (2002, 2003); Geng 2003; Geng and Hammer (2003, 2004a, 2004b)). When machine Y is an input state machine, i.e., the output of Y is the state of Y, the controller C is called a state feedback controller. The existence of such a controller C that takes the system out of a cycle depends on certain reachability properties of the system. These reachability properties can be characterized in terms of a numerical matrix called the "skeleton matrix" of the system. The skeleton matrix is calculated from the various transitions of the machine. This skeleton matrix gives a methodology to derive the necessary and sufficient conditions for the existence of a corrective controller C. The function of the controller is twofold: it eliminates the effects of the cycle on the machine and assigns to the closed loop a specified behavior. The controller C functions by forcing an input character change while the machine is in a cycle; this may induce a critical race. The outcome of this unpredictable behavior is then used by the controller to assign a proper transition, as required to match the operation of the model. In this way, the cycles of the machine are stopped, and the machine exhibits the desired external behavior. The modelmatching problem described here is basically a continuation of the work of Hammer (1994, 1995, 1996a, 1996b); Murphy (1996); Murphy, Geng and Hammer (2002, 2003); Geng (2003); and Geng and Hammer (2003, 2004a, 2004b). There are a number of papers that relate to the modelmatching problem for synchronous sequential machines (Dibinedetto et al. (1994, 1995a, 1995b, 2001), Barrett and Lafortune (1998)). The studies relating to synchronous machines do not take into consideration the differences between stable and unstable states, fundamental and semifundamental mode of operation (Chapter 2), and other issues that are vital to the operation of asynchronous machines. Our study seems to be the first one to explore control theoretic tools to eliminate the effects of infinite cycles on asynchronous machines. Eliminating the effects of infinite cycles is not the only situation in which model matching is beneficial (Dibenedetto et al. (2001)). For example, most large digital system are designed in a modular fashion, with a number of subsystems. An error in the behavior of the machine detected late in the design phase may make it more economical to use a controller instead of redesigning, or rebuilding, the entire machine. In other words, model matching offers a lowcost option to remedy design and construction errors (Fujita (1993)). Moreover, the controller can also be used to improve the reliability and performance of the system, by deploying it before a fault develops in the system. In this way, the controller can guard against potential malfunctions, while being "transparent" before a malfunction occurs. Thus, in machines where high reliability is vital, our study provides a new design option. The early work on automata theory was carried out by Turing (1936). Huffman (1954a, 1954b, 1957) investigated various aspects of the synthesis of asynchronous relay circuits. There is a well established technical literature relating to the subject of design of hazardfree machines (e.g., Liu (1963), Tracey (1966), Kohavi (1970), Maki and Tracey (1971)). This is achieved by appropriate state assignment techniques. Classical methods for hazard free state assignments (Huffman (1954a, 1954b)) are reviewed in most textbooks on digital circuit design (e.g., Kohavi (1970)). More recently, studies on the subject were done by Masuyama and Yoshida (1977), Sen (1985), Datta et al. (1988), Nowick and Dill (1991), Fisher and Wu (1993), Chu (1994), Lavagno et al. (1994), Nowick and Coates (1994), and Lin and Devadas (1995). Evading hazards using a locally generated clock pulse was introduced by Unger (1977), Nowick and Dill (1991), and Moore et al. (2000). A graph theoretic approach for state assignment of asynchronous machines was introduced by Datta, Bandopadhyay and Choudhury (1988). Of course, all the above studies discuss the hazard free design of asynchronous machines, and can be applied only before the machine is constructed; only Murphy (1986); Murphy, Geng and Hammer (2002, 2003); Geng 2003; and Geng and Hammer (2003, 2004a, 2004b) detail methods to overcome hazards in an existing asynchronous machine. Other early works on the synthesis of asynchronous machines were by Mealy (1955) and Moore (1956). These works investigated state and circuit equivalence, and provided methods for synthesizing asynchronous and synchronous sequential machines. Their models of sequential machines are most commonly used today. In the work done by Liu (1963), all internal transitions of a machine go directly from unstable states to terminal states; with no sequencing permitted though stable states. This method of hazard free assignment (called single transition time state variable assignment) uses assignments similar to an equidistant errorcorrecting code. This kind of assignment, which can be accomplished by mapping the rows of a flow table onto the vertices of a unit ndimensional cube, is not guaranteed minimal, but it works effectively with incompletely specified flow tables. Tracey (1966) extended this work to techniques that maximize the speed of the machine. A method for sequencing (though unstable states are allowed before a stable state is reached when an input character is applied) was presented by Maki and Tracey (1971), using a technique called the shared row state assignment method. This method generally required fewer state variables than single transition time assignments. Other work on hazardfree state assignment techniques can be found in Hazeltine (1965); McCluskey (1965); Armstrong, Friedman and Menon (1968); Hlavicka (1970); Mago (1971); Chiang and Radhakrishnan (1990); Lavagno, Keutzer and SangiovanniVincentelli (1991); Piguet (1991); Oikonomou (1992); Chu, Mani and Leung (1993); and Fisher and Wu (1993). Some other techniques for avoiding hazards were proposed by Yoeli and Rinon (1964) and Eichelberger (1965). They proposed ternary logic models to analyze certain aspects of the machines. Ternary algebra seems to provide an efficient method for detection and analysis of hazards in sequential circuits. These models were further worked on by Brzozowski and Seger (1987, 1989) and Brzozowski and Yoeli (1987). Another method of avoiding hazards was by generating a clock pulse from other signals in the machine (Bredeson and Hulina (1971), Whitaker and Maki (1992)). Most applications of asynchronous machines assume that the environment of operation is the fundamental mode (Unger (1969)); that is, an input change is applied only after the machine has reached stability. No input change is allowed when the machine transits through unstable states. Our study specifies conditions where fundamental mode is not applicable, leading to what is called semifundamental mode of operation (Chapter 2). Recent work in asynchronous sequential machines allows the simultaneous change of several input variables. This mode of operation is referred to as burstmode (Davis et al. (1993a), Nowick (1993), Yun (1994), and Oliviera et al. (2000)). Deterministic behavior of the machine in this approach needs special restrictions to be imposed on the machine. Plenty of literature is available on the application of control theory to automata and asynchronous machines under discrete event systems. One such example that can be readily quoted is supervisory control (Ramadge and Wonham (1987, 1989)). This is based on formal language theory, and assumes that certain events in the system can be enabled or disabled. The control of the system is achieved by choosing control inputs such that the events are enabled or disabled. Literature on discrete event systems is extensive (Ozveren et al. (1991), Lin (1993), Koutsoukos et al. (2000), Alpan and Jafari (2002), Hubbard and Caines (2002), Park and Lim (2002)). Our study employs finite state machines models, which are more suitable to the investigation of engineering implementations than formal language theory (Dibenedetto et al. (2001)). Asynchronous machines are widely used in industry, as they result in economical digital systems. Some examples of industrial applications are the adaptive routing chip (Davis et al. (1993b)), a cache controller (Nowick et al. (1993)) and the infrared communications chip (Marshall et al. 1994). The organization of this dissertation is as follows. Terminology and background is provided in Chapter 2. A detailed analysis of infinite cycles, detection algorithms, and the existence conditions are detailed in Chapter 3. This chapter also introduced the concepts of generalized state machines, and the use of transition matrices and skeleton matrices in determining the existence of the controller. Chapter 4 gives a detailed solution to the model matching problem for asynchronous sequential machines with cycles, and an algorithm for the construction of the controller. Chapters 3 and 4 contain the necessary and sufficient conditions for the existence of a controller. An example is solved in Chapter 5, detailing the transition and output functions of the controller states, and finally, a conclusion and possible directions of further research are provided in Chapter 6. CHAPTER 2 TERMINOLOGY AND BACKGROUND 2.1 Asynchronous Machines and States Here, the background and notation is introduced and the basic theory of asynchronous sequential machines is described. An asynchronous machine is activated by a change of its input character; it generates a sequence of characters in response. To explain the mathematical theory, we introduce the notation and terminology involved in describing sequence of characters. An alphabet is a finite nonempty set A; the elements of this set are called characters. A word w over an alphabet A is a finite and ordered (possibly empty) string of characters from A. Let A be a finite nonempty alphabet, let A* denote the set of all strings of characters of A, including the empty string, and let A+ be the set of all nonempty strings in A*. The length wl of a string w e A* is the number of characters of w. For two strings wi, w2 e A*, the concatenation is the string w:= wiW2, obtained by appending w2 to the end of wi. A non empty word wi in A* is a prefix of the word w2 if w2 = wiw; and wi is a suffix of the word w2 if w2 = w'wl, where w, w' e A*. A partial function f: S1>S2 is a function whose domain is a subset of S1 (Eilenberg (1974)). We now introduce the concept of a sequential machine. A sequential machine provides a working mathematical model for a computing device with finite memory. It has the following characteristic properties: * A finite set of inputs can be applied to the machine in a sequential order. * There is a finite set of internal configuration that the machine can be in. These configuration are called states, and physically, these states correspond to the setting on the flip flop or the bit combinations in memory devices. * The current internal configuration or state and the applied input character determine the next internal configuration or state that the machine achieves. For deterministic systems, the next state is unique. * There is a finite set of input characters. There are two broad classes of sequential machines: asynchronous machines and synchronous machines. An asynchronous sequential machine responds to input changes instantaneously as they occur. On the other hand, a synchronous sequential machine is driven by a clock, and the values of input variables affect the machine only at clock "ticks". The current work concentrates on asynchronous sequential machines. These machine describe the structure of the fastest computing systems. An asynchronous machine is defined by the sextuple Y := (A,Y,X,xo,f,h), where A, Y, and X are nonempty sets, x0 is the initial state, and f: XxA > X and h : XxA > Y are partial functions. The set A is the set of input values, Y is the set of output values, and X is the set of states. The partial function f is the recursionfunction and h is the output function. The operation of the machine is described by the recursion xk+l = f(Xk, Uk), yk = h(xk, Uk), k = 0, 1, 2,... (21) A valid pair (x,u) e XxA is a point at which the partial functions f and h are defined. We assume that the initial state xo is provided with Y. An input sequence is permissible when all pairs (xk, Uk), k = 0, 1, 2, ... are valid pairs. The integer k acts as the step counter. An increment in the step counter takes place with every change of the input value or with a state transition. For consistency, we assume that the functions f and h have the same domain. It is clear from the above description that the recursion (21) represents a causal system. When the output function h only depends on the state and does not depend on the input, the machine induces a strictly causal system. If the functions f and h are functions rather than partial functions, the machine is said to be complete. A deterministic finite state machine is often referred to as the Mealy machine (Mealy (1955)). If the output function does not depend on the input variable, then the machine is referred to as the Moore machine (Moore (1956)). An asynchronous Mealy machine can be transformed into an equivalent Moore machine, and vice versa. A nondeterministic finite state machine X = (A,Y,X,xo,f,h) has the following objects: * A finite, nonempty set A of permissible input characters, termed as the input alphabet; * A finite, nonempty set Y of permissible output characters, termed as the output alphabet; * A finite, nonempty set X of states of the machine. Any number of the states can be designates as initial or terminal states; * A nondeterministic partial transition function f: 3(X)xA > 3(X), where 3(X) denotes the set of all the subsets of X (i.e., the power set of X); * A partial function h : XxA > Y, called the output function; and * The initial state of the machine xo e X. The transition function f can generate sets of states as its values, i.e., f(x,a) = {xi, .., xk}, rather than just single values; here xl, .., k E X and a e A. In contrast, the output function h takes only single values, i.e., there can be only one output character associated with each state. The class of deterministic finite state machines is a subclass of nondeterministic finite state machines. The operation of the machine Y can be described as follows. The machine Y starts from the initial state xo and accepts input sequences of the form u := uo ul ... where uo, ui, ... e A. In response to this set of applied input characters, it generates a sequence of states xo, xl, x2, ... e X and a sequence of output values yo, y1, y2, ... E Y, according to the recursion in Equation 21. Finally, the machine Y is an input/state machine when Y = X and the output is equal to the state at each step, that is, Yk = Xk, k = 0, 1, 2, ... (22) An input/state machine Y can be represented by the quadruple (A,X,xo,f), since the output is the state. Using the notion of the transition function f, we can define the partial function f*: XxA+ > X by setting f*(x,u) := f(...f(f(f(x,uo),ul),u2)...,Uk) for some state x E X and an input string u = uoulu2...uk e A+. Thus, f* provides the value of the last state in the path generated by the input string u. For simplicity of notation, we will use f for f*. Some basic terminology important to the study of asynchronous machines is now described. A valid pair (x,u) e XxA of the machine Y is called a stable combination if f(x,u)= x, i.e., if the state x is a fixed point of the function f An asynchronous machine will linger at a stable combination until an input change occurs. A pair (x,v) that is not a stable combination is called a transient combination. A potentially stable state x is one for which there is a stable combination. Of course, states that are not potentially stable serve only as transition states; the machine cannot stop or linger in them, and they are not usable in applications. Due to this, it is common practice to ignore states that are not potentially stable; will adhere to this practice and not include such state in our state set. Consider the sequential machine Y of Equation 22. Let x be the state of the machine and u the input value. When a stateinput pair (x,u) is not a stable combination, the machine Y will go through a chain of input/state transitions, starting from (x,u), which may or may not terminate. If the machine reaches a stable combination (x',u) with the same input value, then the chain of transitions terminates. It must be noted that the input value must remain constant throughout the entire transition; and the transition will end if and only if such a stable combination as (x',u) exists. In such a case, x' is called the next stable state of x with input value u. When the next stable state is not uniquely determined, that is, the transition at some point has more than one value, we have a critical race. In case there is no next stable state for x with input value u, we obtain an infinite cycle. Critical races and infinite cycles are the types of hazards that can occur in an asynchronous machine. 2.2 Modes of Operation When the value of an input variable is changed while the asynchronous machine undergoes a chain of transitions, the response of the machine may become unpredictable, since the state of the machine at which the input change occurs in unpredictable. To avoid this potential uncertainty, asynchronous machines are usually operated in fundamental mode, where only one variable of the machine is allowed to change each time. In particular, in fundamental mode operation, a change in the input variable is allowed only while the machine is in a stable combination. One of the main topics of our present discussion relates to the control of an asynchronous machine in an infinite cycle. When a machine is in an infinite cycle, fundamental mode operation becomes impossible, since the machine will not reach a stable combination without a change of the input variable. Nevertheless, we will show later that, when taking the machine out of its infinite cycle, it is not necessary to forego fundamental mode operation for more than one step. When an asynchronous machine operates in fundamental mode in all but a finite number of steps, we say that it operates in semifundamental mode. The conditions and procedures for operation in semi fundamental mode is described in Chapter 3. Consider a defectfree asynchronous machine Y = (A,X,xo,Y,f,h) operating in fundamental mode. Let the machine start at the state xo, and be driven by the input string w = vovi...vm1. The machine now has transitions through the states xo,..., xm, where xi+l = f(xi,vi); i = 0,1,2,...,ml, where the last pair (xm,Vml) is a stable combination. Fundamental mode operation implies that vi = vi+l whenever (xi,vi) is not a stable pair, i = 0,...,m1. Thepath is defined as the set of pairs P(,xo,w) = {(xo,v0), (x1,v1),...,(xml,vm1), (Xm,vm1)}. (23) When a cycle occurs, there is no final stable pair, and the path becomes infinite P(E,xo,w) = {...,(xi,vj), (xi+l,vj),...,(xi+t,vj), (xi,vj),... }. As mentioned earlier, the step counter k advances one step during each state transition or input change. Of course, for fundamental mode operation, the input character remains constant during all transition chains. Consider the case where the input value of the machine is kept constant at the character v, while the machine goes through a string of state transitions. At each state transition, the step counter of the system advances by one. This results in the input value being represented as a repetitive string vvv... v, where each repetition corresponds to an advance of the step counter. It is convenient to represent all such repetitions of the input character by a single character, so that, for example, a string of the form w = vovoviviviv2V2 is represented by w = voviv2. Here, it is understood that each input value is repeated as many times as necessary. In the case of an infinite cycle, the input value is repeated indefinitely. Next, let Y be an asynchronous machine without hazards. Then, the notion of the next stable state leads to the notion of the stable transition function, which plays an important role in our discussion. As the machine Y has no hazards, every valid pair (x,u) of Y has a next stable state x'. Define a partial function s : XxA > X by setting s(x,u) := x' for every valid pair (x,u), where x' is the next stable state of x with the input character u. The function s is called the stable transition function of the machine Y. Note that the stable transition function describes the operation of the machine in the fundamental mode, i.e., under the requirement that the input value be changed only after the machine reaches a stable combination. This is a standard restriction in the operation of asynchronous machines, and it guarantees that the machine produces a deterministic response. The stable transition function can be used to describe the operation of an asynchronous machine Y in the following way. We know that the machine always starts from a stable combination (xo,u1), at which the machine has been lingering for some time. Suppose now that an input string u := uoul...Uk e A+ is applied to the machine. Then, the machine moves through the a list of states xl, ..., xk+l of next stable states, where xi+1 = s(xi,ui), which implies that (xi+l,ui) is a stable combination for i = 0, 1, ..., k. The input list u ispermissible if (xi,ui) is a valid combination for i = 0, 1, ..., k. Since the machine operates in the fundamental mode, the input character changes from ui to ui+l only after the stable combination (xi+1,ui) has been reached. This guarantees that the state of the machine is well determined at the time when the input value changes. In general, when a machine does not have infinite cycles, the intermediate transitory states are ignored, as they occur very speedily and are not noticeable by a user. Thus, the operation of an asynchronous machine without infinite cycles, as observed by a user, is best described by the stable transition function s. However, when the machine has infinite cycles, it is not possible to ignore the transitory states involved in the cycle, as the machine lingers among these transitions indefinitely. In Chapter 3, we will introduce a generalized notion of the stable transition function which accommodates infinite cycles by considering them as another form of persistent states. Using the stable transition function s, we define the asynchronous sequential machine XIs := (A,X,Y,xo,s,h), which is called the stable state machine induced by X. For an input/state machine, the stable state machine is given by the quadruple (A,X,xo,s). To deal with input strings, we can define a partial function s* : XxA+ > X by setting s*(x,u)= s(... s(s(s(x,uo),ul),u2)...,Uk), for some state x E X and a permissible input string u = uouI...Uk e A+. The partial function s* provides the last state in the path generated by the input string u. As before, we shall abuse the notation somewhat by using s for s*. In the case where we do not have a Moore machine, we can define the partial function h* : XxA+ Y in a similar fashion by setting h*(x,u) := h(... s(s(s(x,uo),ul),u2)...,Uk) for a state x e X and a permissible input string u= uoui...Uk e A+, as was done for the stable transition function s defined earlier. The partial function h* gives the last output value generated by the input list u. It is necessary in some cases to compare different states of a sequential machine. Two states x and x' of a machine Y are distinguishable if the following condition is valid: there is at least one finite input string which yields different output sequences when applied to Y starting from the initial states x or x'. Two states x and x' of the machine Y are equivalent when, for every possible input sequence, the same output sequence is produced regardless of whether the initial state is x or x'. Qualitatively, two states are equivalent if we cannot distinguish them by the input/output behavior of the machine. If two states are equivalent, then so are all corresponding states included in any paths started from x and x'. If a machine Y contains two equivalent distinct states, then one of the states is redundant, and it can be omitted from the mathematical model of the machine. A machine Y is minimal or reduced if it has no distinct states that are equivalent to each other. Consider two machines Y = (A,Y,X,f,h) and 2' = (A',Y',X',f,h'). Let x be a state of Y and let x' be a state of Y'. The states x and x' are equivalent if both have the same permissible input sequences, and if, for every permissible input sequence, the output sequence generated by Y from the initial state x is the same as the output 19 sequence generated by 2' from the initial state x'. The two machines Y and 2' are equivalent whenever there exists an equivalent state in Y for every state in 2', and similarly, an equivalent state in Y for every state in Y'. A number of texts dwell on the various aspects of the theory of sequential machines and automata, including McCluskey (1965); Arbib (1969); Kalman, Falb and Arbib (1969); Kohavi (1970); Eilenberg (1974); and Evans (1988). CHAPTER 3 INFINITE CYCLES 3.1 Introduction An infinite cycle is caused when there is no next stable state for a valid pair (x,u) of a finite state asynchronous machine Y = (A,X,xo,Y,f,h). In such case, the machine will keep moving indefinitely from one transient combination to another. Only a finite number of states can be involved in these transitions, since Y is a finite state machine. An infinite cycle can then be characterized by listing these states and the corresponding input which causes the infinite cycle. Specifically, let the state set of Y be X = {x1, x2, ...,xn. Consider a infinite cycle p of Y that involves p states, say the states xkl, xk2 ..., xk e X, and let a e A be the input character causing the infinite cycle. The infinite cycle then functions according to the recursion xkj+1 = f(xkj, a), j = 1,..., , and xkl = f(xk, a). (31) As a shorthand notation, we will use p = a;xkl, xk2, ..., xke}, where a is the input character of the infinite cycle, and xk xk2, ..., xk are its states. A stateinput pair (xkj ,a), for some j = 1, ..., is then said to be apair of the cycle p. The length of the infinite cycle p is defined as the number of distinct states it contains. It follows that a cycle of length has distinct inputstate pairs. A brief examination of Equation 31 leads to the following conclusion: Let (x,a) be any pair of the infinite cycle p. Then, x' is a state of p if and only if there is an integer j such that x' = fJ(x,a). Then, the recursion can be followed for the entire length of the cycle. It is convenient to denote by {fi(x,a)}j=o the set of all distinct states included in the set {x, f(x,a), f2(x,a), ...}. This leads us to the following lemma. Lemma 31 Let (x,a) be any pair of the infinite cycle p. Then, the state set of p is {fi(x,a)}jo. Lemma 31 gives a way of finding the states of a cycle. A machine can have several infinite cycles, and we demonstrate below an algorithm that finds all infinite cycles of a given machine. It is relevant to see that an infinite cycle of length 1 is nothing but a stable combination. To distinguish between infinite cycles and stable combinations, the length of an infinite cycle must at least be 2. According to the next statement, infinite cycles associated with the same input character must have disjoint state sets. Lemma 32 A valid input/state pair (x,a) of an asynchronous machine Y can be a member of at most one infinite cycle. Proof 32. Let pl and p2 be two infinite cycles of the machine Y associated with the same input character a. If pi and p2 contain the same pair (x,a), then, using Lemma 31, we conclude that pi and p2 have the same state set. In other words, p1 = p2, and our proof concludes. * The above Lemma 31 gives us an insight into the structure of the cycle. Since no state can be a member of more than one cycle, we can say that a pair of a cycle is unique to that cycle. We can now find a bound on the maximal number of infinite cycles a machine can have. Indeed, consider the set of all infinite cycles involving the input character a. In view of Lemma 32, all such infinite cycles have disjoint state sets. But then, the fact that a infinite cycle must contain at least 2 states, implies that there cannot be more than n/2 such infinite cycles, where n is the number of states of the machine. Finally, recalling that the machine has m input characters, we obtain the following. (Denote by [a] the largest integer not exceeding a.) Proposition 33 Let Y be a sequential machine with n states and an alphabet A consisting of m characters. Then, Y cannot have more than m[n/2] infinite cycles. * For the sake of brevity, "infinite cycles" will be referred to as just "cycles" in the rest of the document. 3.2 Detection of Cycles In this section, a procedure to detect the cycles associated with a machine will be outlined. Consider an asynchronous machine Y = (A,X,xo,Y,f,h) with n states and an alphabet A of m input characters. Next all the cycles of the machine Y will be determined. To this end, an nxn matrix M(f) is recursively constructed as follows. The (i,j) entry of M(f) is the set of all characters u e A for which xi= f(xj,u). If there is no input character u e A for which xi = f(xj,u), then the (ij) entry of M is denoted F, where F is a character not included in the alphabet set A. Thus, the matrix becomes u E A:xi = f(xj,u), Mi,j(f) := (32) F otherwise, i, j = 1, ..., n. Multiple entries in a cell are separated using a comma. We refer to M(f) as the onestep transition matrix of the machine E. We now define two matrix operations for onestep transition matrices. First, the sum of two nxn onestep transition matrices A and B is defined element wise by (A U B)j := Aij U Bij, i, j = 1, ..., n. (33) The sum operation is reminiscent of the numerical addition of matrices. The following operations on members of the set A U F is now defined. uFF:= F uui := F Ful := uF Uu2 := r FU := (34) ui U := ui ui Uui := F ui U u2 := Also, for any two sets, the operation of multiplication is defined by {al, a2, ..., aq}.{bi, b2, ..., br = {aibj}i= ,...,q,j=I ...,r This is similar to the classical definition of the scalar product of two vectors. Using these operations of multiplication, the definition of matrix combination is defined as follows. (AB)ij := Uk=l,...,nAikBkj for all i, j = 1, ..., n. (35) Consider two functions g, h : XxA > X. The composition of g and h is defined by gh(x,u) := g(h(x,u),u). The composition of function is closely related to the combination of the corresponding onestep transition matrices, as indicated by the following. The next statement shows that the multiplication of two onestep transition matrices on two recursion functions is the transition matrix on the composition of the two functions. Lemma 34 Let g, h : XxA > X be two recursion functions with one step transition matrices M(g) and M(h), respectively. Then, M(g)M(h) = M(gh). Proof 34. Using Definition 34, we have M(g)M(h) = Uk=l..n Mi,k(g)Mk,j(h). (36) Now, each entry of M(g)M(h) is either a character of A or F; the definition of matrix composition implies that the following two statements are equivalent: (i) The (ij) element of M(g)M(h) is u. (ii) There is a k e {1, ..., n} for which Mi,k(g)= u and Mkj(h) = u. When (ii) holds, we have xi = g(xk,u) and xk = h(xj,u), so that xi = g(h(xj,u),u) = gh(xj,u). Then, the (i,j) entry of M(gh) is u. Conversely, if the (ij) entry of M(gh) is u, then xi = gh(xj,u), so that xi = g(h(xj,u),u). Now, the value h(xj,u) is, by definition, an element of X, say the element xk, k e {1, ..., n}. Then, xk = h(xj,u) and xi = g(xk,u), which implies that (ii) is valid for this k. Thus, we have shown that (ii) is equivalent to (iii) Mij(gh) = u. Using the fact that (ii) is equivalent to (i), the Lemma follows. * Thus, the product of two transition matrices with two different transition functions is the transition matrix of the composition of the two functions in the order of multiplication. Consider now the a machine Y with recursion function f. Let M(f) be its onestep transition matrix. Then, by Lemma 34, M(f)M(f) = M(f2), M(f2)M(f) = M(f3), and so on. This leads to the following corollary. Corollary 35 Let Y = (A,X,xo,Y,f,h) be an asynchronous machine. Then, for every integer p > 0, the onestep transition matrix satisfies MP(f) = M(fP). * Consider a machine Z = (A,X,xo,Y,f,h). As mentioned earlier, a stable combination (x,u) of Y can be considered as a cycle of length 1. This observation helps simplify the following statement, which forms an important tool in our process of finding all cycles of the machine Y. Lemma 36 Let Y be an asynchronous machine with the recursion function f and the state set X = {x1, ..., xn}. Let xi e X be a state and let u be an input character of Y. Then, the following three statements are equivalent. (i) There is an integer c > 1 such that xi = f(xi,u) (ii) u appears on the (i,i) diagonal entry of the matrix Mt(f). (iii) (xi,u) is a pair of a cycle whose length X is an integer divisor of c. Proof 36. First, we show that (i) implies (ii). Assume that (i) is valid, so that xi = ft(xi,u) for some integer c > 1. Then, by Equation 32, the character u appears on the diagonal entry (i,i) of the matrix M(ft). By Corollary 35, M(f) = MZ(f); this implies that u appears on the diagonal entry (i,i) of the transition matrix MZ(f). Next, we show that (ii) implies (iii). Let k > 1 be the smallest integer satisfying xi = f(xi,u). Then, < Tc. Now, if k = 1, then (xi,u) is a stable combination of Y, and hence forms a cycle of length 1. Otherwise, (xi,u) is a pair of the cycle {xi, f(xi,u), .., fl1(xi,u); u} of length k. Now, using the integer division algorithm, we can write c = qX + p, where q and p are integers and 0 < p < k. If p > 0, then, using the equality xi = f(xi,u), we can write xi = f(xi,u) = fP(fq(xi,u),u) = fP(xi,u), so that xi = fP(xi,u). The latter contradicts the fact that X was the smallest integer satisfying xi = f(xi,u), since 0 < p < k. Thus, we must have p = 0, and X must be an integer divisor of c. Finally, we show that (iii) implies (i). Assume that (iii) is valid, i.e., that (xi,u) is a pair of a cycle whose length k is a divisor of c. Then, there is an integer q such that c = qk. But then, ft(xi,u) = fq(xi,u) = xi, and (i) is valid. This concludes the proof. Thus, by taking the powers of the onestep transition matrix M(f) and observing the diagonal matrix at each step, the states of the machine involved in cycles can be isolated. The next lemma indicates a method of identifying the elements of each cycle. Lemma 37 Let Y be an asynchronous machine with state set X = {x, ..., xn} and recursion function f. Assume that Y has a cycle of length k > 1 that includes the pair (xJo,u). Then, the other states xJi, ..., xJi1 of the cycle can be found from the matrix M(f) in the following way: for every integer i = 0, ..., k2, the index ji+l is given by the position of the entry u in the column ji of the matrix M(f). Proof 37. Consider a cycle of length > 1. Let {xJo, xi1, ..., xJ 1} be the states involved in the cycle, and let u be the input character. We know f(xio,u) = xJ. This implies that the input character u appears exactly in the position (jo, j ) of the matrix M(f). Thus, the value of ji is given by the position of the character u in the row jo. Continuing recursively, assume that, for some 0 < k < X, the indices jo,, ..., jk of the states xJo, xJi, ..., xJk of the cycle have been found. Then, since xJk+1 = f(xJk,u), the character u will appear exactly in position jk+l of the row jk of the matrix M(f). This concludes our proof. Thus, the knowledge of the states involved in cycles of a particular length can be used to find the cycles specifically by applying Lemma 37. An algorithm that finds all the cycles of an asynchronous machine Y whose recursion function is f will now be outlined. Let #A denote the number of elements in the set A. Algorithm 38 Let Y = (A,X,xo,Y,f,h) be an asynchronous machine, and let M(f) be its transition matrix. Step 1: All entries on the main diagonal of M(f) represent stable combinations (i.e., cycles of length 1). For each input character u e A, let Ai(u) be the set of all states for which u is included in a diagonal entry of the matrix M(f); set 41(u) := A(u). Step 2: For i > 2, let Ai(u) be the set of all states for which u is included in a diagonal entry of the matrix Mi(f). Define the difference set si(u) := Ai(u) \ UI < Stop the algorithm for the character u when i+1 > n 1 #aj(u). * The significance of Algorithm 38 is pointed out by the following statement. Proposition 39 Let i > 1 be an integer. Then, in the notation of Algorithm 38, the following are true. (i) The set 4i(u) consists of all states of the machine Y that are members of cycles of length i with the input character u. (ii) The machine Y has exactly #,i(u)/i cycles of length i. Suppose there are 2X states in 4j(u). This means there are 2 cycles of length k in the machine. Pick one state from 4j(u); use Lemma 37 to find the other k1 members of that cycle. Now, pick another state from the k remaining states in 4j(u), and using Lemma 37, the second cycle can be determined. This procedure is extended to any number of cycles of a certain length. Proof 39. Let X = {x1, ..., xn} be the state set of Y, and let u e A be a character of the input set. By Lemma 36, the following two statements are equivalent: (a) The matrix Mi(f) has an entry including u on its main diagonal, in a column that corresponds to the state xr of y. (b) The state xr is a member of a cycle whose length is i or an integer divisor of i. The case i = 1 is simple, since the elements on the main diagonal of M(f) represent the stable combinations of the system, and whence the cycles of length 1. For i > 1, assume that the algorithm has not stopped before i, i.e., that i < n Y' #8j(u). Then, a slight reflection shows that the construction Equation 37 of ,i(u) removes all states that are included in cycles of length less than i. Combining this with the equivalence of (a) and (b), it follows that xr E 4i(u) if and only if xr is a member of a cycle of length i. Finally, consider the case where i+1 > n '1 #aj(u), and u(u) be the number of states of Y that are members of cycles of length k < i with the character u. From the definition of 4j(u), it follows that u(u) = '1 #aj(u). Thus, when i + 1 > n u(u), there are not enough states left to form a cycle of length i + 1 with the character u; whence the machine Y has no cycles of length greater than i with the character u. This completes the proof of part (i) of the Proposition. Regarding part (ii) of the Proposition, note that the set ,i(u) consists of all states that form cycles of length i with the input character u. By Lemma 32, no two cycles can have common states. Consequently, the number of elements of ,i(u) is a multiple of i, and the number of cycles in 4i(u) is given by #,i(u)/i. This concludes our proof. 3.3 Stable State Representations for Machines with Cycles In this section, a form of representation of only the next stable states and the extension of the definitions to the case of a machine with cycles will be explained. For an asynchronous machine Y = (A,X,Y,xo,f,h) without cycles, a valid pair (x,u) always has a next stable state x'. Consequently, for such a machine, one can define a partial function s : XxA X by setting s(x,u) = x' for every valid pair (x,u). The function s is then called the stable recursionfunction of the machine Y. When s is used as a recursion function, it induces the stablestate machine Is = (A,X,Y,xo,s,h). The stable state machine describes only persistent states of the machine, and ignores unstable transitions. This function describes the behavior of Y as experienced by a user, i.e., the transition of the machine to its next stable state is described. A reformulation of the finite state machine with cycles will now be explained, so that an equivalent stable state machine can be described from this reformulated machine. As mentioned earlier in Chapter 2, asynchronous machines are normally operated in fundamental mode. In specific terms, fundamental mode operation is as follows. Let Y be an asynchronous machine without cycles, resting in a stable combination (x,uo). Consider a string of input values u = ui...Uk e A' applied to the machine. When the input of X switches to ui, the machine may engage in a string of transitions culminating in the next stable state s(x,ul). In fundamental mode operation, the input character ui is kept fixed until the machine has reached its next stable state, to guaranty deterministic behavior. Then, once the machine reaches the stable combination (s(x,ul),ul), the input character is switched to u2, and the machine eventually settles on its next stable state s(s(x,ul),U2). This process continues until we reach the final input value uk. The last stable state reached in this process is given by x" := s(... (s(s(s(x,uo),ul),2)...,Uk). To simplify our notation, we shall write in brief x" := s(x,u). As mentioned earlier, the stable state machine describes persistent states of an asynchronous machine. For machines with cycles, a cycle describes a persistent state of the machine (i.e., the "state" of being in a cycle). Hence, when cycles are present, they must be represented in the stable state machine. Our next objective is to generalize the definition of the stable state machine, so it gives due representation to cycles, whenever they are present. Consider an asynchronous machine X = (A,Y,X,xo,f,h) having t > 0 cycles pi, ..., pt. To define a stable state machine XIs that represents the persistent behavior of X, we first augment the state set X of X by t new elements xn+1, ..., xn+t to obtain the augmented state set XP := X U {xn+l, ..., xn+t}. (38) Each one of the new states, called the cycle states, corresponds to one of the cycles of X, i.e., xn+i corresponds to the cycle pi, i = 1, ..., t. Define the function s' : XxA XP by setting {s(x,u) if x e X and (x,u) is a stable combination, sl(xu = (39) xn+ if (x,u) e pi. For a cycle p = {xkl, xk2, ..., xkp;a}, ki e [1,...,n], denote sl[p,u] := {s(xk,u), sl(xk2,u), ..., sl(xkp,u)}. (310) Now, the function s2 : XPxA XP is defined by setting s(xu) if x e X, s2(x,u) := i x (311) s [pi,u] if x = xn+ The generalized stable state machine EIs of Y is then the input/state machine defined by quintuple (A,XP,xo,s2). For the sake of notational convenience, we will omit the primes from s2 in the future, and write YIs = (A,XP,xo,s). The function s is called the generalized stable recursion function of E. A cycle p associated with a cycle state x is said to be stoppable if there exists an input character u e A such that at least one of the outcomes of s(x,u) e X. In the present work, we assume that all the cycles are stoppable. It is necessary to make this assumption; if not, there will be no controller that can stop the cycle. Note that when there are no cycles, the generalized stable recursion function of X is identical to the stable recursion function of Y. Let cs, be the generalized stable state machine induced by the closed loop system Ec shown in Figure 11. The present work concentrates on finding the solution to the next statement; consequently, this statement is the main topic of our discussion. The Model Matching Problem 310 Let X be a machine and let X' be a stable state machine with the same input and output alphabets as E. Find necessary and sufficient conditions for the existence of a controller C such that the generalized stable state machine Ecs = E'. When C exists, provide a method for its design. * The controller C of Problem 310 assigns to closed loop system the stable state behavior of the specified machine X'. Of particular interest to us here is the case where the machine X has infinite cycles. In such case, the controller C of 310 eliminates the effect of infinite cycles on the closed loop system. The model matching problem for asynchronous machines with critical races, but not infinite cycles, was discussed in Murphy 1996, Murphy, Geng and Hammer 2002, 2003, Geng 2003 In the following section, a solution for the model matching problem for the case where the controlled system X has infinite cycles is derived, and in Chapter 5 the design of an appropriate controller is demonstrated by means of an example. 3.4 Stable Reachability The extension of the stable state machine to machines with cycles will now be described. This requires a reformulation of the machine. Consider an asynchronous machine X represented by the sextuple (A,Y,X,xo,f,h), and assume that X has t > 0 cycles pi, ..., pt. Let Xis = (A,XP,xo,s), where XP X U {xn+l, ..., xn+t}, and xn+i is the generalized state corresponding to the cycle pi. We aim to define the notion of stable reachability for the machine X so as to characterize the "stable" states X can reach from a given initial condition, in response to various input strings. To this end, we need to define several notions. A generalized stable combination of the machine X is either a stable combination of X or a pair of the form (xn+i,u), where u is the input character of the cycle pi. A state of XIs is potentially stable if it is part of a generalized stable combination of X. When applying a control input to a machine that is in an cycle, it is not possible to operate in the fundamental mode. The input character must be changed while the cycle is in progress in order to attempt to interrupt the cycle. In other words, the input character is changed while the machine is not in a stable combination. Of course, if this change in input leads the machine to a stable combination, then fundamental mode operation can be resumed from there on. We arrive at the following notion, which describes the mode of operation that is closest to fundamental mode operation. Definition 311 A machine X is said to operate in semifundamental mode if the machine operates in fundamental mode when it is not in an cycle. * Recall that the states of the generalize stablestate machine XIs are either potentially stable states of X or cycle state that represent cycles. Thus, semi fundamental mode operation of X becomes fundamental mode operation of XIs. Definition 312 Let X be an asynchronous machine with generalized state set XP and generalized stable recursion function s. A state x' e XP is stably reachable from a state x e XP if there is a input string u =uoui...uk of X for which x'= s(x,u). * The following assumption is essential in determining the controller operation. If an input character forms a valid combination with one outcome of a critical race, then it forms a valid combination with all other outcomes of the same race. This assumption can always be satisfied by extending the definition of the recursion function of the machine. It is necessary to assume this statement because we need the controller to be operational will all outcomes of the critical race that follows the cycle. 3.5 Matrix of Stable Transitions and the Skeleton Matrix Consider an asynchronous machine Y = (A,Y,X,xo,f,h) with the state set { x1, ..., xn}, and assume that Y has t > 0 cycles pi, ..., pt. Let is = (A,XP,xo,s), where XP= X U {xn+l, ..., xn+t} and xn+i is the generalized state corresponding to the cycle pi. Let sx(xJ,xi) be the set of all characters u e A such that x1i s(xi,u). The matrix of onestep generalized stable transitions gives all the possible stable onestep transitions of the machine is; it is an (n+t)x(n+t) matrix R(is), whose (i,j) entry is given by rsx(xJ,xi) if sx(xJ,xi) # 0, Rij(s) (312) SN otherwise, i, j = 1, ..., n+t. Recall that, if xJ is a generalized state, then a critical race may occur when an input character u is applied at xJ. This race is represented in the matrix R(Yis) by the appearance of the character u in more than one row of column j. Note that Equation 312 is similar to Equation 32, except for the fact that R(Yis) has some augmented states instead of cycles. We turn now to a description of some operations on the matrix R(Yis). Let A* be the set of all words over the alphabet A. The operation of unison / is defined over the set A* U N as follows. Let wi, w2 be either subsets of the set A* or the character N; then, set wI U w2 if w1 c A* and w2 c A*, w1 if w1 c A* and w2 =N, wi W w2 := (313) w2 if w = N and w2 c A*, N if w = w2 = N. Extending this definition to matrices, the unison C := A 1 B of two nxn matrices A and B is defined by Cij := Aij J Bij, i, j = 1, ..., n, i.e., an elementwise operation as defined in Equation 313 As usual, the concatenation of two words wi, w2 e A* is given by wiw2, i.e., wl followed by w2. For elements wi, w2 are elements of A* or the character N, the concatenation is defined as follows. WiW2 if Wl, W2 e A*, conc(wi,w2) := N if N o 2 N. (314) N if w, =N or w2 =N. More generally, let W = {wi, w2, ..., Wq} and V = {vI, v2, ..., Vr} be two subsets, whose elements are either words of A* or the character N. Define conc(W,V):= Ui=l,...,q conc(wi,vj). (315) j=l,...,r Note that the concatenation is either a subset of A*, or it is the character N. The concatenation is noncommutative, and N takes the place of a "zero". Let C and D to be two nxn matrices whose entries are subsets of A* or the character N. Let Ci and Dij be the (i,j) entries of the corresponding matrices. Then, the product Z := CD is an nxn matrix, whose (i,j) entry Zj is given by Zij := L lconc(Cik,Dkj), ij = 1, ..., n. (316) Using this notation, we can define powers of the onestep transition matrix recursively, by setting RW(ls) := RW (Els)R(ils), t = 2, 3, ... (317) The matrix R"(EXs) has the following physical significance. The (ij) element of R"(Yls) is the set of all input strings that take xJ to xi in exactly [t steps. Thus, R"(Yls) is called the matrix ofu step stable transitions. This follows from Corollary 35, which states that the powers of the onestep transition matrix is equal to the transition matrix of the powers of the recursion function, i.e., the steps of the transition matrix. Define the matrix R(")(EIs) := Uk=l... Rk(ls), v=2,3,...,(n+t1). (318) By construction, the (i,j) entry of R( )(Ys) consists of all strings that can take the machine Yls from the state xJ to the state x1 in [t or fewer steps. The following statement is important to our discussion; the proof is similar to that of Murphy, Geng and Hammer, 2003, Lemma 39. Lemma 313 The following two statements are equivalent: (i) There is an input string that can take the machine Yls from the state xi to the state x1. (n+t1) (ii) The ij entry Rij (Ys) N. * Now, R(n+t1)(Yls) contains not only the stable transitions, but also the critical races that are cause when an input character is applied to a cycle state. To satisfy the model matching problem, we need a matrix for which the same input string does not lead to multiple outcomes. This is achieved by modifying the above matrix. This modified matrix is at the center of our discussion. Definition 314 Let Y be an asynchronous machine. The matrix of stable transitions T(Is) is constructed by performing the following operation on each column of the matrix R(n+t1)(Yis): remove all occurrences of strings that appear in more than one entry of the column; if empty entries result, replace them by the character N. * To understand the significance of the matrix T(Is), it is instructive to compare it to the matrix R(n+t1)(lsi). A string u in the (ij) entry of the matrix R(n+t1)(lis) indicates, of course, that u takes Is from xJ to xi. However, if the string u appears in another entry in column j of R(n+t1)(YIs), say in entry k, then the same string may also take YIs from xi to xk; this indicates a critical race. The construction of the matrix T(ls) removes then all transitions that involve critical races. As a result, an input string u that is included in the (i,j) entry of T(Is) takes the machine YIs from the state xJ to the state xi, and to no other state. Definition 315 Let Y be an asynchronous machine with the generalized state set {x1, ... xn+t}. A generalized stable transition from a generalized state xi to a generalized state xi is a uniform transition when one of the following is true: (i) xi can be reached from xJ without passing through a critical race, or (ii) there is a succession of critical races through which xi can be reached from xJ for all possible race outcomes. * Note that in case (ii) of Definition 315, the input string applied to the machine may depend on the outcomes of the critical races encountered by the machine along its way from the state xJ to the state xi. Specifically, let x(k,p) be outcome k of race p along the way from xJ to x1. The input string applied to the machine will then be a function of the outcomes u(x(kl,,l1), ..., x(ki,,,pl)) The set Ua= 1...,ru(x(kr,l,1), ..., x(kr,,pr,)) is (i,j) transition set, where r is the number of possible input strings taking into account all the critical races encountered in the path from xJ to xi. This means that pr races are encountered in the path followed by the rth string, and x(kr,,pr,) is the outcome kr,p of the race pr. Further, By construction, the elements of T(Is) will contain sets of strings that satisfy the following proposition. Proposition 316 The (i,j) entry of T(Is) is different from N if and only if there is a uniform transition from xJ to xi. Furthermore, if the (i,j) entry of T(Is) is not N, then it includes an (i,j) transition set. * Thus, depending on the sequence of critical races that occur, the entries of T(Is) gives a set of strings that can be used for the control process. The skeleton matrix is now defined as follows matrix: Definition 317 Let T(Is) be the matrix of stable transitions of the generalized stable state machine Is. The skeleton matrix K(X) of Y is a matrix of zeros and ones, whose (ij) entry is given by ri if Tij(s) N, Kij() = I (319) 0 otherwise i= 1,...,n,j = 1,...,n+t. * The skeleton matrix K(X) has a simple interpretation. In view of Lemma 313, the following is true Proposition 318 Let K(X) be the skeleton matrix of a given machine Y. Then, the (ij) entry of K(X) is 1 if and only if there exists a string that takes the machine XIs from the generalized state xJ to the state xi and to no other state. * The skeleton matrix plays a critical role in our discussion, reminiscent of the role it played in Murphy, Geng and Hammer 2002, 2003 3.6 Corrective Controllers The basic considerations in the construction of a corrective controller and its limitations for asynchronous input/state machines will now be outlined. Let X be an asynchronous machine, being controlled in the configuration Figure 11 with the controller C. Recall that Yc denotes the closed loop machine of Figure 11; let Xcs be the stable state machine induced by Yc. Now, let X' = (A,X,xo,s') be a stable state input/state machine, with the same input set and the same state set as the machine Y. Referring to the configuration Figure 11 and the Model Matching Problem 310, we are investigating the existence of a controller C for which cs, = X'. Consider the input/state machine X = (A,X,X,f,h) and the controller C = (AxX,A,E,4,r). Let the generalized stable state machine associated with X be X1s. As shown below, the controller C will operate in the semifundamental mode: when the controlled machine X moves toward a stable combination, the controller C will operate in fundamental mode it will keep its output value constant until X has reached its next stable combination; however, if X moves into an infinite cycle, the controller has no choice but to change its output value while X is cycling otherwise, X will remain in the cycle forever. In this case, the controller operates in the semifundamental mode. Recalling that Y has the state set X and that C has the state set E, it follows that the composite machine Yc of Figure 11 has the state set XxE. We can then represent Ec by the quintuple (A,X,XxE,fc,hc), where fc is the recursion function of Yc and he is its output function. Being an input/state system, the machine Y has the output function h(x,u) = x. As the output of Yc is the same as the output of Y, it follows that hc(x,,,v) = x. Formally, let 7tx: XxEX : 7Tx(x,) > x be the standard projection. Then, we have he = 7tx. Now, let y be the recursion function of cIs. We know that the output of cs, is the state of Y. So, if cIs = Y', then, for every valid pair (x,v) of Y', there is a state e E for which (x,i,v) is a valid pair of c,s. This leads to the conclusion hcy(x,,,v)= s'(x,v), (320) and, using the equality he = 7x, we obtain 7Txy(x,,,v) = s'(x,v). Note that, if s' is not constant over one of the cycles, then the response of the closed loop machine will depend on the state of the cycle at which the input character is applied, creating a critical race. In other words, in order for the response of the closed loop system to be deterministic, the stable recursion function of the model must be constant over each cycle of the controlled machine Y. To state this fact formally, consider a cycle p = {xkl, xk2, ..., xkp;a}, ki E [1,...,n], of the machine Y. Let s'{p) := {s'(xk,a), ..., s'(xkp,a)}, i.e., the set of values of s' over the cycle. We say that s' is constant over the cycle p if all members of the set s'{p} are identical. Proposition 319 Let Y and 2' be two machines, where 2' is a stable state machine. Assume that there is a controller C such that c Is = Y'. If the closed loop machine cs, has a race free response, then the recursion function s' of the model 2' is constant over every cycle of Y. * We are now ready to state one of the main results of our discussion. The following theorem deals with the fundamental conditions for the existence of a model matching controller (compare to Murphy, Geng and Hammer 2002, 2003, Theorem 4.3). Before stating the theorem, we need some notation. For a cycle state z e XP, let p(z) = {a; xk, xk2, ..., xkp}, ki e [1,...,n], be the corresponding cycle, and let 7Txp(z) := {xkl, xk2, ..., xkp } be the states of the cycle. Define i z if z is a regular state, P(z)= (321) t=xp(z) if z is a cycle state. Note that (p(z) is always a set of regular states, not cycle states. Theorem 320 (Existence of Controller) Let Eis = (A,XP,xo,s) be the generalized stable state machine induced by an input/state machine Y = (A,X,xo,f). Let z1, ..., zk be generalized states of Eis and let U1, ..., Uk be sets of input characters such that zlxU1, z2xU2, ..., zkxUk are distinct sets of valid pairs of is. For each i = 1, ..., k, let z'i be a state of Y that is stably reachable from the generalized state z1. Then, there exists a controller C for which cs, is equivalent to a stable state machine 2' = (A,X,xo,s'), whose recursion function s' satisfies (i) s'[p(zi),Ui] = z'i for all i = 1,...,k, and (ii) s'(x,t) = s(x,t) for all (x,t) e XxA / Ui=1 ...,k ZixUi. Moreover, the closed loop system Yc is well posed, and it operates in the semi fundamental mode. Proof 320. By Proposition 319, the recursion function of the model is constant over all cycles of the machine Y. Thus, since z'i is stably reachable from the generalized state zi, there exists a string wi e A+ such that s(zi,wi) = z'i, where s is the stable recursion function of Y. Let m(i) be the length of wi; write wi = v ...vm(i)1 where vo, v., ..., vm(i) are individual characters of the input alphabet A and i = 1,..., k. With this input string wi, the recursion function s generates a string of generalized states, which we denote by xi, := s(zi,vi), xi,2 := s(x l,v ), ..., xi,m(i) := s(xi,m(i)2vm(i)2), := s(xim(il,vm(il), i = 1, ..., k. (322) Let U(zi) c A be the set of all input characters that form stable combinations with the generalized state zi, i = 1, ..., k. Define the following sets: S := Ui=1, ..., k ziU(zi), V := Ui=l, ..., k zixUi, (323) where Ui are the input character sets given in the statement of the Theorem. Then, a controller C = (AxX,A,E,4,r) that satisfies the requirements of Theorem 320 can be constructed as follows. (i) The state set E of C has 2 + lm(i) states given by = 1, El im(1) 1 m(2) m(k)} (324) ^ 05 0, 1. 5' 2'!$ ' ^2! , '*' ^' **' k (324) The significance of these states is explained below. (ii) The initial state of the controller C is o0. The controller moves to the state j1 upon the detection of a stable combination with one of the generalized states zl,..., zk e XP. Note that, for cycle states, this transition occurs during the cycle, and is therefore a semifundamental mode transition. For states that are not cycle states, this transition is in fundamental mode. To implement these transitions, the recursion function 4 of C is defined by (ko,(z,t)):= o for all (z,t) E XxA \ S, (,o,(x,u)) := 1 for all (x,u) e S. (325) The state o indicates that the machine X is not in a state in which its response must be changed, and hence, when in the state o, the controller does not interfere with the operation of X; it simply applies to X its own external input. To this end, the output function r of C at the state o is defined by r(o,(z,t)) := t for all (z,t) e XxA. (326) The output function at the state ,1 is defined as follows. Choose a character ui e U(zi); set r(li,(zi,t)) := ui for all t e A, i = 1, ..., k. (327) Then, the machine X continues to rest at the generalized state z1. (iii) Next, assume that X is in a stable combination with the generalized state zi, i = 1, ..., k, and an input value u e Ui is applied. Then, the controller C will begin to apply the string wi to Y, to take Y to the state z,. To this end, the recursion function of C is defined as follows. (l,(zi,u)) := i for all u e Ui, i = 1, ..., k; 4(1,(z,t)) := o for all pairs (z,t) e XxA\V. (328) Upon reaching the state i, the controller generates the first character of the input string wi of Y, to start taking Y to the desired state z'i. Accordingly, the controllers output function value at this point is r(G,(z,t))= v0 for all (z,t) e XxA, i = 1, ..., k. (329) Upon application of this input character, the machine Y will move to its next generalized stable state xi,1, where (xi, vi) is the next generalized stable combination. (iv) In order for the controller to continue to generate the string wi as input for Y, we define its recursion function as follows. (,,(xid,u)) := ,1 for all u e Ui, (330) j = 1,...,m(i)l, i = 1, ..., k. Now, the controller feeds to Y the next character in the string wi, i.e., the character vi. So the output function must satisfy r(i ,(z,u)) := v for all (z,u) e XxA, (331) i = 1,...,k,j = 1, 2, ..., m(i)l. (v) At the step j = m(i)l, the controller completes generating the string wi. It assumes then a stable combination, and continues to feed the input character vm(i) 1 until its external input character is changed. To implement these requirements, the transition and output functions of the controller are defined by (((i),(z'iu)) := m(i) for all u e Ui (i),(z,t)) := o for all (z,t) e XxA\ z'ixUi, m(i) m(i) 1 r(i(i),(z,u)) := v(i). (332) k i = 1,...,k. Note that, since the stateinput sets {zixUili=l are all disjoint, there is no ambiguity in the definition of the recursion function 4. From the above construction, the stable recursion function y of the closed loop system Ec can be deduced. On analysis, this recursion function satisfies, for all i = 1,...,k: y(zi,o,u) = (s(zi,u),S1) for all u e U(zl), y(z,o,t) = (s(z,t),o) for all (z,t) e XxA\(SUV), y(zi,l4,ui)= (z'i, m(i)) for all ui e Ui, y(zi,l,u) = (zi,1) for all u e U(zi), y(zi,,l,t) = (zi,,o) for all t e A\(U(zi) U Ui), y(z'i,m(i),u) = (z'i,gm(i)) for all u e Ui, y(z,im(i),t)= (s(z,t),o) for all (z,t) e XxA\z'ixUi, (333) i = 1,...,k. Thus, the equivalence of 7xY and s' as defined in the beginning of this section holds true. Also, the closed loop system operates in the semifundamental mode as the definitions of 4 and r specify. We know E is an inputstate system, hence it is strictly causal; consequently the closed loop system ,c is well posed (Hammer 1996). This concludes the proof. * Chapter 4 deals with the specific solution to the model matching problem for this problem. The necessary and sufficient conditions for the existence of the controller, using the skeleton matrices are put forward, and if the controller exists, an algorithm to construct the states is also given. CHAPTER 4 THE MODEL MATCHING PROBLEM In this section we present a solution to the model matching problems for machines with infinite cycles. The solution to the model matching problem for deterministic systems and for machines with races was presented in Murphy, Geng and Hammer, (2002, 2003). Let Y be an asynchronous machine with all cycles stoppable, and let 2' be the stablestate model to be matched. The skeleton matrix Ko(') of the model 2' is given as in Definition 317. For the solution to the model matching problem, a form of the skeleton matrix with columns augmented to include the solution to cycles is introduced; this is the augmented skeleton matrix K(2'). The matrix K(2') is an nx(n+t) matrix of zeros and ones. It is obtained by augmenting the matrix Ko(') with t columns corresponding to the cycle states, as follows. Let z be a cycle state, and let 7Txp(z) be the states of the cycle. Then, K (E'), i,j = 1,...,n, Kij(Y')= 1 if K (Y')= 1 for all xk e 7xp(x), i = 1,...,n, j = n+l,...,n+t, (41) 0 otherwise. In view of Proposition 319, the model 2' can be matched only if its stable transition function is constant over the states of each cycle of Y. Assume then that 2' satisfies this requirement. In such case, it follows by Equation 41 that the entries of the column corresponding to xk, k = n+l,...,n+t in K(X') are all 1. The solution to the model matching problem for a machine with infinite cycles can now be stated as follows. Theorem 41 Let Y be an asynchronous machine all of whose cycles are stoppable, and let is = (A,XP,xo,s) be the generalized stable state machine induced by Y. Let 2' = (A,X,xo,s') be a stablestate input/state machine with the same state set X and the same input set A as those of Y. Let K(X) be the skeleton matrix of Y, and let K(X') be the skeleton matrix of Y'. Then, the two following statements are equivalent. (i) There is a controller C for which the closed loop system cs, is equivalent to 2', where cIs operates in the semifundamental mode and is well posed. (ii) The skeleton matrices satisfy K(X) > K(E'). Theorem 41 provides a simple necessary and sufficient condition for the existence of a solution to the model matching problem for systems with infinite cycles. The proof of the Theorem, which is provided later in this section, includes an algorithm for the construction of an appropriate controller C. When the model matching problem is solvable, the controller C operates by transforming into unstable combinations all generalized stable combinations of Y that do not correspond to stable combinations of the model Y'. In this way, the stable state machine cs, induced by the closed loop system becomes stably equivalent to Y'. The skeleton matrix of the given machine K(X) is never fully zeros, since each state is potentially stable. Thus, there always exists a stable state machine Y" with skeleton matrix equal to K(X). When considered as a model, the machine Y" satisfies condition (ii) of Theorem 41. Consequently, there is a controller C for which cIs = ", and this controller eliminates the effects of the infinite cycles of Y. Thus, feedback controller can turn every machine with stoppable cycles into a deterministic stable state machine. We turn now to a preliminary technical discussion that will lead us to the proof of Theorem 41. Let s be the stable recursion function of the generalized stable state machine EIs of E, and let s' be the stable recursion function of the model E', with the codomain of s' extended to XP. Build the discrepancy set of E as D(E,E') := {(x,u) e XxA : (x,u) is a valid pair of E' and s(x,u) s'(x,u)}. (42) In intuitive terms, D(E,E') is the set of all valid pairs of E' for which the next stable state of E' is different from the next generalized state of EIs. Now, since K(E) > K(E'), for each (x,u) e D(E,E'), there exists an input string w e A+ for which s(x,w) = s'(x,u); let S(x,u) c A+ (43) be the set of all input strings w satisfying s(x,w) = s'(x,u). Next, consider a pair (x,u) e D(E,E') and an input string w e S(x,u). Let P(E,x,w) be the corresponding path of E, and let p(E) := {(z,r) : (z,r) e XxA, (z,r) e pi, i = 1,...,t) (44) be the set of all stateinput pairs involved in cycles. Define the set DN(E,E') := {(x,u) e D(E,E') : there is a string w e S(x,u) such that P(X,x,w)n p(X) = 0}. (45) For elements (x,u) e DN(E,E'), the machine E can reach the value s'(x,u) without passing through a cycle. Here, the controller will simply feed to E the string w, so that the next stable state of the combination Yc will match the next stable state of the model Y'. Finally, on the difference set Dc((,Y') := D( ,:')\DN(=,X'), (46) the machine Y cannot match the response of 2' without passing through a cycle. In this case, the controller will have to generate an input string for Y that will initially drive the machine into a cycle, and then take it out of the cycle. When Y comes out of the cycle, its next state may be one of several possible states, as exit from a cycle may give rise to a critical race. The controller will then have to resolve the indeterminancy of the race and drive the machine to the next stable state determined by the model 2'. The exact process by which this is accomplished is described in the following proof. Proof 41. Assume first that condition (i) of Theorem 41 is valid, i.e., that there exists a controller C such that cs, = Y'. Let Sc be the stable recursion function of Yc, and recall that s' is the stable recursion function of the model 2'. The last equality implies that c,(x,u) = s'(x,u) for all pairs (x,u) e XxA. Now, since the controller C accesses Y only through its input, there is a string w(x,u) e A+ such that Sc(x,u) = s(x,w(x,u)) where s is the stable recursion function of Y. Consequently, s(x,w(x,u))= s'(x,u), and the state s'(x,u) is stably reachable from the state x in the machine Y. Thus, any state that is stably reachable from the state x in the machine 2' must also be stably reachable from the state x in the machine Y. In other words, K(X) > K(2'), and we conclude that part (i) implies part (ii). Conversely, assume that (ii) is true, i.e., that K(X) > K(X'). We construct below a controller C that satisfies statement (i) of Theorem 41. Recalling the set D(X,2') of Equation 42, note that if D(X,2') = 0, then the stable transition function of Y matches that of Y', and no controller is needed. Next, consider the case D( 0,2') 0. Define the set D by replacing in D(X,2') all the pairs included in cycles by the corresponding generalized pairs, that is, Dc := {Dc(X,') \ p(X)} U {(xn+i,u) : pi D(n,X') 0} (47) The set of all input characters that pair with a state x in D is given by D(x) := {u e A: (x,u) e D}. (48) Let rx : XPxA > XP: (x,u) > x be the standard projection. Then, r7xD is the set of all generalized states x e XP for which there is an input character u E A such that (x,u) e D. Also, let U(x) be the set of all input characters that form a stable combination with the generalized state x e XP. The set V := x x U(x): x e ctxD} (49) is then the set of all generalized stable combinations with states in rxD. Suppose that DN(X,X') 0. Then, for each (x,u) e DN(X,X'), there exists an input string w0(x,u) such that s(x,w0(x,u)) = s'(x,u) and the path P(X,x,w) does not contain any cycle states. Let m(0;x,u) = Iw0(x,u)l be the length of this string, write it in terms of 0 0 0 its characters as w0(x,u) = wo(x,u)wl(x,u) ... wm(x,u)l(x,u). Then, w0(x,u) takes the machine through a succession of stable states, which we denote as follows. 0 xoI(x,u) := s(x,wo(x,u)), 0 x0'2(x,u) := s(x,1(x,u),wl(x,u)), ..., xO,mn(x,u)(x,u) := s(xOn(x,u)2(X,U),Wm(x,u)2(X,U)), and, by selection of the string w0(x,u), s(xm(x,u)l(x,u),Wn(x,u)1(x,u)) = s'(x,u). (410) Thus, to guarantee fundamental mode operation, we see that the controller must have m(0;x,u) states associated with the pair (x,u). Now, let (zl,ul), ..., (zn(N),un(N)) be the elements of DN(X,'). Then, for each pair (zi,ui) e DN(X,'), the controller needs m(0;zi,ui) states to facilitate fundamental mode operation, say the states il(zi,ui), .. m(o;zi,ui)(zi,ui). This leads to the set of controller states EN:= R{l(zl,ul), ..., mn(o;z,ul)(zl,ul), ..., (zn(N),un(N)), ..., m(o0;zn(N),un(N))(zn(N),un(N))}. (411) In case DN(X,') = 0, set EN := 0. We turn now to the set DC of Equation 47, assuming that it is not empty. Let n(C) be the number of elements of DC. Recall that, for each pair of DC, the machine must pass through at least one cycle in the process of matching the response of the model Y'; one of these cycles may be the initial step. Consider a pair (x,u) e DC, let T(1s) be the matrix of stable transitions of X. Recall that the state set of Y is X = {xl, ..., xn} and the generalized state set of Y is XP = {x1, ..., xn+t}. In the case x is a cycle state, say x = xY, where y e {n+1, ..., n+t}, let p(xY) := {xv(1), ...,x(P)} c X. Setting xP := s'(xa(1),u) e X, it follows by Proposition 3 19 that s'(xa(i),u) = xP for all i = 1, ..., p. The fact that x := s'(xa(i),u) implies that Kpa(i)(X') = 1, i = 1, ..., p. By Equation 41, we then have that Kpy(X') = 1. The inequality K(X) > K(X') implies then that the entry Tpy(ls) is not empty. Furthermore, letting w(x,u) be an element of Tpy(ls), it follows by Proposition 318 that s'(x,u) = s(x,w(x,u)). Consider now the path P(ls,x,w(x,u)). Recalling that (x,u) e DC, the following hold. If x is not a cycle state, then the path P(ls,x,w(x,u)) must include a cycle. If x is a cycle state, then P(ls,x,w(x,u)) may or may not include an additional cycle. The string w(x,u) takes the machine through one possible outcome of each cycle encountered along the path P(ls,x,w(x,u)). Depending on the outcome of the critical races that occur as the machine Y passes through the cycles along the path P(ls,x,w(x,u)), different strings may need to be used to take the machine to the state s'(x,u). Let wo(x,u) be the initial segment of the string w(x,u) that takes the machine Y to the state following the first cycle state along the path P(Xls,x,v(x,u)). By construction, the shortest length of wO(x,u) is one character, and it is obtained when the state x is itself a cycle state. The controller C initially feeds this string to the machine Y character by character, to achieve semifundamental mode operation. The last character of w(x,u) leads Y into a critical race, as it exits from the corresponding cycle. The inequality K()) > K(X') implies that there is an input string that leads Y from each outcome of this race to the next cycle along its way to the state s'(x,u). This string will then similarly be generated by the controller and applied to the machine Y. This process continues through each cycle encountered along the way, and is formally described next. 0 Writing the initial substring in terms of its individual characters, set w(x,u) = wo 0 0 (x,u)wl(x,u) ... wm(o;x,u)l(x,u); here, m(O;x,u) = w(x,u)l is the length of the string. This string take the machine Y through the following sequence of generalized stable states. 0 xo,(x,u) := s(x,wo(x,u)), 0 x0,2(,) := S(X0,1(X,U),Wl(x,u)), ..., xO,m(0;x,ul(xu) := S(xO0,m(;x,u)2(X,U),Wm(0;x,u)2(X,U)), X(1)(x,u) := s(xOm(O;xu)l(x,u),Wm(o;x,u)1(x,u)), (412) where X(1)(x,u)= {x(1,1), ..., x(1,ri)} c X is the set of all states of Y that form possible outcomes of the critical race. Since the string w0(x,u) takes Y up to one step past a cycle state to the outcome of the corresponding critical race, it follows that xo,m(o;x,u)l(x,u) is a cycle state. Note that if the initial state x is a cycle state, then m(0;x,u) = 1, namely, the substring wO(x,u) has just a single character. The next substring of characters in w(x,u) takes the machine from the present outcome of the cycle to the outcome of the next cycle (or to the final destination, if no other cycle is encountered). Denote this substring by wi(x,u,x(1,ii)). It takes the machine from the state x(1,ii) to the outcome of the next cycle; the process is similar to the process described in Equation 412, and wl(x,u,x(1,ii)) has at least one character. If a cycle leading to a critical race is reached at the end of the substring wl(x,u,x(1,ii)), then, letting r2(ii) be the number of its outcomes, we denote the set of outcomes by X(2,ii)(x,u) and let its members be {x(2,il,1), ..., x(2,i1,r2(i1))} c X. Let 1 1 m(1;x,u,x(1,il)) = wl(x,u,x(1,il))l be the length of the string, and let wo(x,u,x(1,ii)), wi (x,u,x(1,il)), ..., Wm(1;x,u,x(1,i))l(x,u,x(l,il)) be its characters. The next such substring depends on the outcome of both the races encountered, and is given by w2(,ux(2,il,i)). The number of cycles encountered may vary, depending on the outcome of the critical races through which the machine has passed. Let q be the number of cycles encountered along our path to the target s'(x,u). The outcomes of the q critical races caused by the cycles are then denoted by x(1,il), x(2,ii2), ..., x(q,il, iq). In order to simplify the notation, define x(k,i( input characters that takes the machine from (x,u) to s'(x,u) consists then of the following segments w(x,u) := w(x,u) w1(x,u,x(1,i( where each one of the segments takes the machine from the outcome of one cycle to the outcome of the next cycle along the path. The length of the segment wJ(x,u,x(j,i( m(j;x,u,x(j,i(j))) > 1. Each segment can then be written in terms of its individual characters in the form J J wJ(x,u,x(j,i( wm(j;x,u,x(ji( ))1(x,u,x(j,i( where the possible values for each variable are il = 1, ..., r, i2 = 1, ..., r2(i), ..., ij = 1, ..., rj(il,...,ij_i), and j = 1, ..., q. Using the same notation introduced earlier, let rj(i( 1)) = rj(i,...,ij_i) for some j. q1 Each of the substrings {wJ(x,u,x(j,i(gj)))}j=1 drives the machine through a string of the stable transitions similar to Equation 412. The last segment wq(x,u,x(q,i(
