Synthesis of supervisors for time-varying discrete event systems

SISTEMAS A EVENTOS DISCRETOS

Synthesis of supervisors for time-varying discrete event systems

Eduard Montgomery Meira Costa^I; Antonio Marcus Nogueira Lima^II

^IDepartamento de Engenharia Elétrica, Universidade Federal da Bahia 40210-630 Salvador, BA, Brasil, [e-mail] ^IIDepartamento de Engenharia Elétrica, Universidade Federal de Campina Grande 58109-970 Campina Grande, PB, Brasil, [e-mail]

ABSTRACT

We introduce a time-varying automaton to model discrete event systems. The structure of this time-varying automaton is very similar structure to (max,+) automaton, but allowing variable event lifetimes. Based on this time-varying automaton the design of timed supervisors is obtained by using the dioid algebra, where the languages used to describe the discrete event system as well the desired specification are replaced by matrices defined in such algebra and the supervisor synthesis is achieved through simple matrix operations. The proposed synthesis algorithm allows one to synthesize supervisors for un-timed DES, timed DES with constant event lifetime and timed DES with variable event lifetime. All these cases are treated with the same basic algorithm, the differences rely only on the definition of the event lifetime functions. The proposed algorithm presents a complexity order equal to the supervisor synthesis algorithm of un-timed discrete event systems. The proposed approach can be considered as an alternative procedure, based on a non-traditional algebraic structure, to achieve the supervisor synthesis for discrete event systems.

Keywords: Time-Varying Automata, discrete event systems, supervisory control.

RESUMO

O autômato com temporização variável é introduzido nesse artigo para modelar sistemas a eventos discretos. A estrutura desse autômato é bastante similar à estrutura do autômato (max,+), mas apresentando tempos de vida variáveis. Baseado nesse autômato o projeto de supervisores temporizados é obtido por meio da álgebra de dióides, onde as linguagens utilizadas para descrever o sistema a eventos discretos, bem como a especificação de comportamento desejada são definidas por matrizes descritas nesta álgebra e a síntese do supervisor é formalizada através de simples operações matriciais. O algoritmo de síntese proposto permite sintetizar supervisores para sistemas a eventos discretos não temporizados, sistemas a eventos discretos temporizados com tempos de vida constantes e e variáveis. Todos esses casos são tratados com o mesmo algoritmo básico, em que a diferença existe apenas na definição das funções de tempos de vida dos eventos. O algoritmo proposto apresenta uma ordem de complexidade igual ao algoritmo de síntese do supervisor para sistemas a eventos discretos não temporizados. A formulação proposta pode ser considerada como um procedimento alternativo baseado numa estrutura algébrica não tradicional, para construir supervisores para sistemas a eventos discretos.

Palavras-chave: Autômatos com Temporização Variável, Sistemas a Eventos Discretos Controle Supervisório.

1 Introduction

Manufacturing systems, traffic systems, computer networks, communication protocols, process control plants are examples of discrete event systems (DES). A DES is a dynamic system in which state changes occur in response to the occurrence of events. The behavior of a DES can be expressed in terms of a language L and the desired behavior is specified by another language E . In general, L Í E meaning that the DES may generate illegal behaviors. A supervisor is designed to eliminate the illegal behaviors. The set of events (S) is partitioned into controllable (S_c) and uncontrollable (S_uc) events thus creating the possibility for controlling the DES. Controllable events can be enabled or disabled by a supervisor which actively monitors the DES and can intervene at any moment to prevent an illegal behavior. The supervisor control problem can be elegantly solved by using the Supervisory Control Theory (SCT) (Ramadge e Wonham,1987b; Ramadge e Wonham, 1987a; Ramadge e Wonham, 1982).. Automata theory and formal languages theory form the basis of this theory. The supervisor as synthesized by the SCT deals only with the un-timed or logic behavior where there is no timing information explicitly associated to the events of the DES.

The timed behavior of DES is of great applied interest but also of significant complexity. Timed automata are one of the most studied models for representing real-time systems (Saksena e Selic, 1999). In some cases the timing information must be explicitly introduced to guarantee that the control action be feasible within the designated time bounds. Furthermore, these time bounds may be uncertain or time-varying and thus an adaptive supervisor must synthesized.

One approach to control a timed DES is to adopt a global clock and to introduce a clock-tick event (Brandin e Wonham, 1994). The use of the 'tick' event, introduces new classes of events (prospective, remote, forcible, prohibitible and eligible) and increases the complexity of the problem since the state space is augmented in order to represent the timing information related to each activity in the system. In this case there are two representations for the DES: i) for displaying the activity transition graph (ATG) (Ostroff e Wonham, 1990) is employed and ii) the timed transition graph (TTG) (Lawford, 1997) where the timing information is explicitly represented by using 'tick' transitions. The desired behavior is given by a timed-language and the classical supervisor synthesis provided by the SCT is applied to the TTG.

The use of a max-algebra provides another alternative to deal with some control problems of timed DES (Cofer e Garg, 1996). In this case the DES is represented by a timed-event graph and the dynamics is modelled by a system of linear equations written in a nontraditional algebraic structure known as a dioid. The desired behavior is given by a range of acceptable execution times for the events and a supervisor synthesis algorithm was developed since the max-algebra model prevents the use of the classical algorithm provided by the SCT. It is important to remark that the synthesis of timed and un-timed supervisors is usually done by employing different models for the DES.

This article proposes an unifying framework based on dioid algebra for synthesizing both timed and un-timed supervisors. It exploits the advantage of the dioid algebra for compactly representing the timing information and on the other hand allowing to express the DES model as well as the desired behavior in terms of languages. The proposed approach employs a time-varying automaton (TVA) to represent the DES by using its incidence matrix. The synthesis algorithm is based on the classical algorithm provided by the SCT and it is implemented in the matrix form.

This paper is organized as follows: in Section some basic definitions concerning dioid algebra, (max,+) automaton, formal series and languages are presented; in Section the time-varying automaton is introduced; in Section the supervisor synthesis is formulated; in Section the supervisor synthesis algorithm is presented; in Section several illustrating examples are studied and in Section the conclusions of this work are presented.

2 PRELIMINARIES

Definition 1 A dioid is a set D endowed with two operations: Å (addition) and Ä (multiplication), that satisfy the following axioms:

Axiom 1 Commutativity of Å:

Axiom 2 Associativity of Å:

Axiom 3 Associativity of Ä:

Axiom 4 Distributivity of Ä over Å:

Axiom 5 Null element in Å:

Axiom 6 Absorbing element in Ä:

Axiom 7 Identity element in Ä:

Axiom 8 Idempotency in Å:

A dioid is said commutative if Ä is commutative.

Considering that D = _max: = È - ¥, the null element is : = -¥ and the identity element is e: = 0. The Å operator is the usual max and the Ä is the usual sum. In this case D is commutative and the related algebra is known as the (max,+) algebra.

2.1 (max,+) automaton

The (max,+) automaton can be used to model the timed behavior of DES. In this case the system dynamics can be described through formal series as explained in the following and it is also possible to consider the partition of the set of events (S) into controllable (S_c) and uncontrollable (S_uc) events, i.e., S = S_cÈS_uc, as usual in the SCT.

Definition 2 A finite (max,+) automaton over an alphabet S is a quadruple A_(max,+) = (Q,q,T,f) where Q is a finite set of states, q, f, T are maps q:Q ® _max, f: Q ® _maxT:Q×S×Q ® _max (named initial delays, final delays, and transition times, respectively).

For displaying purposes a (max,+) automaton is represented by valued multigraph where the set of vertices is given by Q and there are three types of arcs:

i) The internal arcs i j, "i,j Î Q, s Î S. If T_i,s,j¹ the arc i ® j is valued by the scalar T_i,s,j like i

j;

ii) The input arcs ® i, "i Î Q. If q_i¹ the input arc is valued by the scalar q_i like i;

iii) The output arcs i ® , "i Î Q. If f_i ¹ the output arc is valued by the scalar f_i like i .

Example 1 Let S = {a,b} . The automaton with set the of states Q = {0,1,2}, transition times T_0,a,1 = 1, T_0,a,2 = 3, T_1,a,2 = 4 , T_2,b,2 = 1, T_2,b,1 = 5, T_2,b,0 = 7, T_1,b,1 = 1, T_1,b,0 = 2, final and initial delays f₀ = 2 and q₀ = 0, respectively (all the other values of f, q and T are equal to ) is shown in Figure 1. The values equal to 0 are omitted from the diagram, i.e., the not valued arc ® 0 stands for q₀ = 0.

Comparing a (max,+) automaton with an un-timed automaton having the same structure we can note that the transition function is embedded in the T map. The initial state is defined at the vertex q₀Î Q in which q_q0¹ e and the marked states are those vertices q_m Î Q where f_qm¹ . The dynamics of a (max,+) automaton can be explained as follows:

1. There is a global clock that is continuously being incremented;

2. The arcs are valued by T_i,s,jÎ T, i,j Î Q. This means that the transition from i to j takes at least T_i,s,j units of time, or, in other words, given that the automaton reached state i, then it will jump to state j after the occurrence of s, however the event s will be enabled to occur only after T_i,s,j units of time. The term T_i,s,j is denoted the lifetime of the event s.

3. The initial state q₀Î Q will be reached only after q_q0 units of time with respect to the global clock time origin;

4. When the automaton reaches a given state i the counters associated to events such that T_i,s,j ¹ will be initialized with T_i,s,j and all start decrementing simultaneously. When a given counter reaches zero it stops decrementing and the respective event becomes enabled and may occur from now on;

5. When a given event occurs all the running counters are stopped and the state of the automaton changes;

6. When a marked state q_m is reached it takes the final delay for the automaton to recognize the event sequence started at q₀;

7. If at a given state i there are two arcs leaving that state and the labels are equal but valued with different lifetimes then the automaton is said non-deterministic.

Example 2 The dynamics of the (max,+) automaton shown in Figure 2 can be described in the following way: i) After started the global clock at t = 0 it takes 2 units of time to reach the initial state 1. ii) At t = 3 the automaton may recognize the string 3e, where e is the empty string. iii) At t = 4 the counter of event a reaches zero and it becomes enabled until its occurrence. iv) If a occurs at state 1 the automaton will jump to state 2. v) Once at state 2 it takes 3 units of time for event b to become enabled. vi) If b occurs at state 2 the automaton will jump to state 1. vii) Once again in state 1 it takes one more unit of time for the automaton to recognize the string 8ab. viii) If b did not occurred at state 2 then after one more unit of time k becomes enabled. Then, after t = 8 the events b and k are both enabled until one of them occurs. ix) If k occurs at state 2, the state 3 is reached. x) At state 3 it takes 2 units of time for b to become enabled. xi) When b occurs the automaton returns to state 1 and then, after one unit of time it recognizes the string 11akb.

In a (max,+) automaton a sequence of states is defined as a path. A path of length n is given by

where

A string s = s₁...s_n is recognized in a path if

where W(p,s) is the path weight function. In other words, a string is recognized if it takes a finite time for its completion. The multiplicity of a string is the maximum of the weights for all the paths where that string is recognized, namely

A dater is a map y:S^*® _max and (y|s) is interpreted as the time for completing the sequence of events that composes s. A (max,+) automaton recognizes a dater if

Example 3 The string s = ab is recognized by the automaton shown in Figure 2 since

with p = (1,2,1).

Example 4 The two automata shown in Figure 3(a) and ^(c) recognize the same timed-languages. For the sake of comparison, the automaton given in Figure 3(a) is an ATG (Brandin e Wonham, 1994) where the events are defined by (s_q,q',t_s,¥) Î S. Then, in terms of Brandin and Wonham notation we have that the events (a_1,2,2,¥), (b_2,3,2,¥), (b_3,4,2,¥), (a_4,1,3,¥), (k_4,5,1,¥), (l_5,1,2,¥) are all of remote type. The automaton shown in Figure 3(b) is a TTG representing the dynamics of the ATG. ^{Figure 3(c)} shows a (max,+) automaton that exhibits the same dynamics. In the TTG, each arc labelled with a t ('tick') indicates one unit of time. It is worth noting that the number of states of the (max,+) automaton is largely inferior to the number of states of the TTG. Besides, the timing information is more compact and directly represented with the (max,+) automaton.

2.2 (max,+) automaton and formal series

Formal series can be used to describe timed and un-timed languages (Berstel e Reutenauer, 1998; Klimann, 1999).

Definition 3 A formal series f over an alphabet S with coefficients in D is a map

where each string s Î S^* has its image f(s) Î D that is denoted (f|s) and represents the coefficient of s in f.

The set of all the formal series over f with coefficients in D is denoted D á á S ñ ñ . Given f₁:S^*® D, f₂:S^*® D and "s Î S^* the set D á á S ñ ñ is endowed with the following operations

These operations are known as the Cauchy sum and product, respectively. The Cauchy sum represents the union of languages and the Cauchy product represents the concatenation. The convention (f|s) = indicates that s never occurs.

The star operation can also be defined for the formal series.

Definition 4 The star operation for a formal series f Î D á á S ñ ñ is defined by

where 'e' is the identity element and

The formal series allows to describe languages by using equation (18). An un-timed language can also be described as formal series if D = = {, e} that is a binary semi-ring.

Definition 5 A regular language L = {s₀, s₁,...} Í S^* can be described by

where á á S ñ ñ is the semi-ring of formal series with (y|s) Î and s Î S^*.

Example 5 The language L = {e, a, ab, ba, aa, bb, bab} defined over S = {a, b} can be represented by the following formal series

where (y|s) = e,"s Î L, and (y|s) = ,"s Î S^*-L. The above formal series can also be written as

or

since Ä L = , e Ä L = L, "L Í S^*.

Similarly, a timed language (Alur e Henzinger, 1992; Tripakis, 1998; Fribourg, 1998 Asarin, 1998) can be described by a formal series defining that D = _max. A timed language L is a language where each s Î L has a scalar value t_s associated to it. This scalar is a time stamp that indicates how much units of time it takes for a timed automaton to recognize that string (Alur e Dill, 1990; Alur e Dill, 1994; Alur e Dill, 1995; Alur, 1997). This concept can be formalized by the following definition:

Definition 6 A timed language L = {t_s0s₀,t_s1s₁,...} with {s₀,s₁,...} Î S^* and t_s0,t_s1,... Î _max, can be represented by

where

_maxá á S ñ ñ is a semi-ring of formal series with coefficients in _max and noncommutative variables in S.

Example 6 The language L = {3e, 4a, 2ab, 3ba, 5aa, 2bb, bab} defined over S = {a,b} can be represented by

where (y|e) = 3, (y|a) = 4, ..., (y|bab) = e. The above expression can be simplified to

or

since Ä L = , "L Í S^*.This series represents a language recognized by a (max,+) automaton. The meaning of (y|s) = is that the automaton does not recognizes the string s.

The above definitions allows to state that formal series can be employed to describe the automaton dynamics and to determine its marked language. Then, the language recognized by a (max,+) automaton can be described by its daters as

with s Î _maxá á S ñ ñ .

In general, when there is no ambiguity, the Ä is omitted from the expressions. Thus, from now on the notation ab meaning aÄb will be used to represent this operation between any elements in the dioid algebra.

Definition 7 The map m:S ® , is a map from T_i,s,j, "i,j Î Q, s Î S over , where is a dioid (_max,max,+) defined for square matrices having dimension equal to |Q|×|Q| .

By using this map we can construct a matrix m(s)_ij: = T_i,s,j. From this matrix and by identifying Q as a row vector with all the input arcs and F as column vector with all the output arcs we can write that:

where s = s₁...s_n. Then, we say that the series Ymax á á S ñ ñ is recognizable if exists a (max,+) automaton, represented by the triple (Q,m,F), Q Î , F Î , m:S^*® for finite Q such that

Example 7 For the automaton shown in Figure 4 we have that

Computing (y|s) when s = ab we obtain (y|ab) = Qm(ab)F = Qm(a)m(b)F = 5. On the other hand, Ymax á á S ñ ñ for this automaton is given by

Where Ymax á á S ñ ñ represents all the strings formed by a and b, always starting with a and recognized by the automaton.

In the present paper the basic tool for representing discrete event systems is the incidence matrix as defined in the following.

2.3 (max,+) automata and incidence matrices

Definition 8 Let A_(max,+) a (max,+) automaton. Its incidence matrix represented by A, is defined by

where t_s is the lifetime of s. If there is more one event linking state i to state j then a_i,j = is a regular expression. The initial state is always the state 1 and is represented by the row vector Q(A) = [t_in ... ] , where t_in is the initial delay. The marked states are defined by the column vector F(A) = ^T, where represent the final delays.

Example 8 The (max,+) automaton shown in Figure 4, has the following matrix representation

The incidence matrix can also be constructed by

where m(s_i) is as defined by Definition 2.2. Then, the incidence matrix satisfies all the properties described in the previous section.

Formal languages can be used to construct languages from the timed incidence matrices. The following definition will help the construction of languages.

Definition 9 Let A be an incidence matrix. An element a_i,j = s Î (S_c È S_uc) can be interpreted as a path of length 1 through which the automaton jumps from state i to state j with a lifetime equal to t_s. Then, the matrix

is a path matrix where each element represents one or strings s = s_n...s_n of length n from state i to state j and the total lifetime is t_s = + ... + . The initial and final vectors of Aⁿ are the same of A.

If there is no path from state i to state j then = .

Example 9 The (max,+) automaton shown in Figure 5 can be represented by

The path matrix A² for this automaton is

with Q(A²) = Q(A) and F(A²) = F(A) . The path matrix A³

is also with Q(A³) = Q(A) and F(A³) = F(A) . In these matrices, each element represents a string of length 2 and 3, respectively. The string ab is recognized since

according to Eq. (30).

Based on these operators it is possible to construct the timed language L(A) as specified in the following definition.

Definition 10 Given an incidence matrix A, the language L(A) is defined by

where q₁(A) denotes the first element of the initial state row vector Q(A) and Î Aⁱ.

The following definition determines how to construct the marked language L_m(A) .

Definition 11 Given an incidence matrix A, the language L_m(A) is defined by

where f_j(A) is j-th element of the column vector F(A) and Î Aⁱ.

Example 10 The matrix representation for the automaton shown in Figure 6 is

To determine its language we compute

The elements of these matrices are strings of length 2, 3, and so on. Multiplying these matrices by q₁(A) we found that

Note that e Î L(A) and t_e = 1 that is the initial delay of the automaton. On the other hand, all the strings of length i are found at the first line of the Aⁱ matrices. By multiplying the first line Aⁱ by q₁(A) and f_k(A) we found the marked language of the automaton

That is the same marked language we obtain by using formal series as given by

with L_m(A) = Y

_{max á á S ñ ñ} .

With these definitions, the languages related to the A_(max,+) automaton will be referred as L(A) or L_m(A) to make an explicit reference to its incidence matrix.

The reachability and co-reachability of a (max,+) automaton can be determined from its incidence matrix as defined below.

Definition 12 The j-th row of an incidence matrix A is said reachable if $i, i Î N^*, such that

where P is a column vector, its j-th element is p_j = e and all the other elements are p_k = , k ¹ j, k = 1,...,dim(A) .

The row j is said reachable if, starting from the first row, there is at least one string s ¹ that leads to row j.

Definition 13 The row i of an incidence matrix A is said co-reachable if $k , k Î ^*, such that

where ¡ is a row vector, its i-th element is u_i = e, and all the remaining elements are u_k = ,k ¹ i, k = 1,...,dim(A) .

The row i is said co-reachable if, starting from that row, there is, at least, one string s ¹ that leads to a marked row j.

An incidence matrix is said reachable if all its rows are reachable. An incidence matrix is said co-reachable if all its rows are co-reachable. An incidence matrix is said trim if its both reachable and co-reachable at the same time.

Example 11 The automaton shown in Figure 6 is reachable since

and

This automaton is also co-reachable since

Then the automaton is trim.

The equivalence between timed-automata can be defined in terms of its respective incidence matrices as shown below.

Definition 14 Let A and B denote two timed matrices, such that "a_i,j, a_i,j Î S^*, "b_i,j, b_i,j Î S^*. These matrices are said equivalent, denoted by A º B, if for any two timed strings s_A (A) and s_B (B), such that (y_A|s_A) = (y_B|s_B), there exists a s Î S that is feasible both in A and B, such that (y_A|s_As) = (y_B|s_Bs).

Example 12 The timed matrices A₁ and A₂ are equivalent

and thus exhibit the same timed language

and its respective automata recognize the same marked language

The automata represented by these two matrices are shown in Figure 7.

2.4 Synchronous composition

To define the synchronous composition in terms of the timed incidence matrices it is necessary to introduce the following operator.

Definition 15 Given a dioid D = _maxá áS ñ ñ , the operator defines the intersection between elements as

"a,b Î D, where

"s,s₁,s₂Î S and "t_s,t_s1,t_s2,t¢_s Î _max. For timed incidence matrices the intersection operation is defined by

where a_i,j

b_i,j is as defined above with

From this definition and considering that the elements of Q(·) and F(·) belong to

_max, the operation is equivalent to the Å operation. However, when dealing with the control of a DES this definition must be restricted since the alphabet of events is partitioned as S = S_c È S_uc and only the controllable events S_uc can be delayed by the supervisor.

Definition 16 Consider that the incidence matrix A denotes the desired timed behavior for a given timed DES represented by an incidence matrix B. The elements of the matrices A and B (a_i,j and b_i,j) can be regular expressions like t_s1s₁+...+t_sks_k and t¢_s1s₁+...+t¢_sks_k, respectively. In this case the a_i,j

b_i,j is defined by

The operator as defined previously can be employed in the supervisor synthesis algorithm as it will be shown in the following.

To deal with the possibility of having uncontrollable events with variable lifetimes the synchronous product of timed incidence matrices must be defined as follows:

Definition 17

Given two timed incidence matrices A, dim(A) = m, and B_n×n, dim(B) = n, corresponding, respectively, to the automaton A_(max,+) with an alphabet of events S_A and to the automaton B_(max,+) with an alphabet of events S_B. The timed incidence matrix P , dim(P) = q = mn and an alphabet of events given by S = S_AÈ S_B corresponding to the automaton resulting from the synchronous composition of these two automata is defined as

where k = i_A+m(i_B-1) and l = j_A+m(j_B-1) such that

if S_A = S_B. The marked states of the composite automaton are defined by a column vector F_q×1(P) and its k-th element is given by

with k = i_A+m(i_B-1) . The initial state vector of the composite automaton a row vector defined as

If $ s_AÏ S_A, or $ s_BÏ S_B, such that S_A Ç S_B¹ Ø, then

where

dim(C^¬) = m×n, A^¬B is the matrix with elements of S_A that does not belong to S_A and is a matrix having dimension m×m such that its diagonal contains the elements b_i,j not defined in A while e is put in all the other elements.

The algorithm for constructing the synchronous product P = A||B of two timed incidence matrices is given below:

Algorithm 1 Algorithm for constructing the synchronous product P = A||B

1. j_A ¬ 1;

2. j_B ¬ 1;

3. i_A ¬ 1;

4. i_B ¬ 1;

5. q1 (P) ¬ q1 (A) Å q1 (B);

6. while i_B < n, do

a) if b_iB;jB = , do j_B¬ j_B + 1;

b) if j_B> n, do i_B¬ i_B + 1 and j_B¬ 0;

c) while i_A < m, do:

i. if a_iA;jA = , do j_A¬ j_A + 1;

ii. if j_A > m, do i_A¬ i_A + 1 and j_A¬ 0;

v.k ¬ i_A + m(i_B -1);

vi.l ¬ j_A + m(j_B -1);

vii.pk;l ¬ ai_A;j_A bi_B;j_B;

viii. øk (P) ¬ øi_A (A) øi_A (B);

ix.j_A¬ j_A + 1;

x. if j_A > m, do i_A ¬ i_A + 1 and j_A ¬ 0;

d)j_B¬ j_B + 1;

e) if j_B> n, do i_B¬ i_B + 1 and j_B¬ 0;

7. if $s_A ÏS₂ or $s_B ÏS₁, makeC^¬, and do pk;l ¬ pk;lÅ.

Remark 1 This algorithm is very similar to the algorithm employed for the synchronous composition of un-timed automata. The computational complexity of this algorithm has the order of O(nm) .

Example 13 Given

representing the automata shown in Figures 8(a) and 8(b), respectively, the synchronous product matrix P can be determined. The elements of such matrix defined by p_k,l = p_{(iA,iB),(jA,jB)}, k = i_A+m(i_B-1) and l = j_A+m(j_B-1) when a_iA,jA = b_iB,jB¹ , are given by

• k = 1+2×0 = 1,

  l = 2+2×1 = 4,

  p

  _1,4 =

  p

  _(1,1),(2,2) =

  a

  _1,2

  

  b

  _1,2 = 2a

• k = 2+2×1 = 4,

  l = 1+2×0 = 1,

  p

  _4,1 =

  p

  _(2,2),(1,1) =

  a

  _2,1

  

  b

  _2,1 = 3b

• k = 2+2×2 = 6,

  l = 1+2×1 = 3,

  p

  _6,3 =

  p

  _(2,3),(1,2) =

  a

  _2,1

  

  b

  _3,2 = 4b

Considering that l,h Î B, but l,h Ï A, it is required to build the matrix C^¬ given by

and thus

where Q(P) and F(P) are given by (73). Finally, matrix P together with Q(P) and F(P) represent the automaton A_(max,+)3 shown in Figure 8(c).

It must be noted that all the elements of row 2 are such that p_2,j = and it can be reached after the string s = Q(P) ÄP³Äp = p_1,4p_4,6p_6,2 = 9ahl, for

This shows that from the composition of A_(max,+)1 with A_(max,+)2 may result an automaton with a blocking state.

Remark 2 The definition 17 establishes that the composition of two automaton when S_AÇS_B = Ø requires the determination of the matrix C^¬. It is worth noting that such composition is based on the operator (see Definition 15). However, when the alphabet of events S is partitioned into controllable S_c and uncontrollable events S_uc, the intersection operator must be redefined according to Definition 16.

3 TIME-VARYING AUTOMATON

Based on the formalism outlined the previous sections we introduce here an extended version of the (max,+) automaton named time-varying automaton (TVA).

Definition 18 A time-varying automaton TVA over an alphabet S is a quintuple given by

where:

• Q = {

  q

  ₀,...,

  q_n} is a finite set of states;

• S = {s

  ₁,...,s

  _m} is an alphabet of events;

• q

  ₀ is the initial state;

• t

  ₀:

  q

  ₀®

  R

  _max is the initial delay;

• t

  _i:

  t

  _i-1×

  Q×S×

  Q®

  R

  _max is the transition function and

• t_f:

  t_i

  _-1×

  Q®

  R

  _max is the final delay function.

The graphical representation of an TVA is a graph constituted by vertices representing Q and three types of arcs:

1. Internal arcs q_j

q_j+1, "q_j,q_j+1Î Q, s Î S such that t_i ¹. The q_j q_j+1 is valued by t_i = f(t_i-1);

2. Input arc ® q₀ valued by t₀¹ ;

3. Output arcs q_j ® valued by t_f, "q_f Î Q such that t_f = f(t_j-1) ¹.

Note that the (max,+) automaton is simply a special case of the TVA automaton when all the transition functions are considered to be constants. Then, consequently, the dynamics of the TVA is quite similar to the dynamics of the (max,+) automaton.

1. There is a global clock that is continuously being incremented;

2. Given that the automaton reached state i-1, then it will jump to state i after the occurrence of s, however the event s will be enabled to occur only after t_i units of time. In a TVA t_i is not constant as in a (max,+) automaton but depends on t_i-1, i.e., t_i = f(t_i-1).

3. The initial state q₀Î Q will be reached only after t₀ units of time with respect to the global clock time origin;

4. When the automaton reaches a given state i the counters associated to events t_i(s) all start decrementing simultaneously. When a given counter reaches zero it stops decrementing and the respective event becomes enabled and may occur from now on;

5. When a given event occurs all the running counter are stopped and the state of the automaton changes;

6. If at a given state i there are two arcs leaving that state and the labels are equal but valued with different transition times then the TVA is said non-deterministic.

Example 14 Let S = {a,b} , Q = {1,2,3}, t₀ = 2, the following transition functions

and the final delay function

The other transition functions are equal to . The corresponding automaton is shown in the Figure 9. The t in the above expressions is measured in units of time (of a given time base) must be interpreted as the last lifetime, i.e., t_i-1 as explained previously. The value of the lifetime for a related with the arc q₁

q₂

is since t₀ = 2. The final delay for recognizing e (if a does not occur) is

and consequently the total time it takes for recognizing e is 6 units of time. However, if a occurs the automaton jump to state 2 where the lifetime for a is

and the lifetime for b is

If at state 2, a occurs the automaton jumps to state 3 where the lifetime for b is

If at state 2, b occurs the automaton jumps to state 1 where the lifetime for a is

the final delay for recognizing ab is

and consequently the total time it takes for recognizing ab is 13.6 units of time.

It is worth noting that the recognition of a given string occurs when a marked state is reached and the final delay has passed. This string recognition process can also be described by the daters of the strings as presented in the following:

Definition 19 A dater is a map given by

where Y is the time it takes for the string

to be processed within a TVA.

The dater defines the lifetimes related to the strings of S^*. Consequently, a TVA takes Y units of time to change its state from q to q¢ by processing s, where (y|s) denotes the value of Y for the string s.

Definition 20 A dater is said recognized if there exists a TVA such that

Example 15 For the automaton of the Example 14, we can see that s = ab is a recognized string since

3.1 TVA and formal series

The use of formal series to define the dynamics of a TVA is quite similar what has been done for the (max,+) automaton. Thus, it follows that:

Definition 21 A timed language

with s,s¢,... Î S^* and t_s,t_s¢,... Î _max, can be represented by a formal series

where

denotes the semi-ring of the formal series having coefficients in

_max and non commutative variables in S.

Example 16 The language L = {3e,4a,2ab,3ba} over S = {a,b} can also be represented by

since Ä L = , "L ÍS^*. This series represents the language recognized by a TVA. The term (y|s) denotes the coefficient of the string s that is equal to 'e' if s is not recognized by the TVA.

According to this formalism, a dater function Y can be described by using a formal series defined over S with coefficients defined in _max, as presented in the following:

Definition 22 A timed language of a TVA is defined by a formal series

where (y|s) Î _max denotes the dater of the string s Î S^*.

Example 17 For the automaton of the Example 14, the formal series Ymax á á S ñ ñ related to the recognized timed language is given by

3.2 TVA and incidence matrices

The definition of an incidence matrix for a TVA follows similar rules as it was done for the (max,+) automaton. However, instead of fixed lifetimes, the elements of the incidence matrix will be related with the transition functions as shown in the following:

Definition 23 Given a TVA, its incidence matrix, denoted by A, is defined as

where f(t_s) represents the lifetime of event s. The automaton jumps from state i to state j upon the occurrence of s. If more than one string may provoke the jump from state i to state j then the respective element of the matrix must be written as a timed regular expression like a_i,j = Å_kf(t_sk) s^k. For mathematical convenience, the state 1 is always considered as the initial state and can be represented by the row vector Q(A) = [t₀ ... ], the marked states are also represented by the column vector F(A) = [f(t_f1) f(t_f2) ... f(t_fn) ]^T.

Example 18 The TVA shown in Figure 9 has the following matrix representation

The t in the above matrices and vectors is measured in units of time (of a given time base) and must be referred to the last transition time.

All the matrix formalisms already presented for the (max,+) are also valid for the time-varying automaton. However, when defining languages by using path matrices we must consider that the lifetimes change at every automaton execution as illustrated by the following example:

Example 19 The matrix representation for the TVA shown in Figure 10 is given by

The path matrix A² for this automaton is given by

where Q(A²) = Q(A) and F(A²) = F(A) . Note that some elements of A² contain different lifetimes since every t_i is calculated separately.

For the proposed TVA formulation the language definitions given in 10 and 11, the definitions for reachability, co-reachability as well as the automata composition operator defined previously for the (max,+) automaton are also valid.

4 SUPERVISOR SYNTHESIS

The so called SupC(L) algorithm (Ramadge e Wonham, 1987a) provides a procedure for synthesizing a supervisor for a DES. The synthesis of a timed (fixed lifetime) supervisor based on this algorithm has already been proposed (Ramadge e Wonham, 1994). The supervisor synthesis as proposed in the present article is also based on the SupC(L) algorithm but allows one to consider variable event lifetime. The following definitions are required in order to state the proposed synthesis procedure:

Definition 24 Given an alphabet of events S, partitioned into S = S_cÈ S_uc, and an timed incidence matrix A, we can define its uncontrollable timed incidence matrix A_uc by

where f(t_suc) represents the lifetime of s_uc. The automaton jumps from state i to state j upon the occurrence of s_uc. If more than one string may provoke the change from state i to state j then the respective element of the matrix must be written as a time regular expression like (a_uc)_i,j = Å_lf(t_sl)s^l. The initial state and the marked state vectors are given by Q(A_uc) = Q(A) and F(A_uc) = F(A).

The desired behavior for the closed-loop DES, usually denoted by specification, is an essential input information for any supervisor synthesis procedure.

Definition 25 The specification for a TVA is denoted by a matrix E defined by

where f(t_s) represents the lifetime of s. The automaton jumps from state i to state j upon the occurrence of s. If more than one string may provoke the change from state i to state j then the respective element of the matrix must be written as a time regular expression like e_i,j = Å_lf(t_sl)s^l. For mathematical convenience, the state 1 is always considered as the initial state and can be represented by the row vector Q(E) = [t₀ ... ], the marked states are also represented by the following column vector F(E) = [ f(t_f1) f(t_f2) ... f(t_fn) ]^T. If the state k is not a marked state, then f(t_fk) = .

Definition 26 A supervisor synthesized for a given specification E is also defined as a matrix

where st_i,j = for a_i,j ¹ , indicates that either it is possible to prevent the occurrence the event enabled at a_i,j, a_i,j Î S_c or that the state j (row j) its not reachable. If more than one string is allowed at a_i,j then st_i,j = Å_lf(t_sl)s^l. For mathematical convenience, the state 1 is always considered as the initial state and can be represented by the row vector Q(S) = [t₀ ... ] the marked states are also represented by the column vector F (S) = [ f(t_f1) f(t_f2) ... f(t_fn) ]^T. If the state k is not a marked state, then f(t_fk) =

The control action of the timed supervisor is executed as follows: the supervisor observes the events and its respective lifetimes and determines the control input for the DES by delaying the occurrence of the controllable events as illustrated in Figure 11.

The set of control inputs for the timed supervisor is defined by:

Definition 27 The set of control inputs for a timed supervisor is defined by

where

with

The meaning of f(t¢_sk) > f(t_sk) is that s_k will inhibited by t = f(t¢_sk)-f(t_sk) units of time, i.e., the lifetime is increased.

According to the definition 27, the control input provided by the timed supervisor is g = f(t¢_s)s that defines what are the enabled events in a given state as well as its respective lifetimes (f(t¢_s) > f(t_s)). In other words, the supervisor may inhibit a given event at a given state by f(t¢_s)-f(t_s) units of time or block completely its occurrence if f(t¢_s) = . The dynamics of the supervised time system can be studied either by constructing the recognized language through formal series or by using the synchronous composition of S||A as obtained according to Definition 11.

In order to make a formal binding of the proposed approach with the standard supervisory control theory it is important to consider the following remarks:

1. A sub-automaton has a similar structure but contains a sub-set of the states or a sub-set of the arcs of a given automaton. The lifetimes associated to the arcs of the sub-automaton must be greater than or equal to the respective lifetimes of a given automaton;

2. A timed sub-language presents a sub-set of the strings of a given timed language. The lifetimes associated to the strings of the sub-language must be greater than or equal to the respective lifetimes of the strings of the language. Given that L¢ Ì L this does not necessarily imply that the automaton built for recognizing L¢ is a sub-automaton of the automaton built for recognizing L;

3. A sub-matrix is formed by the first m rows and first m columns of a given incidence matrix. The sub-matrix has an elementwise relationship with the matrix but considering that the lifetimes of its elements are greater or equal to the respective lifetimes of the elements of the matrix.

In order to synthesize the timed supervisor as proposed in the present paper it is required that the incidence matrix representing the specification be a sub-matrix of the incidence matrix representing the DES; i.e., E must be a sub-matrix of A. If this is not the case we must transform A into A^# and build E^# to be a sub-matrix of A^# such that

By doing this, whenever E is a sub-matrix of A, or due to the suggested transformation E^# is a sub-matrix of A^#, the following order relationship

is always satisfied.

The transformation to be applied when E is not a sub-matrix of A, is described in the following procedure:

1. Build a synchronous composition of A with a matrix E^* that generates S^* to create A^# such that

The matrix E^* is derived from E by adding to it a forbidden state (rom i_e/column j_e), named error state. Then the matrix A^# is obtained by

2. The matrix E^# is obtained from A^# by making all the elements of the form (i_A,i_e) = and (j_A,j_e) = . By doing this, the matrix E^# is such that

with

and such that E^# is a sub-matrix of A^#;

3. The lifetimes for E are used to determine the lifetimes for E^# (that are equal to the lifetimes of A) by computing t_s Å t¢_s, where t_s is the lifetime of s Ì e_i,j and t¢_s is the lifetime of , for k representing the pair (i_A,i_E) for i_E = i and l representing the pair (j_A,j_E) for j_E = j;

4. The vector Q(E^#) is obtained from Q(E) by

5. The vector F(E^#) is also determined from F(E) by

where k represents the pair (i_A,i_E) with i = i_E and f_i(E) ¹ .

Following these steps, E^# will be a sub-matrix of A^# and consequently

Remark 3 The lifetimes for E^* must be t_s = e such that L(A) = L(A||E^*).

The transformation of E into E^* and the transformation of E into E^#, respectively can be achieved with following algorithms:

Algorithm 2 Algorithm for transforming E into E^*

1. "i, do f_i(E) ¬ e, and

do

2. for each row i of E, include the self-loops e_i,i = S-{s¹,s²,...,sⁿ}, such that s^kË e_i,j,k = 1,2,...,dim(E) ;

3. make dim(E) ¬ dim(E) +1, where (i,dim(E) ) and (dim(E) ,j) are the elements of the error row/column (i_e/j_e);

4. q_dim(E) (E)¬ ;

5. f_dim(E) (E)¬ e;

6. for i = 0 until i < i_e, do:

a) for j = 0 until j < j_e, do:

i. for k = 0 until k < j_e, do:

I) if s Ì e_j,iÚ s Ì e_j,j and e_i,k ¹ s do e_i,je¬ s;

ii. if e_i,j ¹ s¢ do e_i,je¬s¢;

7. e_ie,je¬ S.

Algorithm 3 Algorithm for transforming E into E^#

1. Transform E in E^*;

2. Construct A^# = A||E^*;

3. for i = 1 until n×m do:

i. for j = 1 until n×m, do:

a) if ¹, do ¬ .

4. for k = 1 until n×m:

a) if f_k(A^#) ¹ , do

and

5. do q₁(E^#) ¬ q₁(E^#) q₁(E) .

In this algorithm mod is the operator that determines the remainder of the division k/m. The step 4 of this algorithm define the final delays and step 5 defines the initial delay in order to make sure that L(E^#) = L(E) and L_m(E^#) = L_m(E) .

The use of these algorithms will be illustrated by an example where the transition functions of the TVA are constants, like in a (max,+) automaton.

Example 20 Consider the matrix

and the desired specification

where S_uc = {b₁, b₂} . To build E^# such that L(E^#) Ì L(A^#) = L(A) we first create E^* that generates S^*. In this case

where the error row/column is the third one. Now computing A||E^* we obtain

and then we get E^# as given by

Note that only f₁(E^#) ¹ since f₁(E^#) = f₁(A) f₁(E) .

In order to synthesize the timed supervisor S it is required to introduce the following operators:

Definition 28 The ACES operator is defined as

The operation ACES(A) eliminates all the elements a_i,j of a non-reachable i row. For a given matrix F, the ACES operator can be implemented by the following algorithm:

Algorithm 4ACES Operator

1. Create a vector vac_1×N of reachable states.

2. for i = 1 until N, do:

a) for j = 1 until N, do:

i. if F(1,j) ¹ , do vac(j) ¬ 1.

ii. if i > 1 and F(i,j) ¹ and vac(i) = 1, then do vac(j) ¬ 1.

3. for i = N-1 until 1, do:

b) for j = 1 until N, do:

i. if F(i,j) ¹ and vac(i) = 1, then do vac(j) ¬ 1.

4. for i = 1 until N, do:

a) for j = 1 until N, do:

i. if vac(i) = 0, do F(i,j) ¬ .

Definition 29 The COACES operator is defined as

The COACES(A) operation eliminates the elements that lead to non-reachable rows. For a given matrix F, the COACES operator can be implemented by the following algorithm:

Algorithm 5COACES Operator

1. Create a vector vco_N×1 of coreachable states.

2. for i = 1 until N, do:

a) for j = 1 until N, do:

i. if F(1,j) ¹ and f_j(F) = e, do vco(i)¬ 1.

ii. if i > 1 and F(i,j) ¹ and (f_j(F) = e or vco(j) = 1), then do vco(i)¬ 1.

3. for j = 1 until N, do:

b) for i = N-1 until 1, do:

i. if F(i,j) ¹ and (f_j(F) = e or vco(j) = 1), then do vco(i)¬ 1.

4. For j = 1 until N, do:

a) for i = 1 until N, do:

i. if vco(j) = 0, do F(i,j) ¬ .

Definition 30 The operator TRIM is defined by

The use of the TRIM operator for a given incidence A yields an incidence matrix B that is both reachable and co-reachable.

The last but not least operator to be introduced allows to compare two matrices to determine if the language generated by one is contained in the language generated by the other.

Definition 31 Given two timed incidence matrices A = [a_i,j] and B = [b_i,j] , the operator is defined by

Similarly, the operators , and can be defined by

Based on definition 31, and considering a generic element s = f(t_s1) s¹+...+f(t_sn) sⁿ, the determination of A B can be achieved through the following algorithm:

Algorithm 6 Algorithm for determining A B

1. for i = 1 until N, do:elemento a_i,j faça:

i. for j = 1 until N, do:

a) if s ÏB and a_i,j = s, then A

B;

b) if (a_i,j = +...+,> t_si) Ú (a_i,j = ) , where sⁱ,...,s^kÌ s and b_i,j = t_s s, then A

B;

2. if q₁(A) > q₁(B) , then A

B.

3. for i = 1 until N, do:

i. if (f_i(A) > f_i(B)) or (f_i(A) = Ù f_i (B) ¹ ) or (f_i(A) = Ù "f_i(B) = ), then A

B.

The condition A B implies the execution time of every sequence in A (string of events with its respective lifetimes) must be greater than or equal to the execution time of the same sequence in B. In other words, given two timed languages L(A) and L(B) this condition also implies that L(A) Í L(B) , i.e., the execution time of a given timed language is always less than or equal to the execution time of any sub-language of that language (Alur e Dill, 1990; Alur e Dill, 1994; Alur, 1997). Equivalently,

where the lifetime of every event satisfies

Example 21 The automaton shown in Figure 12(a) has the following matrix representation

and the automaton shown in Figure 12(b) has the following matrix representation

Executing the Algorithm 6 we determine that A₁

A₂.

Besides the use of these operators, the proposed supervisor synthesis procedure requires that the desired specification E must be valid and controllable.

Definition 32 A specification E for a given DES A is said valid if E ¹ [] and

where [] is the null matrix that all its elements equal to and if "i,j, s Ì e_i,j, s Î S.

The controllability condition is applied for valid a specification as

Definition 33 A specification E for a given DES A is said controllable if

and

The last condition can be employed to determine the existence of supervisor for a given DES.

Lemma 1 Given A (system) and E (specification) a supervisor S is defined if and only if

If the specification E satisfies the controllability condition then the supervisor S is determined by taking its trim component.

Corollary 2 Given A (system) and E (specification) the supervisor S is given by

if and only if

Example 22 The automaton shown in Figure 13(a) has the following matrix representation

where S = {a,b,k,m}, S_uc = {k} and S_c = {a,b,m}. Considering that the specification given by

corresponding to the automaton shown in Figure 14(b), we have

where q₁(E) > q₁(A) (q₂ and q₃ are equal), f₁(E) = 5t, f₃(E) = 2 provided that E is controllable. Since E is also trim, the supervisor is given by S = TRIM(E) = E.

For a given specification when ACES(EÅA_uc) E, it is required to determine the supremal controllable sub-language in order to synthesize the supervisor. This case will be discussed in the following:

Definition 34 For a given E we can form the matrix

that is denoted the path matrix of order n. In this matrix the first element of every string is an element of E and all the others belong to A_uc. The marked states vector is defined by

and the initial state vector by

In a path matrix a given event s_uc belonging to (a_uc) _i,j always appears as the last event in the elements of ()_k,j. These terms of are preceded by ()_k,i. Considering this we have that:

Theorem 3 If for a valid E and a given A _uc

then the supremal controllable sublanguage supC(L) will be determined recursively by:

1. For n = 1, S¹ = E.

2. For n = n+1 while (n < N) Ù$s_ucÏ E do

The term is n-th event of a string of an element of that can be s_ucÏ E.

3. If (n > N) Ù($s_ucÏ E in Sⁿ) then S = [] .

5 SYNTHESIS ALGORITHM

Based on the previous formalism we can state the algorithm to synthesize the supervisor:

Algorithm 7 Supervisor synthesis algorithm

1. if E A, construct A^# and E^# starting of A and E, and do E¬ E^# and A¬ A^#.

2. do D¬ ACES(EÅA_uc) .

3. if D = E, do S¬ TRIM(E) and stop.

4. if D

E, do n¬ 1:

a) for k = 1 until M (M is the number of distinct elements between A_uc and E_uc), do:

i. Sⁿ¬ E, xdif(k,n-1)¬ i and ydif(k,n-1)¬ j (where A_uc¹ E_uc);

b) compute ;

c) for k = 1 until M, do:

i. search the elements in

where ÏE ( being the last element of the sequence).

(1) if Ï E and s¹Î S _c, do

and compute

(2) if Ï E and s¹Î S_uc, do

and

d) for k = 1 until M, do:

i. if

"k, stop.

ii. else, do:

(1)n ¬ n + 1;

(2) if n < N then return to step 4.b.

(3) else stop (E is not feasible).

6 ILLUSTRATIVE EXAMPLES

In this section we presented selected examples to illustrate the supervisor synthesis procedure as proposed in the present paper. The examples will focus the supervisor synthesis for un-timed automata, (max,+) automata and for TVA automata.

Example 23 Consider that for the TVA shown in Figure 13 the specification is given by

The automaton for this specification is shown in Figure 15(a). The controllability test shows that

ACES(E Å A_uc) E.

and then the synthesis procedure employing the path matrix must be employed. The first step is

S¹ = E.

Next we compute

from where we can identify the terms

()_1,3 = mk

and

()_2,3 = mk,

that contain a controllable m event followed by an uncontrollable k event that does not belong to E. Since m is controllable, we can set

to avoid this sequence and, as a result the state 3 becomes unreachable, i.e.,

The the supervisor can determined by taking the trim component of S² as given by

and is shown in Figure 15(b).

Exemplo 24 Consider the Example 20 that is an extension of classical problem of a system consisting of machines and buffer. Consider that S = {a₁,a₂,b₁,b₂} , S_uc = {b₁,b₂} and the extended specification E^# shown in Figure 16. The controllability teste shows that

ACES(E^#Å A^#) E.

Note that and does not belong to E^# and must not occur. Then, the synthesis procedure employing the path matrix must be employed. The first steps are to make S¹ = E^#, Q(S¹) = Q(E^#), F(S¹) = F(E^#) and compute = E^#Ä . Observing we identify ()_5,9 = 4a₁b₁, ()_7,11 = 4a₁b₁ and ()_8,9 = 6b₂b₁ that are terms resulting from Ä ()_6,9, Ä ()_8,11 and Ä ()_6,9, respectively. The inhibition of the controllable events that precedes b₁ in and make row 8 unreachable and consequently we does not need to examine the term ()_8,9. In this case S² is given by

By making S² = COACES(S²) followed by S² = ACES(S²) we eliminate the not co-reachable and not reachable states, respectively. The results is

which is the supervisor shown in Figure 17. This supervisor makes sure that the events will be enabled after a certain delay such that the timed language of the supervised system will satisfy

Example 25 Consider the automaton shown in Figure 18 where S = {a,b,k,h,l,m} and S_uc = {a,l} . The incidence matrices A and A_uc are

and

For each marked state there is an output arc valued with f_qm = e; the initial state is an input arc valued with q_q = e and for all the remaining arcs its transition functions are f_s(t) = e. The specification is given by

and corresponds to the automaton shown in Figure 19. It is ease to see that E is valid and E

A, however the controllability test fails since

ACES(EÅA_uc) E.

The term (a_uc) _5,4 = l does not belong to E. Then, the synthesis procedure based on the path matrix must be employed, i.e., make S¹ = E and compute = E Ä A_uc

with Q() = Q(A) = Q(E) , F() = F(A) = F(E) , to determine what events must be disabled to generate the language restricted by the supervisor. In this case we are interested in disabling the event that has made the controllability test to fail. Observing we see that ()_4,4 has the sequence bl, that leads the automaton, through the controllable event b, from state 4 to state 5, and then back to state 4 through the uncontrollable event l that does belong to E. Since b is controllable we can set = to avoid that sequence and the completing S². By making S² = COACES(S²) we eliminate the non co-reachable states to obtain

or

Now computing S² = ACES(S²) we eliminate all unreachable states and obtain the supervisor

as it is shown in Figure 20. Note that the final supervisor was presented with dimension 2, indeed it has same dimension 7, the same of S². However, all the elements of rows and columns from k = 3,...,7 are all equal to e. This examples shows that the un-timed synthesis is a special case of the general time-varying supervisory control problem.

7 CONCLUSIONS

We have provided the framework for studying time-varying DES problems. The proposed time-varying automaton allows to model systems where the event lifetime varies during its execution. Such type of timed discrete event systems cannot be modelled by (max,+) automata. The paper has also provided a synthesis procedure that is based on the standard algorithm of supervisory control theory. However, the use of a non-traditional algebraic structure (dioid) and the representation of system and its specification in matrix format were introduced. This fact has allowed to achieve, with the proposed formalism, the synthesis of both un-timed supervisor, fixed lifetimes supervisor and time-varying lifetimes supervisors with the same basic algorithm.

For the general case the order of complexity of the proposed supervisor synthesis algorithm is O(N⁴) where N is the dimension of the incidence matrix. However, if the specification incidence matrix is a sub-matrix of the system incidence matrix the order of complexity is reduced to O(N²). When the event lifetimes of the system model are fixed the complexity of the proposed algorithm is the same as that of the Ramadge and Wonham approach.

The proposed framework allows to deal with more general issues in the design of supervisory control problems as illustrated by the selected examples presented in the paper. Indeed, by the same basic synthesis procedure we can design finite state supervisors for un-timed DES, fixed lifetime DES, time-varying DES that can be either cyclic or acyclic. Thus, the proposed approach provides an extension of timed automata for representing more general classes of real-time problems like communication protocols.

Artigo submetido em 24/04/2002

1a Revisão em 31/07/2002; 2a. Revisão em 20/11/2003

3a. Revisão em 6/04/2004

• Alur, R. (1997). Timed automata, Proc. NATO-ASI Summer School, Antalaya, Turkey .
• Alur, R. e Dill, D. (1990). Automata for modeling real-time systems, Proc. 17th International Colloquim on Automata, Languages and Programming, Lectures Notes on Computer Science, New York: Springer Verlag 443: 322335.
• Alur, R. e Dill, D. (1994). A theory of timed automata, Theoretical Computer Science 126(2): 183235.
• Alur, R. e Dill, D. (1995). Automata-theoretic veri cation of realtime systems, Technical report, Computing Science Research (Bell Labs) and Computer Science Department (Stanford University).
• Alur, R. e Henzinger, T. (1992). Back to the future: Towards a theory of timed regular languages, Proceedings of the 33rd Annual Symposium on Foundations of Computer Science, pp. 177186.
• Asarin, E. (1998). Equations on Timed languages, Hybrid Systems: Computation and Control, Springer-Verlag.
• Berstel, J. e Reutenauer, C. (1988). Rational Series and their Languages, Springer.
• Brandin, B. e Wonham, W. (1994). Supervisory control of timed discrete-event systems, IEEE Transactions on Automatic Control 39(2): 329342.
• Cofer, D. e Garg, V. (1996). Supervisory control of real time discrete-event systems using lattice theory, IEEE Transactions on Automatic Control 41(2): 199209.
• Fribourg, L. (1998). A Closed-Form Evaluation for Extended Timed Automata, Research Report LSV-98-2, Laboratoire Speci cátion et Vérication, Ecole Normale Supérieure de Cachan, France.
• Klimann, I. (1999). Langages, Séries et Contrôle de Trajectoires, PhD thesis, l'Université Denis Diderot - Paris 7.
• Lawford, M. (1997). Model Reduction of Discrete Real-Time Systems, PhD thesis, University of Toronto.
• Ostroff, J. e Wonham, W. (1990). A framework for real-time discrete event control, IEEE Transactions on Automatic Control 35 (4): 386397.
• Ramadge, P. e Wonham, W. (1982). Supervision of discrete event processes, Procedings of 21st Conference on Decision and Control pp. 12281229.
• Ramadge, P. e Wonham, W. (1987a). On the supremal controllable sublanguage of a given language, SIAM Journal of Control and Optimization 25(3): 637659.
• Ramadge, P. e Wonham, W. (1987b). Supervisory control of a class of discrete event processes, SIAM Journal of Control and Optimization 25(1): 206230.
• Saksena, M. e Selic, B. (1999). Real-time software design -state of the art and future challenges, IEEE Canadian Review 2 (32): 58.
• Tripakis, S. (1998). L'Analyse Formelle Des Systémes Temporisés En Pratique, PhD thesis, L'Université Joseph Fourier.

Publication Dates

• Publication in this collection
  11 Feb 2005
• Date of issue
  Dec 2004

History

• Accepted
  06 Apr 2004
• Reviewed
  31 July 2002
• Received
  24 Apr 2002