Equivalence and Minimization of Output Augmented DEVS∗ Moon Ho Hwang Simulation & Control Center, Cubictek. Co. Ltd., Seoul, Korea [email protected], http://hmh2002.hihome.com Abstract – We propose an augmented DEVS (discrete event system specification) which is able to generate an event string when it receives an input event or its scheduled internal event is triggered. This augmentation is useful in the model analysis since we can generate equivalent behavior with fewer states. For identifying equivalent behavior, introduced in this paper is a timed language that is a set of event trajectories. Based on the general timed language, this paper also defines a timed language which is generated by the augmented DEVS. Ways of identifying equivalent states and equivalent DEVSs are introduced according to language. We also show some methods for minimization of the augmented DEVS while guaranteeing preservation of equivalent behavior in terms of its generating languages. Keywords: Timed Language, Output Augmented DEVS, Equivalence, Minimization

1

Introduction

DEVS (Discrete Event System Specification) [1] is a formalism describing system behavior in terms of time when discrete events occur in a modular and hierarchical manner. DEVS is recognized as a promising method for modeling, analysis, and simulation of discrete event dynamic systems (DEDS) [2]. Due to its modeling power and its simulation functionality, it has been applied to various kinds of systems such as software, communication systems , control systems, fuzzy systems , manufacturing systems and so on. In spite of its many applications, however, two important questions have remained unanswered: 1) How can we determine that two DEVSs are equivalent in terms of behavior? 2) How can we minimize the states of a DEVS while preserving equivalent behavior? Unlike the previous researches [4] and [5] using untimed behavior, we would like to state the equivalence and minimization in the sense of timed behavior. So we first define the timed language as a set of event trajectories. The language is used to define a behavior of a DEVS by tracking which events happen at a specific ∗ 0-7803-7952-7/03/$17.00

c 2003 IEEE.


time. In addition, this paper proposes an augmented DEVS because its compactness will contribute to minimizing the number of states more effectively than the ordinary DEVS. In this paper, we augment DEVS such that it allows the generation of an event string when it receives an input event or its internal event time arrives. Using the timed language and the augmented DEVS, we can define some equivalencies and show some methods of minimization of the proposed DEVS. However, from the view point of ordinary DEVS formalism in which there are two models: atomic and coupled, this paper concerns with the atomic DEVS not the couple one. Thus similar approach to output augmented DEVS networks will be researched in the future. This paper is organized as follows: Section 2 presents the event segment, its operation, and timed event language. In Section 3, we present the output augmented DEVS, its trajectory functions, and some languages generated by the proposed DEVS. Based on the most specific language, denoted by LTX@Y , Section 4 defines equivalences of two states and two DEVSs, and shows a minimization method of the proposed DEVS. In terms of a timed language, denoted by LTXY which is less exact but more abstract than LTX@Y , the equivalence and a minimization method are shown in Section 5. Section 6 summarizes this paper.

2

Event Segments and Timed Language

For the definition of a timed event segment, we need to introduce an arbitrary event set A and a totally or(non negative real number). dered time base T = +∞ 0 We can consider a situation that a event string s ∈ A∗ occurs when time is t ∈ T where A∗ denotes the set of all finite strings of elements of A, called the Kleene closure of A [3]. For example, if A = {a, b}, then A∗ = {ø, a, b, aa, ab, ba, bb, aaa, aab, aba, baa, abb, bab, bba, bbb, . . .} where ø denotes nonevent. Here, we can say that the timed event string is defined as (s, t). A function of the form ω : T → A∗ is called a trajectory function. Notice that since nonevent is an element of A∗ for any A so the trajectory function answers that event string in-

cluding an event and nonevent occurs at a certain time. For representing a trajectory, we can also use a relation set such as (A∗ , T ) instead of the ω function form. Restricting w to a T  ⊆ T is denoted by ω|T  : T  → A∗ where ω|T  = w(t), ∀t ∈ T  . A restriction of ω to a time interval [ti , tf ] is called an event segment(hereafter, “segment”) and we sometimes write ω : [ti , tf ] → A∗ or ω[ti ,tf ] , in which ti is the initial time and tf is the final time such that ti ≤ tf . If there is a segment ω[ti ,tf ] , then we can define two functions: length function l : (A∗ , T ) → T0+∞ such that l(w[ti ,tf ] ) = tf − ti , and domain function dom : (A∗ , T ) → T × T such that dom(w[ti ,tf ] ) = [ti , tf ]. If there are two segments ω1 and ω2 then we can say that dom(ω1 ) = dom(ω2 ) if and only if their initial times and final times are equivalent, respectively. Figure 1(a) shows an example of an event segment. ω(t1 ) = b, ω(t2 ) = aabc,ω(t3 ) = cb, ω(t) = ø, otherwise. And this event segment has its own length l(ω) = t4 −t0 and its own domain as dom(ω) = [t0 , t4 ]. For each τ ∈ T , we define a unary operator on the segment, translation operator: T RAN Sτ : (A∗ , T ) → (A∗ , T ). If there is ω : [ti , tf ] → A∗ then T RAN Sτ (ω) = ω  : [ti + τ, tf + τ ] → A∗ such that ω  (t) = ω(t − τ ), t ∈ [ti + τ, tf + τ ]. Figure 1(b) shows a translation example of the segment of Figure 1(a), in which the translation value τ = −t1 . A pair of segments ω1 : [t1 , t2 ] → A∗ and ω2 : [t3 , t4 ] → A∗ are said to be contiguous if their domains are contiguous, i.e., t2 = t3 . For contiguous segments ω1 and ω2 we define the concatenation operation ω1 · ω2 : [t1 , t4 ] → A∗ such that   , t ∈ [t1 , t2 ) ω1 (t) ω1 · ω2 (t) = ω1 (t) · ω2 (t) , t = t2   ω2 (t) , t ∈ (t3 , t4 ] where ω1 (t) · ω2 (t) is the concatenation of the event string such that if ω1 (t) = (s1 , t) and ω2 = (s2 , t) then ω1 (t) · ω2 (t) = (s1 s2 , t). Figure 1(c) illustrates an example of concatenation. If there is no confusion, we will omit ‘·’ so ω1 ω2 is the same as ω1 · ω2 . 1 Without changing the domain of the segment, we can operate on the range of a segment. There is a projection unary operation PBT : (A∗ , T ) → (B ∗ , T ) for B ⊆ A such that  (PB (s), t) if ω1 = (s, t) T PB (w1 ) = T T PB (w2 )PB ((s, t)) if ω1 = ω2 (s, t) where ω1 , ω2 ⊆ (A∗ , T ), s ∈ A∗ , t ∈ T . And PB : A∗ → 1

For concatenation of two discontiguous segments such as ω1:[t1 ,t2 ] , ω2:[t3 ,t4 ] where t2
= t3 , we can apply the translation operator to ω2 for making them contiguous. For example,  T RAN St2 −t3 (ω2 ) = ω2 such that ω2:[t . And then we 2 ,t4 −t3 +t2 ] can apply the concatenation operation between ω1 and ω2 .

Figure 1: Segment and its Operation (a) ω : [t0 , t4 ] → A∗ where A = {a, b, c} (b) Translation (c) Concatenation (d) Projection to B = {b, c} B ∗ for B ⊆ A such that   ø PB (s1 ) = c   PB (s2 )PB (c)

if s1 = c ∧ c ∈ B if s1 = c ∧ c ∈ B if s1 = s2 c

for s1 , s2 ∈ A∗ , c ∈ A. Figure 1(d) shows a projected segment whose original segment is of Figure 1(a) and the projection space is B = {b, c}. Finally, a timed language is a set of event segments. For example, LT1 = {ω[0,30] } where ω[0,30] (t) = b ∈ {0, 1}, if t = c ∗ 10, c = 0, 1, 2, and ω[0,30] (t) = ø, otherwise. If there are ω1 = (0, 0)(0, 10)(0, 20), ω2 = (0, 0)(0, 5)(0, 15) and ω3 = (1, 0)(2, 10)(3, 20) then ω1 ∈ LT1 but ω2 , ω3 ∈ LT1 . All kinds of operation over segments can be extended to apply to timed languages. Let LTA and LTB be timed languages over event states A and B, respectively. 1. The translation of LTA , {T RAN Sτ (ω)|∀ω ∈ LTA }.

T RAN Sτ (LTA )

and 2. The concatenation LTA T T T LA LB ={ω1 ω2 |∀ω1 ∈ LA , ∀ω2 ∈ LTB }.

= LTB ,

3. The projection LTA to LTB where B ⊆ A, PBT (LTA ) = {PBT (ω)|∀ω ∈ LTA }.

3 3.1

Output Augmented DEVS Formal Definition

Following is the formal definition of the output augmented DEVS. An output augmented DEVS is a 8-tuple, D =< X, Y, S, s0 , SF , ta , λ, δ > where, • X is the input events set. • Y is the output events set. • S is the sequential states set.

• s0 ∈ S is the initial state. • SF ⊆ S is the finally acceptable states set whose elements can be considered task completion states. is the time advance function • ta : S → +∞ 0 denotes non-negative real numbers. where +∞ 0 Here, we can define the total state such that Q = {(s, r)|s ∈ S, 0 ≤ r ≤ ta (s)} where r is the remaining time in a state s ∈ S. Suppose tL is the last event time and t is the current time then the remaining time r is equal to tL + ta (s) − t. • λ : S × (X ∪ {@}) → Y ∗ is the output function where @ ∈ X denotes the scheduled event occurring when its remaining time reaches 0 without any interruption of x ∈ X and Y ∗ is the Kleene closure of Y . • δ : S × (X ∪ {@}) → S is the state transition function or transition function. For s ∈ S, we call δ(s, x) an external transition and δ(s, @) an internal transition. Example 1 (Simple Traffic Lights) Let’s consider a traffic light system which has one green light and one red light with a toggle button as shown in Figure 2 (a). If one of two lights is turned on, the other will be turned off. The lights will alternate every 15 seconds unless the toggle button is pushed. That is, if the toggle button is pushed, the lights will switch. We can model the light system using OA-DEVS as following. X = {x}, Y = {g:0, g:1, r:0, r:1},2 S = {G, R}, s0 = G, SF = {G}, ta (G) = 15, ta (R) = 15, δ(G, x)=δ(G, @) = R, δ(R, x)=δ(R, @) = G, λ(G, x)=λ(G, @) =g:0r:1, and λ(R, x)=λ(R, @) =r:0g:1. Figure 2(b) illustrates the OA-DEVS model for the light system. We uses the following graphical notation in this paper: a state is denoted by a circle; the initial state is indicated by an arrow; a final state is denoted by a double circle; a directed arrow s1 and s2 with a label x/y1 y2 ... indicates a transition δ(s1 , x) = s2 and an output λ(s1 , x) = y1 y2 .

3.2

Trajectories of OA-DEVS

Now we turn our attention to trajectories associated with OA-DEVS. The time base of event segments T is real number (=) and suppose D is an atomic OADEVS D =< X, Y, S, s0 , SF , ta , λ, δ >, s ∈ S and a, b ⊆ ΩX@ where ΩX@ is the set of ((X ∪ {@})∗ , T ), and c ∈ X ∪ {@} ∪ {ø}. Then we can define the following timed trajectories: The transition trajectory δˆ : S × ΩX@ → S, is defined as  s if a = (c, t) ∧ ¬δ(s, c)!    δ(s, c) if a = (c, t) ∧ δ(s, c)! ˆ a) = δ(s, ˆ ˆ b), c)!  δ(s, b) if a = b(c, t) ∧ ¬δ(δ(s,    ˆ ˆ b), c)! δ(δ(s, b), c) if a = b(c, t) ∧ δ(δ(s, (1) 2g

: 0 denotes 0 is outputted through port g

Figure 2: Simple Traffic Lights (a) Target System (b) OA-DEVS. where δ(s, c)! denotes that δ(s, c) is defined while ¬δ(s, c)! denotes that δ(s, c) is not defined. The total ˆ : S × ΩX@ → ΩX@Y where ΩX@Y is the set trajectory Γ of ((X ∪ {@} ∪ Y )∗ , T ), is defined as  if a = ø ˆ a) = ø Γ(s, ˆ b), c), t) if a = b(c, t) (2) ˆ b)(c · λ(δ(s, Γ(s,

3.3

Timed Languages of OA-DEVS

Based on the timed trajectories defined in Section 3.2, we can define some timed languages associated with OA-DEVS. Suppose that D is a OA-DEVS D =< X, Y, S, s0 , SF , ta , λ, δ >. And ΩX@ and ΩX@Y denotes the sets ((X ∪ {@})∗ , T ) and ((X ∪ {@} ∪ Y )∗ , T ), respectively. The timed transition language, denoted by LTX@ (D) is defined as ˆ 0 , a) = s ∈ SF } LTX@ (D) = {a ⊆ ΩX@ | δ(s

(3)

The timed total language or timed language tracing all kinds of input events X, the internal event @, and output events Y , denoted by LTX@Y (D), and is defined as ˆ 0 , a) = b} LTX@Y (D) = {b ⊆ ΩX@Y | ∀a ∈ LTX@ (D), Γ(s (4) Sometimes we are concerned only with the input events and the output events and would like to ignore the internal events. At this time, the appropriate language is the timed IO language, denoted by LTXY , and it is defined as LTXY (D)

T = PXY (LTX@Y (D))

(5)

T is the language projection from ΩX@Y to where PXY ΩXY = ((X ∪ Y )∗ , T ).

Example 2 (Languages of Traffic Lights) For language examples associated with an OA-DEVA D, we would like to use the traffic lights introduced in Example 1 as D. Assume the situation without

pushing the button. Then (@g:0r:1,15)(@r:0g:1,30) and (@g:0r:1,15)(@r:0g:1,30)(@g:0r:1,45)(@r:0g:1,60) are elements of LTX@Y (D) but (@g:0r:1,15) and (@g:0r:1,15)(@r:0g:1,30)(@g:0r:1,45) are not. Suppose we push once when time is 20. Then (@g:0r:1,15)(xr:0g:1,20) is also an element of LTX@Y (D) but (@g:0r:1,15)(xr:0g:1,20)(@g:0r:1,35) is not. If we are interested in the IO timed language, (g:0r:1,15)(r:0g:1,30), (g:0r:1,15)(r:0g:1,30)(g:0r:1,45)(r:0g:1,60) and (g:0r:1,15)(xr:0g:1,20) can be elements of LTXY (D).

4

LTX@Y Equivalence and Minimization

Under the condition tracing all event types including X, {@} and Y , the equivalent states means that they are substitutable for each other, so one equivalent state can be substituted for another for state minimization.

4.1

LTX@Y Equivalence of States

Suppose D is an OA-DEVS and p and q are two of its states. If from p and q, D generates the identical LTX@Y languages then we can say that p and q are LTX@Y equivalent. Following is the formal definition. Definition 1 (LTX@Y Equivalent states) Let D be a OA-DEVS D =< X, Y, S, s0 , SF , ta , λ, δ >. For p, q ∈ S, two states p and q is said to be LTX@Y equivalent if LTX@Y (Dp ) = LTX@Y (Dq ) where LTX@Y (Dp )(LTX@Y (Dq )) denotes LTX@Y of D with initial state p(q) instead of s0 . If two states are not LTX@Y equivalent, then we say they are distinguishable. That is, state p is distinguishable from state q if 1) ta (p) = ta (q), or 2) item there exists an event x ∈ X ∪ {@} such that λ(p, x) = λ(q, x), or 3) item there exists a timed segment u ⊆ ((X∪{@})∗ , T ) ˆ u) and δ(q, ˆ u) is in SF and such that exactly one of δ(p, the other is not. To find those states that are LTX@Y equivalent, we make our best efforts to find pairs of states that are distinguishable. The algorithm, which we refer to as Finding IP: D → 2S×S where D is an OA-DEVS and S is its state set. StatePairSet Finding IP(D) { // D =< X, Y, S, s0 , SF , ta , λ, δ > // IP : StatePairSet;(indistinguished) // DP : StatePairSet;(distinguished) // ISP : S × S → 2S×S : input state pair set // ISP (r, s)={(p, q)|∀x ∈ X ∪ {@}, // δ(p, x)=r, δ(q, x)=s} 1 ∀p, q ∈ S, 2 add (p, q) to IP ;

3 4 5 6 7 8 9 10 11 12 }

∀(p, q) ∈ IP , if( ta (p) = ta (q) or ∃x ∈ (X ∪ {@}), λ(p, x) = λ(q, x) or p ∈ SF , q ∈ SF or p ∈ SF , q ∈ SF ) move (p, q) from IP to DP ; ∀(r, s) ∈ DP , ∀(p, q) ∈ ISP (r, s), if( (p, q) ∈ IP ) move (p, q) from IP to DP ; return IP ;

Finding IP is a procedure that returns the indistinguished pair set from an OA-DEVS D. Initially, all pairs of states are categorized into indistinguished pairs (see lines 1-2). For a state pair p and q from the indistinguished pair set (IP), if their remaining times are different (line 4) or their outputs are different (line 5) or exactly one of them is an element of SF but the other is not (line 6), the pair (p, q) is moved from IP to DP (distinguished pair set) (line 7). For efficient searching of distinguishable pair p, q such ˆ u) or δ(q, ˆ u) is in SF and the other is not for that δ(p, a segment u ⊆ ((X ∪ {@})∗ , T ), we introduce the input state pairs function ISP : S × S → 2S×S . The input state pairs function ISP returns a input state pairs set such that r, s ∈ S, ISP (r, s) = {(p, q)|∀x ∈ X ∪ {@}, δ(p, x) = r, δ(q, x) = s}. For all pairs (r, s) ∈ DP and for all pairs (p, q) ∈ ISP (r, s), if (p, q) is an element of IP , the pair (p, q) is removed from IP and is appended to DP (lines 8-11). This test will continue to the end pair of DP . As mentioned before, the output of Finding IP is a set of indistinguished state pairs. The next theorem shows the meaning of the indistinguished state pair set. Theorem 1 (Indistinguishable = Equivalent) Let D be an OA-DEVS D =< X, Y, S, s0 , SF , ta , λ, δ > and p, q ∈ S. Then states p and q are LTX@Y equivalent, that is, LTX@Y (D(p)) = LTX@Y (D(q)) if (p, q) ∈ IP of Finding IP. Proof: By testing of lines 8-11 of Finding IP, IP guarantees that every pair (p, q) ∈ IP has no transition entering to DP . That means (p, q) can remains in IP after every transition from it. That is, every ˆ u) ∈ SF pair (p, q) ∈ IP , ∀u ⊆ ((X ∪ {@})∗ , T ), δ(p, ˆ if and only if δ(q, u) ∈ SF . So we can say that LTX@ (D(p)) = LTX@ (D(q)). Let u ⊆ (ø, T ) such that its length is less then its scheduled time, that is, l(u) < ta (p). Then ˆ u) = u = ødom(u) = Γ(q, ˆ u) regardless of whether Γ(p, (p, q) is in IP or not. For a (p, q) ∈ IP , suppose u ∈ LTX@ (D(p))(= LTX@ (D(q))) and u = v(x, t) where v ⊆ ((X ∪ {@})∗ , T ), x ∈ X ∪ {@} ∪ {ø} and t ∈ T ˆ v) = r and δ(q, ˆ v) = s. Since there and let δ(p, is no path from (p, q) ∈ IP to DP , (r, s) must be

in IP . Moreover, by line 4 and 5 of Finding IP, ta (r) = ta (s) and λ(r, x) = λ(s, x) for (r, s) ∈ IP . Thus ˆ u) = Γ(p, ˆ v)(xλ(r, x), t) = Γ(q, ˆ v)(xλ(s, x), t) = Γ(p, ˆ u). Therefore, we can say that LT Γ(q, X@Y (D(p)) = LTX@Y (D(q)).


4.2

LTX@Y Equivalent OA-DEVSs

The LTX@Y state equivalency of the previous section is also useful in identifying equivalence of two OA-DEVSs. Now consider two OA-DEVSs D1 =< X1 , Y1 , S1 , s10 , S1F , ta1 , λ1 , δ1 > and D2 =< X2 , Y2 , S2 , s20 , S2F , ta2 , λ2 , δ2 >. Based on LTX@Y language, the LTX@Y equivalence of D1 and D2 is defined as follows. Definition 2 (LTX@Y Equivalent OA-DEVSs) Two OA-DEVSs D1 and D2 are said to be LTX@Y equivalent if LTX@Y (D1 ) = LTX@Y (D2 ). To compare the two languages generated by two OADEVSs, we can use the Finding IP algorithm. Imagine one OA-DEVS D whose states are the union of the states of D1 and D2 . After using the Finding IP algorithm, we test whether the start states of the two original D1 and D2 are indistinguishable. If they are indistinguishable than they are equivalent. That means if LTX@Y (D(s10 )) = LTX@Y (D(s20 )) then we can say that LTX@Y (D1 ) = LTX@Y (D2 ) because LTX@Y (D1 ) = LTX@Y (D(s10 )) and LTX@Y (D2 ) = LTX@Y (D(s20 )). The following algorithm is testing whether two OADEVSs D1 and D2 are LTX@Y equivalent assuming X1 = X2 = X, Y1 = Y2 = Y, and S1 ∩ S2 = ∅. Bool Is LTX@Y Equivalent(D1 , D2 ) { // D1 =< X1 , Y1 , S1 , s10 , S1F , ta1 , λ1 , δ1 > // D2 =< X2 , Y2 , S2 , s20 , S2F , ta2 , λ2 , δ2 > // D =< X, Y, S, s0 , SF , ta , λ, δ > // EP : StatePairSet; 1 S = S1 ∪ S 2 ; 2 s0 = s10 or s20 ; 3 SF = S1F ∪ S2F ; 4 ta (s) = ta1 (s), if s ∈ S1 5 = ta2 (s), if s ∈ S2 6 λ(s, x) = λ1 (s, x), if s ∈ S1 ,x ∈ X ∪ {@} 7 = λ2 (s, x), if s ∈ S2 ,x ∈ X ∪ {@} 8 δ(s, x) = δ1 (s, x), if s ∈ S1 ,x ∈ X ∪ {@} 9 = δ2 (s, x), if s ∈ S2 ,x ∈ X ∪ {@} 10 EP =Finding IP(D); 11 return ( (s10 , s20 ) ∈ EP ); } Example 3 (LTX@Y Equivalent OA-DEVSs) Let’s compare two OA-DEVSs D1 and D2 shown in Figure 3. As mentioned in the Is LTX@Y Equivalent algorithm, first this is merging two OA-DEVS into one, creating state set S = {GE1,GX1,RS1,RE1,RX1,GS1,GE2, GX2,RS2,RE2,RX2,GS2,GE3,GX3,RS3,RE3,RX3,GS3

Figure 3: LTX@Y Equivalent DEVSs

}. s0 = GE1 and SF = {GE1,GE2,GE3}. After testing differences of ta and λ of the Finding IP algorithm (lines 4-7), we can first achieve the indistinguishable pair set IP = { (GE1,GE2),(GE1,GE3), (GE2,GE3) (GX1,GX2), (GX1,GX3), (GX2,GX3), (RS1,RS2), (RS1,RS3), (RS2,RS3), (RE1,RE2), (RE1,RE3), (RE2,RE3), (RX1,RX2), (RX1,RX3), (RX2,RX3), (GS1,GS2), (GS1,GS3), (GS2,GS3) }. And the remaining pairs are classified as the distinguishable pair set. For testing of lines 811 of the algorithm, we note (GE1,GX1) ∈ DP . ISP (GE1,GX1)={(GE1,GS2)}. However, (GE1,GS2) is already in DP but not in IP , so there are no pairs ∈ ISP (GE1,GX1) which should be moved from IP to DP . In addition to the (GE1,GX1) case, since there are no pairs (p, q) such that (p, q) ∈ IP ∧ (p, q) ∈ ISP (r, s) ∧ (r, s) ∈ DP , no pairs should be moved from IP to DP . That means the pairs ∈ IP such as (GE1,GE2),(GE1,GE3), (GE2,GE3) (GX1,GX2), (GX1,GX3), (GX2,GX3), (RS1,RS2), (RS1,RS3), (RS2,RS3), (RE1,RE2), (RE1,RE3), (RE2,RE3), (RX1,RX2), (RX1,RX3), (RX2,RX3), (GS1,GS2), (GS1,GS3), and (GS2,GS3) are equivalent in terms of LTX@Y . As a result, since the pair (s10 , s20 ) = (G1, G3) is equivalent so LTX@Y (D1) = LTX@Y (D2) and we can say that D1 and D2 are equivalent.

4.3

LTX@Y Minimization

Another important consequence of identifying the LTX@Y equivalence of states is that the results help us to minimize an OA-DEVS. In other words, for any OADEVS we can make a minimized one which has the fewest possible states of any OA-DEVS generating the same LTX@Y language. The key idea behind the minimization is that the notion of LTX@Y state equivalence lets us partition the states into blocks such that 1) All the states in a block are equivalent, 2) No two states chosen from two different blocks are equivalent. The following two procedures are the algorithms for minimizing OA-DEVS in terms of LTX@Y . The first is the algorithm for the partition of representative blocks from an OA-DEVS. Using the partitioning algorithm, the second achieves the minimized OA-DEVS while guaranteeing LTX@Y equivalency. As we can see that, LTX@Y minimization is a procedure that substitutes for all states their representative blocks. StateBlockSet Paritition Blocks(D) { // D =< X, Y, S, s0 , SF , ta , λ, δ >: // SB: state block set ⊆ 2S // EP : equivalent pair set 1 EP = Finding IP(D); 2 ∀(p, q) ∈ EP , { 3 Set B = ∅; 4 append p to B; 5 ∀p ∈ B, 6 ∀q ∈ S, 7 if( (p, q) ∈ EP, q ∈ B ) { 8 append q to B; 9 remove (p, q) from EP ; 10 } 11 append B to SB; 12 } 13 return SB; } OA-DEVS LTX@Y Minimization(D) { //D =< X, Y, S, s0 , SF , ta , λ, δ > //Dm =< X, Y, Sm , sm0 , SmF , tam , λm , δm > 1 Sm = Paritition Blocks(D) ; 2 sm0 = sm such that s0 ∈ sm ; 3 SmF ={sm ∈ Sm |∀s ∈ SF , s ∈ sm }; 4 tam (sm , 0){//sm ∈ Sm , 5 find s such that s ∈ sm ; 6 return ta (s); 7 } 8 λm (sm , x){//sm ∈ Sm , x ∈ X ∪ {@}, 9 find s such that s ∈ sm ; 10 return λ(s, x); 11 } 12 δm (sm , x){//sm ∈ Sm , x ∈ X ∪ {@}, 13 find s such that s ∈ sm ; 14 p = δ(s, x); 15 find pm ∈ Sm such that p ∈ pm ;

Figure 4: LTX@Y Minimized DEVS of D1 in Figure 3 16 return pm ; 17 } 18 return Dm ; } Example 4 (LTX@Y Minimization) Let us reexamine model D1 of Example 3 whose OA-DEVS has 12 states. In the example, LTX@Y equivalent state pairs are (GE1,GE2), (GX1,GX2) (RS1,RS2), (RE1,RE2), (RX1,RX2), and (GS1,GS2). By employing Paritition Blocks, we can categorize its states into 6 blocks GE={(GE1,GE2)}, GX={(GX1,GX2)}, RS={(RS1,RS2)}, RE={(RE1,RE2)}, RX={(RX1, RX2)}, and GS={(GS1,GS2)}. And by applying the LTX@Y Minimization algorithm, we can achieve the LTX@Y minimized OA-DEVS as shown in Figure 4

5

LTXY Equivalence and Minimization

LTX@Y is the most specific language, however, LTX@Y equivalency requires the exact equivalent with respect to all kind of event set. Thus sometimes LTX@Y minimization doesn’t work any more. See Figure 5 in which there are some modifications from model D1 of Example 3 such as: (1) additional state D, (2) λ(GX2,@)=ø, δ(GX2,@)=D, (3)λ(D,@)=g:0, δ(D,@)=RS2. This modification will cause no LTX@Y equivalent states so LTX@Y minimization cannot reduce its states. The reason why there is no equivalent state with respect to LTX@Y is due to its exactness of language. This section will deal with LTXY in which internal event @ is ignored so it is less exact than LTX@Y .

5.1

@T -compressible State

We have found that there are some states which are not meaningful in terms of LTXY . Figure 6(a) shows the concept of the compressible state. Imagine that an OADEVS D has a state q which changes into another state r immediately such that ta (q) = 0. In this case, the state q can be merged into the previous state p. And the compression has no influence to LTXY . Following is the formal definition of the @T -compressible state.

@T -compressible OA-DEVS has at least one @T compressible state. The compression of @T compressible OA-DEVS merges an @T -compressible state with its preceding state until the preceding one is no longer @T -compressible. Following is the @T compression algorithm.

Figure 5: DEVS for Traffic Lights: No LTX@Y Minimization possible

Figure 6: @T -compressible State q Definition 3 (@T -compressibility) Let D be an OA-DEVS D =< X, Y, S, s0 , SF , ta , λ, δ >. Suppose p, q, r ∈ S and p = q, q = r and δ(p, x) = q for x ∈ X ∪ {@} and δ(q, @) = r. Then q is said to be @T -compressible if 1. q = s0 ∧ q ∈ SF 2. ta (q) = 0 ∧ ∀x ∈ X, ¬δ(q, x)! And D is said to be @T -compressible if D has a @T compressible state. Definition 4 (@T -incompressibility) An OADEVS D is said to be is @T -incompressible or simply incompressible if D has no @T -compressible state. Example 5 (LTXY Compressible States) Consider the model of Figure 5. In the Figure 5 model, GX1,RS1,RX1,GS1,GX2,RS2,RX2,GS2, and D are @T -compressible states and the model of Figure 5 is a @T -compressible OA-DEVS. We can imagine that there is some algorithm making an @- incompressible OA-DEVS from any @T compressible OA-DEVS. We will address the @T compression algorithm of an OA-DEVS in the next section.

5.2

@T -compression

Recall the meaning of an @T -compressible state in Section 5.1. According to Definition 3, an

OA-DEVS @T -compression(D) { // D =< X, Y, S, s0 , SF , ta , λ, δ > // D : Compressed OA-DEVS // δ(p, x) = q 1 D = D; // copy D to D’ 2 ∀q ∈ D .S such that q is compressible{ 3 λ(p, x) = λ(p, x)λ(s, @); 4 δ(p, x) = δ(q, @); 5 remove q from D .S; 6 } 7 return D ; } In the algorithm @T -compression, every compressible state q is merged with p such that δ(p, x) = δ(q, @) (1) by concatenation such as λ(p, x) = λ(p, x)λ(q, @) (see line 3), (2) by changing transitions δ(p, x) = δ(q, @) (line 4), (3) by removing q from the state set (line 5). Figure 6(b) shows the result of LTXY compressing q of Figure 6(a). Followings are two Lemmas associated with @T -compression. Lemma 1 (Preserving LTXY ) @T -compression preserves LTXY . Proof: Imagine an OA-DEVS D =< X, Y, S, s0 , SF , ta , λ, δ > in which there are p, q, r ∈ S as shown in Figure 6(a). Suppose u(x@, t)v ∈ LTX@ . Then ˆ 0 , u(x@, t)v)) Γ(s ˆ (x@, t))Γ(r, ˆ v) ˆ 0 , u)Γ(p, = Γ(s ˆ ˆ ˆ ˆ v) = Γ(s0 , u)Γ(p, (x, t))Γ(q, (@, t))Γ(r, ˆ ˆ = Γ(s0 , u)(xyp , t)(@yq , t)Γ(r, v) ˆ v). ˆ 0 , u)(xyp @yq , t)Γ(r, = Γ(s T Since u(x@, t)v ∈ LX@ , T ˆ 0 , u(x@, t)v) (Γ(s PXY T ˆ 0 , u))P T ((xyp @yq , t))P T (Γ(r, ˆ v)) = PXY (Γ(s XY XY T T ˆ ˆ = PXY (Γ(s0 , u))(xyp yq , t)PXY (Γ(r, v))—-(a). After compression of state q, u(x, t)v ∈ LTX@ because we have assumed u(x@, t)v ∈ LTX@ previously. So ˆ 0 , u(x, t)v)) Γ(s ˆ (x, t))Γ(r, ˆ v) ˆ 0 , u)Γ(p, = Γ(s ˆ v) ˆ 0 , u)(xyp yq , t)Γ(r, = Γ(s Since u(x, t)v ∈ LTX@ , T ˆ 0 , u(x, t)v) (Γ(s PXY T ˆ 0 , u))P T ((xyp yq , t))P T (Γ(r, ˆ v)) = PXY (Γ(s XY XY T T ˆ ˆ = PXY (Γ(s0 , u))(xyp yq , t)PXY (Γ(r, v))—-(b). Since (a)=(b), @T -compression of a state preserves the trajectories which have passed q. That means, @T -compression of all @T -compressible states also preserves the original LTXY .


Lemma 2 (Generating the Incompressible ) @T -compression achieves a @T -incompressible OADEVS. Proof: Suppose D is an OA-DEVS and D is the OA-DEVS which is the result of applying @T -compression(D). We can see the @T -compression algorithm compresses all @T -compressible states until there is no more @T -compressible states. Thus D must be one of following results: (1) |D .S| = 1 and D .s0 ∈ D .S or (2) |D .S| > 1. ∀s ∈ |D .S|, s is @T incompressible. Both cases of (1) and (2), D has no @T -compressible state, so D is an @T -incompressible OA-DEVS.
Example 6 (LTXY Compression) Recall the @T compressible OA-DEVS shown in Figure 5. Suppose we would like to compress GX1. We can see that the result of merging GX1 and RS1 of Figure 7(a) is shown in Figure 7(b). Even after compressing GX1, the merged state RS1 is still compressible so we can apply to compress the state RS1 as well. Figure 7(c) shows the state transition diagram after compression of RS1. By applying the compression algorithm to the model of Figure 5, we can achieve the @T -incompressible OA-DEVS of Figure 7(d).

5.3

LTXY Equivalent States

Definition 5 (LTXY Equivalent states) Let D be an OA-DEVS such that D =< X, Y, S, s0 , SF , ta , λ, δ >. For p, q ∈ S, two states p and q are said to be LTXY equivalent if LTXY (Dp ) = LTXY (Dq ) where LTXY (Dp )(LTXY (Dq )) denotes LTXY of D with initial state p(q) instead of s0 . We have shown the @T -compression algorithm preserves LTXY . If we can make a Dp and Dq which are compressed from D with modification such as s0 = p ∈ S and s0 = q ∈ S, respectively, then we can apply the algorithm of Is LTX@Y Equivalent(D1 , D2 ). Following is the procedure for testing LTXY equivalent states. bool Is LTXY Equivalent(D, p, q) { // D =< X, Y, S, s0 , SF , ta , λ, δ > // p, q ∈ S 1 D.s0 = p; 2 Dcp = @T -compression(D); 3 D.s0 = q; 4 Dcq = @T -compression(D); 5 return Is LTX@Y Equivalent(Dcp , Dcq ); } Lemma 3 (Is LTXY Equivalent) Let D be an OADEVS. The LTXY (D(p)) = LTXY (D(q)) if the return value of Is LTXY Equivalent(D,p,q) is true.

Figure 7: Compression of States (a) GX1 and RS1 are compressible (b) RS1 is compressible (c) All are incompressible (d) @T -Incompressible OA-DEVS Proof: Let Dp and Dq be the same as D except s0 = p and s0 = q, respectively. Then LTXY (Dcp ) = LTXY (Dp ). (by Lemma 1) T T (LTX@Y (Dcp )) = PXY (LTX@Y (Dp )) − − − (i). PXY Similarly, LTXY (Dcq ) = LTXY (Dq ). (by Lemma 1) T T (LTX@Y (Dcq )) = PXY (LTX@Y (Dq )) − − − (ii). PXY T If Is LX@Y Equivalent(Dcp , Dcq ) is true, that means By substitution LTX@Y (Dcp ) = LTX@Y (Dcq ). LTX@Y (Dcp ) of (i) with LTX@Y (Dcq ), (i) becomes T T (LTX@Y (Dcq )) = PXY (LTX@Y (Dp )) which is the PXY T T T same as (ii) PXY (LX@Y (Dcq )) = PXY (LTX@Y (Dq )) . T T Thus [LXY (Dp ) = LXY (Dq ).


5.4

LTXY Equivalent OA-DEVSs

Definition 6 (LTXY Equivalent OA-DEVSs) Two OA-DEVSs D1 and D2 are said to be LTXY equivalent if LTXY (D1 ) = LTXY (D2 ). Similar to the procedure of identifying whether two states are LTXY equivalent, we use the @T -compression and Is LTX@Y Equivalent. The Following algorithm will test whether two OA-DEVSs are LTXY equivalent.

Bool Is LTXY Equivalent(D1 , D2 ) { // D1 =< X1 , Y1 , S1 , s10 , S1F , ta1 , λ1 , δ1 > // D2 =< X2 , Y2 , S2 , s20 , S2F , ta2 , λ2 , δ2 > 1 Dc1 = @T -compression(D1 ); 2 Dc2 = @T -compression(D2 ); 3 return Is LTX@Y Equivalent(Dc1 , Dc2 ); } Lemma 4 Let D1 and D2 be OA-DEVSs. LTXY (D1 ) = LTXY (D2 ) if the return value of Is LTXY Equivalent(D1 , D2 ) is true. Proof: Since the proof of this is very similar to that of Lemma 3, we can refer to it.
Example 7 (LTXY Equivalent OA-DEVSs) Let’s test two OA-DEVSs D1 and D2 using Let D1 Is LTX@Y Equivalent(D1 , D2 ) algorithm. be that of Figure 4 and D2 be that of Figure 5. After applying @T -compression, we can achieve two @T incompressible OA-DEVS Dc1 and Dc2 such that Dc1 is the same as in Figure 2(b) and Dc2 Figure 7(d). In testing of Is LTX@Y Equivalent(Dc1 , Dc2 ), the indistinguishable pair set (IP) is { (G,GE1), (G,GE2), (GE1,GE2), (R,RE1), (R,GRE2), (RE1,RE2), }. (D1 .s0 , D2 .s0 )=(G,GE1) ∈ IP so D1 and D2 are LTXY equivalent.

5.5

LTXY Minimization

Now we are ready to construct from an OA-DEVS a minimized OA-DEVS which has as few states as any LTXY equivalent OA-DEVS. We use the previously introduced procedures @T -compression and LTX@Y Minimization in the following algorithm. OA-DEVS LTXY Minimization(D) { // D =< X, Y, S, s0 , SF , ta , λ, δ > // Dm : the Minimized OA-DEVS 1 Dc = @T -compression(D); 2 Dm = LTX@Y Minimization(Dc ); 3 return Dm ; } Theorem 2 (LTXY Minimization) If D is an OADEVS and Dm is the OA-DEVS constructed from D by the algorithm LTXY Minimization, then Dm has as few states as any OA-DEVS LTXY equivalent to D. Proof: By line 1 of LTXY Minimization, T Dc is an @ -incompressible OA-DEVS such that T (LTX@Y (Dc )) = LTXY (Dc ) = LTXY (D). That is, PXY T T PXY (LX@Y (D)). By line 2 of the algorithm, Dm is the minimized OA-DEVS such that LTX@Y (Dm ) = LTX@Y (Dc ). By substitution LTX@Y (Dc ) of (i) with T (LTX@Y (Dm )) = LTX@Y (Dm ), it follows that PXY T T T T LXY (Dm ) = LXY (D) = PXY (LX@Y (D)). Therefore Dm is the minimized OA-DEVS such that LTXY (Dm ) = LTXY (D).


Example 8 (LTXY Minimization) Let’s reduce the states of the OA-DEVS shown in Figure 5. After applying @T -compression, we can achieve the @T incompressible OA-DEVS in Figure 7(d). By applying LTX@Y Minimization to the @T -incompressible OADEVS, we can achieve the LTXY minimized OA-DEVS shown in Figure 2(b). In this example, an ordinary DEVS model with 13 states can be minimized to the LTXY equivalent OA-DEVS with just 2 states.

6

Conclusions

To show some DEVSs are equivalent and to reduce their states state, firstly introduced in this paper was the timed language in which events and their respective timing are considered. Based on the time language, we defined a behavior of an augmented DEVS which is extended from the ordinary DEVS such that it generates an output event string when it receives an input event or it is triggered by its internal scheduling. This paper also showed that concerning event sets, there might be various levels of timed languages generated by one OADEVS. Especially focusing on two timed languages such as LTX@Y and LTXY , we defined equivalencies of states, OA-DEVSs, demonstrated a method of minimizing an OA-DEVS while preserving its specific language. This augmentation to DEVS and equivalency and minimization of OA-DEVS can be expected to be useful in model analysis in which fewer states more efficient.

References [1] B.P. Zeigler, H. Praehofer, and T.G. Kim, Theory of Modeling and Simulation, (2nd Edition): Integrating Discrete Event and Continuous Complex Dynamic Systems, Academic Press, 2000 [2] Y.C. Ho, “Forward to the Special Issue,” Discrete Event Dynamic Systems: Theory and Applications Vol. 3, 1993, pp. 111 [3] J.H. Hopcroft, R. Motwani, and J.D. Ullman, Introduction ot Automata Theory, Languages, and Computation, (2nd Edition), Pearson Education, 2001 [4] T.G. Kim, S.M. Cho and W.B. Lee, “DEVS Framework for Systems Development: Unified Specification for Logical Analysis, Performance Evaluation and Implementation,” Discrete Event Modeling And Simulation Technologies(H.S.Sarjoughian and F.E. Cellier Editors), Chapter 8, pp 131-166, 2001, Springer-Verlag, New York, Inc. [5] M.H. Hwang, “Identifying Equivalence of DEVSs: Language Approach,” Proceedings of 2003 Summer Computer Simulation Conference, Montreal, Canada, July, 2003