ware, su - 2015 - progressive time optimal control of reactive systems

8/17/2019 Ware, Su - 2015 - Progressive Time Optimal Control of Reactive Systems

1/6

Progressive Time Optimal Control of Reactive Systems

Simon Ware and Rong Su;

Abstract— In many practical applications, we need to com-pute a nonblocking supervisor that not only complies with pre-specified safety requirements but also achieves a certain timeoptimal performance such as maximum throughput. Previoustime optimal synthesis methods have had the significant draw-back of only being able to deal with acyclic behavior. In thispaper we propose a time optimal synthesis method which candeal with potentially infinite behavior. This is accomplishedby dividing a system into progressive behaviors with whichthe system must be capable of finishing it task within a finiteamount of time, and nonprogressive behaviors which can leadto the system having more tasks to complete, and potentiallyinfinite behavior. We also proposed an algorithm with pseudopolynomial time complexity for computing such a supervisor.

I. INTRODUCTION

Since the Ramadge-Wonham supervisory control paradigm

[1], [2] was invented, a large volume of research has

been done on how to synthesize a nonblocking supervisor

that complies with safety and liveness requirements. But

in practical applications we are also frequently asked to

achieve a certain optimal performance, in particular, the time

optimal performance such as throughput [3]. In this paper

we discuss progressive time optimal supervisory control.

The system under our consideration consists of a finite-

state automaton, whose events are associated with weights,

representing their firing durations, and a set of resources

which are used by certain events. Since events have du-rations, events which make use of different resources may

overlap. By initiating event firings at appropriate moments

in different components, a supervisor may drive the system

from the initial state to a desirable state within the minimum

duration which takes into account the possible elongation

caused by the firings of uncontrollable events. Previous work

on time optimal supervisory control necessarily resulted in

acyclic supervisors. Many systems however, can be given an

arbitrary number of tasks for completion, potentially being

given new tasks before it has finished all of its current

ones. In order to achieve time optimal control for such a

system we divide system behaviour into either progressive

behaviour and non progressive behaviour where progressivebehaviour represents behaviour used by the system to achieve

its assigned tasks, and non progressive behaviour represents

behaviour which is used to give the system either additional

tasks to carry out or to change the tasks which it currently

needs to do. The task of time optimal supervisory control

then becomes to ensure that the system will always complete

its assigned tasks in minimal time assuming that only pro-

gressive behaviour is used, while allowing non progressive

behaviour to occur except in instances where to do so would

cause either controllabity or blocking issues.

To solve the aforementioned control problem, we maketwo contributions in this paper. First, we introduce the

concept of a progressive time optimal controllable sublan-

guage and provide a precise formulation of the supremal

progressive time optimal nonblocking supervisory control

problem. Finally, we present an algorithm that computes the

supremal progressive time optimal controllable sublanguage.

The algorithm utilized determines the execution time of each

string based upon the method developed in [4]. For our

approach we first assume that the system we are seeking a

time optimal supervisor for is already the result of a standard

nonblocking supervisory control problem, which results in a

supermal controllable sublanguage satisfying the prescribed

requirement.

The use of progressive events in supervisory control is

discussed in [5], [6].

A similar setting to timed discrete-event systems has been

discussed in the literature about performance evaluation. For

example, in [3], [7], [8], [9], time information is described

by durations of events, and in [7], [9] the theory of heaps-of-

pieces is used to analyze execution time of specific sched-

ules. In comparison with our work, the above mentioned

references are about analysis and not about synthesis. More

explicitly, these references do not tell how to modify a

systems behavior by using control in order to achieve certainperformance. In our case, we need to find a supervisor

that can achieve time optimal performance by simply using

appropriate event disabling. Furthermore, in their settings no

uncontrollable events are considered.

[10] also allows time optimal control with a cyclic super-

visor. It requires that all cyclic behaviour must go through

a marked state however. Thus in [10] new tasks must be

assigned after the system has completed all of its current

tasks, whereas for progressive time optimal control new tasks

can be given while the system is still in the process of

completing its current task.

This paper is divided into six sections. In sect. II we firstprovide all relevant necessary concepts about languages and

time-weighted automata. Sect. III introduces the concept of

a progressive finite makespan language, as well as defining

progressive time optimal control for time weighted systems.

Sect. IV describes how to synthesize a progressive finite

makespan closed language which is used in the synthesis

of progressive time optimal supervisors. Sect. V describes

how to synthesize a progressive time optimal supervisor for

a time weighted system. Sect. VI goes through an example

of the use of progressive time optimal control.

2015 IEEE 54th Annual Conference on Decision and Control (CDC)December 15-18, 2015. Osaka, Japan

978-1-4799-7886-1/15/$31.00 ©2015 IEEE 3542


2/6

I I . PRELIMINARIES

A. Events, Strings and Languages

Event sequences and languages are a simple means to

describe discrete system behaviours. Their basic building

blocks are events, which are taken from a finite alphabet Σ .The alphabet Σ is simultaneously divided into a set of controllable/uncontrollable events such that Σc ∪ Σuc =

Σ, as well as progressive/non progressive events such thatΣ p ∪ Σnp = Σ.Σ∗ denotes the set of all finite strings of events from Σ,

including the empty string ε. A set of traces L ⊆ Σ∗ iscalled a language. The concatenation of two strings s, t ∈ Σ∗

is written as st. The prefix closure of a language L isL = {s ∈ Σ∗| There exists a trace t ∈ Σ∗ such thatst ∈ L}. A language K ⊆ Σ∗ is controllable with respectto a language L ⊆ Σ∗ if K Σuc ∩ L ⊆ K [1]. The set of controllable languages of a language L ⊆ Σ∗, written C (L)is equal to {K ⊆ L|K is controllable with respect to L}. Alanguage L ⊆ Σ∗ is Σ p-nonblocking if for every trace s ∈ Lthere exists a trace t ∈ Σ∗ p such that st ∈ L [5], [6]i.e. for

every partial trace in L it is possible to complete that traceusing only progressive events.

B. Finite State Automata

System behaviours are modeled using finite state au-

tomata.

Definition 1: A finite-state automaton is a 5-tuple G =(X, Σ, δ , x0, X m) where Σ is a finite alphabet of events, X is a finite set of states, δ : X ×Σ → X is the state transitionrelation, x0 ∈ X is the initial state, and X m is the set of marked states.

The transition relation is extended to strings in Σ∗ by let-ting δ (x, ǫ) = x for all x ∈ X , and δ (x,sσ) = δ (δ (x, σ), s).

For a state x ∈ X , the set of active or eligible events isdefined as E (x) = { σ ∈ Σ | δ (x, σ)!}. Further the con-tinuation language of x is defined as L(x) = {δ (x, s)!|s ∈Σ∗} whereas the marked language is defined as Lm(x) ={δ (x, s) ∈ X m|s ∈ Σ

∗}. The continuation and markedlanguages of the automaton G is L(G) = L(x0) andLm(G) = Lm(x0) respectively.

The restriction of an automaton G with respect to aset of states X ′ ⊆ X is written G|X′ where G|X′ ={X ′, Σ, δ |X′ , x0, X m∩ X

′} such that for all (x, σ) ∈ X × Σit holds that δ |X′(x, σ) = δ (x, σ) if and only if x ∈ X

′ and

δ (x, σ) ∈ X ′.

C. Timed Automata

Let N the set of natural numbers. A finite-state time-

weighted automaton is a 3-tuple (G,f,R), where G =(X, Σ, δ , x0, X m) is a finite-state automaton with X beingthe state set, Σ the alphabet, x0 the initial state, X m ⊆ X themarker state set, and δ : X × Σ → X the (partial) transitionfunction, which is extended to X × Σ∗. The total functionf : X ×Σ → N∪{+∞} is called the weight function, whichassigns to each transition of G a finite natural number, and+∞ to other undefined pairs, i.e., f (x, σ) < +∞ if andonly if the transition δ (x, σ) is defined, which is denoted

as δ (x, σ)!. The weight denotes the duration required forthe corresponding transition to be completed. R ⊆ 2Σ is aset of resources. For every pair of events σ, σ′ ∈ Σ thereexists a resource r ∈ R such that σ, σ′ ∈ r if and onlyif the firings of σ and σ′ are mutually exclusive, i.e., if one event is under execution, the other cannot be fired. Let

L(G) := {s ∈ Σ∗|δ (x0, s)!} be the closed behavior of Gand Lm(G) := {s ∈ L(G)|δ (x0, s) ∈ X m} the marked

behavior of G. Let φ(Σ) and ϕ(Σ) denote respectively theset of finite-state automata, and the set of finite-state time-

weighted automata, whose alphabets are Σ. We bring in theconcept of makespan.

Definition 2: [4] Given a time-weighted automaton

(G,f,R) ∈ ϕ(Σ), let s ∈ L(G). Suppose s = σ1 · · · σnfor some n ∈ N. Let sq := σ1 · · · σq ≤ s. If q = 0 thensq := ǫ.

1) A time-stamp of s with respect to (G,f,R) is anondecreasing list of natural numbers ρ = (tsk ∈ N|k =1, · · · , n), where for all q, v ∈ {1, · · · , n}, q < v if there exists a resource r ∈ R such that σq, σv ∈ rthen tsq + f (δ (x0, sq−1), σq) ≤ t

sv. Each t

s

k

denotes a

starting moment of firing σk in s.2) Let ΘG,f,R(s) be the set of all time-stamps of

s, and υG,f,R(s) := minρ∈ΘG,f,R(s) max{ts1 +

f (x0, σ1), · · · , tsn + f (δ (x0, sn−1), σn)} is called ex-ecution time of s with respect to (G,f,R). A s aconvention, υG,f,R(ǫ) := 0.

To calculate the string execution time υG,f,R(s), whichallows us to evaluate the makespan of a language, we present

the following approach. Let I be the collection of integers.

Definition 3: The (max,+) semiring Imax is the set I ∪{−∞}, equipped with the operation max, written additively(i.e. a ⊕ b = max{a, b}), and the usual sum, writtenmultiplicatively (i.e. a

⊗ b = a + b). In this semiring, the

zero element is −∞, and the unit element is 0. The matrix operations are induced by the semiring struc-

ture as follows. For matrices A and B of appropriate di-mensions, (A ⊕ B)qv := Aqv ⊕ Bqv = max{Aqv , Bqv} and(A ⊗ B)qv := ⊕k(Aqk ⊗ Bkv) = maxk(Aqk + Bkv). For ascalar a ∈ Imax, (a ⊗ A)ij := a ⊗ Aij = a + Aij . Fromnow on we omit the ⊗ sign, and directly use AB to denoteA ⊗ B. By the definition of semiring we get that the matrixmultiplication is associative, i.e. (AB)C = A(BC ).

Given (G = (X, Σ, δ , x0, X m), f , R) ∈ ϕ(Σ), let T :={(x, σ) ∈ X × Σ|δ (x, σ)!}. For each x ∈ X let Lx :={s ∈ Σ∗|δ (x, s)!} be the set of strings defined at x, and let

πx : Lx

→ T ∗

be a map, which maps each string s ∈ Lx

into the path in G, whose event labels form s. By [4] there

exists a morphism MG,f,R : T ∗ → I|R|,|R|max , where I

|R|,|R|max is

the collection of all matrices whose dimensions are |R|×|R|such that MG,f,R(ǫ) is defined as the unit matrix I|R|×|R|,i.e., all diagonal entries are 0 and all other entries are −∞.We call MG,f,R a morphism induced by (G,f,R). By [4],

υG,f,R(s) = 1t|R|MG,f,R(πx0(s))1|R|, (1)

where 1|R| ∈ I|R|max is the |R|-dimensional column vector,

whose entries are all equal to 0, and 1t|R| is the transpose of

3543


3/6

1|R|. Let 0|R| ∈ I|R|max be the |R|-dimensional column vector,

whose entries are all equal to −∞. When the context is clear,we use M to denote MG,f,R.

As an illustration, the left picture in Figure 1 depicts a sim-

ple time-weighted automaton (G,f,R), where Σ = {a,b,c},and each edge has an event label followed by its time weight,

e.g., the transition from z0 to z1 is labeled by a and has atime weight of 2. The resource set is R = {{a, b}, {c}},

z 0

z 1

z 2

z 0

z 1

z 2

b/1

a/2 c/5

Fig. 1. Example 1: (G , f , R) (left) and its morphismM (right)

i.e., events a and b are mutually exclusive. Based on [4], thecorresponding morphism M is depicted in the right pictureof Figure 1. We can think of having 2 resources (or machines)

- one is used by a and b, and the other one is used by c. It ispossible that some event may use more than one resource

simultaneously. We can check that the execution time of

s = ac is 5, which is equal to 1t|R|M(z0, a)M(z1, c)1|R|,

and the execution time of s′ = ab is 3, which is equal to1t|R|M(z0, a)M(z1, b)1|R|.

For the purposes of deciding on an optimal control strategy

it is often only neccessary to consider the relative time until

each resource becomes free, after executing a particular trace,

not the absolute time at which resources become free. For

this reason we define the function gr such that for a givenvector |R| column vector c it holds that gr(c) = c − min(c).This has the effect of translating all the values of c such thatthe minimum value equals zero. For confenience we use the

property that max(c) = c1|R|.

III . PROGRESSIVE T IM E O PTIMAL C ONTROL

A language has progressive finite makespan if under allcircumstances, assuming no new non progressive events

occur, then the system is guaranteed to complete all of its

task after a finite number of progressive events.

Definition 4: Given a language L ∈ Σ∗, and a set of progressive events Σ p ⊆ Σ, L is finite Σ p make-spanlanguage if and only if L is Σ p nonblocking and there existsa natural number n ∈ N such that for all s ∈ L and t ∈ Σ∗ psuch that st ∈ L it holds that |t| ≤ n.

For any given language L we define the functionPF (L, Σ p), as the set of all languages K such that K ⊆ L,K is controllable with respect to L, and K has Σ p finitemakespan.

Definition 5: Given an automaton L = (X, Σ, δ , x0, X m),and a set of progressive events Σ p ⊆ Σ p we definePF (L, Σ p) = {K ∈ C (L)| such that K is finite Σ pmakespan }.

We additionally define PF with respect to automata andstates.

• PF (G, Σ p) = {K ∈ C (Lm(G))| such that K is finiteΣ p makespan }.

• PF (x, Σ p) = {K ∈ C (Lm(x))| such that K is finiteΣ p makespan }.

x0 x1

x2

x3

x4

p1/2

p1/2

p1/2

p2/1

p2/1

pu/1

nc/1

nu/1

Fig. 2. Example of an automaton which is not Σp finite makespan closed

We now introduce progressive time optimal control. Pro-

gressive time optimal control for a time weighted system

(G,f,R) and set of progressive events Σ p is is achieved bysynthesizing a sublanguage K ⊆ Lm(G) such that; firstlyK is controllable with respect to L(G) and K has finite Σ pmakespan; and secondly for every trace s ∈ K , K ensuresthat, assuming only progressive event occurs, that the system

G will be guided towards the marked state in the minimumamount of time possible while still ensuring controllability.

Definition 6: Given a time weighted system (G,f,R),and a set of progressive events Σ p, we derive the followingdefinitions.

Given a language K ∈ PF (G, Σ p), and a trace s ∈ K we define ωK,f,R,Σp(s) = υG,f,R(x0, st)|t ∈ Σ

∗ p such that

st ∈ K }.Given a language K ∈ PF (G, Σ p), it holds that K ∈

OPF (G,f, Σ p) if and only if for all K ′ ∈ P F (G, Σ p) ands ∈ K it is the case that either s /∈ K ′ or ωK,f,R,Σp(s) ≤ωK ′,f,R,Σp(s)

Later in this paper we will show how to calculate thesupermal optimal progressive finite makespan supervisor for

a given time weighted system (G,f,R).

IV. PROGRESSIVE F INITE M AKESPAN CLOSED

LANGUAGE

We define a Σ p finite makespan closed language to beany language L such that for every trace s ∈ L, there existssome language K ∈ PF (L, Σ p) such that s ∈ K i.e., forany given trace s in the prefix closure of L it is possible tosynthesize a language K which has Σ p finite make-span, iscontrollable with respect to L, and contains s in its prefixclosure.

Definition 7: Let L ⊆ Σ∗

be a language, and Σ p ⊆ Σ bea set of progressive events. L is Σ p finite makespan closedif for every trace s ∈ L there exists some language K ∈PF (L, Σ p) such that s ∈ K

Example 1: Consider the language represented by the

automaton in figure 2, where Σc = { p1, p2, nc}, Σuc ={ pu, nu}, Σ p = { p1, p2, pu}, and Σnp = {nc, nu}. The lan-guage represented is not Σ p finite closed as for the trace p2nuas well as every other trace which enters the state x3; thereexists no language K ∈ PF (G, Σ p) such that p2nu ∈ K .This is because pu is both progressive, uncontrollable, and

3544


4/6

self-looped; therefore all languages which are controllable

with respect to the automaton, allow the event pu to be firedan arbitrary number of times after the p2nu; this means thatit is not possible to synthesize a language which contains

the trace p2nu and is both controllable and has Σ p finitemakespan at the same time.

It is significantly easier to synthesize a progressive time

optimal supervisor for a Σ p finite makespan closed language

than otherwise. To illustrate consider the state x0 in theautomaton from figure 2; in order to ensure progressive time

optimal control it would make sense for a time optimal

supervisor to ensure that the system takes the path p2 p2which takes two time units rather than the path p1 p1 whichtakes four time units, this would be incorrect however as

there exists no controllable and Σ p finite makespan languageof L(G) which can enter the state x1, this is because x1 canenter the state x3, uncontrollably via the non progressiveevent nu. If an automaton represents an Σ p finite makespanclosed language however we can be certain that no such state

exists in the automaton however; this is because for every

trace s in the prefix closure of a language L which is Σ p finitemakespan closed language there exists a sub language K inPF (L, Σ p) such that s in the prefix closure of K . Because of this it is possible to focus solely on the progressive behaviour

of a state when determining progressive time optimal control

for a Σ p finite makespan closed language.For this reason we introduce a method for synthesizing a

Σ p finite makespan closed controllable sublanguage for anygiven language L.

Definition 8: Let G = (X, Σ, δ , x0, X m) be an automaton,Σ∗ p be a set of progressive events, and k, l ∈ N be two naturalnumbers.

ζ k,l(G) =

• {x ∈ X m ∩ θl(G)|E (x) ∩ Σ p,uc = ∅}, if k = 0• {x ∈ θl(G)| There exists σ ∈ E (x) ∩ Σ p such that

δ (x, σ) ∈ ζ k−1,l(G) and for every event σ ∈ E (x) ∩Σ p,ucit holds that δ (x, σ) ∈ ζ k−1,l(G)} ∪ ζ k−1,l(G) ,otherwise.

ζ l(G) = ll∈N ζ k,l(G)

θ(G) =

• X , if l = 0• {x ∈ ζ l−1(G)| for all s ∈ L(x) ∩ Σ∗uc it holds that

δ (x, s) ∈ ζ l−1(G)}, otherwise

θ(G) = ll∈N θl(G).

The function ζ l(G) finds the set of all states x in G|θl(G)

for which there exists a finite makespan controllable sub-language of Lm(x) ∩ Σ∗ p i.e. it finds the set of all stateswhich have a controllable sublanguage when considering

only progressive behaviour. It is calculated iteratively such

that ζ k,l(G) contains all states which have a controllablefinite makespan language K such that for every trace t inK it holds that |t| ≤ k. The set θl(G) then restricts the setζ l−1(G) to only those states which cannot uncontrollablyreach a state outside the set ζ l−1(G). Once a number l ∈ N is found such that θl(G) = ζ l−1(G) the automaton G|θl(G)is guaranteed to either be Σ p finite makespan closed, or be

empty, as for each state in θl(G) there exists a controllableΣ p finite makespan sublanguage, and there exists no traces ∈ Σuc which leads to a state without such a language. Inaddition it is assured for all l ∈ N that PF (Gθl(G), Σ p) =PF (G|θl+1(G), Σ p) as at each step only states which have nocontrollable, Σ p finite make span sublanguage are removed;therefore both automata have the same time optimal Σ p finitemakespan time optimal sublanguage.

Theorem 1: Let G = (X, Σ, δ , x0, X m) be an automaton,Σ p ⊆ Σ be a set of progressive events.

Then G|θ(G) is Σ p finite makespan closed and PF (G, Σ p)= P F (G|θ(G), Σ p).

As each iteration of θ decrease in size θ will reach a fixpoint within |X | iterations. Furthermore as each iteration of ζ l increases in size ζ l reachs a fix point within |X | iterations.Each iteration of ζ k,l can be calculated by looking at most|X | × |Σ| transitions, thus calculating ζ l is O(|X |2 × |Σ|).Each iteration θl requires the calculation of ζ l−1 and findingall states which can reach a removed state uncontrollably, this

can be calculated by looking at at most |X |×|Σ| transitions.Thus calculating θ has O(|X |3 × |Σ|) time complexity.

V. SYNTHESIS OF P ROGRESSIVE T IM E O PTIMAL

CONTROL

In order to ensure optimal behaviour after a given trace sfor a time weighted system it is not enough to consider only

the state reached in G after s. For a time weighted systemhowever the vector 1|R|M(s) is also important, and willdetermine which events should be enabled/disabled in order

to ensure time optimal control. For this reason we construct

the automaton φQ(G,f,R, Σ p) such that each state is of theform (x, xf ) where x is a state in the original automaton,and xf is a contour. The transition relation δ Q is constructed

such that for any trace s ∈ L(G) it holds that δ Q(x0,opt, s) =(δ (x0, s), gr(1|R|M(s))). As the contour gr(1|R|M(s)) hasbeen normalized we can restrict the state set X opt to onlycontain a finite number of states, yet at the same time the

normalized contour contains enough information to be able

to calculate time optimal control. On this automaton we use

a Brave-Heyman style algorithm [11] to calculate for each

state the minimum amount of time required to reach a marked

state, while both ensuring controllability but assuming that

no new non progressive events occur. Once this is calculated

for each state, the automaton φ(G,f,R, Σ p) is constructedby disabling any event which does not ensure that optimal

time is achieved assuming that the event is both progressive

and controllable. Definition 9: Let (G,f,R) be a time weighted system

such that L(G) is Σ p finite closed, Σ p be a set of progressiveevents, it holds for all σ ∈ Σ p that f ( , σ) > 0 and R ∈ 2

Σ p )

be a set of resources R. Let c = max({f (x, σ)|x ∈ X andσ ∈ Σ}).

We define φQ(G, f, R, Σ p) = (X opt, Σ, δ Q, x0,opt,X m,opt) where X opt = {(x, xf ) ∈ X × (R → N )| Wheremax(xf ) ≤ c}, δ Q : X opt × Σ → X opt is defined suchthat δ Q((x, xf ), σ) = (δ (x, σ), gr(xf M(x, σ))), x0,opt =(x0, 1|R|) and X m,opt = {(x, ) ∈ X opt|x ∈ X m}.

3545


5/6

Q0(x, xf ) =

• max(xf ), if x ∈ X m and E (x) ∩ Σ p,uc = ∅.• +∞, otherwise.

For all k ∈ N − {0} it holds that Qk(x, xf ) =

• max{min(xf M(x, σ)) + Qk−1(δ (x, σ), gr(xf M(x,σ))|σ ∈ E (x) ∩ Σ p,uc}, if E (x) ∩ Σ p,uc = ∅.

• min{min(xf M(x, σ)) + Qk−1(δ (x, σ, gr(xf M(x,

σ)))|σ ∈ E (x) ∩ Σ p} ∪ {Qk−1(x, xf )}, otherwise.We define φ(G, f, R, Σ p) = (X opt, Σ, δ opt, x0,opt,

X m,opt) where δ opt : X opt × Σ → X opt is defined suchthat δ opt((x, xf ), σ) = δ opt((x, xf ), σ) if Q|X |(x, xf ) ≥Q|X |(δ Q((x, xf ) + min(xf M(x, σ)) or σ /∈ Σ p, x0,opt= (x0, 1|R|) and X m,opt = {(x, ) ∈ X opt|x ∈ X m}.

It can be shown that Lm(φ(G,f,R, Σ p)) is inOPF (G,f,R, Σ p) and that every other language inOPF (G,f,R, Σ p) is either equal to or a subset of Lm(φ(G,f,R, Σ p)).

Theorem 2: Let (G,f,R) be a time weighted system suchthat L(G) is Σ p finite closed, Σ p be a set of progressiveevents, and R ∈ 2Σ be a set of resources R.

Then it holds that Lm(φ(G,f,R, Σ p)) ∈OPF (G,f,R, Σ p) and that for all K ∈ OPF (G,f,R, Σ p)it holds that K ⊆ Lm(φ(G,f,R, Σ p)).

Complexity 1: Let Σ p be a set of progressive events,(G,f,R) be a time weighted system such that L(G) is Σ pfinite closed and f (x, σ) ≥ 0 for all (x, σ) ∈ X ×Σ p, and c =max{f (x, σ)|(x, σ) ∈ X ×Σ}. There are at most |X |×(c+1)|R| states in X opt as for all (x, xf ) ∈ X opt it holds that x ∈X and max(xf ) ≤ c. For any k ∈ N , assuming Qk(w, wf )has been calculated for every state (w, wf ) ∈ X opt, inorder to calculate Qk+1(x, xf ) it neccessary to calculatemin(xf M(x, σ)) + Qk−1(δ (x,σ,gr(xf M(x, σ))) for ei-ther all σ ∈ Σ p∩E (x) or all σ ∈ Σ p,uc∩E (x), in order to findeither the minimum or the maximum value. In either case this

calculation must be done at most |Σ| times for each state(x, xf ) ∈ X opt, for each iteration. Therefore to calculateQk+1(x, xf ) for every state (x, xf ) ∈ X opt will require atmost |X |×|X |×(c+ 1)|R|×|Σ| operations. Finally in orderto calculate δ opt it is necessary to calculate min(xf M(x, σ))+ Q|X|(δ (x,σ,gr(xf M(x, σ))) for all σ ∈ Σ p∩E (x). Thusrequiring |X |×(c+1)|R|×|Σ| operations. Therefore the timecomplexity to calculate φ2 is |X | × |X | × (c + 1)|R| × |Σ|.

VI . EXAMPLE OF A C LUSTER T OO L

As an illustration, we apply the aforementioned technique

we apply them to a linear cluster tool example derivedfrom the one used in [12]. The 2 cluster system is de-

picted in figure 3. The system consists of one entering

load lock (Lin) and one exit load lock (Lout), 5 chambers(C 11, C 12, C 21, C 22, C 23) a one-slot buffers (B), 2 trans-portation robots (R1, R2). In the entering load lock a requestcan be made to process an additional waver, this is the

only nonprogressive event in this system. If a request has

been made to process a new waver then a waver can be

transported into the system from the entering load lock by

the robot R1. Once R1 picks up a waver it is moved through

Fig. 3. A linear cluster tool with 2 clusters

designated chambers for processing based on pre-specified

routing sequences by relevant robots located in different

clusters. Routing information is represented by specification

automata H 11, H 12, H 13, H 14, H 21, H 22, H 23, H 24, these au-tomata enforce the order in which the robots R1 and R2should move wafers between the components in the model.

Finally, processed wafers are transported out of the system

through the exit load lock by R1. Each robotic action requires

one time unit to complete, and the processing operation ineach chamber takes four time units to complete, requesting

that a new waver be processed requires no time. Wafers are

routed through the cluster tool thus: Lin → C 11 → B →C 21 → C 22 → C 23 → B → C 12 → Lout.

We consider the the synchronous product of LIn , LOut,B, C 11, C 12, C 21, C 22, C 23, R1, R2 to be the centralizedplant automaton G whereas the synchronous product of H 11,H 12, H 13, H 14, H 21, H 22, H 23, H 24 is the specification K .

Processed φ supCN Wavers Time Time

100 830 2808

200 1630 5608

300 2430 8408400 3230 11208

500 4030 14008

600 4830 16808

700 5630 19608

800 6430 22408

900 7230 25208

1000 8030 28008

TABLE I

TIME NEEDED TO PROCESS x WAVERS.

Our progressive time optimal supervisor is constructed

first by creating a standard controllable nonblocking su-

pervisor for the system supCN (G, K ), we further re-strict supCN (G, K ) to θ(supCN (G, K )). We then constructthe automaton φQ(θ(supCN (G, K )),f,R, Σ p) and calculateQ|X| for every state in that automaton. Finally we con-struct φ(θ(supCN (G, K )),f,R, Σ p). The original supervi-sor supCN (G, K ) has 3810 states and 12430 transitions,while φQ(θ(supCN (G, K )),f,R, Σ p) has 115268 states and354199 transitions, and φ(θ(supCN (G, K )), f , R , Σ p) has21008 states and 48960 transitions. On a 3.02Ghz PC theentire process took 39.43 seconds.

We compare the time performance of

3546


6/6

φ(θ(supCN (G, K )),f,R, Σ p) against supCN (G, K )by simulating waver processing with both supervisors. For

our simulation we make the assumption that whenever the

supervisor allows a request to process a new waver that the

request is made. Otherwise at each step in the simulation the

respective supervisor will be asked what events are enabled.

Of those events the event which can be fired the earliest will

be chosen. If there is more than one such event, an event

will be chosen randomly from amongst those events. TableI show the amount of time units each supervisor required in

order to process up to 1000 wavers. As can be seen it takesthe standard supervisor roughly 3.5 times longer than thetime optimal supervisor to process an equivalent number of

wavers.

VII. CONCLUSION

In this paper we introduce the concept of progressive

time optimal control as a means of ensuring time optimal

behaviour in cyclic systems. In addittion we show how a

progressive finite makespan time optimal supervisor can be

calculated for time weighted systems. The algorithm has

been implemented and shown to work for a small clustertoolmodel.

REFERENCES

[1] P. Ramadge and W. Wonham, “Supervisory control of a classof discrete event processes,” SIAM Journal on Control and Optimization, vol. 25, no. 1, pp. 206–230, 1987. [Online]. Available:http://dx.doi.org/10.1137/0325013

[2] W. Wonham and P. Ramadge, “On the supremal controllablesublanguage of a given language,” SIAM Journal on Control and Optimization, vol. 25, no. 3, pp. 637–659, 1987. [Online]. Available:http://dx.doi.org/10.1137/0325036

[3] J. Yi, S. Ding, M. Zhang, and P. van der Meulen, “Throughput analysisof linear cluster tools,” in Automation Science and Engineering, 2007.CASE 2007. IEEE International Conference on, Sept 2007, pp. 1063–1068.

[4] R. Su, J. H. van Schuppen, and J. E. Rooda, “The synthesis of timeoptmial supervisors by using heaps-of-pieces,” IEEE Transactions on

Automatic Control, vol. 57, pp. 105–118, 2012.[5] S. Ware and R. Malik, “Progressive events in supervisory

control and compositional verification,” Control Theory and Technology, vol. 12, no. 3, pp. 317–329, 2014. [Online]. Available:http://dx.doi.org/10.1007/s11768-014-4097-8

[6] ——, “Supervisory control with progressive events,” in 11th IEEE International Conference on Control & Automation, ICCA 2014,Taichung, Taiwan, June 18-20, 2014, 2014, pp. 1466–1471. [Online].Available: http://dx.doi.org/10.1109/ICCA.2014.6871138

[7] S. Gaubert, “Performance evaluation of (max,+) automata,” AutomaticControl, IEEE Transactions on, vol. 40, no. 12, pp. 2014–2025, Dec1995.

[8] J. Wang., Timed Petri Nets: Theory and Application. KluwerAcademic Publishers, 1998.

[9] S. Gaubert and J. Mairesse, “Modeling and analysis of timed petri

nets using heaps of pieces,” Automatic Control, IEEE Transactionson, vol. 44, no. 4, pp. 683–697, Apr 1999.

[10] J. Huang and R. Kumar, “Optimal nonblocking directed control of discrete event systems,” in American Control Conference, 2007. ACC ’07 , July 2007, pp. 4285–4290.

[11] Y. Brave and M. Heymann, “On optimal attraction of discrete-eventprocesses,” Information Sciences, vol. 67, pp. 245–276, 1993.

[12] R. Su, J. van Schuppen, and J. Rooda, “Aggregative synthesis of distributed supervisors based on automaton abstraction,” AutomaticControl, IEEE Transactions on, vol. 55, no. 7, pp. 1627–1640, July2010.

3547

ware, su - 2015 - progressive time optimal control of reactive systems

Documents