String Execution Time for Finite Languages: Max is Easy, Min is Hard Rong Su a , Gerhard Woeginger b a
Division of Control and Instrumentation, School of Electrical and Electronic Engineering, Nanyang Technological University, 50 Nanyang Avenue, Singapore 639798
b
Department of Mathematics and Computer Science, Eindhoven University of Technology, PO Box 513, 5600 MB Eindhoven, The Netherlands
Abstract In performance evaluation or supervisory control, we often encounter problems of determining the maximum or minimum string execution time for a finite language when estimating the worst-case or best-case performance. It has been shown in the literature that the time complexity for computing the maximum string execution time for a finite language is polynomial with respect to the size of an automaton recognizer of that language and the dimension of the corresponding resource matrices. In this paper we provide a more efficient algorithm to compute such maximum string execution time. Then we show that it is NP-complete to determine the minimum string execution time.
Key words: languages, finite-state automata, (max,+) semiring, heap models, computational complexity
1
Introduction
The Ramadge-Wonham (RW) formalism [9] [12] has been widely adopted for logic control of discrete-event systems. The usage of automata can effectively handle parallel composition, nondeterminism and concurrency. On the other hand, max-plus algebra has been fruitfully used for performance related evaluation, scheduling and control [5] [1]. Seeing the advantages of automata theory and max-plus algebra the author of [3] utilizes max-plus automata to combine two formalisms together for effective treatment of timed behaviors with nondeterminism and concurrency. In [4] the authors show that some task resource models commonly used for performance evaluation in queuing networks can be recast in the max-plus automata framework, which has a nice graphical interpretation by the theory of heaps-of-pieces [11]. In [6] [7] the authors translate the concept of controllability in the RW framework to one that fits in the max-plus automaton framework and formulate the corresponding supervisor synthesis problems accordingly. As a result of the new algebraic modeling formalism, their algebraic supervisor synthesis techniques for logical constraints are completely different from those in the RW frameEmail addresses:
[email protected] (Rong Su),
[email protected] (Gerhard Woeginger).
Preprint submitted to Automatica
work. In [10] the authors present a timed supervisory control framework, which utilizes the standard RW supervisor synthesis procedures to handle logic constraints and a task resource model in the max-plus automata framework to deal with time performance optimization. When using max-plus automata for performance evaluation, scheduling or supervisor synthesis, we often encounter the problem of determining the maximum or minimum string execution time for a finite language, which corresponds to the worst-case or the best-case performances respectively. For example, in [10] the authors use the maximum string execution time as a supervisor’s performance measure, and aims to synthesize a supervisor, whose maximum string execution time is minimum among all supervisors – in other words, the optimal supervisor has the best “worst-case” performance. The choice of a finite language has a practical root in manufacturing industry where products are usually processed in batches with a finite definite size, as illustrated in [10]. In [3] it has been shown that the time complexity of determining the maximum string execution time for a finite language is polynomial with respect to the size of an automaton recognizer of that language and the dimension of the corresponding resource matrices. In this paper we provide a much more efficient polynomial algorithm to compute such maximum string execution time. We then show that finding the minimum string execution
14 November 2012
1, · · · , n), where for all q, v ∈ {1, · · · , n},
time for a finite language turns out to be NP-complete. These results can help us decide whether worst-case or best-case execution time should be used in a large system. For example, it justifies that the choice of using the maximum string execution time as the performance measure of a supervisor in [10] is reasonable from a computational point of view.
q < v ∧ (σq , σv ) ∈ h ⇒ tsσq + f (σq ) ≤ tsσv . Let T (s, w) := max{tsσ1 + f (σ1 ), · · · , tsσn + f (σn )} be the execution time of s with respect to the time stamp w. Let Θ(s) be the collection of all possible time-stamps for s. We call υ(s) := inf w∈Θ(s) T (s, w) the string execution time of s. For all K ⊆ Σ∗ , let ω(K) := sups∈K υ(s) be the maximum string execution time of K, and ψ(K) := inf s∈K υ(s) be the minimum string execution time of K. As a convention, let ω(∅) = ψ(∅) := +∞. 2
We organize this paper as follows. In Section II we introduce the concepts of language and automaton, and present the problems of determining the maximum and minimum string execution time for a finite language. Then we provide a polynomial algorithm to solve the maximum execution time problem in Section III. After showing the NP-completeness of solving the minimum string execution time problem in Section IV, we draw concludes in Section V. 2
Each tsσk in a time-stamp is interpreted as the starting moment of event σk being executed, and tsσk +f (σk ) is the ending moment for the execution of σk . If (σq , σv ) ∈ h and q < v, then we know that before executing σv , the execution of σq must have been finished because of the firing mutual exclusion between σq and σv . Thus, we have tsσq + f (σq ) ≤ tsσv . The string execution time υ(s) is interpreted as the minimum time required to finish the execution of s. Next, we will show that given a finite language K ⊆ Σ∗ , the time complexity of computing ω(K) is polynomial, but computing ψ(K) is NP-complete.
Basic concepts
Let Σ be a finite alphabet. We use Σ∗ to denote the free monoid of Σ with ϵ being the unit element and string concatenation as the monoid operation. Given s, t ∈ Σ∗ , s is a prefix substring of t, written as s ≤ t, if there exists s′ ∈ Σ∗ such that ss′ = t, where ss′ denotes the concatenation of s and s′ . A subset K ⊆ Σ∗ is called a language. Given two languages L, L′ ⊆ Σ∗ , let LL′ := {ss′ ∈ Σ∗ |s ∈ L ∧ s′ ∈ L′ } denote the concatenation of two sets. Given a set S we use |S| to denote the size of S. A finite-state automaton is a 5-tuple G = (X, Σ, ξ, x0 , Xm ), where X stands for the state set, Σ for the alphabet, x0 for the initial state, Xm ⊆ X for the marker state set, and ξ : X × Σ → X for the (partial) transition function, which is extended to X × Σ∗ . Let Lm (G) := {s ∈ Σ∗ |ξ(x0 , s) ∈ Xm } be the marked behavior of G. We say a language K ⊆ Σ∗ is recognized by G if Lm (G) = K.
3
A polynomial algorithm for computing ω(K)
In this section we first introduce a heap model with respect to (Σ, f, h), based on which we can compute υ(s) for each s ∈ Σ∗ . Then we present a polynomial algorithm to compute ω(K) for a finite language K ⊆ Σ∗ . 3.1
A heap model with respect to (Σ, f, h)
Definition 2 A heap model for (Σ, f, h) is a 4-tuple H(Σ, f, h) = (T , R, R, u), where
Let R+ be the set of nonnegative reals. We define a map f : Σ → R+ , which assigns a nonnegative value f (σ) to each event σ ∈ Σ. Such a value can be interpreted as the duration of executing σ. In practical applications different event executions may overlap. For example, in a manufacturing system two robots can transport work pieces during the same period. Owing to resource competitions, usually some events must be mutually exclusive in the sense that their executions cannot overlap. To capture this idea we define a mutual exclusion relation h ⊆ Σ × Σ, which is reflexive and symmetric, but not necessarily transitive. For example, action a may compete with action b for resource r1 , which means (a, b) ∈ h (or symmetrically (b, a) ∈ h). If action b competes with action c for resource r2 , i.e., (b, c) ∈ h, it does not necessarily imply (a, c) ∈ h because these two actions may require completely different resources.
(1) (2) (3) (4)
T := Σ, R is a finite set determined from h, R : T → 2R is a map, u : T × R → R+ ∪ {0, −∞} is a map, where { (∀σ ∈ T )(∀r ∈ R) u(σ, r) :=
f (σ) if r ∈ R(σ) −∞ otherwise
2
Each r ∈ R is interpreted as a resource. For each σ ∈ T and r ∈ R(σ), we interpret u(σ, r) as the occupation time of σ over r. To determine R and define the map R we perform the following construction. A subset λ ⊆ T is complete if for all σ, σ ′ ∈ λ we have (σ, σ ′ ) ∈ h. A clique cover of T is a collection of complete subsets such that every pair of h is contained in at least one complete subset. Such a clique cover need not be unique. Although finding a clique cover with the minimum size is NP-hard (which is derivable from a result in [8]), we can certainly
Definition 1 Given a string s = σ1 · · · σn for some n ∈ N, a time-stamp of s is a list w = (tsσk ∈ R+ |k =
2
find a clique cover whose size is not necessarily minimum within polynomial time. Let R be a clique cover of T . For each σ ∈ T let R(σ) := {λ ∈ R|σ ∈ λ}.
The objective is to find a directed path P∗ from x0 to a marker state x′ ∈ Xm that maximizes the max-plus product U (P∗ )1R . Equivalently, we want to compute
Definition 3 The (max,+) semiring Rmax is the set R ∪ {−∞}, equipped with the operation max, written additively (i.e. a ⊕ b = max{a, b}), and the usual sum, written multiplicatively (i.e. a⊗b = a+b). In this semiring, the zero element 0 is −∞, and the unit element 1 is 0. 2
ω(K) = ω(Lm (G)) =
The matrix operations are induced by the semiring structure as follows. For matrixes A and B of appropriate dimensions, (A⊕B)qv := Aqv ⊕Bqv = max{Aqv , Bqv }, and (A ⊗ B)qv := ⊕k (Aqk ⊗ Bkv ) = maxk (Aqk + Bkv ). For a scalar a ∈ R∪{−∞}, (a⊗A)ij := a⊗Aij = a+Aij . From now on we omit the ⊗ sign, and directly use AB to denote A⊗B. By the definition of semiring we get that, the matrix multiplication is associative, i.e. (AB)C = A(BC).
For every vertex xk with k = 0, . . . , n − 1 let F [k] be a |R|-dimensional row vector and for every coordinate c with c = 1, . . . , |R| we use F [k; c] to denote the cth coordinate of F [k], which is defined in the following way:
Finally, for 1 ≤ c ≤ |R| we denote by e[c] the |R|dimensional max-plus unit-vector that has 0 in the cth coordinate and −∞ in all other coordinates.
F [k; c] :=
if q = v and q ∈ / R(σ) 1 := u(σ, v) if q, v ∈ R(σ) 0 otherwise,
F [k] := ⊕P ∈P(xk ) U (P ) Proposition 4 Consider a vertex xk and a coordinate c, and let P ∈ P(xk ) be a maximizing path with U (P )e[c] = F [k; c]. Let xℓ be the penultimate vertex on path P and σ be the event label of the last arc (xℓ , xk ) on this path, and let M(σ)e[c] = (m1 , . . . , m|R| ). Then
and M(ϵ) being the unit matrix I (i.e. all diagonal entries are 1 and all other entries are 0). Let 1R be the |R|dimensional column vector, whose entries are all equal to 1, and 0R be the |R|-dimensional column vector, whose entries are all equal to 0. We use 1tR (and 0tR ) to denote the transpose of 1R (and 0R ). From [3] we have that for all s ∈ T ∗ , υ(s) = 1tR M(s)1R .
F [k; c] =
max F [ℓ, c′ ]mc′ = F [ℓ]M(σ)1R .
1≤c′ ≤|R|
Proof: Let P ′ denote the sub-path of P that goes from x0 to xℓ , and let U (P ′ ) = (u1 , . . . , u|R| ). Then F [k; c] results as the max-plus product of U (P ′ ) and M (σ)e[c], that is, as the maximum value of uc′ + mc′ where c′ runs through all coordinates. Then the corresponding maximizing coordinate c′ must satisfy uc′ = F [ℓ; c′ ], as otherwise we could still reach a larger value.
In summary, once (Σ, f, h) is given we can build a heap model H(Σ, f, h), which uniquely determines the morphism M. Then the string execution time of each s ∈ T ∗ can be computed. 3.2
max U (P )e[c].
P ∈P(xk )
In other words, F [k; c] is the largest value taken by the cth coordinate of the vectors U (P ), as P runs through all the paths from x0 to xk . By the definition of max-plus matrix operations,
Let RR,R max be the set of all matrices, whose dimensions are |R| × |R|. Let M : T ∗ → RR,R max be a morphism, where
(∀σ ∈ T ) M(σ)qv
max U (P )1R .
P ∈P(xn )
A polynomial time algorithm
Let K ⊆ Σ∗ be a finite language recognized by G = (X, Σ, ξ, x0 , Xm ), i.e., Lm (G) = K. We choose G to be the canonical recognizer of K, i.e., |X| is minimum among those of all other automata that recognize K. Clearly, G can be treated as a directed acyclic graph with the vertex set X = {x0 , · · · , xn−1 } and the edge set A := {(xi , xj ) ∈ X × X|(∃σ ∈ Σ) xj = ξ(xi , σ)}.
We show how to compute F [k] (0 ≤ k ≤ n − 1) in polynomial time by a dynamic programming approach.We compute F [0] := 1tR . Now suppose that we have already computed all F [ℓ] with xk = ξ(xℓ , σ) for some σ ∈ Σ. According to Prop. 4 we have
For a vertex xk ∈ X, we denote by P(xk ) the (finite) set of all directed paths from the source x0 to xk . Consider some fixed directed path P ∈ P(xk ) that traverses a sequence s = σπ(1) . . . σπ(ℓ) of arcs, i.e., xk = ξ(x0 , s). We associate with this path P the vector
Based on the aforementioned strategy for F [k] we propose the following algorithm to compute the worst-case execution time. In the algorithm we use “:=” to stand for the assignment operation as commonly used in the programming languages. For example, we use v := v + 1 to denote that the new value of the variable v is equal to the sum of the current value and 1.
F [k] = ⊕(xℓ ,σ)∈X×Σ:xk =ξ(xℓ ,σ) F [ℓ]M(σ).
U (P ) = 1tR M(σπ(1) )M(σπ(2) ) · · · M(σπ(ℓ) ).
3
Procedure 1:
S2 such that the sum of the numbers in S1 equals the sum of the numbers in S2 ? 2
(1) Input: an acyclic graph G and a morphism M. (2) Initialization: Act := {x0 }, for each xk ∈ X let { F [k] :=
Suppose S = {a1 , a2 , · · · , an }, where each ai (i = 1, · · · , n) is a positive integer. We construct the following automaton GS = (X, Σ, ξ, x0 , Xm ), where
1tR if xk = x0 0tR otherwise
• Σ := {σ1,ai , σ2,ai |i = 1, 2 · · · , n}, • X := {xj |j = 0, · · · , n}, Xm := {xn }, • ξ : X × Σ → X : ξ(xi−1 , σ1,ai ) = ξ(xi−1 , σ2,ai ) := xi for i = 1, · · · , n.
P re(xk ) := {(xp , σ) ∈ X × Σ|xk = ξ(xp , σ)} P ost(xk ) := {(σ, xp ) ∈ Σ × X|xp = ξ(xk , σ)}. (3) while Act ̸= ∅, (4) for each vertex in Act, say xk , (5) Act := Act − {xk }, for each (σ, xp ) ∈ P ost(xk ), (6) (7) F [p] := F [p] ⊕ F [k]M(σ), (8) P re(xp ) := P re(xp ) − {(xk , σ)}, (9) if P re(xp ) = ∅, (10) Act := Act ∪ {xp }. (11) Output ⊕xr ∈Xm F [r]1R .
For each i ∈ {1, · · · , n} let fS (σ1,ai ) = fS (σ2,ai ) := ai , and let hS = {σ1,ai |i = 1, · · · , n} × {σ1,ai |i = 1, · · · , n} ∪ {σ2,ai |i = 1, · · · , n} × {σ2,ai |i = 1, · · · , n}. As an illustration, suppose S = {a1 , a2 , a3 }. The automaton GS is
σ1,a1 2
x0
x1
σ2,a1
We can check that for each vertex xk ∈ Act, every one of its ancestor vertices, say xℓ , must be in Act before, i.e., its value F [ℓ] has been computed. From lines 6-8 we have
σ1,a3 x2
σ2,a2
x3
σ2,a3
Fig. 1. An automaton GS
depicted in Figure 1.
F [k] = ⊕(xℓ ,σ)∈P re(xk ) F [ℓ]M(σ)
Carefully checking the model GS we can see that for any string s ∈ Lm (GS ) either σ1,ai or σ2,ai (i = 1, 2, · · · , n) must appear in s only once, and they cannot both appear in s. This corresponds to our intention to partition S into two disjoint subsets S1 and S2 such that every member ai ∈ S must be put in only one subset. Given a string s ∈ Σ∗ , we use σ ∈ s to denote that event σ appears in s at least once. For each string s ∈ Lm (GS ), let
By using Prop. 4 it is straightforward to see that ω(K) = ⊕xr ∈Xm F [r]1R . In Procedure 1 each edge is traversed only once (see line 6 and the assumption that G is acyclic), and the time complexity of the computation in line 7 is O(|R|2 ). Thus, the overall time complexity of Procedure 1 is O(|A||R|2 ), which is no more than O(n2 |R|2 ) because |A| ≤ n2 . In [3] another polynomial algorithm is given to compute ω(K). Let q be the length of the longest path from x0 to xn−1 in G. Then the time complexity of this existing algorithm is O(qn3 |R|3 ) due to the computation of the product of q tensor products, where the dimension of each tensor product of the resource matrix and the transition matrix associated with each event a ∈ Σ in G is n|R| × n|R|. Clearly, Procedure 1 introduced in this paper is more efficient, especially considering that in practical applications we usually have |A| ≪ n2 for a large automaton. 4
σ1,a2
S1s := {ai ∈ S|σ1,ai ∈ s} and S2s := {ai ∈ S|σ2,ai ∈ s}. We call ϖ(s) := {S1s , S2s } the auxiliary set of s with respect to S. We have the following two lemmas. Lemma 6 Given a multiset S, let GS be constructed above. Then S has a partition {S1 , S2 } if and only if there exists s ∈ Lm (GS ) such that ϖ(s) = {S1 , S2 }. 2 Lemma 7 Given a multiset S, let (GS , fS , hS ) be constructed above. For each∑s ∈ Lm∑ (GS ) let ϖ(s) = {S1s , S2s }. Then υ(s) = max{ a∈S s a, a′ ∈S s a′ }. 2
NP-completeness of computing ψ(K)
1
Given a finite language K ⊆ Σ∗ , we use MET (standing for Minimum Execution Time) to denote the problem of computing ψ(K). To show that solving MET is NPcomplete, we will polynomial-time reduce the well known NP-complete problem, the Partition Problem (PP), to MET. The PP is stated as follows [2]:
2
To show that solving MET is NP-complete we present the following reduction procedure. Reduction Procedure: (RP) (1) Input: a multiset S of positive integers. Suppose S = {ai |i = 1, 2, · · · , n}. (2) Construct (GS , fS , hS ). (3) Compute ψ(Lm (GS )).
Problem 5 (PP) Decide whether a multiset S of positive integers can be partitioned into two subsets S1 and
4
∑n (4) If ψ(Lm (GS )) = ( i=1 ai )/2 then output yes. Otherwise, output no. 2 Theorem 8 Solving MET is NP-complete.
language. Clearly, K{σ}∗ is an infinite language for any σ ∈ Σ. It is not difficult to see that ψ(K) = ψ(K{σ}∗ ). Thus, finding the minimum execution time of an infinite language must be at least as hard as NP-complete because otherwise the problem for finite languages will not be NP-complete. An elaborated argument omitted here due to limited space confirms the NP-completeness result for infinite languages. Our result for the worst-case performance can be applied to one interesting case found in adaptive time optimal supervisory control, where we have a plant model G = (X, Σ, ξ, x0 , Xm ) with Lm (G) being possibly infinite and a collection of supervisors {S(x0 )} ∪ {S(x)|x ∈ Xm }. The supervisor S(x0 ) is applied first when the plant’s state is x0 . Subsequently, whenever a marker state, say x ∈ Xm , is reached, the corresponding supervisor S(x) will be activated. We can use Procedure 1 to determine the worst-case performance of each supervisor, which provides a glimpse of the overall performance of the adaptive system.
2
Proof: We first show that RP can be used to solve PP. Suppose the∑answer of RP is yes, then we have n ψ(Lm (GS )) = ( i=1 ai )/2, which ∑n means there exists s ∈ Lm (GS ) such that υ(s) = ( i=1 ai )/2. By Lemma s s 6, S has a partition } = ϖ(s). Then∑ by Lemma ∑ {S1 , S2∑ n 7, υ(s) = max{ a∈S s a, a′ ∈S s a′ } = ( i=1 ai )/2. 2 ∑ ∑ 1 ∑ n ′ Since = s a + a∈S a′ ∈S2s a i=1 ai , we have 1 ∑ ∑ ′ a = a . Thus, the answer to PP is yes. s s ′ a∈S1 a ∈S2 Suppose the answer to PP is yes, we know that there ∑exists a∑partition {S1∑ , S2 } of S such that n max{ a∈S1 a, a′ ∈S2 a′ } = ( i=1 ai )/2. By Lemma 6 there must exist a string s ∈ Lm (GS ) such that ϖ(s) = {S1 , S2 }. By Lemma 7, υ(s) = max{
∑
a∈S1
a,
∑ a′ ∈S2
′
a}=(
n ∑
References
ai )/2.
i=1
[1] Cohen, G., Gaubert, S., & Quadrat, J. P. (1999). Max-plus algebra and system theory: where we are and where to go now. Annual Reviews in Control, 23(1), 207–219.
′ Clearly, for all s′ ∈ Lm (G∑ S ) we have υ(s ) ≥ υ(s). Thus, n ω(Lm (GS )) = υ(s) = ( i=1 ai )/2, which means RP outputs yes. Thus, RP can be used to solve PP. Because Lm (GS ) is finite and for each s ∈ Lm (GS ) the execution time υ(s) can be computed by a polynomial algorithm (e.g., the one presented in Section III), we know that ψ(Lm (GS )) can be computed, and the problem is in the NP class. It is not difficult to check that the time complexity of constructing (GS , fS , hS ) is polynomial with respect to the size of S. Therefore, if the time complexity of solving MET at Step (3), i.e., computing ψ(Lm (GS )), is polynomial, then the time complexity of solving PP is polynomial. Unfortunately, it is well known that PP is NP-complete. Therefore, solving MET at Step (3) is NP-complete.
5
[2] Garey, M. R., & Johnson, D. S. (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman and Company, New York. [3] Gaubert, S. (1995). Performance evaluation of (max,+) automata. IEEE Trans. Autom. Control, 40(12), 2014-2025. [4] Gaubert, S., & Mairesse, J. (1998). Task resource models and (max,+) automata. Idempotency. Cambridge University Press, pages 133-144. [5] Heidergott, B., Olsder, G. J., & van der Woude, J. (2006). Max Plus at Work. Princeton University Press. [6] Komenda, J., Lahaye, S., & Boimond, J. L. (2008). Control of (max,+) automata: logic and timing aspects. Proceedings of the 9th International Workshop on Discrete Event Systems (WODES08), Gothenburg, Sweden (pp. 55-60). [7] Komenda, J., Lahaye, S., & Boimond, J. L. (2009). Supervisory control of (max,+) automata: a behavioral approach. Discrete Event Dynamic Systems, 19(4), 525-549.
Conclusions and discussions
[8] Orlin, J. B. (1977). Contentment in graph theory: covering graphs with cliques. Indagationes Mathematicae (Proceedings), 80, 406-424.
In this paper we have presented an efficient algorithm (Procedure 1) to compute the maximum string execution time for a finite language, and shown that determining the minimum string execution time is NP-complete. These results can help us decide which performance measure to use in a large system. For example, the worst-case measure in terms of maximum string execution time may be applicable to a (relatively) large system. But using minimum execution time should be avoided because of the complexity issue, unless a good heuristic algorithm can be found that computes a sub-optimal solution effectively.
[9] Ramadge, P. J., & Wonham, W. M. (1987). Supervisory control of a class of discrete event systems. SIAM J. Control and Optimization, 25(1), 206–230. [10] Su, R., van Schuppen, J. H., & Rooda, J. E. (2009). The synthesis of time optimal supervisors by using heaps-ofpieces. SE Technical Report No. 2009-8, Systems Engineering Group, Department of Mechanical Engineering, Eindhoven University of Techonology, Eindhoven, The Netherlands. ISSN 1567-1872. URL: http://se.wtb.tue.nl/sereports. [11] Viennot, G. X. (1997). Heaps of pieces, I: Basic definitions ´ and combinatorial lemmas. Combinatoire Enum´ erative, Labelle and Leroux, Eds., no. 1234 in Lecture Notes in mathematics, pages 321–350.
Although we have concentrated on finite languages, the obtained results are applicable to cases of infinite strings. For example, suppose a plant K ⊆ Σ∗ is a finite
[12] Wonham, W. M., & Ramadge, P. J. (1987). On the supremal controllable sublanguage of a given language. SIAM J. Control and Optimization, 25(3), 637–659.
5
