Exploiting symmetry of state tree structures for discrete-event systems with parallel components

Transcription

1 TSpace Research Repository tspace.library.utoronto.ca Exploiting symmetry of state tree structures for discrete-event systems with parallel components Ting Jiao, Yongmei Gan, Guochun Xiao & W. M. Wonham Version Post-Print/Accepted Manuscript Citation (published version) Ting Jiao, Yongmei Gan, Guochun Xiao & W. M. Wonham. (0). Exploiting Symmetry of State Tree Structures for Discrete-event Systems with Parallel Components. Published online. doi: 0.00/ Publisher s Statement This is an Accepted Manuscript of an article published by Taylor & Francis in on July 0, available online: How to cite TSpace items Always cite the published version, so the author(s) will receive recognition through services that track citation counts, e.g. Scopus. If you need to cite the page number of the TSpace version (original manuscript or accepted manuscript) because you cannot access the published version, then cite the TSpace version in addition to the published version using the permanent URI (handle) found on the record page.

2 Exploiting Symmetry of State Tree Structures for Discreteevent Systems with Parallel Components Journal: Manuscript ID TCON-0-0.R Manuscript Type: Regular Paper Keywords: supervisory control theory, state tree structures, symmetry, abstract control functions

3 June 0, 0 tcon Page of To appear in the Vol. 00, No. 00, Month 0XX, MANUSCRIPT Exploiting Symmetry of State Tree Structures for Discrete-event Systems with Parallel Components (June 0, 0) We consider discrete-event systems (DES) consisting of parallel arrays of machines and buffers. The machines are divided into groups in each of which the members have identical structure, i.e. same state set and isomorphic transitions. This feature allows event relabeling of the machines in a given group to a standard prototype machine. In these systems, to avoid the underflow or overflow of the buffers, the controller needs only the information of the total numbers of components at each state and the numbers of workpieces in the buffers. By exploiting the identical structure of each group, we extract such control information from the control functions computed by the state tree structures (STS) to generate abstract control functions. Thanks to the symmetry of the system, we show that all controllable events relabeled to the same symbol share an invariant abstract control function, which is independent of the total number of machines, as long as the buffer sizes are fixed. The approach is illustrated by two examples. Keywords: supervisory control theory; state tree structures; symmetry; abstract control functions; invariance property. Introduction Many large systems exhibit similarity of structure (symmetry) within subsets of its components, allowing the same control law to be applied in each subset. In mathematical physics the notion of symmetry is widely exploited to simplify modeling and computation, for instance by means of invariants under the permutation or rotation groups (Weyl, 0, ). An example from control theory is the feedback group and its invariants, the controllability indices, of a linear system (Wonham, ). In the supervisory control theory (SCT) of DES, references (Eyzell & Cury, 00) and (Eyzell & Cury, ) use group theory to characterize symmetry arising from isomorphic components connected serially, thereby obtaining a reduced controller equivalent in control action to the original controller. In (Rohloff & Lafortune, 00), the control and verification of similar modular systems are explored. There, similar modular systems are comprised of subsystem modules that exhibit isomorphic local behavior coordinated on global event occurrences; the state size of the monolithic system is reduced by the quotient automaton construction. In (Rohloff & Lafortune, 00), the state size of modular systems containing permutation symmetry is reduced by the permutation symmetric µ-calculus. Modular systems constructed from a given template are also studied in (Wang et al., 0), which analyzes deadlock and blocking for systems consisting of isomorphic modules initiated from a template. In (Su, 0), a commutative and associative broadcasting-based parallel composition rule of a multi-agent system with one template is proposed. By contrast, in the present paper we consider parallel component arrays constructed by several templates, and reduce system complexity by event relabeling. For a given supremal supervisor, we require the relabeling map to be control-definite to guarantee that the relabeled supremal supervisor is equivalent in control action to its counterpart in the relabeled system. Based on this condition, we achieve controller reduction by extracting control information from the control functions computed by STS (Ma & Wonham, 00). As control functions are based on the current state of each machine

4 June 0, 0 tcon Page of and numbers of workpieces in buffers, it s feasible to obtain the numbers of machines at each state in every group, i.e. abstract control information. By such abstraction, we get succinct and invariant abstract control functions, which are shown to be equivalent in control action to the original ones. In (Bherer et al., 00), the control is investigated of parametrized DES when specifications are given in terms of predicates and satisfy a similarity assumption, while in our paper, we focus on the specification to prohibit underflow and overflow of buffers with fixed capacity. Parametrization of templates is also discussed in (Grigorov et al., 00, 0) to facilitate the design of software for DES control. Reference (Ekberg & Krogh, 00) uses state machine templates to program DES and references (Das & Holloway, ; Holloway & Chand, ) design time templates for discrete-event fault monitoring in manufacturing systems. In this paper, we exploit symmetry of STS to obtain abstract control functions. As STS is often efficient in supervisor synthesis and transparent in control logic, it provides a simpler alternative to show the invariance property of abstract control functions than our previous work did (Jiao et al., 0). The latter uses only relabeling and endeavors to show the hidden invariance property of reduced supervisors computed by the Supreduce( ) algorithm (Wonham, 0b), while, by the control logic of abstract control functions proposed in this paper, this invariance property is self-evident. Moreover, the controller complexity of the final controller (in terms of state size of abstract control functions) is greatly reduced compared to the state size of the directly computed monolithic Supcon supervisor (Wonham, 0b). For this, an example is given in Subsection.. The rest of the paper is organized as follows. Section provides preliminaries. Section discusses the relationship between relabeling and controllability. Section formalizes the extraction of abstract control functions and shows the consistency between abstract control functions and the original ones in control action. Section presents two examples. Section states our conclusions. A summary conference precursor of this paper has appeared as (Jiao et al., 0).. Preliminaries. Supervisory control theory Supervisory Control Theory (SCT) deals with the control of DES (Ramadge & Wonham, ; Wonham, 0a). In SCT, the system is modeled by an automaton with labeled events. The latter comprise disjoint subsets of controllable events and uncontrollable events. A controllable event can occur only if it is enabled by an external agent, while the latter has no control over an uncontrollable event. To make the system operate as desired, a supervisor is needed to disable selected controllable events, often to forestall the occurrence of subsequent uncontrollable events which may lead to violation of the behavioral specifications. The formal structure of a DES to be controlled is a generator, say G = (Q, Σ, δ, q 0, Q m ) Here Σ = Σ c Σ u is a finite alphabet of symbols that we refer to respectively as controllable and uncontrollable event labels, Q is the state set, δ : Q Σ Q is the (partial) transition function, q 0 is the initial state, and Q m Q is the subset of marked states. The transition function δ is often extended to a function δ : Q Σ Q by induction on length of strings. The closed behavior of G is the language L(G) := {s Σ δ(q 0, s)!}

5 June 0, 0 tcon Page of rep LG RLG R rep G relabel RG Figure. Schematic of relabeling function in which the notation δ(q 0, s)! means δ(q 0, s) is defined. The marked behavior is L m (G) := {s L(G) δ(q 0, s) Q m } L(G) A supervisory control for G is any map V : L(G) Γ, in which Γ is the set of all control patterns Γ = {γ P wr(σ) γ Σ u } The pair (G, V ) will be written as V/G, to suggest G under the supervision of V. Let M L m (G). Define a marking nonblocking supervisory control (MNSC) for the pair (M, G), as a map V : L(G) Γ; for the marked behavior of V/G we define L m (V/G) = L(V/G) M. Let E Σ be a specification language and C(E) = {K E K is controllable with respect to G} the class of controllable languages contained in specification E (Ramadge & Wonham, ; Wonham, 0a). C(E) has the supremal element supc(e) = {K K C(E)} By applying supervisor reduction (Su & Wonham, 00), we can often obtain a simplified controlequivalent supervisor.. Relabeling Relabeling maps event symbols of the original system to new event symbols. Let T be the event set of symbols after relabeling, partitioned as T = T c T u. Let Σ = Σ c Σ u and R : Σ T be a relabeling map, satisfying the following conditions: R(ε) = ε (ε denotes the empty string); R(σ) T c, σ Σ c ; R(σ) T u, σ Σ u ; A schematic of R is shown in Fig.. Let R(sσ) = R(s)R(σ), s Σ, σ Σ. G = (Q, Σ, δ, q 0, Q m ) RG = (Z, T, ζ, z 0, Z m ) The result of rep( ) is an automaton representing the corresponding language. In TCT (Wonham, 0b), we compute RG = relabel(g) to implement R such that L m (RG) = RL m (G), L(RG) =

6 June 0, 0 tcon Page of # i MINi i j BUF MOUTj,,,,, i m j n 0 i 0 j i j MINi MOUTj 0 i i j j BUF Figure. Schematic of manufacturing facility in Subsection. RL(G). What relabel( ) does is first apply a direct transition relabeling to G and then convert the result to a deterministic automaton by the subset construction algorithm (SCA) (Rabin & Scott, ). As the relabel( ) algorithm calls the SCA, its time complexity is the same as that of the SCA. The latter involves the determination of nondeterministic automata; thus, it is in general a complex process with time complexity O( n ) in the worst case. Similarly, the construction of quotient automata involves the determination of the symmetric group. Although both algorithms are exponential in time complexity, thanks to the symmetry of identical components, relabel( ) usually performs more quickly than its worst-case complexity would suggest and the result of this algorithm has many fewer states than the original automaton. For example, in the system shown in Fig., assume that there are m N input machines MINi, i {,, m}. The synchronous product MIN := m i= MINi has m states, where denotes synchronous product (Wonham, 0a); while relabel(min) only has m + states as at most m input machines work simultaneously. Namely, the relabeling map reduces size of the state space by extracting common properties of identical components (e.g. number of input machines working simultaneously in this example). Moreover, the relabeling map is (in our opinion) more straightforward and easier to understand than the process of quotient automaton construction.. State tree structures STS model hierarchical and concurrent organization of the system state set. By encoding STS models with binary decision diagrams (BDD) (Bryant, ), the computational complexity of supervisor synthesis is often successfully managed (compared with the flat DES model). A state tree structure (STS) S (Ma & Wonham, 00, 00) for modeling DES is a six-tuple S = (ST, H, Σ,, ST 0, ST m ) Here ST is the state tree organizing the system s state set into a hierarchy; H is the set of holons (finite automata) matched to ST that describe the local behavior of G; Σ is the finite event set, partitioned into the disjoint controllable subset Σ c and uncontrollable subset Σ u. Let S(ST ) denote the set of all sub-state-trees of ST. The global transition function is defined as : S(ST ) Σ S(ST ); ST 0 S(ST ) is the initial state tree; and ST m S(ST ) is the set of marked state trees. The STS model of the manufacturing facility shown in Fig. is displayed in Fig.. This STS model consists of m + n + holons, i.e. MIN,, MINm, MOUT,, MOUTn, BUF. The state tree shown in Fig. is a match (Ma & Wonham, 00) of holons to represent the local dynamics. These holons are AND-adjacent (Ma & Wonham, 00) to S, indicated by the symbol. As only one state is activated in each holon in any given instant, the states in holons are connected by the disjoint union symbol. The set of all sub-state-trees of ST consists of well-formed state trees j

7 June 0, 0 tcon Page of S MIN 0 MINm m 0 m MOUT MOUTn n 0 Figure. STS of manufacturing facility S 0 n MIN MINm MOUT MOUTn BUF Figure. State tree of manufacturing facility 0 (Ma & Wonham, 00) of ST. The global transition function evolves from one sub-state-tree to another. In the initial state tree, all components are at their respective initial state. For each state tree in the set of marked state trees, each component is at one of its marked states. In this example, the set of marked state trees is a singleton of the initial state tree. Let B(ST ) denote the set of all basic state trees of ST (Ma & Wonham, 00). A predicate P defined on B(ST ) is a function P : B(ST ) {0, } where 0 (resp. ) represents logical false (resp. true ). Thus, P can be identified by the subset B P of basic state trees with B P := {b B(ST ) P (b) = }, where P (b) = is often written as b P. Also for a sub-state-tree T S(ST ), define T P iff ( b B(T ))b P. Given the initial predicate P 0 with B P0 := {b B(ST ) b P 0 } = B(ST 0 ), and the marked predicate P m with B Pm := {b B(ST ) b P m } = T ST m B(T ), the STS G can be rewritten as S = (ST, H, Σ,, P 0, P m ) For the manufacturing facility shown in Fig., let qi, q j denote the currently activated states of MINi, MOUTj respectively. Let ν BUF denote the number of workpieces in the buffer. The structure of a basic state tree is shown in Fig.. Equivalently, the initial state tree can be denoted by predicate P 0 : qi = 0 q j = 0 ν BUF = 0. In this example, the marked predicate P m is identical to P 0. Write P red(st ) for the set of all predicates on B(ST ). Next introduce for P red(st ) the partial order by P P iff (P ) P ; namely, P P holds when b P b P for every b B(ST ). The reachability predicate R(S, P ) holds on only those basic trees that can be reached in S, from some b 0 P P 0, via a path of state trees all satisfying P. Dually, the coreachability predicate CR(S, P ) is defined to hold on those basic trees that can reach some b m P P m by a path of state trees all satisfying P. A predicate P is nonblocking with respect to S if R(S, P ) CR(S, P ), i.e. every basic state tree reachable from some initial state tree can also reach some marked state BUF j j 0 i i

8 June 0, 0 tcon Page of MIN MINm MOUT MOUTn BUF q q i q m S q qj q n Figure. Basic state tree of manufacturing facility tree in S. For σ Σ define a map M σ : P red(st ) P red(st ) by b M σ (P ) iff (b, σ) P with P P red(st ). A predicate P is called weakly controllable if ( σ Σ u )P M σ (P ). Let P P red(st ). Let N C(P ) denote the family of nonblocking and weakly controllable subpredicates of P. As N C(P ) is nonempty and is closed under arbitrary disjunctions, it contains the supremal element supn C(P ) := {K K N C(P )}. Define a state feedback control (SFBC) f to be a function f : B(ST ) Π, where Π := {Σ Σ Σ u Σ }. For σ Σ define a control function f σ : B(ST ) {0, } according to f σ (b) = iff σ f(b). Then the control action of f is fully represented by the set {f σ σ Σ}. By definition f σ ( ) = true for every uncontrollable event σ. The closed-loop STS formed by S and f is then written as S f = (ST, H, Σ, f, P f 0, P f m) where P f 0 = R(S f, true) P 0, Pm f = R(S f, true) P m, and f (b, σ) = (b, σ) if f σ (b) = and f (b, σ) = otherwise. A SFBC f is nonblocking if R(S f, true) CR(S f, true). Let P P red(st ) and P 0 supn C(P ) false. Then there exists a nonblocking SFBC f such that R(S f, true) = R(G, supn C(P )) and SFBC f is represented by the control functions f σ, σ Σ with f σ := M σ (supn C(P )) (Ma & Wonham, 00). Thus for every b B(ST), f σ (b) = iff (b, σ) supn C(P ). Control functions can be synthesized by the software STSLib (Ma, 00).. Relabeling and controllability In this section we discuss the relationship between relabeling and controllability, exploiting the symmetry of parallel components. As usual let G = (Q, Σ, δ, q 0, Q m ) be the plant to be controlled, Σ = Σ c Σ u a partition of Σ into controllable and uncontrollable events. G is composed of n groups of parallel (identical) components. In each group G i, i {,, n}, for any two machines G ij, G ij, j, j {,, G i }, relabel(g ij ) is identical to relabel(g ij ). Thus, G := i=n,j= Gi i=,j= G ij. Assume that in any component G ij, for any q, q Q i, there is at most one transition from q to q, i.e. δ ij (q, σ) = q with σ Σ ij. Let G ij =(Q i, Σ ij, δ ij, q i0, Q im ), BUF G ij =(Q i, Σ ij, δ ij, q i0, Q im ), j, j {,, G i } We say σ Σ ij, σ Σ ij is a replicated pair if δ ij (q, σ) = q, δ ij (q, σ ) = q with q, q Q i, R(σ) = R(σ ). If σ, σ is a replicated pair, they are relabeled to the same symbol. We say relabeling map R is shared event free (SEF) if for any σ, σ Σ that is not a replicated pair,

9 June 0, 0 tcon Page of R(σ) R(σ ). Namely, we require that any two distinct events be relabeled to different symbols if they are not a replicated pair. The manufacturing facility shown in Fig. is composed of two groups of identical components, G := {MINi, i {,, m}}, G := {MOUTj, j {,, n}}. With events i, i, j, j being relabeled as,,, respectively, we have that the relabeling map R is SEF. Let E Σ be the specification language. In this paper, we focus on the specification to avoid underflow and overflow of buffers. To ensure that the supervisor will make identical decisions on strings relabeled to the same string, the specification should enable or disable all events relabeled to a single event every time a decision is made. To this end, we require that specification E have the relabeling normality property (RNP), i.e. E = R (R(E)), where R (R(E)) := {s Σ R(s) R(E)}. In DES composed of parallel components, the specification has the RNP inherently as we needn t be concerned with the details of individual components. For example, in the system shown in Fig., the specification language is represented by automaton BUF. All events i are enabled at states 0, and disabled at state ; all events j are enabled at states, and disabled at state 0. Obviously, we have L(BUF) = R (RL(BUF)). Let L m (SUP) := supc(l m (G) E), L(SUP) := L m (SUP) L m (RG) := R(L m (G)), L m (XRSUP) := supc(l m (RG) R(E)) L(XRSUP) := L m (XRSUP) L m (RSUP) := R(L m (SUP)) = {R(s) L(RG) s L m (SUP)} Let D : L(SUP) Pwr(Σ) with Let A : L(SUP) Pwr(Σ) with s D(s) := {σ Σ c sσ L(G) & sσ / L(SUP)} s A(s) := {σ Σ c sσ / L(G) or sσ L(SUP)} We say R is control definite (CD) with respect to L(SUP) if ( s, s L(SUP))( σ, σ Σ)R(s) = R(s ), R(σ) = R(σ ) [sσ / L(G) or sσ L(SUP)] [s σ / L(G) or s σ L(SUP)] Or equivalently, by contraposition and notational interchange, sσ L(G) & sσ / L(SUP) s σ L(G) & s σ / L(SUP) The intuition for CD is that the supervisor will make identical decisions on strings relabeled to the same string. If σ, σ Σ with R(σ) = R(σ ), then both of them should be enabled or undefined after the occurrence of strings s, s L(SUP) with R(s) = R(s ). Equivalently, if one of them is disabled, then the other should also be disabled. Lemma : If R is CD with respect to L(SUP), then for any s, s L(SUP), R(s) = R(s ) R(D(s)) R(A(s )) = R(A(s)) R(D(s )) = Proof. Let σ D(s), σ A(s ) with s, s L(SUP), R(s) = R(s ). As σ D(s), we have sσ L(G), sσ / L(SUP). As σ A(s ), we have s σ / L(G) or s σ L(SUP). Assume

10 June 0, 0 tcon Page of R(σ ) = R(σ), i.e. R(D(s)) R(A(s )). Then R(sσ) = R(s σ ). As R is CD with respect to L(SUP), s σ / L(G) or s σ L(SUP) imply sσ / L(G) or sσ L(SUP), which contradicts sσ L(G), sσ / L(SUP). Thus, R(D(s)) R(A(s )) =. Similarly, with s, s interchanged, there follows R(A(s)) R(D(s )) =. Lemma tells us that from the perspective of the relabeled-level, the event disablement (resp. enablement) is consistent with the relabeling of strings. Next we design an algorithm to determine whether R is CD with respect to L(SUP). Let SUP = (Z, Σ, ζ, z 0, Z m ). Denote by ZC := {Z i Z i Z, i I} the set of state subsets generated in the process of converting the direct transition relabeling result of SUP to its deterministic counterpart by SCA. Although the time complexity of this process is the same as the SCA, i.e. O( n ) in worst case, it often performs more quickly than its worst-case complexity would suggest as explained in Subsection.. By the semantics of relabel( ), we have that for any two states z, z Z i, i I, there exist strings s, s Σ such that ζ(z 0, s ) = z, ζ(z 0, s ) = z with R(s ) = R(s ). Let ZD := {(z, dis(z))} represent the result of Condat( ), in which z Z, dis(z) is the set of controllable events disabled at state z. Applying relabeling to every event in dis(z), we get ZRD := {(z, R(dis(z)))}. The pseudo-code shown in Algorithm describes how to verify whether R is CD with respect to Algorithm Algorithm to verify whether R is CD with respect to L(SUP) Require: ZC := {Z i Z i Z, i I},ZRD := {(z, R(dis(z)))} Ensure: true or false : procedure CD(ZC,ZRD) : for i = to I do : for j = to n = Z i, Z i := {z,, z n } do : if R(dis(z ))! = R(dis(z j )) then : return false : end if : end for : end for : return true 0: end procedure L(SUP). The idea of the algorithm is to verify whether for all states in Z i ZC, the corresponding sets of events to be disabled computed by Condat are the same after relabeling. If they are, then the event disablement is consistent with the relabeling of strings and the algorithm returns true; otherwise, the algorithm returns false. Regarding ZC, ZRD as known arguments, the time complexity of this algorithm is O(n ) as it contains two nested for-loops. Taking the manufacturing facility shown in Fig. for example, we illustrate Algorithm as follows. DAT = Condat(DES,DES) returns control data DAT for the supervisor DES of the controlled system DES. If DES represents a controllable language (with respect to DES), as when DES has been previously computed with Supcon, then DAT will tabulate the events that are to be disabled at each state of DES (Wonham, 0a). DES = Supcon(DES,DES) is a trim generator for the supremal controllable sublanguage of the marked legal language generated by DES with respect to the plant DES (Wonham, 0a).

11 June 0, 0 tcon Page of Table. Illustration of Algorithm ZC ZD := {(z, dis(z)), z Z i, i {0,, }} Z 0 = {0} (0, {}) Z = {, } (, {, }), (, {, }) Z = {} (, {, }) Z = {} (, ) Z = {, } (, {}), (, {}) Z = {} (, {, }) For clarity, let m =, n = and assume that the buffer size is. We have M :=( i=mini) MOUT SUP =supcon(m, BUF) (, ) SUP.dat =condat(m, SUP) RSUP =relabel(sup) (, ) Let Z = {0,, } denote the state set of SUP. The state set of RSUP and its correspondence with states of SUP are shown in the first column of Table. The second column of this table denotes the result of Condat( ). We need to check that for each entry in the second column, all sets R(dis(z)) are identical. For example, for the second entry in the second column, R({, }) = R({, }) = {, }, which corresponds to the fourth line in Algorithm. As all entries in the second column pass the check, R is CD with respect to L(SUP) in this example. Lemma : If R is SEF and E has the RNP, then R is CD with respect to L(SUP). Proof. Let s, s L(SUP), σ, σ Σ with R(s) = R(s ), R(σ) = R(σ ). Assume sσ L(G), sσ / L(SUP). We need to show s σ L(G), s σ / L(SUP). As G is composed of parallel components and R is SEF, for sσ L(G) with R(s) = R(s ), there exists an event σ Σ with R(σ) = R(σ ) such that s σ L(G). As sσ / L(SUP), sσ, s σ L(G), we have that event σ is disabled after the occurrence of s as E has the RNP. Thus, s σ / L(SUP). Lemma provides another direct approach to verify whether R is CD with respect to L(SUP). The significance of Algorithm is that it can verify the result under the weaker assumption that R is not SEF. Next we explore how to achieve optimal supervisory control of G with respect to E by working at the more abstract relabeled level of RG and R(E). Lemma : R(L m (SUP)) = R(L m (SUP)), i.e. R(L(SUP)) = L m (RSUP). Proof. ( ) Let t R(L m (SUP)). Then there exists some s L m (SUP) such that R(s) = t. Also, there exists some w Σ such that sw L m (SUP). Then R(sw) = tr(w) R(L m (SUP)). Hence, t R(L m (SUP)). ( ) Let t R(L m (SUP)). For some w T, we have tw R(L m (SUP)). Then there exists sv L m (SUP) such that R(sv) = tw with R(s) = t, R(v) = w. Thus, s L m (SUP). Hence, t = R(s) R(L m (SUP)). Now suppose the language H L(RG) is controllable with respect to L(RG). We define the

12 June 0, 0 tcon Page 0 of language K L(G) such that R(K) = H by the following, Similarly, K := R (H) L(G) = {s L(G) R(s) H} K := R (H) L(G) = {s L(G) R(s) H} We say H is inverse image nonblocking (IINB) if K = K, i.e. R (H) L(G) = R (H) L(G). The intuition for IINB is that for a nonblocking language H, its inverse image under the relabeling map is also nonblocking. Next we prove that the relabeled original supremal supervisor is isomorphic to its counterpart in the relabeled system. Proposition : Assume that for every controllable sublanguage H L(RG), H is IINB. If R is CD with respect to L(SUP) and E has the RNP, then L m (RSUP) = L m (XRSUP). Proof. First we show that L m (RSUP) is controllable with respect to L(RG). We need to show ( t, τ)t L m (RSUP), τ T u, tτ L(RG) tτ L m (RSUP) Let t L m (RSUP), τ T u, tτ L(RG). As R(L(SUP)) = L m (RSUP) by Lemma, we have t R(L(SUP)). Then there exists s L(SUP) such that R(s) = t. As tτ L(RG) = RL(G), there exist some s L(G), σ Σ u such that s σ L(G) with R(s ) = t, R(σ ) = τ. As R is CD with respect to L(SUP) and s L(SUP), R(s) = R(s ) = t, we have s L(SUP) by induction on length of strings s, s. Thus, s σ L(SUP) by the controllability of L m (SUP). Hence, R(s σ ) = tτ R(L(SUP)) L m (RSUP) by Lemma. Next we show that L m (RSUP) is supremal. Assume that H L(RG) is controllable with respect to L(RG). We need to show H L m (RSUP). Define We show that K is controllable, i.e. K := R (H) L(G) = {s L(G) R(s) H} ( s, σ)s K, σ Σ u, sσ L(G) sσ K As s K = R (H) L(G) = R (H) L(G) by the assumption that H is IINB, we have t := R(s) H. Let τ := R(σ). With tτ = R(sσ) L(RG), we have tτ H by the controllability of H. Hence, sσ R (H) L(G) = R (H) L(G) = K as H is IINB. Besides, K = R (H) L(G) R (R(E)) L(G) E by the RNP. We have K L m (SUP) as L m (SUP) is the supremal controllable sublanguage with respect to L(G). Hence, R(K) = H R(L m (SUP)) = L m (RSUP). Proposition tells us that if R is CD with respect to L(SUP), E has the RNP and all controllable sublanguages of L(RG) are IINB, then under event relabeling, the original supremal supervisor is consistent in control action with its counterpart in the relabeled system. Our assumptions here are indeed borne out in the intended applications (e.g. Subsections. and. below). 0

13 June 0, 0 tcon Page of BUF BUFk Gij nbuf nbufk i q j Figure. Schematic of a basic state tree f g S {disable,enable} Figure. Relationship between f σ and φ. Extraction of abstract control functions In this section, based on the condition that R is CD with respect to L(SUP), we extract control information from the control functions computed by STS to obtain succinct abstract control functions. We divide the components of a DES into n groups. The machines in a given group are isomorphic (i.e. identical in structure). Denote the j th component in group G i, i {,, n} as G ij = (Q i, Σ ij, δ ij, q i0, Q im ) Let L m (SUP) = supc(l m (G) E). For s L m (SUP) =: L(SUP), denote by SC(s) := (ν BUF,, ν BUF k, q,, q G,, qn,, q n G n ) the status configuration after the occurrence of s. Here qj i, j {,, G i } represents the currently activated state of component G ij in group G i ; ν BUF l, l {,, k} represents the number of workpieces in buffer BUFl. SC(s) corresponds to a legal basic state tree as shown in Fig.. Denote by ASC(s) := (ν BUF,, ν BUF k, ν 0,, ν Q,, νn 0,, ν n Q n ) the abstract status configuration after the occurrence of s. Here νj i represents the number of components in group G i whose currently activated state is state j, j {0,, Q i }. Next we discuss the relationship between control function f σ and abstraction map φ (defined below) as shown in Fig.. For a given σ Σ c, we compute the set of status configurations for the control function f σ by STS. Let Ψ en := {SC(s) s L(SUP) & [sσ / L(G) or sσ L(SUP)]}, Ψ dis := {SC(s) sσ L(G) & sσ / L(SUP)}

14 June 0, 0 tcon Page of Write Ψ := Ψ en Ψ dis. The control function f σ : Ψ {enable, disable} is defined as f σ (SC(s)) = { enable disable if SC(s) Ψ en if SC(s) Ψ dis If f σ (SC(s)) = enable, then event σ is enabled after the occurrence of string s. Correspondingly, Ω en := {ASC(s) s L(SUP) & [sσ / L(G) or sσ L(SUP)]}, Ω dis := {ASC(s) sσ L(G) & sσ / L(SUP)} Write Ω := Ω en Ω dis. Define the abstraction map φ : Ψ Ω according to φ(sc(s)) = ASC(s) for every s L(SUP). Lemma : Assume that R is SEF. For any s, s L(SUP), φ(sc(s)) = φ(sc(s )) R(s) = R(s ) Proof. ( ) The proof is by induction on the length of s, s. Basis: Let s = s = ε. As all components are at their initial states and the buffers are empty, SC(s) = SC(s ). We have φ(sc(s)) = φ(sc(s )), R(s) = R(s ) = ε. Inductive step: Assume R(s) = R(s ), φ(sc(s)) = φ(sc(s )) = (, ν BUF l,, ν i q,, ν i q, ) Assume that there exist µ, µ Σ such that sµ, s µ L(SUP), φ(sc(sµ)) = φ(sc(s µ )) and the occurrence of µ will increment ν BUF l, νq i and decrement νq i. Then there exists some machine G ij = (Q i, Σ ij, δ ij, q i0, Q im ) G i, j {,, G i } such that δ ij (q, µ) = q, where q, q Q i. As φ(sc(s)) = φ(sc(s )), φ(sc(sµ)) = φ(sc(s µ )) by the inductive assumption and R is SEF, there exists j {,, G i } such that µ, µ is a replicated pair and the occurrence of µ will also increment ν BUF l, ν i q and decrement ν i q. Thus R(µ) = R(µ ) by the definition of replicated pair. A similar argument applies if ν BUF l is decremented by the occurrence of µ or µ. Thus, R(sµ) = R(s µ ). The reverse direction follows the same way. With the foregoing definitions, we prove that the diagram in Fig. commutes. Proposition : If R is CD with respect to L(SUP), then for every σ Σ c there exists an abstract control function g σ : Ω {disable, enable} such that the diagram in Fig. commutes. Proof. We need to show ker φ ker f σ, where ker( ) denotes equivalence kernel (Mac Lane & Birkhoff, ). Let s, s L(SUP) with φ(sc(s )) = φ(sc(s )), i.e. (SC(s ), SC(s )) ker φ. As φ(sc(s )) = φ(sc(s )), we have R(s ) = R(s ) by Lemma. Assume SC(s ) Ψ en, i.e. s σ L(SUP) or s σ / L(G). As R is CD with respect to L(SUP), we have s σ / L(G) or s σ L(SUP). Thus, SC(s ) Ψ en by the definition of Ψ en. Assume SC(s ) Ψ dis, i.e. s σ L(G), s σ / L(SUP). We have s σ L(G), s σ / L(SUP) as R is CD with respect to L(SUP). Thus, SC(s ) Ψ dis by the definition of Ψ dis.

15 June 0, 0 tcon Page of s G i G in f g ' {disable,enable} f ' Figure. Schematic of the same abstract control function for a replicated pair SC s f, i f n n, Thus, for a given σ Σ c, we have in s G i G in ASC s Figure. Schematic of the shared abstract control function g σ { enable g σ (ASC(s)) = disable if ASC(s) Ω en if ASC(s) Ω dis g, If g σ (ASC(s)) = enable, then event σ is enabled after the occurrence of string s. Proposition tells us that if R is CD with respect to L(SUP), the control actions defined on the abstract status configurations are identical with the control actions defined on the status configurations. Let σ, σ Σ c be a replicated pair. If φ(sc(s)) = φ(sc(s )), sσ, s σ L(G) with R(σ) = R(σ ), we have g σ (φ(sc(s))) = g σ (φ(sc(s ))) as R is CD. Thus, events σ, σ share the same abstract control function g σ as displayed in Fig.. For a given controllable event τ T c := R(Σ c ), denote by Σ τ := {σ Σ R(σ) = τ} the set of controllable events relabeled as τ. Clearly, for any σ, σ Σ τ, σ, σ is a replicated pair. For τ, τ T c with τ τ, Σ τ Σ τ = as two distinct events which don t comprise a replicated pair will not be relabeled as the same symbol. We have τ T c Σ τ = Σ c. For a given group G i := {G i,, G in }, n = G i, let Σ ij denote the event set of G ij, j {,, n}. Let events σ j Σ ij be relabeled as τ T c. As R is CD, we have that f σj (φ(sc(s))) evaluate equally after the occurrence of some string s Σ. Thus, f σj (φ(sc(s))) can be represented by a single abstract control function g σ, σ Σ τ with R(σ) = R(σ j ), as shown in Fig.. Furthermore, for each τ i T c, i {,, T c }, all events in Σ τi share an abstract control function. Let gi represent the shared abstract control functions for events in Σ τi. Then the overall control mechanism of the whole system can be represented as shown in Fig. 0, in which we use abstract control functions gi for the new controllers.

16 June 0, 0 tcon Page of Examples s G ASC s g g T c Figure 0. Schematic of the overall control mechanism with abstract control functions We provide two examples to illustrate the process of extracting abstract control functions. The first is a manufacturing facility (MF) with multiple input and output machines and a buffer with fixed size; the second is a transfer line (TL) incorporating material feedback.. Manufacturing facility The MF shown in Fig. consists of parallel arrays of machines and a buffer with fixed size. Let events i, i, j, j be relabeled as,,, respectively. Let M :=( i=mini) ( j=moutj) RM =relabel(m), RBUF = relabel(buf) SUP =supcon(m, BUF) (, ) XRSUP =supcon(rm, RBUF) (, ) As R is SEF and L(BUF) has the RNP, R is CD with respect to L(SUP) by Lemma. By Algorithm, we confirm this result again. We also verify that R (L m (XRSUP)) L(M) = R (L m (XRSUP)) L(M) i.e. L m (XRSUP) is IINB. By Proposition, we have that relabel(sup) is isomorphic to XRSUP, which is confirmed by direct computation. For s L(SUP), SC(s) is denoted by (ν BUF, q, q, q, q, q ) in which qi, q j represent the currently activated state of MINi, MOUTj respectively. ASC(s) is denoted by (ν BUF, ν0, ν, ν 0, ν ), in which νi j represents the number of machines whose currently activated state is state j. By the computation of STS, event is enabled at the status configurations shown in Table. As R is CD with respect to L(SUP), Proposition holds and we extract the abstract status configurations as shown in Table. Also, we have that all events i, i {,, } are enabled at the abstract status configurations shown in Table. Moreover, in this example, to enable events i, we only need the information embodied in ν and ν BUF, i.e. the number of input machines at work and the number of workpieces in the buffer, Table can be further reduced to Table, which illustrates the predicate that events i are enabled if: Buffer is empty (ν BUF = 0) and at most one input machine is working (ν );

17 June 0, 0 tcon Page of Table. Table. Table. Table. Status configurations where event is enabled ν BUF MIN MIN MIN MOUT MOUT / 0/ 0/ / 0/ / 0/ 0/ denotes that the currently activated state is either 0 or. Abstract status configurations where events i are enabled ν BUF ν0 ν ν0 ν The symbol denotes don t care. Reduced abstract status configurations where events i are enabled ν BUF ν Reduced abstract status configurations where events j are enabled ν BUF There is one workpiece in the buffer (ν BUF = ) and no input machine is working (ν = 0). To enable events j, j {, }, we only need the information in ν BUF because events j are enabled if the buffer is not empty. The reduced abstract status configurations for events j are listed in Table. Therefore, the control decisions of the whole system are based on Table and Table, which are independent of the number of input and output machines as the entries in these two tables are independent of the total number of input and output machines, when buffer size is fixed at. However, the state size of SUP is dependent on the number of input and output machines and increases rapidly with their increments. For example, let m =, n =. The corresponding monolithic supervisor SUP has states and its relabeled version has 0 states. This example illustrates that the controller complexity of abstract control functions is much less than the complexity of the directly computed monolithic supervisor. The generalization to a buffer of arbitrary size should be clear.. Transfer line We apply the same idea to the TL (Wonham, 0a) shown in Fig.. Let m =, n =, l =. We divide the components into three groups G :={M, M, M, M} G :={M, M, M} G :={TU, TU, TU}

18 June 0, 0 tcon Page of i Mi i i B Mi i 0 k j # j Mj Mj j j k i,, m, j,, n, k,, l 0 i 0 j 0 k B i k j 0 j k B B k,k TUk Figure. Schematic of transfer line # k Let events i, i, j, j, k, k, k be relabeled as,,,,,, respectively. Let TL :=( i=mi) ( j=mj) ( k= TUk) B :=B B RTL =relabel(tl), RB = relabel(b) SUP =supcon(tl, B) XRSUP =supcon(rtl, RB) By Algorithm, we confirm that R is CD with respect to L(SUP). By the same approach in Subsection., we verify that relabel(sup) is isomorphic to XRSUP. For s L(SUP), SC(s) is denoted by (ν B, ν B, q, q, q, q, q, q, q, q, q, q ) in which qi, q j, q k represent the currently activated state of MINi, MOUTj, TUk respectively. ASC(s) is denoted by (ν B, ν B, ν 0, ν, ν 0, ν, ν 0, ν ) in which νj i represents the number of machines in G i whose currently activated is state j. We model the system with STS and obtain the status configurations where event is enabled as shown in Table. As the control decisions are made on the number of workpieces in each buffer and the number of working components in each group, we extract the information (ν B, ν B, ν, ν, ν ) from Table to get the reduced abstract status configurations as shown in Table. Similarly, we get the reduced abstract status configurations for the enablement of events j and k as shown in Tables and respectively. As the control functions computed by STS are nonblocking by the semantics of supcon( ) in STS, and we have proved that the control decisions made on status configurations are consistent (identical) with those made on abstract status configurations, the abstract control functions represented by Tables to are nonblocking. As the entries in Tables to are independent of the total number of machines in each group, the abstract control functions are invariant. For arbitrary sizes of buffers, although the control logic is not as obvious as that of the MF, we can still extract abstract control functions by following the steps in this example. TUk k

19 June 0, 0 tcon Page of Table. Table. Table. Table. Status configurations where event is enabled ν B ν B M M M M M M M TU TU TU / / / 0/ / 0/ 0/ The currently activated state of M is 0 and the buffer sizes of B and B are and respectively. Reduced abstract status configurations where events i are enabled ν B ν B ν ν ν / Reduced abstract status configurations where events j are enabled ν B ν B ν ν ν Reduced abstract status configurations where events k are enabled ν B ν B ν ν ν. Conclusion This paper exploits the symmetry of DES with parallel components and fixed buffer sizes to extract the invariance property of abstract control functions. We demonstrate the process of extracting abstract control functions from control functions computed by STS. Moreover, we prove that the abstract control functions are equivalent to the original control functions in control action. Finally we apply our method to two examples to illustrate its validity. As STS is efficient in the synthesis of control functions, our future work will aim to extract abstract control functions of more complex systems with symmetric structures. Acknowledgement This work was supported by the China Scholarship Council under Grant [0]0.

20 June 0, 0 tcon Page of References Bherer, H., Desharnais, J., & St-Denis, R. (00). Control of parameterized discrete event systems. Discrete Event Dynamic Systems, (),. Bryant, R. (). Graph-based algorithms for boolean function manipulation. IEEE Trans. Computers, C- (),. Das, S. R., & Holloway, L. E. (). Learning of time templates from system observation. Proceedings of the American Control Conference, Seattle, Washington, (pp. 0). Ekberg, G., & Krogh, B. H. (00). Programming discrete control systems using state machine templates. Proceedings of the th International Workshop on Discrete Event Systems, Ann Arbor, Michigan, USA, 00 (pp. 00). Eyzell, J. M., & Cury, J. E. R. (). Exploiting symmetry in the synthesis of supervisors for discrete event systems. Proceedings of the American Control Conference, Philadelphia, Pennsylvania, Jun. (pp. ). Eyzell, J. M., & Cury, J. E. R. (00). Exploiting symmetry in the synthesis of supervisors for discrete event systems. IEEE Transactions on Automatic Control, (vol., no., pp. 00 0). Grigorov, L., Cury, J. E. R., & Rudie, K. (00). Design of discrete-event systems using templates. Proceedings of the American Control Conference, Seattle, WA, USA, 00 (pp. 0). Grigorov, L., Butler, B. E., Cury, J. E. R., & Rudie, K. (0). Conceptual design of discrete-event systems using templates. Discrete Event Dynamic Systems,, 0. Holloway, L. E., & Chand, S. (). Time templates for discrete event fault monitoring in manufacturing systems. Proceedings of the American Control Conference, Baltimore, Maryland, (pp. 0 0). Jiao, T., Gan, Y., Yang, X., & Wonham, W. M. (0). Exploiting symmetry of discrete-event systems with parallel components by relabeling. TENCON 0-0 IEEE Region 0 Conference, Macau, 0 (pp. ). Jiao, T., Gan, Y., Xiao, G., & Wonham, W. M. (0). Exploiting symmetry of state tree structures for discrete-event systems with parallel components. th International Workshop on Discrete Event Systems (WODES 0), Xi an, China, June 0 ( pp.). Ma, C. (00). Design Software: STSLib. (accessed Nov. 0). Ma, C., & Wonham, W. M. (00). Nonblocking Supervisory Control of State Tree Structures. Springer- Verlag, Berlin Heidelberg. Ma, C., & Wonham, W. M. (00). Nonblocking supervisory control of state tree structures, IEEE Transactions on Automatic Control, (),. Mac Lane, S., & Birkhoff, G. (). Algebra, rd edn. Chelsea Publishing Company, New York. Rabin, M. O., & Scott, D. (). Finite automata and their decision problems. IBM Journal of Research and Development, (),. Ramadge, P. J., & Wonham, W. M. (). Supervisory control of a class of discrete event processes. SIAM J. Control Optim., (), 0 0. Rohloff, K., & Lafortune, S. (00). Symmetry reductions for a class of discrete event systems. rd IEEE Conference on Decision and Control, Atlantis, Paradise Island, Bahamas, 00 (pp. ). Rohloff, K., & Lafortune, S. (00). The verification and control of interacting similar discrete event systems. SIAM Jornal on Control and Optimization, (),. Su, R., & Wonham, W. M. (00). Supervisor reduction for discrete-event systems. Discrete Event Dynamic Systems: Theory and Applications,,. Su, R. (0). Discrete-event modeling of multi-agent systems with broadcasting-based parallel composition. Automatica, (), 0 0. Wang, W., Su, R., & Lin, L. (0). On analysis of deadlock and blocking freeness in isomorphic module systems, American Control Conference, Washington, DC, 0 (pp. ). Weyl, H. (0). The Theory of Groups and Quantum Mechanics. Dover Publications. Weyl, H. (). Symmetry. Princeton, N.J.: Princeton University Press. Wonham, W. M. (). Linear Multivariable Control - A Geometric Approach. Springer-Verlag. Wonham, W. M. (0a). Supervisory Control of Discrete-event Systems. Syst. Control Group, ECE Dept, Univ. Toronto, Toronto, ON, Canada, 0 [Online]. Available: Wonham, W. M. (0b). Design Software: TCT. Systems Control Group, Dept. of ECE, Univ. of Toronto, 0 [Online]. Available:

21 Page of Paper Reference: TCON-0-0 Journal: Title: Exploiting Symmetry of State Tree Structures for Discrete-event Systems with Parallel Components Response to Referee All page numbers below correspond to the anonymised version of the resubmitted paper. The examples shall be distributed throughout the paper, not all at the end of the paper. For example, after introducing state tree structure G, an example of G can be given immediately to illustrate the definition. Similarly, an example can be given immediately after Algorithm to illustrate the algorithm. Action: We take the Manufacturing Facility (MF) shown in Fig. as the example to distribute throughout the paper. Items ), ) and ) below are newly added. ) In Subsection., we use this example to show that the result of the relabel algorithm has many fewer states than the original automaton. ) In Subsection. (State tree structures), we illustrate the definition of state tree structure as follows. First we display the state tree structure of the MF in Fig., with which we explain the definition of holons. Then we show the state tree of the MF in Fig., with which we explain the definitions of sub-state-trees, global transition function, initial state tree and the set of marked state trees. The supplementary material above corresponds to the last paragraph on Page and first paragraph on Page. We show the basic state tree of the MF in Fig., with which the definitions of basic state tree, initial predicate and marked predicate are explained. The supplementary material above corresponds to the second to the last paragraph on Page. ) With events i, i, j, j being relabeled as,,,, we have that the relabeling map defined in this way is SEF. This illustration corresponds to the second paragraph on Page. ) After the analysis of Algorithm, we apply this algorithm to the MF. For clarity, assume that the buffer size is and let m =, n =. We compute the plant M, the supervisor SUP and its relabeled version RSUP. Then list the state set of RSUP and its correspondence with states of SUP in the first column of Table. The second column of this table denotes the result of Condat. We check that for each entry in the second column, all sets R(dis(z)) are identical. Hence, the relabeling map R is CD with respect to L(SUP) in this example.

22 Page 0 of The supplementary material above corresponds to the last paragraph on Page and first two paragraphs on Page. ) The definitions in Section are illustrated by two examples in Section. In Subsection., we first illustrate that Proposition is applicable to the MF. Then we illustrate the process of extracting abstract status configurations to derive the abstract control functions. With this example, we show the invariance property of abstract control functions, i.e. the control decisions are independent of the total number of input and output machines, when buffer size is fixed. In Subsection., a more complex example (Transfer Line) is employed to illustrate the ideas of the paper again. Some notations are confusing. Do not use the same letter to represent different things. For example, ST(ST) is a bad notation. Also, G is used to denote both automaton and state tree structure. There are several other cases of such confusions. Action: We make the following modifications of notations and mark them in red throughout the manuscript. Definition denoted by the notation Original notation New notation State tree structure G S Sub-state-tree of ST ST(ST) S(ST) Closed loop STS formed by G and f G f S f Set of controllable events disabled at state z D(z) dis(z) We change the notation of the set of controllable events disabled at state z from D(z) to dis(z) because D(z) may be confused with the notation D(s) defined on Page, i.e. Let D: L(SUP) Pwr(Σ) with s D(s) {σ Σ c sσ L(G) & sσ L(SUP)}