International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
A synthesis process to arrange the eligibility conditions for the structural
decentralised discrete-event systems
Sang-Heon Lee
The School of Engineering,
The university of South Australia, Mawson Lakes, SA 5095, Australia.
Jae-Sam Park
Professor, Department of Electronics Engineering,
Incheon National University, 119 Academy Road, Yeon Su Gu, Incheon, Korea.
Corresponding author
the major obstacles for the wider application of SCT into real
industry is in their computational complexity. To overcome
this problem, within this framework, modular or decentralised
control [4,5,6,7,8,9,10,11] have been proposed and studied.
However the computational complexity still remains as a
critical issue since the whole plants need to be checked for the
eligibility conditions of the scheme for every single
specification given. This means for example, even though a
decentralised control is designed and synthesised for a given
plant with some specifications, if there is a minor change
required in a specification (like product or operation sequence
changes in batch operations in manufacturing or chemical
factory), the whole decentralised discrete-event system needs
to be verified for the eligibility conditions again to ensure the
centralised optimality. This definitely could incur a huge
computational burden.
More recently, a structural decentralised approach in SCT has
been proposed [3]. The major contribution of this approach is
to arrange the structure of the whole plant to be most suitable
for a certain set of decentralised operations. Once it is done,
the concurrent operations of much simpler decentralised
plants will be identical with that achieved by the centralised
supervision. In contrast with other decentralised approaches,
in this approach, the conditions need to be verified only once
for the structure of the system not for each specification, and
then the decentralised control can be achieved for all similar
future operations. Hence it would be obvious to achieve a
great amount of computational savings in the long term
operations. Intuitively, this is logical since when a certain
system established or major changes are introduced to it, it is
much better to have more flexible structure of the system so
that a set of similar future specification changes can be
handled without any modification in the plant configuration.
Two sufficient conditions on the structure of the system are
developed: the shared-event-marking condition and the
mutual controllability condition. The shared-event-marking
condition roughly says that the states before the shared events
in each decentralised system should be marked: Intuitively,
this may mean that before the coordination with other
decentralised plants, each decentralised plant should complete
its respective tasks and be ready for the synchronisation with
other decentralised plants. The mutual controllability
condition states that a decentralised system should allow and
track any uncontrollable shared event occurring in the other
AbstractIn the supervisor control theory framework of discrete-event
systems, modular or decentralised control schemes are
proposed and used to overcome computational complexity
problem. However in most studies, the eligibility conditions to
establish those schemes are required to be verified for every
specification. This means that even a minor modification of
specifications such as production sequences or material
mixing rates, the whole decentralised control needs to be
verified again for the eligibility conditions. The structural
decentralised supervisor control scheme [3] tried to overcome
this issue by establishing the conditions in the structure of the
system rather than the specification itself. Hence once the
given structure of the system is verified, then a set of future
decentralised controls would guarantee the centralised optimal
supervision. It has shown that this would bring an exponential
computational savings. In this paper, as a natural extension,
we propose a way to modify the structure of decentralised
discrete-event system such that the resultant system could
possess such desired structural properties. The synthesis
process needs to be done in certain points when the major
changes to the plants are introduced, and once established, a
number of variations in their specifications can be
implemented without further computationally expensive
verification. Hence even though the process is seemed to be
complicated, in the long run, it will save the huge
computational burden. This paper presents a process to
arrange such conditions for the given structure of the system
and demonstrate it with examples.
Keywords: Discrete-event system, supervisory control theory,
structural decentralised control, structural synthesis.
Introduction
The Supervisory Control Theory (SCT) proposed by Ramadge
& Wonham [1] and Wonham [2] was developed to represent
event-driven systems whose behaviour is characterised by
asynchronous, discrete, and qualitative changes of state values
with abrupt occurrences of events over time rather than by
ticks of a clock. Basically, the SCT determines the maximal
permissive behaviours (represented by a language) such that
only the specified and designed behaviours are allowed to
happen even in the presence of uncontrollable events. One of
4554
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
over Σ. The closed behaviour, L(G), and the marked
behaviour, Lm(G) of G are defined as L(G)= {s ∈ Σ*| δ(q0,s) is
defined}, and Lm(G)= {s ∈ L(G) | δ(q0,s) ∈ Qm},
respectively. A string s ∈ Σ* is defined as a prefix of u∈ Σ* if
there is a string v ∈ Σ* such that u = sv. The prefix closure of
H ⊆ Σ* is H  {s  * | v  * such that sv  H } and if
decentralised systems. These conditions are the first
computational efficient ones that systematically guarantee the
optimality of decentralised control in the structure of DES
rather than on certain specifications only. It has shown in a
more detailed analysis that by achieving these two structural
conditions, there is generally an exponential saving of the
computational efforts involved [3].
One of natural extensions of this work is “for the DES
structure which does not satisfy these two conditions, is there
any way to modify it so that the resultant system could possess
the desired structural properties?” Since it has proven that
there would be huge computational savings by re-arranging
the structure of the DES, a synthesis method to establish such
DES structure would provide a great benefit. That is the main
motivation for this paper. In this paper, we firstly present a
way to ensure that all states before shared events occur are
marked to satisfy the shared-event-marking condition.
Secondly, for the mutual controllability condition, we develop
a way to allow any uncontrollable events in other
decentralised plants to occur by introducing selflooping of
such shared uncontrollable event to the necessary states.
Intuitively, this can be interpreted as allowing uncontrollable
events (like machine breakdown or safety event) to occur in
other decentralised plants but they should be monitored in all
other decentralised plants, so that any necessary actions could
be taken in the corresponding decentralised plants. The whole
synthesis would need to be conducted at the initial stage of
establishing such DES, followed by the real implementation
of physical system accordingly. Once established, minor
changes of the system would be implemented without further
complicated verifications. Only when major changes requiring
rearrangement of physical system are introduced, this
synthesis process needs to be done to ensure that such
physical systems satisfy these two conditions. It is clear that
this modification is exactly matched with the intuitive
understanding of operations of DES. Note again that the
procedure to arrange the conditions in the structure seems a
bit complex but once those two conditions are verified for the
given structure, any future decentralised operations can be
achieved without further verification since the structure of the
system guarantees the optimality of centralised supervision
without blocking.
The remaining of this paper is organised as follows. In
Sections 2 and 3 some basic concepts used in this paper are
introduced. The methods to arrange the shared-event-marking
condition and the mutual controllability condition are
presented in Section 4. Examples are provided in Section 5 for
illustration. This paper will end with some concluding
remarks in Section 6.
H  H , H ⊆ Σ* is closed. For languages, F and H, let F ⊆ H
⊆ Σ*. Then F is H-closed if F  F  H . Define  H as the
set of all H-closed languages. A language F is nonblocking
with respect to H if F  F  H . Certainly if G
satisfies Lm (G)  L(G) , then L(G) is non-blocking. For Σ1 and
Σ2, where Σ1 Σ2 ≠  and Σ = Σ1  Σ2, the natural projection
pi: Σ* Σi* is defined by
 p ( s) if    i
pi ( )   and pi ( s )   i
 pi ( s) Otherwise,
for s ∈ Σ and σ ∈ Σ. The natural projection on a string s is just
to delete all occurrences of event  in s in Σ-Σi. The
synchronous composition [13] is defined using this concept
and can be used to combine several DES into a larger one
DES as follows: For L1 ⊆ Σ1* and L2 ⊆ Σ2*, the synchronous
composition L1 || L2 ⊆ Σ* is defined
as
L1 || L2  p11 ( L1 )  p21 ( L2 ), where p11 is the inverse
projection of pi. If the closed behaviour of smaller plant
L(Gi)= Li for i =1, 2, then L1 || L2 is considered as
‘cooperatively’ generating the larger DES by agreeing to
synchronise those events with common labels in each G1 and
G2 while events with different labels occur whenever possible.
The DES G simply allows any events defined in * to occur
without any means of control. To implement control to such a
DES, a supervisor needs to be designed so that the behaviour
of G is restricted to a desirable subset of states and transitions.
By doing this, the supervisor ensures that the resulting closedloop system behaviour satisfies the specifications. To
introduce control to G, it is assumed that a supervisor can
disable (prevent from occurring) and enable (permit to occur)
some events whenever desired. These events Σc ⊆ Σ, are
called controllable events and the remaining events Σu = Σ-Σc
are uncontrollable and considered as always enabled. By
enabling or disabling controllable events, the plant G can
generate the desired behaviour according to the specification
(E). A supervisor S which can generate such behaviour can be
obtained by an algorithm presented in Wonham & Ramage
[1]:
Lm(S/G) =  L (G ) (Lm(E)Lm(G))
*
Basically, it is considered  L (G ) as representing the process
of synthesising a least restrictive, optimal, supervisor for a
plant (G) satisfying the given specification (E).
The following two concepts are necessary for subsequent
discussions. Recall that throughout this paper, we assume that
a DES has finite sets of states and events.
Supervisory Control of Discrete-Event Systems (DES)
A finite state DES within SCT framework is modelled by a 5tuple automaton [2, 12], G =(Q, Σ, δ, q0,Qm), where Q is a set
of finite states, Σ is a finite set of event labels, called
alphabets, δ : Q × Σ → Q is a (partial) state transition
function, q0 ∈ Q is the initial state, and Qm ⊆ Q is a set of
marker states. Any set of finite sequences generated by G
represents the behaviour G. Let Σ* denote such event labels
with the empty string,   . Any subset of Σ* is a language
Definition 1: A selfloop is defined as a transition for which
the exit state and the entrance state are the same. Formally, a
transition (q,  , q') in G is defined as a selfloop, if q' = q.
Then the Selfloop operation is defined as follows: for a given
4555
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
generator G1 = (Q1 , 1 , 1 , q10 , Q1,m ) , where 1   , a state qs
Lm  L1,m || L2,m ||
 Q1 and a set of events, o   ,
L  L1 || L2 ||
S q o (G1 ) : (Q1 , 1  o , 1s , q10 , Q1,m ),
 1s :=
Q1×( 1  o ) 
Q1 is defined as follows: for q  Q1,   ( 1  o ),
1.
if 1 (q,  ) is defined, then 1s (q,  ) is defined as
1 (q,  ) ,
2.
if q = qs,  o , and 1 (q,  ) is not defined, then
( pi )1 ( Li ,m )
1
( pi ) ( Li )
and
respectively.
The
of pi on L. The centralised specification for the centralised
plant will then be E : ni1 ( pi |L )1 ( Ei ). Then, we have the
following problem.
1s (q,  ) is defined as q,
3.
|| Ln 
n
i 1
n
i 1
specification can be established in a similar way. Let Ei ⊆ Li,m
be Li,m-closed language representing a specification on a
decentralised plant Gi. The corresponding specification on the
centralised
plant
G
can
be
taken
to
be
( pi |L )1 ( Ei )  pi 1 ( Ei )  L, where (pi|L) denotes the restriction
s
where the partial transition function
|| Ln,m 
Problem 1: For the decentralise control, under what
condition the centralised supervisory control on the
centralised plant should be the same as the concurrent actions
of decentralised supervisory control applied in each
decentralised plant?
That is, find the condition to ensure
undefined, otherwise.
Selfloop operation is just to add additional selfloop transitions
to a specific state in a given generator. Since no selfloop
transition  o is added to the states of G1 at which  is
already defined, the selfloop operation does not violate the
property of determinism of G1.
 ni1 ( pi | L ) 1 ( Li ( Ei ))   L ( E ),
or, ( L1 ( E1 )) || ( L2 ( E2 )) ||  || ( Ln ( En ))   L1|| L2 ||Ln ( E1 || E2 ||  || En ).
Definition 2: Let Gi = (Qi , i ,  i , qi 0 , Qi ,m ) for i=1, 2 be trim,
Since Problem 1 is not generally true, many researches were
conducted to develop a set of conditions to ensure the global
optimality [7, 15, 16]. However in most studies, the eligibility
conditions to establish the decentralised schemes are required
to be verified for every specification. This means that even a
minor modification of specifications such as production
sequences or material mixing rates, the whole decentralised
control needs to be verified again for the eligibility conditions.
The computational complexity becomes high if the
specification changes are required frequently. The structural
decentralised supervisor control scheme [3] tried to overcome
this issue by establishing the conditions in the structure of the
system rather than the specification itself. Hence once the
given structure of the system is verified, then a set of future
decentralised controls would guarantee the centralised optimal
supervision. Theorem 1 is the main result of their research.
For the details, refer to [3].
finite automata. Assume that Lm(G2)  Lm(G1). Then we say
that G2 refines G1 if
(s, t  Lm (G 2 )),  2 (q20 , s)   2 (q20 , t ) implies 1 (q10 , s)  1 (q10 , t ).
Also, if G2 refines G1, then there exists a unique function h:
Q2 Q1, satisfying
h   2 (q20 , s)  1 (q10 , s) for s  Lm (G 2 )
Then the following Lemma can be defined.
Lemma 1 Let Gi := (Qi , i ,  i , qi 0 , Qi ,m ) for i = 1, 2 be trim,
finite automata. Let G = G1 × G2. Then G refines G1 and G2.
Note G1 × G2 is the product of two DES and defined by
G1 × G2=Rch (Q1  Q2 , 1  2 , 1   2 ,(q10 , q20 ), Q1,m  Q2,m ) ,
according to
( 1 (q1 ,  ),  2 (q 2 ,  )) if for  ,  1 (q1 ,  ) is defined and  2 (q 2 ,  ) is defined
Undefined, Otherwise.

 1   2 ((q1  q 2 ),  )  
Note that Rch (…) means the reachable component of a DES.
Theorem 1 [16] Suppose that for i, j {1, 2, ···, n} and i ≠ j,
i)
 *i (Σi  Σj)  Li ,m  Li ,m (Σi  Σj) and  *j (Σj  Σi)
 L j ,m  L j ,m (Σi  Σj) (Shared-Event-Marking
Structural Decentralised Supervisory Control
For a decentralised system, a centralised plant is assumed to
be divided into several smaller decentralised plants [14] and
the concurrent operations of simpler decentralised plants
could achieve the centralised optimality under certain
conditions [15]. Let Σ1, Σ2, ···, Σn be the event alphabets of
decentralised plants, G1, G2, ···, Gn, respectively. It is allowed
that Σi ∩ Σj ≠ , for i, j {1, 2, ···, n} and i ≠ j. Assume Σi=
ΣicΣiu and two subsystems, Gi and Gj (i ≠ j), agree to the
control status of shared events, i.e., ΣiuΣj = ΣiΣju. Let the
event set, the controllable events and uncontrollable events of
the centralised system (G), respectively, as
 :  ni1 i ,  c :  ni1  ic , and  u :  ni1  iu .
ii)
Condition)
Li and Lj are mutually controllable, that is, for all i,
j {1,2, …, n} and i ≠ j, Li ( ju  i )  piij ( pijj )1 L j  Li ,
and L j (iu   j )  pijj ( piij )1 Li  L j , where Li = L( G i ),
and piij and p ijj are natural projections from
(ΣiΣj)* to  *i and to  *j , respectively (Mutual
controllability condition).
Under these conditions, for i=1, 2, …, n and any El  Li ,m ,
the set of Li ,m -closed languages,  ni1 ( pi | L ) 1 ( L ( Ei ))   L ( E ),
and pi ( L ( E )) is not blocking with respect to Li ,m .
Let pi be the natural projection from Σ* to Σi*. Let Li,m, Li ⊆ Σ*
represent respectively the marked and closed behaviours of
decentralised plant Gi. The marked and closed behaviours of
the
centralised
system
G
are
i
Note that piij ( p ijj ) 1 L j models the “external’ behaviour of Gj as
seen by Gi. The next natural question would be “for the DES
4556
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
structure which does not satisfy these eligibility conditions, is
there any way to modify it so that the resultant system could
possess the desired structural properties?” Since it has proven
that there would be huge computational savings by rearranging the structure of the DES, a synthesis method to
establish such DES structure would provide a great benefit in
the long term. The remaining part of this paper will address
this.
by Procedure I will satisfy the shared-event-marking
condition.
Lemma 2 Suppose that for given systems Gi, for i = 1,2, …, n,
DES G i are constructed by Procedure I. Then G'i marks
i   j for any i ≠ j.
Proof: Let s *i (i   j )  L'i ,m . That is s   *i ,   (i
 j ) and s  L'i ,m  L'i . So s  Li . Let q :=  i (q i 0 , s) .
Sysnthesis of Structural Discrete-Event System
This section presents a synthesis method to arrange the two
structural conditions of Theorem 1 for a given DES structure.
Firstly it will show how to synthesis DES structure for the
shared-event-marking conditions followed by that of the
mutual controllability conditions
Since s  L'i , i.e.,  i (q i 0 , s ) is defined,    G (q).
i
Arrangement for the shared-event-marking condition
Let Gi= (Qi , i ,  i , qi 0 , Qi ,m ) be generators over the alphabet
Intuitively, procedure I will ensure that before the
synchronous operations with other decentralised plants, each
decentralised plant should complete its respective tasks and be
ready for the synchronisation with other decentralised plants.
Therefore, G (q)  ( j i ( j ))   . So, q Qi,m . That is
i
 i (q i 0 , s)  Qi',m
Hence
s

Li,m
.
Therefore,
s  L'i ,m (i   j ) . The proof is done.
i   for i = 1, 2, …, n. Let i  ic  iu . Let Li and Li,m
be respectively the closed and marked behaviours of Gi. It is
assumed that Li ,m  Li , i.e., each decentralised plant is non-
Arrangement for the mutual controllability condition
In this section we present algorithms to arrange the system for
the mutual controllability condition. Assume Gi =
(Qi , i ,  i , q i 0 ) is defined as above. Suppose that the mutual
blocking. Suppose that the shared-event-marking condition in
Theorem 1 is not satisfied for some Gi, for i {1, 2, …, n}. In
other words, Li,m does not mark i   j for some j and j ≠ i.
controllability condition between Gi and Gj are not satisfied.
An algorithm is developed to modify it so that the resultant
systems, G i and G j , will satisfy the mutual controllability
For this situation, we develop the following Procedure I to
modify the system Gi so that the resultant generators G i = (Qi,
i ,  i , qi 0 , Q'i,m) will satisfy the shared-event-marking
condition. That is, for all i, j {1, 2, …, n} and i ≠ j,
*i (i   j )  Li,m  Li,m (i   j ), where Li,m is the
condition. That is, for all i, j {1,2, …, n} and i ≠ j,
Li( ju  i )  piij ( pijj )1 Lj  Li and Lj (iu   j )  pijj ( piij )1 Li  Lj .
For this, we firstly introduce the following Selfloop algorithm.
Let Ga:= (Qa , a ,  a , q a 0 ) and Gb:= (Qb , b ,  b , q b 0 ) be the
marked behaviour of G i . The new marker states of G i ,
finite, reachable generators. Assume that a  au  ac ,
b  bu  bc , au  b  bu  a and   a  b . Let
Qi,m  Qi, is obtained by Procedure I. Assume that all the
states are numbered, i.e., Qi = {q0, q1, …,
.
qli }, where li+1 is
pa and pb be the natural projections from ( a  b )* to  *a
the number of states of Gi. Let  G (qk ) be the active event set
i
and to  *b , respectively. Selfloop algorithm simply adds
selfloops of shared uncontrollable events to some states of
DES Ga when necessary. Hence the general structure of DES
Ga is not changed except that selfloops of some uncontrollable
shared events are added to some states. We denote the
selfloop algorithm as the following function for notational
simplicity:
at the state qk  Qi.
Procedure I: for shared-event-marking
Qi,m : Qi ,m . k : 0.
For k  li do
if q k  Qi ,m and  G i (q k )  ( j i ( j ))   ,
then Qi,m : Qi,m  {q k }
G as  S(G a , G b ).
end (if). k : k  1
end (for)
Gi : (Qi ,  i ,  i , qi 0 , Qi,m ).
Selfloop Algorithm
This procedure simply ensures all states before the
synchronisation among decentralised plants Gi to be marked.
The property of nonblocking in the original structure is
preserved. Since each Gi has a finite set of transitions and
states, the procedure will stop in a finite number of steps. The
following Lemma 2 shows that the resultant DES G i obtained
4557
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
G ab : G a  G b  (Qa  Qb , ,  ab , (qa 0 , qb 0 )).
function h:Q1 Q2 such that h○ 1 (q10 , s) =  2 (q20 , s) for s 
Define
L(G1).) Then L(G1)(  u )  L(G2)  L(G1) if and only if
h : Qa  Qb  Qb ,
g : Qa  Qb  Qa ,
( q a , q b )  qb
(q  Q1 ), G2 (h(q))  u  G1 (q).
( q a , qb )  q a .
Number Qa  Qb : Qa  Qb  {q0 , q1 ,..., ql }.
Proof: For one implication (), consider an event  such
that, for q  Q1,   G (h(q))  u . Since q  Q1 and G1 is
2
G as (1) : G a . k : 0.
For k  l do
reachable, there exists a string s  L(G1) such that q =
1 (q10 , s)  Q1. Also,   G 2 (h(q))  G 2 (h(1 (q10, s))) 
 sk :  G b (h(qk ))  ( au   b )   G a b (qk ).
If  sk   , then
G as (k ) : S
end (if).
g ( qk ) s
(G a (k  1)).
 sk
G 2 ( 2 (q20, s)). That is  2 (q20 , s ) is defined, or s  L(G2).
Therefore s  L(G1)(  u )  L(G2)  L(G1). Hence
defined.
So
1 (q 10 , s )  Q1 or
1 (q 10 , s ) is
k  k 1
end (for)
G as : G as (k ).
  G (1 (q10 , s))  G (q). For the reverse implication
1
Then, the following Algorithm I produces two systems that
satisfies one direction of mutual controllability condition:
L(G1),   (u ) , and s  L(G2). Hence 1 (q10 , s)  Q1.
Therefore
by
assumption, G (h(1 (q10 , s)))  u 
2
Algorithm I (One Directional Mutual Controllability
condition)
G1 (1 (q10, s))
1. G : (Q ,  a ,  , q ) such that L(G )  pa ( pb ) L(G b ).
P
b
P
b
P
b
P
b0
P
b
1
(), consider a string s  L(G1)(  u )  L(G2), i.e., s
1
or
G2 ( 2 (q20 , s))  u  G1 (1 (q10 , s)).
Since s  L(G2), one has that  2 (q20 , s )  Q2. That is
,
Therefore,
since
  G 2 ( 2 (q20, s)).
 u
2. Obtain G1as  S(G a , G bP ).
3. k : 1.
  G ( 2 (q20 , s))  u  G (1 (q10 , s)). That is 1 (q10 , s )
4. Find G kas1  S(G kas , G bP ),
2
1
is defined, or s  L(G1).
5. If G kas1  G kas , then G f  G kas1 and stop
6. Otherwise k : k  1 and go to Step 4.
Lemma 4 For given languages K, L * , Ku  L  K
if and only if ( K  L)u  L  ( K  L).
Again, for notational convenience, we denote Algorithm I as a
function:
G f  F1 (G a , G b ).
Algorithm I keeps adding selfloops of shared uncontrollable
events to some states in Ga until L( G ka ) is controllable with
Proof: For one implication (),
( K  L)u  L  Ku  Lu  L  Ku  L  Ku  L  L  K  L
(by assumption)
For the reverse inclusion, let s  Ku  L. Therefore,
respect to pa(pb)-1L(Gb) and ( au  b ), i.e., satisfying one
s  K ,  u and s  L . Hence, s  K  L. Therefore,
direction of mutual controllability condition. Intuitively this
can be interpreted as allowing shared uncontrollable events
(like machine breakdown or safety event) to happen in other
subplants but they should be monitored in all other
decentralised plants, so that any necessary actions could be
taken in the corresponding decentralised plants. Definitely,
Algorithm I will stop since the generators Gi is assumed to
have finite numbers of states and transitions. Proposition 1
shows that L(Gf) is controllable.
s  ( K  L)u  L  ( K  L) by assumption. So, s  K .
Now, one is ready to prove Proposition 1.
Proof of Proposition 1: Recall that the selfloop algorithm
S(G a , G bP ) simply adds selfloops of some shared
uncontrollable events to some states of the original system Ga.
So, when one obtains Gf in Step 5 of Algorithm I, one has that
k
k
G f  G kas  G kas1. Let us define G as : (Qa ,  a ,  a , qa 0 ) and
Proposition 1 Let Ga := ( Qa , a ,  a , qa 0 ) and Gb := (Qb,
are the
G kas1 : (Qa ,  a ,  ak 1 , qa 0 ) , where  a and  a
original transition function  a plus some selfloops added by
the selfloop algorithm. In the first step of the selfloop
algorithm, one has that G kab  G kas  G bP , and hence
G kab refines G kas and G bP . Therefore, there are unique functions
k
b ,  b ,qb0) be defined as in the selfloop algorithm. Let
P
G bP :=( QbP , a ,  bP , qbP0 ) be such that L( G b )=pa(pb)-1L(Gb). Let
G f  F1 (G a , G b ). Then L(Gf) is controllable with respect to
L( G bP ) and  u , i.e., L(Gf)  u  L( G bP )  L(Gf).
We need the following lemmas to prove Proposition 1.
k 1
h:Qa  QbP  QbP and g:Qa  QbP  Qa . Since G kas  G kas1 , one has
that  ak   ak 1 . Thus, for q  Qa  QbP , one has that
k
k
P
 (h(q))  u   (q). Since G ab refines G as and G b , by
Lemma 3 Let Gi := ( Qi , i ,  i , qi 0 ), for i=1, 2, be the
reachable generators. Let   1  2 and   u  c .
Suppose that G1 refines G2 (Thus, there exists a unique
G bP
Lemma
4558
G kab
3,
L(G kab )u  L(G bP )  L(G kab ).
Since
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
condition. Thus, the resultant pair L1 and L2 are mutually
controllable.
Again this algorithm is simply adding selflooping of shared
uncontrollable events to a certain state in one decentralised
plant to allow those uncontrollable shared event happen in
other decentralised plant. Intuitively it is quite logical. Since
we cannot prevent those uncontrollable events happens in the
other plant, we simply allow them to happen but we need to
monitor so that necessary actions in the corresponding
decentralised plant can be made. Using Algorithm II,
Algorithm III is obtained to arrange the mutual controllability
condition for a system with n subsystems.
L(G kab )  L(G kas )  L(G bP ) and G f  G kas , by Lemma 4, we have
P
b
L(G f )u  L(G )  L(G f ).
Using this, we now can establish the following Algorithm II
for the mutual controllability condition for a given pair of
systems, say G1 and G2. Again for notational convenience, we
denote Algorithm II as a function:
(G1 , G2 )  F2 (G1 , G 2 ).
Algorithm II (Mutual Controllability condition for a pair
of system)
1. Let m  0
2. Let G1m  G1 and G 2m  G 2
3. Using algorithm I, find G1m1  F1 (G1m , G 2m ).
4. Again using algorithm I, find G
5. If G
m 1
2
m 1
2
m
2
 F1 (G , G
m 1
1
Algorithm III (Mutual Controllability for a system with n
subplants)
).
1. Let G 0j  G j for j  0, 1,..., n
 G , Then let G1  G1m1 and G 2  G 2m1 and stop.
m
2
2. Let k  0, i  1.
6. Otherwisem, m  m  1, and go to Step 7
3. Let (G ik 1 , G ik12 )  F2 (G ik , G ik1 ).
7. Find G1m1  F1 (G1m , G 2m ).
4. Do (G ik12 , G ik21 )  F2 (G ik11 , G ik2 ), i  i  1, while i  n  2.
8. If G1m1  G1m , Then let G1  G1m1 and G 2  G 2m1 , and stop
5. (G nk 2 , G1k 2 )  F2 (G nk 1 , G1k 1 ).
9. Otherwise, go to Step 4.
6. If G ik 2  G ik for all i  1, 2,...n, then go to Setp 8
Algorithm II is the procedure which adds selfloops of shared
uncontrollable events to some states in a given pair of systems
G1 and G2 repeatedly until the mutual controllability condition
is satisfied. Since the given pair of DES G1 and G2 is assumed
to have finite number of states and transitions, Algorithm II
will stop in a finite number of steps. The proof that L'1 and L'2
are mutually controllable is given in the following Proposition
2, where Li = L( G i ) for i=1, 2.
7. Otherwise, let k  k  2 and i  1 and go to Step 3.
8. Let G i  G ik 2 for all i  1, 2,..., n, and stop
Algorithm III is to arrange all pairs of subsystems in a given
plant using Algorithm II so that each pair of all subsystems is
mutually controllable. Since the number of plants is finite and
each subsystem is assumed to have finite number of states and
transitions, Algorithm III is guaranteed to converge in a finite
number of steps. The following proposition shows that each
pair of the Li , for i=1, 2,…, n, is mutually controllable.
Proposition 2 For a given pair of systems G1 and G2, suppose
that DES G 1 and G 2 are obtained by Algorithm II, i.e.,
(G1 , G2 )  F2 (G1 , G 2 ). Then L'1 and L'2 are mutually
Proposition 3 For given systems Gi, for i=1, 2,…, n, suppose
that the systems G i are obtained by Algorithm III. Then each
controllable.
pair of the Li is mutually controllable.
Proof: The Algorithm II proceeds explicitly as follows. At the
beginning, we obtain G 11 from the pair (G1, G2), using
Algorithm I. So, by Proposition 1, one knows that L( G 11 ) is
controllable with respect to the ‘external’ behaviours of L(G2)
and 2u  1 (one directional mutual controllability
Proof: Since the number of plants is finite and we assume that
each subsystem has finite numbers of states and transitions,
Algorithm III will eventually stop. Thus for some k, one has
that G ik  G ik 2 , meaning that no additional selfloops are
condition). Then again using Algorithm I, we obtain G12 from
the pair (G2, G 11 ). Again by Proposition 1, L( G 12 ) is
controllable with respect to the ‘external’ behaviours of
L( G 11 ) and 1u  2 . If G 12 =G2, one has that L( G 11 ) and
required for the mutual controllability conditions. Hence one
has that G ik  G ik 1  G ik 2 . Therefore, clearly all pairs are
mutually controllable.
Note again that intuitively, selflooping of shared
uncontrollable events on one system Gi can be interpreted as
to allowing those events to happen but ‘monitoring’ the other
subsystem Gj by Gi, with keeping in mind that Gi would need
to take any actions when necessary.
Note that the synthesis looks complicated but it needs to be
done at the initial stage of establishing such DES or any major
changes requiring rearrangement of physical system are
introduced. Once established, any minor changes of the
system would be implemented without further complicated
verifications. Hence in the long run, it could definitely bring
large computational savings. It is clear that these
L( G 12 ) are mutually controllable by the controllability
obtained in the above. So, we denote G1  G11 and G2  G12 .
2
Otherwise, using Algorithm I again, we obtain G 1 . One
knows that L( G 12 ) is controllable with respect to the
‘external’ behaviours of L( G 12 ) and 2u  1 . In here, if G 12 =
G 11 , then L( G 12 ) and L( G 12 ) are mutually controllable. So, we
denote G1  G12 and G 2  G12 . We repeat the procedure until
we find a pair which satisfies the mutual controllability
4559
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
modifications are exactly matched with the intuitive
understanding of operations of DES.
Examples
In this section, we illustrate our results with two examples.
Firstly, an example for the arrangement of the shared-event
marking condition is presented. Figure 1 shows a system with
three subplants. In the figure, a circle represents (○) a state
and an arrow (with a label) from an exit state to the entrance
state represents an event. Also an entering arrow (○)
indicates the initial state and an exiting arrow (○) represents
the marker state, while the double arrow (○) shows the
initial state and the marker state. The arrow with a bar in the
middle represents a controllable event. The event sets for
three subplants are 1 = {1 ,  2 , 3 ,  4 , 1 ,  1} ,  2 =
Figure 2: The resultant systems after the shared-event
marking condition is arranged
{5 ,  6 , 1 , 2 ,  1} and  3 = {7 , 8 , 9 , 1 , 2 ,  1} .
Assume that all events are controllable. Clearly, this system
does not satisfy the shared-event-marking condition, hence
requires arranging the system for the condition. We explain
the procedure for G1 in detail. Firstly, the state A0 is already
Secondly, an example for the mutual controllability condition
is presented. Firstly, for a pair of systems, we consider two
systems modelled as in Figure 3(a). Assume that all the states
are marked. Let G1 and G2 be generators of L1 and L2
respectively, defined as follows: G1 := ( Q1 , 1 , 1 , q10 ), and G2
:= ( Q2 , 2 ,  2 , q20 ), where Q1 = { A0 , A1 , A2 , A3 }, Q2 =
marked, i.e., A0  Qi,m . The active event set for the state A1 is
G1 ( A1 )  {1}. So G1 ( A1 )  ( j 1 ( j ))  . Hence A1  Qi,m .
Also,
for
the
state
A2
G1 ( A2 )  { 1}.
,
So
{ B0 , B1 , B2 , B3 }, 1  {1 ,  2 , 3} , and 2  {1 ,  2 ,  4 } .
The state transition for G1, 1 : ( A0 , 1 )  A1 , ( A1 ,  2 )  A2 ,
( A2 , 3 )  A3 and ( A3 ,  2 )  A3 , and those for G2,
G1 ( A2 )  ( j 1 ( j ))  . Hence A2  Qi,m . However, for the
state A3 , G ( A3 )  { 2 ,  4 }. So G ( A3 ) 
1
1
( j 1 ( j ))  .
Therefore, A3  Qi,m . Similarly, A4  Qi,m . The systems G2
 2 : ( B0 , 1 )  B1 ,
( B1 ,  2 )  B1 , ( B1 ,  4 )  B2 , and
( B2 ,  2 )  B3 . The initial states are q10  A0 and q20  B0 .
The shared event set is 1  2  {1 ,  2 }.
Assume that 1 is a controllable event, while  2 is an
uncontrollable event. So, 1u  2u  { 2 }. Then define a new
and G3 can also be arranged similarly. The resultant systems,
G 1 , G 2 and G 3 are presented in Figure 2. Note that the
implementation of physical system should be done
accordingly so that the decentralised system will guarantee the
same behaviour as the optimal behaviour of the centralised
system.
generator G 2P such that L( G 2P )=p1(p2)-1L(G2) (Figure 3(b));
P
where
),
G 2P : (Q2P , 1 ,  2P , q20
Q2P  {C0 , C1},
 2P : (C0 , 1 )  C1 , (C0 ,  3 )  C0 , (C1 ,  2 )  C1 , (C1 ,  3 )  C1 ,
P
P
and q20
 C0 . Then compute the product G12
 G1  G 2P
P
P
(Figure 3(c)): G12
)),
 G1  G 2P  (Q1  Q2P , 1 , 1   2P , (q10 , q20
P
where
Q1  Q2  {( A0 , C0 ), ( A1 , C1 ), ( A2 , C1 ), ( A3 , C1 )},
1   2P  (( A0 , C0 ),1 )  ( A1 , C1 ), (( A1 , C1 ), 2 )  ( A2 , C1 ) ,
and
(( A2 , C1 ), 3 )  ( A3 , C1 ), (( A3 , C1 ), 2 )  ( A3 , C1 ),
P
P
P
refines G1 and G12
, there exist
(q10 , q20
)  ( A0 , C0 ) . Since G12
unique functions h1: Q1× Q2P  Q2P and g1: Q1× Q2P  Q1,
P
P
such
that
and
h 1 (1 ,  2P )((q10 , q20
), s)   2P (q20
, s)
P
g 1 (1 ,  2P )((q10 , q20
), t )  1 (q10 , t ) , where the strings s, t
P
 Lm (G12
) . So one can easily find the functions h1 and g1
Figure 1: DES models to arrange the system for the sharedevent marking condition
given as follows:
h1 ( A0 , C0 )  C0 ,
h1 ( A1 , C1 )  C1 ,
h1 ( A2 , C1 )  C1 ,
h1 ( A3 , C1 )  C1 ,
g1 ( A0 , C0 )  A0 ,
g1 ( A1 , C1 )  A1 ,
g1 ( A2 , C1 )  A2 , and g1 ( A3 , C1 )  A3 .
4560
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
h1 ( B1 , D1 )  D1 ,
h1 ( B0 , D0 )  D0 ,
Then, using the selfloop algorithm, G11s  S(G1 , G 2P ) is
computed as follows (Step 2 in Algorithm I): Firstly, for a
state ( A0 , C0 )  Q1  Q2P , since (1u  2u )  { 2 } , ( A0 , C0 )
 {1} and (h1 ( A0 , C0 ))  (C0 )  {1 , 3} , one has that
h1 ( B2 , D1 )  D1 ,
h1 ( B3 , D1 )  D1 ,
g1 ( B1 , D1 )  B1 ,
g1 ( B2 , D1 )  B2 , and g1 ( B3 , D1 )  B3
(see
s  (h1 ( A0 , C0 ))  (1u  2u )  ( A0 , C0 )  . So, no selfloop
figure
4(b)). Then,
by the
g1 ( B0 , D0 )  B0 ,
selfloop
algorithm,
G12 s  S(G 2 , G11P ) is computed (Step 2 in Algorithm I) as
is required at the state g 1 ( A0 , C0 )  A0  Q1 . At the state
( A1 , C1 ),  2 is already defined. For the state ( A2 , C1 ) , since
follows: One can find that for the state (B , D1),  s  { 2 } .
So one needs to selfloop  2 at the state g1 ( B3 , D1 )  B3  Q2 .
( A2 , C1 )  {3} and (C1 )  { 2 , 3}, one has that
s  { 2 }. So one needs to selfloop  2 at the state
g1 ( A2 , C1 )  A2  Q1 . Similarly, one can find that  s   at
So G12s =( Q2 ,  2 ,  2 , q20 ) is obtained where  2 consists of all
1
the
transitions
of
1
2
with
an
additional
selfloop
( B3 ,  2 )  B3 . Again one obtains G 22 s  S(G12 s , G11P ) (Step 4
the state ( A3 , C1 ) . So one obtains G11s =( Q1 , 1 , 11 , q10 )
in Algorithm I). It is found that G12 s  G 22 s . So, let G12  G 22 s
where 11 consists of all the transitions of 1 with an additional
selfloop ( A2 ,  2 )  A2 (Figure 3(d)).
(Step 5 in Algorithm I). One knows that L(G12 ) is controllable
with respect to L(G11P ) . Since G12 ≠ G2, one needs to repeat
Algorithm II for a pair G 11 and G 12 (Step 6 in Algorithm II).
Then one obtains G 12 (Step 7 in Algorithm II). It is found that
G12  G11. Therefore, the resultant DESs are given by
G1  G12 and G2  G12 (Step 8 in Algorithm II). The closed
behaviours of the resultant DESs G 1 and G 2 are given in
Figure 4(c). Clearly, one can see that the languages L( G 1 )
and L( G 2 ) are mutually controllable. This process could
easily be extended to the plants consisting more than 2
decentralised plants.
Conclusions
In this paper, for the systems which do not satisfy the
structural decentralised DES conditions, we have developed
an approach to synthesize the systems so that the resultant
systems will possess the desired structural properties. For the
shared-event-marking condition, we have shown a systematic
method in which all the necessary states are marked to ensure
the readiness of synchronisation among the decentralised
plants. For the mutual controllability condition, we firstly
introduce selfloop operation, and then we have presented an
algorithm to add selfloops of shared uncontrollable events so
that the resultant systems are pairwise mutually controllable.
Again the procedure is somewhat complicated. However, this
procedure is applied to the structure of the systems and it
needs to be done only once at the initial establishment stage or
some major changes being introduced. Then for any family of
Li,m-closed specification languages, one can use decentralised
control without further verification process. This definitely
provides a long-term saving on computational burden. In
future works, it might be interesting to find certain structures
which might not need to arrange the eligibility condition. We
have already identified such structures like a plant consisting
of locally mutually exclusive plants.
Figure 3: Example: to arrange the system for mutual
controllability
Then again, we can find G12s  S(G11s , G 2P ) (Step 4 in
Algorithm I) as G11s  G12s . So let G11  G12s (Step 5 in
Algorithm I). Hence by Proposition 1, one knows that
L(G11 ) is controllable with respect to L(G 2P ) (Step 3 in
Algorithm II). Then for the pair G 11 and G2, we define G11P
such that L( G11P )=p2(p1)-1L( G 11 ): G11P : (Q1P , 1 , 11P , q10P ),
where Q1P  {D0 , D1}, 11P  ( D0 ,1 )  D1 , ( D0 , 4 )  D0 ,
( D1 , 2 )  D1 , ( D1 , 4 )  D1 , and q10P  D0 (see Figure
P
4(a)). Then find the product G 21
 G 2  G11P as follows:
P
P
)),
G 21
 G 2  G11P  (Q2  Q1P ,  2 ,  2  11P , (q20 , q10
where
P
1
Q2  Q  {(B0 , D0 ), ( B1 , D1 ), ( B2 , D1 ), ( B3 , D1 )},
 2  11P  (( B0 , D0 ),1 )  ( B1 , D1 ),
(( B1 , D1 ), 4 )  ( B2 , D1 ),
(( B1 , D1 ), 2 )  ( B1 , D1 ),
P
)  ( B0 , D0 ). We
(( B2 , D1 ), 2 )  ( B3 , D1 ), and (q20 , q10
knows that G121P refines G2 and G11P . So one has the unique
functions h1: Q2× Q1P  Q1P and g1: Q2× Q1P  Q2, as follows:
4561
International Journal of Applied Engineering Research ISSN 0973-4562 Volume 11, Number 6 (2016) pp 4554-4562
© Research India Publications. http://www.ripublication.com
[10]
[11]
[12]
[13]
[14]
Figure 4: The resultant system after mutual controllability
condition arrangement
[15]
Acknowledgement
This work was supported by the University of Incheon
(International Cooperative) Research Grant in 2012.
[16]
References
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
P.J. Ramadge and W.M. Wonham, Supervisory
control of a class of discrete-event processes. SIAM J.
Control and Optimization, 25:1(1987) 206-230.
W.M. Wonham, Notes on control of discrete-event
systems. ELE 1636F/1637S 2010-11, Department of
Electrical Engineering, University of Toronto,
Toronto, Canada, 2011.
S.H. Lee & K.C. Wong, Structural decentralised
control of concurrent discrete-event systems.
European Journal of Control, 8:5(2002) 477-491.
P.J. Ramadge and W.M. Wonham, Modular
supervisory control of discrete event systems. Mathematics of Control, Signal and Systems, 1:1(1988)
13-30.
F. Lin and W.M. Wonham, Decentralised
supervisory control of discrete-event systems. Information Sciences, 44(1988) 199-224.
K. Rudie and W.M. Wonham, Think globally, act
locally: Decentralized supervisory control. IEEE
Transactions on Automatic Control, 37:11 (1988)
1692-1708.
T.S. Yoo and S. Lafortune, A general architecture for
decentralized supervisory control of discrete-event
systems, Discrete Event Dyn. Syst., Theory Appl.,
12:3 (2002) 335-377
J. Komenda and J.H. van Schuppen Modular control
of discrete-event systems with coalgebra, IEEE
transaction Automatic Control, 53:2 (2008) 447-460.
J. Komenda, J.H. van Schuppen, B. Gaudin, and H.
Marchand, Supervisory Control of Modular Systems
with Global Specification Languages. Automatica,
44:4(2008)1127-1134.
4562
B. Gaudin and H. Marchand, An efficient modular
method for control of concurrent discrete-event
systems: A language-based approach, Discrete-event
dynamic systems, 17 (2007)179-209.
K. Cai and W.M. Wonham, Supervisor localization:
A top-down approach to distributed control of
discrete-event systems, IEEE Transaction on
Automatic Control, 55: 3(2010) 605-618.
C.G. Cassandras and S. Lafortune, Introduction to
Discrete Event Systems, 2nd ed. Springer, New York,
2008.
C. G. Cassandras, S. Lafortune, and G. J. Olsder,
Introduction to the modelling, control and
optimisation of discrete-event systems. In A. Isidori,
editor, Trends in Control-European perspective,
pages 217-291. Springer-Verlag. 1995.
Y. Willner and M. Heymann, Supervisory control of
concurrent discrete-event systems. International
Journal of Control, 54:5(1991)1143-1169.
P. Kozak and W.M. Wonham, Fully decentralised
solutions of supervisory control problems. IEEE
Transactions on Automatic Control, 40:12
(1995)2094-2097.
H.I. Son, Design and implementation of
decentralised supervisory control for manufacturing
system automation. International Journal of
Computer Integrated Manufacturing, 24:3 (2011)
242-256