LOGICAL CONTROL OF DISCRETE EVENT SYSTEMS AN AUTOMATA BASED APPROACH Jose Eduardo R Cury

LOGICAL CONTROL OF

DISCRETE EVENT SYSTEMS

AN AUTOMATA BASED APPROACH

Jose Eduardo R Cury

OUTLINE:

-Preliminaires

-Basic Control Theory

-Extensions: Modular Control;

Partial Observation;

Hierarchical Control;

limitations: computational complexity

1.Preliminaires

Approach introduced by

logical model: related with the logical behavior of the DES (possible state/event sequences)

timed and untimed versions

DES are modelled as generators of formal languages

Ramadge and Wonham (1984)

synthesis-based

Languages

= set of symbols = alphabet

Definition: A language L, defined over analphabet , is a set of strings of symbols in

Example:

={}

L1={

L2={All possible strings of lenght 3 and beginning with}

L3={All possible finite lenght strings and beginning with}

Regular Expressions

• Concatenation of strings:

u = v = conc.: uv =

• Operations on Languages:

Let A and B be 2 languages. We have

a) Concatenation:AB = {w: w=uv, u A, v B}

b) Kleene closure:

A* = n where: A0 = {}An = An-1A

c) Usual operations over sets

n=0

Example:

= {

L1 = L2 =

Then:

L1L2 = {

L1*= {

L2*= {

L1 L2 = L1 L2 = {

Notation: if u and v are stringsu = {u}

(u+v) = {u,v}={u}v}u* = {u,uu,uuu,...}

uv = {uv}

Definition (Regular Expressions):

1) is a regular expression denoting the empty language), is a regular expression denoting {},is a regular expression denoting {},

2) If r and s are regular expressions, then rs, r*, s*, (r+s) are regular expressions;

3) All regular expressions are obtained by applying rules 1 and 2 a finite number of times

Example:

Let = {}be an alphabet; then:

Definition:A regular language is any language which can be represented by a regular expression

Proposition:If L = {u1, u2,...,un} is a finite language,then L is a regular language

Prefix of a string:u * is a prefix of v * if for somew *, v = uw

Prefix-closure of a Language L:

L is the language composed by all prefixes of L:

L = { u / uvL for some v

Prefix-closed Language:

L * is prefix-closed if L =

i.e., if v L and u is a prefix of v thenu L

L

Finite State Automata

Device which accepts a Language according to specific rules.

Definition:A finite state automaton is a 5-tuple (,X,f,x0,F) where:

is a finite alphabet;X is a set of finite states;f is a state transition function,

f: X Xx0 is an initial state, x0X;F is a set of marked states, FX

Transition State Diagrams

Directed graphs where the nodesrepresent states and the labelededges represent state transitions

Example: (,X,f,x0,F) = {} X= {x,y,z}f(x,x, f(x, f(x,z,f(y,x, f(y, f(y,y,f(z,z, f(z, f(z,y,

x y

z

Language accepted by an automaton

Extended transition function:

f: XX

f(x,u) = f(f(x,u),)u

In the above example:

f(x, = f(f(x,),) = f(f(f(x,),f(f(z,f(z,) = y

Definition: A string u is accepted bya finite state automaton (,X,f,xo,F), if f(xo,u) = x, with x F

Definition: The language accepted by a finite state automaton (,X,f,xo,F) is the set of finite strings {u:f(xo,u)F}.If the automaton is denoted by A, then the language accepted by A é denoted L(A).

Example: Let = {} be an alphabet.Define a task as a sequence of 3 eventsbeginning with , followed by or , and then , followed by an arbitrary sequence.

Corresponding language:

5 0 1

2

3

4

L =

Non-Deterministic Finite State Automata

Example:

0 1

f(0,) = {0,1}; f(0,) = f(1,) = f(1,) = {0}

Definition: A Non-Deterministic Finite State is a 5-tuple:

(,X,f,xo,F)with ,X,xo,F as before, and f a transition state function f: XX

It allows for the expression of incompleteknowledge of the system and for the expressionof the physically admissible set of events whichfollows a state x.

Proposition: If L is the language accepted bysome non-deterministic finite state automaton thhen there exists a deterministic finite state automaton which accepts L.

Language accepted by a non-deterministic automaton

Extended transition function:

f(x,u) = {z: zf(y,) para algum estado yf(x,)}

u

Definition: The language accepted by a non-deterministic finite state automaton (,X,f,xo,F) is the set of finite strings {u:f(xo,u)F }.

Example: Let (,X,f,xo,F) be the automatonof the last example. Let us build adeterministic automaton (D,XD,fD,xo

D,FD)which accepts the same language

D = E

XD = {0,1,01, each element of XD corres- ponds to a subset of X)

xoD = xo = 0;FD = {0,01}

0

01

0

01

1

Equivalence between Finite State Automata and Regular Expressions

Theorem: (Kleene, 1950)If a language is regular, then it can beaccepted by some finite state automaton;and if a language is accepted by a finite state automaton , then it is a regular language.

Example of a non-regular language:L = {denoting: n = we haveL={n n , n = 0, 1, 2, ...}

State Agregation in Automata

Definition: Let (,X,f,xo,F) be afinite stateautomaton and R X. R is said to be formedby equivalent states if, for any pair x,y R, x y, and any u *

In general the number of states in an automaton is not minimal

Minimization equals

Identification of equivalent states

f(x,u) F if and only if f(y,u) F

Observações:

a) se x F e y F então x e y não podem ser equivalentes.

b) se f(x,e) = f(y,e) para qualquer e E (ex- ceto ) então x e y são equivalentes.

c) a propriedade acima se mantém se, para alguns eventos, f(x,e)=y e f(y,e)=x.

d) em geral, se R é tal que R F ou R F = então R é constituído de esta- dos equivalentes se f(x,e) = z R implica que f(y,e) = z, para quaisquer x,y R.

e) se F = X então todos os estados são equi- valentes em relação a F.

Example: Detector of the 1,2,3 sequence.

x1 x12 x123

x3 x2

2

31

2

3

1

23

1

23

1 2

3

1x0

x1 x12 x123

xo

3

2

1

2

3

1

231

23

Algoritmo para a Identificação deEstados Equivalentes:

1) Marcar (x,y) para todo xF, y F

2) Para todo par (x,y) não marcado em 1):

2.1) Se (f(x,e),f(y,e)) está marcado paraalgum e E então:

2.1.1) Marcar (x,y)2.1.2) Marcar todos os pares não-mar

cados (w,z) na lista de (x,y). Repetir para cada (w,z) até quenenhuma marcação seja possível

2.2) Se (f(x,e),f(y,e)) não está marcadopara nenhum e E então:

2.2.1) Se f(x,e) f(y,e), então acres-centar (x,y) à lista de (f(x,e),f(y,e))

Generators

Definition: A Generator is a 5-tuple G = (, X, f, xo, F) where , X, xo, F are defined as for the automataand f is a partial function f: X X , defined only for some elements of X (notation: f(x,)!).

Definition fits with the fact that in systemssome transitions are not physically admissible

Notation:(x) set of admissible events after x X

Language Generated by G:

Properties:

• L(G) is prefix-closed;

• An automaton A is a generator with L(A) = *

•Lm(G) L(G)

Marked Language of G:

L(G) = {u E* / f(xo,u)!}

Lm(G) = {u E* / f(xo,u)F)

Example: Three state machine

sf

b

r

I

W D

= { s, f, b, r}

L(G) = (sf + sbr)*( + s + sb)

represents the set of all physically admissiblesequences in the system.

Lm(G) = (sf + sbr)*

represents the set of all completed tasks possible to occur in the system.

Accessibility and Co-accessibilityof a Generator

Accessible state: A state x X is accessible if x = f(xo,u) for some u *.

Accessible Generator: A generator is accessibleif every x X is a reachable state.

Accessible Component of G:

Gac = (Xac, , fac, xo, Fac)

where:Xac : set of accessible states of GFac : XrFfac : f/Xac

If G is accessible then Gac= G

Co-accessible Generator (non-blocking): A generator is co-accessible (non-blocking)if any u L(G) can be completed into a string in Lm(G).

If u L(G), then w * / uw Lm(G)

Trim Generator: A generator is trim if it isaccessible and co-accessible.

Example:

xo x1

x2

x3

x5

x4

x4 : non accessible state;x5 : non co-accessible state (blocking state)

xo x1

x2

x3

xo x1

x2

x3

x5

Gac: accessible component of G

Gt: Trim generator

Property: A generator is co-accessible(nonblocking) if and only if Lm(G) = L(G)

Composing Generators

Synchronous and Shuffle Product

Natural Projection: Let and i be sets of events with i . The natural projection Pi: *i

is definedas:

Pi() =

Pi() =

if i

if i

Pi(u ) = Pi(u) Pi() onde u * ;

The action of Pi over a string corresponds todeleting events not in Ei.

Extending natural projections to languages:

PiL = Li = {ui i* / ui = Piu for some u L}

Inverse Projection:

Pi-1Li = {u * / Piu Li}

Synchronous Produt:Let L1 1

* e L2 2* (with possibly

1 2 ). Let = 1 2. Thesynchronous produt L1 //s L2 * is defined as:

L1 //s L2 = P1-1L1 P2

-1L2

Observe that u L1 //s L2 if and only ifP1(u)L1 and P2(u) L2

Example: 1 = {

G1:

G2:

G = G1 // G2 :

L(G) = L(G1) //s L(G)2

he synchronous product represents a languagegenerated by a generator which is the result of the joint action of two other generators

Intersection of languages:Corresponds to the synchronous productwith since in this case Pi

-1Li = Li

L1 = (

L2 = (

L1 //s L2 = L2

Example:

Corresponds to the synchronous productwith 2 =

The Shuffle Product of two languages L1 and L2

is the language consisting of all possible interleavings of strings of L1 and L2

Language generated by a generator which is the result of the independent or asynchronous action of two other generators

Shuffle Product:

Example: Two independent and assynchronoususers of the same resource

I2

R2 U2

I1

R1 U1

I = idle; R = requiring the resource; U = using the resource

Assynchronous Composition

G = G1 // G2

States: (x,y), xG1, y G2

Transitions: (x,y) (x’,y) or (x,y) (x,y’)

I1I2R1I2 U1I2

I1R2 R1R2 U1R2

I1U2 R1U2U1U2

L(G) = all strings over E1 E2 which correspond to paths in the graph starting in I1I2

Lm(G) = Idem, but ending in I1I2

G is co-accessible : Lm(G) = L(G)

. Limitations

- DES, SPEC., CONTROLLERS finite state machines;

- Algorithms often polynomials in the number of states of DES, which grows exponentially with the number of components

2. Basic Control Theory. The Control

- Some events can be disabled by an external controller

- Events to be disabled depend on the past behavior of the DES

. Methodology

1. Modeling the OPEN LOOP BEHAVIOR

2. Modeling the SPECIFICATIONS:

Safety, Liveness, Fairness

3. Synthesizing the OPTIMAL CONTROL LAW

Control of DES

• Control action some events can be externally disabled

• Measured variablescurrent state or sequence of past events

DES

Controller

state orsequence of eventsControl

Central Idea:

Methodology

1) Specification of the Open-loop behavior.

2) Specification for the Closed-loop behavior.

Typical specifications:• Safeness• Liveness• Fairness

3) Synthesis of the control law satisfaction of specifications in a least restrictive way

Some characteristics of the approach

• The three steps are performed systematically (including automatic synthesis)

• Plant, closed-loop specifications, and controllermust

be modeled by finite state generators.

• Computational complexity

• research issue

• number of states grows exponentially with the number of sub-systems.

• polynomial in the number of states

Partition of :

= c u

c : set of controllable events

u : set of uncontrollable events

Control input:

If then it is allowed by otherwise is disabled by.

Control Structure

can be disabled

can not be disabled

Subset tal que

u uncontrollable events can not be disabled)

Set of possible control inputs: 2

DES with control structure: Generator G and a set of control inputs .

s, f, r, b};2 = {s, f, b};3 = {r, f, b};4 = {f, b}

Control is permissive

It doesn’t force but just enablesor disables events

Events are generated by the plant

sf

b

r

I

W D

Example: Three states machine.

c=s, r} u={f, b}

Controller which switches the control inputs’, ’’, ’’’,... as a function of the measuredsequence of events.

Formally, a function

h: L

which associates to each possible string L a control input = h()

After generating

h() (f(xo,))

Supervisor:

next event is an element of

System under supervision:

The closed-loop behavior of h/G is defined by the language L(h/G) L(G):

• L(h/G)• L(h/G) if and only if

L(h/G), L(G), h()

Closed-loop generated behavior:

Properties:

• {} L(h/G) L(G)• L(h/G) is non-empty and prefix-closed

(closed-loop system)

Notation:

Closed-loop behavior

h/G : G under supervision of h

Closed-loop marked behavior:

Lm(h/G) = L(h/G) Lm(G)

Lm(h/G) is the part of Lm(G) which survivesunder supervision.

Property:Lm(h/G) Lm(G)

Definition: h is nonblocking for G if

Lm(h/G) = L(h/G)

every generated sequence of eventscan be completed into a marked sequence

It may represent the set of tasks which can be performed under supervision.

State realization of h

Let T be an automaton:(,Y,g,yo,Y)

Let be a complete function from Y to : Y

Let h be a supervisor defined for G = (,X,f,xo,F): h:L

(T,) implements the supervisor h if, for every L(h/G):

y(g(yo,)) = h()

In words, h() can be obtained by

The automaton T has its transitionsdriven by the events in G

Generator G

AutomatonT

enabledevents

y

i. applying to the automaton T, leading it to the state y. ii. applying = y such that y = h() .

Realization by a Generator S

Representation of the supervisor by a generator S

• If L(h/G) then L(S), L(S) only if h() or L(G);• If L(h/G), L(G), h()

then L(S)

• transitions disabled by h and physically possible, don’t appear in the transition structure of S.

• transitions enabled by h, and physically possible, must appear in the transition structure of S.

control action over G implicit in the transition structure of S.

In words

S is the generator (,Y,g,yo,Y)

• transitions: driven by events occured in G in accord to g

• control action: once in the state y S disables events L(G), such that(y)

h() (f(xo,)) (g(yo,)) (f(xo h()

G

S

enabledevents

Closed-loop behavior

The behavior of h/G can be representedby the generator corresponding to the composition of S and G (S // G):

h/G = S // G = {, YX, , (yo, xo), Y F}

where: ((y,x),e) = (g(y,e),f(x,e))

if g(y,e)! e f(x,e)!

In the composition S // G only transitions enabled in both generators can occur. If the supervisor disables a transition, it doesn’toccur.

Example: Dinner of two philosophers

P1 P2

M Ee1

m1

G1:

M Ee2

m2

G2:

EE

m2

e2

MM

EM ME

e1

m1e2

m2

m1

e1

G = G1 // G2

c = {e1, e2}

u = {m1, m2}

Control specification: avoid state EE

Let a supervisor be defined by:

In this case it is easy to see that:

L(h/G) = ((e1m1)+(e2m2))*(e1 + e2)

Lm(h/G) = ((e1m1)+(e2m2))*

h[((e1m1)+(e2m2))*e1] = {e1, m1, m2}

h[((e1m1)+(e2m2))*e2] = {e2, m1, m2}

for all other strings L(G), h() = {e1, e2, m1, m2}

and the control specification is attained.

Realization by (T,):

yo

y1 y2

e1

m1e2

m2

e1 e2 m1e1 e2 m2

m1 m2Automaton T:

(yo) = {e1, e2, m1, m2}(y1) = {e1, m1, m2} = h[((e1m1)+(e2m2))*e1](y2) = {e2, m1, m2} = h[((e1m1)+(e2m2))*e2]

* = irrelevants

e1 e2 m1 m2

yo 1 1 1 1

y1 1* 0 1 1

y2 0 1* 1 1

EE

m2e2

MM

EM ME

e1

m1 e2

m2

m1

e1

yo

y1 y2

e1

m1e2

m2

e1 e2 m1e1 e2 m2

m1 m2

e1 e2 m1 m2

yo 1 1 1 1

y1 - 0 1 1

y2 0 - 1 1

Closed-loop system

Realization by a generator S

yo

y1 y2

e1

m1e2

m2

S: Obs.:L(S) = L(h/G)

Closed-loop system: composition of S and G

EEyo

EMy1 MEy2

e1

m1e2

m2

S // G:

L(S//G) = L(h/G)Lm(S//G) = Lm(h/G)

Some questions:

• Some specifications could not be exactly attained

•Which are the conditions for a specification to be exactly attained ?

• If there exist several incomplet solutions which one is the best ?(in the ex., if (yo) = {m1, m2} specification is attained, but the philosophers will eventually die)

• Are there other ways to express specifications than just by forbidden states?

Controllability and

Existence of Supervisors

Given a DES G with generated behavior L(G) and marked behavior Lm(G)), which closed-loopmarked behaviors KLm are possible to be obtained by the action of a nonblockingsupervisor ?

Problem:

Equivalently,

What are the conditions on KLm

under which there exists h such that

Lm(h/G) = K ?

Lm(h/G) = L(h/G)

Illustration: Dinner of philosophers with “sake”

M E Dei

mi

di

fi

Gi: (i = 1,2)

c = {e1, e2}

P1 P2

e1

m1

e2

m2

d1

f1 e2

m2m1

e1f2

d2

m2

e2f1

d1 d2

f2e1

m1

f2

d2

f1

d1

MM

MEEM

MD

DE ED

EE

G = G1 // G2:

DM

DD

Control Specification: avoid state DD

Control Specification:

G’:

One must find h such that:

L(h/G) = L(G’) or Lm(h/G) = Lm(G’)

e1

m1

e2

m2

d1

f1 e2

m2m1

e1f2

d2

m2

e2f1

d1 d2

f2e1

m1

MM

MEEM

MD

DE ED

EEDM

Impossible: observe that e1d1e2 leads toa state where it is impossible to preventthe occurrence of d2

Controllability

A language K* is said to be controlablewith relation to a language L if

u L K

Obs.: , L(G) e * are controllable w.r.t. L(G)

In words, controlability of K implies that anyprefix of a string in K, when followed by anuncontrollable event such that L, mustremain being a prefix of K ( K)

Systemic Interpretation:

If L represents the generated behavior of a DES G, K is controllable if and only if no sequences in G which are prefixes of K, when followed by uncontrollable events in G exit the prefixes of K

Example:

0 1

2

3

a b

c

de

G:

L(G) = (abc + ade)* ( + a + ab + ad)

If K = (abc)* ab

then: K = (abc)* ( + a + ab)

If u = {a, b, c, d, e} and c = { } thenK is not controllable w.r.t. L(G)

since KEu L = (abc)*( + a + ab + ad)

If u = {a, b, c, e} and Ec = {d } thenK is controllable w.r.t. L(G)

since KEu L = (abc)*( + a + ab)

sf

b

r

I

W D

L(G) = (sf + sbr)*( + s + sb)

Example:

G:

For: K = (sbr)* K = (sbr)* ( + s + sb)KEu L = (sbr)* (sf + sb)K is not controllable w.r.t. L(G)

For: K = (sf)* K = (sf)* ( + s)KEu L = (sf)* (+ sb)K is not controllable w.r.t. L(G)

For: K = {sf, sb} K = {, s, sf, sb}KEu L = {sf sb}K is controllable w.r.t. L(G)

No exemplo do almoço dos filósofos,tanto L(S//sG) como Lm(S//sG) são con-troláveis em relação a L(G).

c1m1

c2m2

b1 d1 c2

m2m1

c1d2

b2

m2

c2d1

b1 b2

d2 c1m1

MM

MCCM

BM MBCC

BC CB

No exemplo do almoço dos filósofoscom vinho, tanto L(G’) como Lm(G’)não são controláveis em relação a L(G).

yo

y1 y2

c1

m1c2

m2

c1 c2 m1c1 c2 m2

m1 m2

Objectives of Supervision

Lm(h/G) = K

Given a specification K Lm(G) whichrepresents the tasks we want to be completed under supervision,

find (if possible) a nonblocking supervisor hsuch that the closed loop behavior satisfies

L - closure

Def.: Let K and L be languages withKL *. K is said to be closed w.r.t L or L-closed if

K = K L

i.e., K is L-closed if every one of its prefixes that belong to L, are also contained in K.

Example:

G:

Lm(G) = { }

K1 = {} is Lm-closed since:

K1 Lm = {} Lm = K1

K2 = {} is Lm-closed since:

K2 Lm = {} Lm = K2

K3 = {} is not Lm-closed since:

K3 Lm = {} Lm K3

Existence of Supervisors

Proposition: Given a generator G, with marked language Lm(G), and a specificationK Lm(G), K , there exists a nonblockingsupervisor h, such that Lm(h/G) = K

if and only if

K is Lm- closed and L- controllable.

Example:

L(G) = (abc + ade)*( + a + ab + ad)

Lm(G) = (abc + ade)*(ab + ad)

G is trim (thus open-loop nonblocking) (Lm = L)

Eu = {a, c, e}Ec = {b, d}

xox1

x2

x3

abc

de

G:

K = (abcade)*(ab + abcad) Lm(G)

K Lm(G) = K andK is controllable

Thus there exists a nonblocking h, such that:Lm(h/G) = K

Supervisor synthesis:

A possible solution is S with L(S) = K

a b c a d

eS:

(abcade)*

()*a()*ab()*abc

()*abca()*abcad

h a b c d e

11

1

1

1

1

1

11

1

1

1

1

0

11

1

1

11

0

1

-

--

-

-

-

-

-

which represents any supervisor h of the form:

Not the solution with minimal number of states.

The solution can be represented by any DES S, such that L(S) //s L(G) = K

Another solution is:

yo y1

a

a

d,e b,c

where:L(S) = [(d + e)*a (b + c)*a]*[ + (d + e)* +

+ (d + e)*a + (d + e)*a (b + c)*]

and L(S) //s L(G) = L(S) L(G) = K

The above DES is a representation of:

(abcade)*( + abca + abcad)

(abcade)*(a + ab + abc)

h a b c d e

1

1 1 1 1

1 1 10

0

Supremal Controllable Sub-language(Least restrictrif (optimal) supervisor)

Controllability is necessary for the existence of supervisors

Question: What to do if K is not controllable ?

We will show that there exists a unique bestapproximation of K, the supremal controllable language contained in K (notation: sup C (K))

Under certain conditions this language satisfiesalso the closure conditions which guarantiesthe existence of a supervisor. Such supervisor is the least restrictive or optimal supervisor.

Existence of the supremal controllablesublanguage of K

Let L(G) (generated by a DES G) andK * (closed-loop specification).

C(K) = {J K / J is L controllable i.e. JEuL(G) J}

Proposition: C(K) is non-empty and closedunder the operation of union.In particular, C(K) contains a unique supremalelement denoted sup C(K).

Proposition: Let K Lm(G) be Lm-closed(K = K Lm). Then sup C(K) is Lm-closed.

Corollary: Let G be a DES with generatedbehavior L(G) and marked behavior Lm(G). We have:

• if KLm, K and K = K Lm, there exists a nonblocking supervisor h such that

Lm(h/G) = sup C(K)

Obs.: The above supervisor induces a behaviorwithin the specifications given by K in theleast possible restrictive way. In this sense itis optimal.

Synthesis of supC(K)

Let:K: a regular languageG: a DES with behaviors L(G) and Lm(G)S: a trim generator with Lm(S) = K Lm(G)

Algorithm 1:

1) Compute Co = G // S; make i=0; (Observe that: Lm(Co) = Lm(G)Lm(S) = K)

2) Identify the bad states in Ci; states (x,y) s. t. u(G’)(x) u(Ci)(x,y);

3) Obtain Ci’ by eliminating the bad states in Ci and their associated transitions. Make Ci+1 = trim Ci’

4) If Ci+1 = Ci , stop since sup C(K) = Lm(Ci); otherwise make i = i+1 and go to step 2.

Algorithm 2:

1) as in the above algorithm;

2) Identify bad states in Ci as in 2 of the above algorithm. If there is no bad states, go to 6;

3) Build Ci’ by deleting all transitions which correspond to controllable events in Ci;

4) Determine other bad states, as those which have paths in Ci’ leading to at least an already identified bad state;

5) Modify Ci, by deletingthe bad states identified in steps 3 e 5, and corresponding transitions; make Ci+1 = trim Ci;

6) If Ci+1 = Ci , stop since sup C(K) = Lm(Ci); otherwise make i = i+1 and go to 2.

Example:

xo x1 x2

a,b

c u

a a

G:

u = {u}; L(G) =(a+b)*ca*ua*

K = (ab)*(acu + c)a*

yoy1 y2

y3

a

b

c

c u a

S:

Lm(S) = L(S) = K

sup C(K) = (ab)*acua*

Example:

yo

y1 y2 y3 y4

y5y6

G:

K =

S:

sup C(K) =

xo

x1 x2 x3 x4

x5x6

u = {}