From its very inception, one fundamental theme in automata theory is the quest for understanding the relative power of the various constructs of the t

Transcription

1 From Bidirectionality to Alternation Nir Piterman a; Moshe Y. Vardi b;1 a eizmann Institute of Science, Department of Computer Science, Rehovot 76100, Israel b Rice University, Department of Computer Science, Houston, TX , U.S.A. Abstract e describe an explicit simulation of 2-way nondeterministic automata by 1-way alternating automata with quadratic blow-up. e rst describe the construction for automata on nite words, and extend it to automata on innite words. Key words: two-way automata, nondeterminisitc nite automata, nondeterministic Buchi automata, alternating nite automata, alternating Buchi automata 1 Introduction The theory of nite automata is one of the fundamental building blocks of theoretical computer science. As the basic theory of nite-state systems, this theory is covered in numerous textbooks and in any basic undergraduate curriculum in computer science. Since its introduction in the 1950's, the theory had numerous applications in practically all branches of computer science, from the construction of electrical circuits [11], to the design of lexical analyzers [10], and to the automated verication of hardware and software designs [30]. Corresponding Author. addresses: nirp@wisdom.weizmann.ac.il, vardi@cs.rice.edu (Moshe Y. Vardi). URLs: nirp, vardi (Moshe Y. Vardi). 1 Supported in part by NSF grants CCR , CCR-99322, IIS , IIS , and EIA , by BSF grant , and by a grant from the Intel Corporation. Preprint submitted to Elsevier Science 21 November 2001

2 From its very inception, one fundamental theme in automata theory is the quest for understanding the relative power of the various constructs of the theory. Perhaps the most fundamental result of automata theory is the robustness of the class of regular languages, the class of languages denable by means of nite automata. Rabin and Scott showed in their classical paper that neither nondeterminism nor bidirectionality changes the expressive power of nite automata; that is, nondeterministic 2-way automata and deterministic 1-way automata have the same expressive power [20]. This robustness was later extended to alternating automata, which can switch back and forth between existential and universal modes (nondeterminism is an existential mode) [2,6,15]. In view of this robustness, the concept of relative expressive power was extended to cover also succinctness of description. For example, it is known that nondeterministic automata and two-way automata are exponentially more succinct than deterministic automata. The language L n = fuv : u; v 2 f0; 1g n and u 6= vg can be expressed using a 1-way nondeterministic automaton or a 2-way deterministic automaton of size polynomial in n, but a 1-way deterministic automaton accepting L n must be of exponential size (cf. [23]). Alternating automata, in turn, are doubly exponentially more succinct than deterministic automata [2,6]. Consequently, a major line of research in automata theory is establishing tight simulation results between dierent types of automata. For example, given a 2-way automaton with n states, Shepherdson showed how to construct an O(n log(n)) equivalent 1-way automaton with 2 states [22]. Birget showed how to construct an equivalent 1-way automaton with 2 3n states [1] (see also []). Vardi constructed the complementary automaton, an automaton accepting the words rejected by the 2-way automaton, with 2 2n states [26]. Birget also showed, via a chain of reductions, that a 2-way nondeterministic automaton can be converted to a 1-way alternating automaton with quadratic blow-up [1]. As the converse ecient simulation is impossible [15], alternation is more powerful than bidirectionality. Our focus in this paper is on simulation of bidirectionality by alternation. The interest in bidirectionality and alternation is not merely theoretical. Both constructs have been shown to be useful in automated reasoning. For example, reasoning about modal -calculus with past temporal connectives requires alternation and bidirectionality [24,25,2]. Recently, model checking of specications in -calculus on context-free and prex-recognizable systems has been reduced to questions about 2-way automata [14]. In a dierent eld of research, 2-way automata were used in query processing over semistructured data [4]. e found Birget's construction, simulating bidirectionality by alternation with 2

3 quadratic blow-up, unsatisfactory. As noted, his construction is indirect, using a chain of reductions. In particular, it uses the reverse language and, consequently, can not be extended to automata on innite words. The theory of nite automata on innite objects was established in the 1960s by Buchi, Mc- Naughton and Rabin [3,16,19]. They were motivated by decision problems in mathematical logic. More recently, automata on innite words have shown to be useful in computer-aided verication [12,30]. e note that bidirectionality does not add expressive power also in the context of automata on innite words. Vardi has already shown that given a 2-way nondeterministic Buchi automaton with n states one can construct an equivalent 1-way nondeterministic Buchi automaton with 2 O(n2 ) states [25]. Our main result in this paper is a direct quadratic simulation of bidirectionality by alternation. Given a 2-way nondeterministic automaton with n states, we construct an equivalent 1-way alternating automaton with O(n 2 ) states. Unlike Birget's construction, our construction is explicit. This has two advantages. First, one can see exactly how alternation can eciently simulate bidirectionality. (In order to convert the nondeterministic automaton into an alternating automaton we use the fact that the run of the 2-way nondeterministic automaton looks like a tree of \zigzags" 2. e analyze the form such a tree can take and recognize, using an alternating automaton, when such a tree exists.) Second, the explicitness of the construction enables us to extend it to Buchi automata. Since it is known how to simulate alternating Buchi automata by nondeterministic Buchi automata with exponential blow-up [17], our construction provides another proof of the result that a 2-way nondeterministic Buchi automaton with n states can be simulated by a 1-way nondeterministic Buchi with 2 O(n2 ) states [25]. e also show how to obtain, still with quadratic blow-up, a 1-way alternating automaton for the complementary language. This is trivial for automata on nite words, but not for automata on innite words. Finally, we show how to use our construction for 2-way nondeterministic Rabin and parity automata, avoiding an unnecessary blow up that results from rst converting those into 2-way nondeterministic Buchi automata. 2 Preliminaries e consider nite or innite sequences of symbols from some nite alphabet. Given a word w, an element in [!, we denote by w i the i th letter of the word w. The length of w is denoted by jwj and is dened to be! for innite 2 The analysis of the form of the \zigzags" is similar to the analysis of runs of pushdown-automata done in [21,29]. 3

4 words. A 2-way nondeterministic automaton is N = h; S; s 0 ; ; F i, where is the nite alphabet, S is the nite set of states, s 0 2 S is the initial state, : S! 2 Sf 1;0;1g is the transition function, and F is the acceptance set. e can run N either on nite words (2-way nondeterministic nite automaton or 2NFA for short) or on innite words (2-way nondeterministic Buchi automaton or 2NB for short). A run on a nite word w = w 0 ; :::; w l is a nite sequence of states and locations (t 0 ; i 0 ), (t 1 ; i 1 ), : : :, (t m ; i m ) 2 (S f0; :::; l + 1g). The pair (t j ; i j ) represents the automaton is in state t j reading letter i j. Formally, t 0 = s 0, i 0 = 0, for all 0 j < m, we have i j 2 f0; :::; lg, and i m 2 f0; :::; l + 1g. Finally, for all 0 j < m, we have (t j+1 ; i j+1 i j ) 2 (t j ; w ij ). A run is accepting if i m = l +1 and t m 2 F. A run on an innite word w = w 0 ; w 1 ; ::: is dened similarly as an innite sequence. The restriction on the locations is removed (for all j, the location i j can be every number in N). In 2NB, a run is accepting if it visits F N innitely often. A word w is accepted by N if it has an accepting run over w. The language of N is the set of words accepted by N, denoted by L(N). A 2-way nondeterministic parity (Rabin) automaton (2NP and 2NR for short) is N = h; S; s 0 ; ; i where ; S; s 0 and are like before and = ff 1 ; :::; F m g is a partition of S ( = fhg 1 ; B 1 i; :::; hg m ; B m ig is a subset of 2 S 2 S ). The index of the automaton is the number of sets (pairs) in its acceptance condition. A run of a 2NP or a 2NR is just like a run of a 2NB. A run r of a 2NP is accepting if the minimal index 1 i m such that r visits F i N innitely is even. A run r of a 2NR is accepting if there exists an i, 1 i m such that r visits G i N innitely often and B i N only nitely often. In the nite case we are only interested in runs in which the same state in the same position does not repeat twice during the run. In the innite case we minimize the amount of repetition to the unavoidable minimum. A run r = (s 0 ; 0); (s 1 ; i 1 ); (s 2 ; i 2 ); :::; (s m ; i m ) on a nite word is simple if for all j and k such that j < k, either s j 6= s k or i j 6= i k. A run r = (s 0 ; 0); (s 1 ; i 1 ); (s 2 ; i 2 ); ::: on an innite word is simple if one of the following holds (1) For all j < k, either s j 6= s k or i j 6= i k. (2) There exists l; m 2 N such that for all h < p < l + m, either s h 6= s p or i h 6= i p, and for all f l; s f = s f +m and i f = i f +m. e show that there exists an accepting run i there exists a simple accepting run. Claim 1 An automaton N (either 2NF A, 2NB, 2NP, or 2NR ) accepts a word w i it accepts it with a simple run. 4

5 Proof. For all automata, a simple run is in particular a run. Given an accepting run r = (s 0 ; 0); (s 1 ; i 1 ); : : : of A on w, we construct a simple run of N on w. Case 1 N is a 2NFA The run r is nite and ends in some pair (s m ; i m ). If r is not simple, there are some j and k such that j < k, s j = s k and i j = i k, consider the sequence (s 0 ; 0); :::; (s j ; i j ); (s k+1 ; i k+1 ); :::; (s m ; i m ): Since (s k+1 ; i k+1 i k ) 2 (s k ; a ik ) and (s k ; a ik ) = (s j ; a ij ) this sequence is still a run. The last state s m is a member of F and i m = jwj hence the run is accepting. Since the run is nite, nitely many repetitions of the above operation result in a simple run of A on w. Case 2 N is a 2NB e cannot simply remove sequences of states like we did in the nite case, since the visits to F may be hidden in these parts of the run. If for some j < k, we have that s j = s k ; i j = i k, and for all j p k we have s p =2 F (no accepting state occurring), we can simply remove this part. e have to show that the limit of all these changes stays a valid and accepting run. Note that we change the run only between occurrences of states from F. So we can divide the run into segments. In each segment the rst state is from F and no states from F occur elsewhere. As states from F occur innitely often in the run we have innitely many segments. Each of these segments is changed a nite number of times, the rst state of the segment does not change nor does the last state of the segment. Gluing the segments together for a run after performing the changes results in a valid run (the rst and the last state in every segment do not change). As every segment starts with a state from F and there are innitely many segments the run is still accepting. Now if there exists some j < k such that s j = s k and i j = i k we conclude that there is a visit to F between the two. e take the minimal j and k and create the run (s 0 ; 0), : : :, (s j 1 ; i j 1 ), ((s j ; i j ); : : : ; (s k 1 ; i k 1 ))!. Again this is a valid run and it visits F innitely often (between s j and s k 1 ). If no such j and k exist the run is simple. Case 3 N is a 2NR This case is very similar to the 2NB case. There is some index c such that the set G c is visited innitely often and the set B c is visited nitely often. Let (s d ; i d ) denote the rst visit to G c after which there are no visits to B c. For all j < k < d such that s j = s k and i j = i k we remove the segment of the run between s j and s k 1. The run clearly stays valid and accepting (nite number of changes). Now just like for Buchi automata, we identify all locations j < k 5

6 for which s j = s k and i j = i k and for all j p k we have s p =2 G c. These run segments are removed from the run. As before, the run obtained in the limit stays valid and accepting. Finally, if there exists some j < k such that s j = s k and i j = i k we conclude that there is a visit to G c between the two. Clearly B c cannot occur between s j and s k and the segment can be converted into an accepting loop. The case that n is a 2NP is treated similarly. The set F c takes the role of G c and S c 0 <c F c takes the role of B c. 2 Given a set S we rst dene the set B + (S) as the set of all positive formulas over the set S with true and false (i.e., for all s 2 S, s is a formula and if f 1 and f 2 are formulas, so are f 1 ^ f 2 and f 1 _ f 2 ). e say that a subset S 0 S satises a formula ' 2 B + (S) (denoted S 0 j= ') if by assigning true to all members of S 0 and false to all members of S n S 0 the formula ' evaluates to true. Clearly true is satised by the empty set and false cannot be satised. Given a formula f 2 B + (S), we dualize f by replacing ^ by _, true by false and vice versa. The dual of f is denoted e f. A tree is a set T N such that if x c 2 T where x 2 N and c 2 N, then also x 2 T. The elements of T are called nodes, and the empty word is the root of T. For every x 2 T, the nodes x c where c 2 N are the successors of x. Thus, successors in our notation are only the immediate successors. The nodes x y where y 2 N are the descendants of x. A node is a leaf if it has no successors. A path of a tree T is a set T such that 2 and for every x 2, either x is a leaf or there exists a unique c 2 N such that x c 2. Given an alphabet, a -labeled tree is a pair (T; V ) where T is a tree and V : T! maps each node of T to a letter in. A 1-way alternating automaton is A = h; Q; q 0 ; ; F i where, Q, q 0, and F are like in nondeterministic automata and : S! B + (Q) is the transition function. Again we may run A on nite words (1-way alternating automata on nite words or 1AFA for short) or on innite words (1-way alternating Buchi (co-buchi) automata or 1AB (1AC) for short). A run of A on a nite word w = w 0 :::w l is a labeled tree (T; r) where r : T! Q. The maximal depth in the tree is l + 1. A node x labeled by q describes a copy of the automaton in state q reading letter w jxj. The labels of a node and its successors have to satisfy the transition function. Formally, r() = q 0 and for all nodes x with r(x) = q and (q; w jxj ) = ' there is a (possibly empty) set fq 1 ; :::; q n g j= ' such that there are n successors to x, fx 0; : : : ; x (n 1)g and xc is labeled by q c+1 for 0 c < n. In particular, there can not appear in the run a node x for which (r(x); w jxj ) = false. Clearly, no set of states can satisfy false. The run is accepting if all the leaves in depth l + 1 are labeled 6

7 by states from F. Note that if x is a leaf such that jxj l, it must be the case that (r(x); w jxj ) = true. The formula true is the unique formula that is satised by the empty set. A run of A on an innite word w = w 0 w 1 ::: is dened similarly as a (possibly) innite labeled tree. A run of a 1AB is accepting if every innite path visits the accepting set innitely often. A run of a 1AC is accepting if every innite path visits the accepting set nitely often. For a nite path, the end of the path is some leaf x such that (r(x); w jxj ) = true. Thus, nite paths do not have to supply other demands. As before, a word w is accepted by A if it has an accepting run over the word. e similarly dene the language of A; L(A). Given an 1AFA A = h; Q; q 0 ; ; F i, the dual of A is the 1AFA e A = h; Q; q 0 ; e; Qn F i where e(q; a) is the dual of (q; a). The automata A and e A accept complementary languages [6], i.e. L( e A) = n L(A). The dualization includes replacing the acceptance condition F by its complement Q n F. Similarly, given an 1AB the dualization of the acceptance condition amounts to changing the acceptance mode from Buchi to co-buchi. Thus, given an 1AB A = h; Q; q 0 ; ; F i, the dual of A is the 1AC e A = h; Q; q 0 ; e; F i. Again the automata A and e A accept complementary languages [1], i.e. L( e A) =! n L(A). Note that dualizing an 1AFA results in an 1AFA and dualizing an 1AB results in an 1AC. Thus, nding the 1AFA complement of an 1AFA is quite simple, while nding the 1AB complement of an 1AB involves a quadratic construction [13] 3. e also consider weak alternating automata. A weak alternating automaton (1A) is a 1AB where the set of states Q is partitioned into disjoint sets, Q i, such that for each set Q i, either Q i F, in which case Q i is an accepting set, or Q i \ F = ;, in which case Q i is a rejecting set. In addition there exists a partial order on the collection of the Q i 's such that for every q 2 Q i and q 0 2 Q j for which q 0 occurs in (q; a), for some a 2, we have Q j Q i. Thus, transitions from a state in Q i lead to states in either the same Q i or a lower one. It follows that every innite path of a run of a 1A ultimately gets \trapped" within some set Q i. The path then satises the acceptance condition F if and only if Q i is an accepting set. Thus, we can view 1A with acceptance condition F as both a 1AB with acceptance condition F, and a 1AC with acceptance condition Q n F. 3 Kupferman and Vardi also prove that this construction can not be improved to linear [13]. 7

8 3 Automata on Finite ords e start by transforming 2NFA to 1AFA. e analyze the possible form of an accepting run of a 2NFA and using a 1AFA check when such a run exists over a word. The construction consists of two stages, in the rst stage we restrict the automaton so that it can move either forward or backward (and not stay in the same place). In the second stage we convert this `always moving' automaton into an alternating automaton. Theorem 2 For every 2NFA N = h; S; s 0 ; ; F i with n states, there exist 1AFA A and A 0 with O(n 2 ) states such that L(A) = L(N) and L(A 0 ) = n L(N). Note that if we further convert the 1AFAs into 1NFAs we get automata with 2 O(n2 ) states. The constructions of Vardi and Birget [26,1] produce smaller automata. 3.1 Removing -moves An -move in a run of a 2NFA is when two adjacent pairs have the same head position. Formally, in the run (s 0 ; 0); (s 1 ; i 1 ); :::; (s m ; i m ), step j > 0 is an -move if i j = i j 1. Our rst conversion is from N = h; S; s 0 ; ; F i with : S! 2 Sf 1;0;1g to an equivalent N 0 = h; S; s 0 ; 0 ; F i with 0 : S 0! 2 Sf 1;1g such that L(N) = L(N 0 ). There are no -moves in the runs of N 0. e start by dening for each state s and alphabet letter a, the set C s a of all states reachable from s by a sequence of -moves reading letter a and one last forward/backward move. 9 9(t 0 ; :::; t k ) 2 S >< + such that >= C s a = (t; ) 2 S f 1; 1g t 0 = s; 1 j k; (t j ; 0) 2 (t j 1 ; a); >: and (t; ) 2 (t k ; a) >; Dene 0 (s; a) = C s a. Claim 3 L(N) = L(N 0 )

9 Proof. Suppose N accepts w. Let r = (s 0 ; 0); :::; (s m ; i m ) be an accepting run of N on w. e turn r into a run r 0 of N 0 on w by pruning -moves: if i j = i j 1 simply remove (s j ; i j ) from the run. It is easy to see that r 0 is an accepting run of N 0 on w. Suppose N 0 accepts w. Let r 0 = (s 0 ; 0); :::; (s m ; i m ) be an accepting run of N 0 on w. e append the -moves from the appropriate sets C s a to complete a run of N on w Two-way runs From this point on we consider only 2NFAs with no -moves. Given a 2NFA N = h; S; s 0 ; ; F i, let A = h; Q; s 0 ; ; F i denote its equivalent 1AFA. Note that A uses the same acceptance set and initial state as N. Recall that a run of N is a sequence r = (s 0 ; 0); (s 1 ; i 1 ); (s 2 ; i 2 ); :::; (s m ; i m ) of pairs of states and locations, where s j is the state and i j is the location of the automaton in the word w. e refer to each state as a forward or backward state according to its predecessor in the run. If it resulted from a backward movement it is a backward state and if from a forward movement it is a forward state. Formally, (s j ; i j ) is a forward state if i j = i j and backward state if i j = i j 1 1. The rst state (s 0 ; 0) is dened to be a forward state. Given the 2NFA N our goal is to construct the 1AFA A recognizing the same language. In Figure 1a we see that a run of N takes the form of a tree of `zigzags'. Our one-way automaton reads words moving forward and accepts if such a tree exists. In Figure 1a we see that there are two transitions using a 1. The rst (s 2 ; 1) 2 (s 1 ; a 1 ) and the second (s 4 ; 1) 2 (s 3 ; a 1 ). In the one-way sweep we would like to make sure that s 3 indeed resulted from s 2 and that the run continuing from s 3 to s 4 and further is accepting. Hence when in state s 1 reading letter a 1 we guess that there is a part of the run coming from the future and spawn two processes. The rst checks that s 1 indeed results in s 3 and the second ensures that the part s 3 ; s 4 ; ::: of the run is accepting. Hence the state set of the alternating automaton is Q = S[(SS). A singleton state s 2 Q represents a part of the run that is only looking forward (s 4 in Figure 1a). In fact, we use singleton states to represent only the last forward state in the run of A that visits a letter. A pair state (s 1 ; s 3 ) 2 Q represents a part of the run that consists of a forward moving state and a backward moving state (s 1 and s 3 in Figure 1a). Such a pair ensures that there is a run segment linking the forward state to the backward state. e introduce one modication, since s 3 is a backward state (i.e. (s 3 ; 1) 2 (s 2 ; a 2 )) it makes sense to associate it with a 2 and not with a 1. As the alternating automaton reads a 1 (when in state s 1 ), it guesses that s 3 comes from the future and 9

10 s 0 s 1 s 2 s 3 s 4 t s 1 t 0 t 1 s 5 s 2 t 2 a 0 a 1 a 2 a 3 s 3 t 3 a 0 a 1 a 2 a 3 a 4 a 5 Fig. 1. (a) A zigzag run (b) The transition at the singleton state t changes direction. The alternating automaton then spawns two processes: the rst, s 4 and the second, (s 2 ; s 3 ); and both read a 2. Then it is easier to check that (s 3 ; 1) 2 (s 2 ; a 2 ). 3.3 The Construction The transition at a singleton state e dene the transitions of A in two stages. First we dene transitions from a singleton state. hen in a singleton state t 2 Q reading letter a j (See Figure 1b) the alternating automaton guesses that there are going to be k more visits to letter a j in the rest of the run (as the run is simple, k is bounded by the number of states of the 2NFA N). e refer to the states reading letter a j according to the order they appear in the run as s 1 ; :::; s k. e assume that all states that read letters prior to a j have already been taken care of, hence s 1 ; :::; s k themselves are backward states (i.e. (s i ; 1) 2 (p i ; a j+1 ) for some p i ). They read the letter a j and move forward (there exists some t i such that (t i ; 1) 2 (s i ; a j )). Denote the successors of s 1 ; :::; s k by t 1 ; :::; t k. The alternating automaton veries that there is a run segment connecting the successor of t (denoted t 0 ) to s 1 (by induction, all states reading letters before a j have been taken care of, this run segment should not go back to letters before a j ). Similarly the alternating automaton veries that a run segment connects t 1 to s 2, etc. In general the alternating automaton checks that there is a part of the run connecting t i to s i+1. Finally, from t k the run has to read the rest of the word and reach location jwj in an accepting state. Given a state t and an alphabet letter a, consider the set R t a of all possible sequences of states of length at most 2n 1 where no two states in an even place (forward states) are equal and no two states in an odd place (backward states) are equal. e further demand that the rst state in the sequence be 10

11 a successor of t ((t 0 ; 1) 2 (t; a)) and similarly that t i be a successor of s i ((t i ; 1) 2 (s i ; a)). Formally 0 k < n >< (t R t a = ht 0 ; s 1 ; t 1 ; :::; s k ; t k i 0 ; 1) 2 (t; a) i < j; s i 6= s j and t i 6= t j >: i; (t i ; 1) 2 (s i ; a) 9 >= >; The transition of A chooses one of these sequences and ensures that all promises are kept, i.e. there exists a run segment connecting t i 1 to s i. (t; a) = _ ht 0 ;s 1 ;:::;s k ;t k i2r t a (t 0 ; s 1 ) ^ (t 1 ; s 2 ) ^ ::: ^ (t k 1 ; s k ) ^ t k The transition at a pair state hen the alternating automaton is in a pair state (t; s) reading letter a j it tries to nd a run segment connecting t to s using only the sux a j :::a jwj 1. e view t as a forward state reading a j and s as a backward state reading a j 1 (Again (s; 1) 2 (p; a j )). As shown in Figure 2a, the run segment connecting t to s may visit letter a j but should not visit a j 1. Figure 2b provides a detailed example. The automaton in state (t; s) guesses that the run segment linking t to s visits a 2 twice and that the states reading letter a 2 are s 1 and s 2. The automaton further guesses that the predecessor of s is s 3 ((s; 1) 2 (s 3 ; a 2 )) and that the successors of t; s 1 and s 2 are t 0 ; t 1 and t 2 respectively. The alternating automaton spawns three processes: (t 0 ; s 1 ); (t 1 ; s 2 ) and (t 2 ; s 3 ) all reading letter a 3. Each of these pair states has to nd a run segment connecting the two states. e now dene the transition from a state in S S. Given a state (t; s) and an alphabet letter a, we dene the set R a (t;s) of all possible sequences of states of length at most 2n where no two states in an even position (forward states) are equal and no two states in an odd position (backward states) are equal. e further demand that the rst state in the sequence be a successor of t ((t 0 ; 1) 2 (t; a)), that the last state in the sequence be a predecessor of s ((s; 1) 2 (s k+1 ; a)) and similarly that t i be a successor of s i ((t i ; 1) 2 (s i ; a)). 11

12 t a 0 s a 1 a 2 a 3 t s 1 t 0 t 1 t s 2 t 2 s s 3 s a 0 a 1 a 2 a 3 a 0 a 1 a 2 a 3 Fig. 2. (a) Dierent connecting segments (b) The transition at the pair state (t; s) R (t;s) a = 0 k < n >< (t 0 ; 1) 2 (t; a) ht 0 ; s 1 ; t 1 ; :::; s k ; t k ; s k+1 i (s; 1) 2 (s k+1 ; a) i < j; s i 6= s j and t i 6= t j >: i; (t i ; 1) 2 (s i ; a) 9 >= >; The transition of A chooses one sequence and ensures that all pairs meet: true If (s; 1) 2 (t; a) >< ((t; s); a) = >: (t 0 ; s 1 ) ^ (t 1 ; s 2 ) ^ ::: ^ (t k ; s k+1 ) Otherwise ht 0 ;s 1 ;:::;t k ;s k+1 i2r (t;s) a 3.4 Proof of correctness To conclude, the complete description of A is h; Q; s 0 ; ; F i where the initial state and the set of accepting states is equal to that of N and is as dened. All the pair-labeled paths in a run of A have to terminate \before falling of 12

13 the edge of the tape" and the singleton-labeled path must \fall o" with an accepting state. Claim 4 L(A) = L(N) Proof. Given an accepting simple run of N on a word w of the form (s 0 ; 0), (s 1 ; i 1 ), : : : ; (s m ; i m ), we annotate each pair by the place it took in the run of N. Thus the run takes the form (s 0 ; 0; 0), (s 1 ; i 1 ; 1), : : : ; (s m ; i m ; m). e build a run tree (T; r 0 ) of A by induction. In addition to the labeling r 0 : T! S [ (S S), we attach a single tag to a singleton state and a pair of tags to a pair state. The tags are triplets from the annotated run of N. For example the root of the run tree of A is labeled by s 0 and tagged by (s 0 ; 0; 0). The labeling and the tagging conform to the following: A node x labeled by state s is tagged by (s; i; j) with i = jxj. e build the tree so that all triplets in the run of N whose third element is larger than j have their second element at least i. A node x labeled by state (t; s) is tagged by (t; i 1 ; j 1 ) and (s; i 2 ; j 2 ) with i 1 = jxj, i 2 = jxj 1, and j 1 < j 2. e build the tree so that all triplets in the run of N whose third element is between j 1 and j 2 have their second element be at least i 1. e start with the root labeling it by s 0 and tagging it by (s 0 ; 0; 0). Obviously this conforms to our demands. Given a node x labeled by t, tagged by (t; i; j), and adhering to our demands (see state t in Figure 1b). If (t; i; j) has no successor in the run of N, it must be the case that i = jwj and that t 2 F. Otherwise we denote the triplets in the run of N whose third element is larger than j and whose second element is i by (s 1 ; i; j 1 ); :::; (s k ; i; j k ). By assumption there is no point in the run of N beyond j visiting a letter before i. Since the run is simple, k < n. Denote by (t 0 ; i + 1; j + 1) the successor of (t; i; j) and by (t 1 ; i + 1; j 1 + 1); :::; (t k ; i + 1; j k + 1) the successors of s 1 ; :::; s k. e add k + 1 successors to x, label them (t 0 ; s 1 ); (t 1 ; s 2 ); :::; (t k 1 ; s k ); t k, to a successor of x labeled by (t l 1 ; s l ) we add the tags (t l 1 ; i + 1; j l 1 + 1) and (s l ; i; j l ), and to the successor of x labeled by t k we add the tag (t k ; i + 1; j k + 1). e now show that the new nodes added to the tree conform to our demands. By assumption there are no visits beyond the j th step in the run of N to letters before a i and s 1 ; :::; s k are all the visits to a i after the j th step of N. Let y be the successor of x labeled t k (tagged (t k ; i + 1; j k + 1)). Since jxj = i, we conclude jyj = i + 1. All the triplets in the run of N appearing after (t k ; i + 1; j k + 1) do not visit letters before a i+1 (e collected all visits to a i ). 13

14 Let y be a successor of x labeled by (t l ; s l+1 ) (tagged (t l ; i + 1; j l + 1) and (s l+1 ; i; j l+1 )). e know that i = jxj hence i + 1 = jyj; j l + 1 < j l+1 and between the j l + 1 element in the run of N and the j l+1 element letters before a i+1 are not visited. e turn to continuing the tree below a node labeled by a pair state. Given a node x labeled by (t; s) tagged (t; i; j) and (s; i 1; k). By assumption there are no visits to a i 1 in the run of N between the j th triplet and k th triplet. If k = j + 1 then we are done and we leave this node as a leaf. Otherwise we denote the triplets in the run of N whose third element is between j and k and whose second element is i by (s 1 ; i; j 1 ); :::; (s m ; i; j m ) (see Figure 2b). Denote by (t 1 ; i + 1; j 1 + 1); :::; (t m ; i + 1; j m + 1) their successors, by (t 0 ; i + 1; j + 1) the successor of t and by (s m+1 ; i; k 1) the predecessor of s. e add m + 1 successors to x and label them (t 0 ; s 1 ); (t 1 ; s 2 ); :::; (t m ; s m+1 ). To a successor of x labeled by (t l 1 ; s l ) we add the tags (t l 1 ; i + 1; j l 1 + 1) and (s l ; i; j l ). As in the previous case when we combine the assumption with the way we chose t 0 ; :::t m and s 1 ; :::; s m+1, we conclude that the new nodes conform to the demands. Clearly, all pair-labeled paths terminate with true before reading the whole word w and the path labeled by singleton states reaches the end of w with an accepting state. In the other direction we stretch the tree run of A into a linear run of N. Let (T; r 0 ) be an accepting run of A on a word w. e assume ordering on the successors of each node according to the appearance of their labels in the transition of A. The recursive algorithm in Figure 3 constructs an accepting run of N. hen rst reaching a node x labeled by pair state (t; s), we add t to the run of N. Then we handle recursively the children of x. hen we return to x we add s to the run of N. hen reaching a node x labeled by a singleton state s we simply add s to the run of N and handle the sons of x recursively. build run (x; r 0 (x) = s; i) build run (x; r 0 (x) = (t; s); i) r := r hs; ii; r := r ht; ii; for all sons x a of x for all sons x a of x build run (x a; r 0 (x a); i + 1) build run (x a; r 0 (x a); i + 1) End (for loop) End (for loop) r := r hs; i 1i; Fig. 3. Converting a run of A into a run of N Starting from the root labeled (s 0 ; 0), we add to the run of N the element (s 0 ; 0). e now handle the successors of the root according to their order. 14

15 Going up to the rst successor c labeled (t; s) we add (t; 1) to the run of N. Obviously from the denition of R s 0 a 0 we know that (t; 1) 2 (s 0 ; a 0 ). e handle the successors of c in recursion. hen we return to c we add (s; 0) to the run of N (to be justied later). e return now to and handle the next successor d. The node d is either labeled by (p; q) or by p. In both cases the denition of R s 0 a 0 ensures that (p; 1) 2 (s; a 0 ). hen we return to after scanning the whole tree the run of N is complete. Getting to a node x labeled (t; s) we add (t; jxj) to the run of x. Adding (t; jxj) itself and passing to the successors of x and between them was justied when handling the root. hen the recursion nished handling the last successor of x we add (s; jxj 1) to the run of N. Suppose the last successor of x was labeled (p; q) then from the denition of R a (t;s) jxj we know that (s; 1) 2 (q; a jxj ) hence this transition is justied. Getting to a node x labeled s is not dierent from handling the root. Instead of using the locations 0 and 1 in the run, we use locations jxj and jxj + 1. e have to show that the run is valid and accepting. Satisfying the transition was shown. In the tree run of A there is a single path labeled solely by singleton states. The last element in the run of N is the same state and reading the same letter as the last in this path. Since the path is accepting the last state there has to be from F and reading letter jwj (which does not exists, w = a 0 :::a jwj 1 ). All other states in the run of N read letters in the range f0; :::; jwj 1g. Otherwise there is some node x in the run of A such that jxj jwj (other than the previously designated node). This is impossible since the run of A is accepting. 2 As mentioned in Section 2 complementing an 1AFA is simple. The complement of A is e A = h; Q; s 0 ; e; Q n F i. As L(A) = L(N), L( e A) = n L(N). 4 Automata on innite words e may try to run the 1AFA from Section 3 on innite words. e demand that pair-labeled paths be nite and that the innite singleton-labeled path visit F innitely often. Although an accepting run of N visited F innitely often we cannot ensure innitely many visits to F on the innite path. The visits may be reected in the run of A in the pair-labeled paths. Another problem is when the run ends in a loop. Theorem 5 For every 2NB N = h; S; s 0 ; ; F i with n states, there exist 1ABs A and A 0 with O(n 2 ) states such that L(A) = L(N) and L(A 0 ) = 15

16 ! n L(N). 4.1 Removing -moves Like in the nite case we rst reduce the problem to automata without - moves. Given an automaton N = h; S; s 0 ; ; F i where : S! 2 Sf 1;0;1g we would like to remove all the -moves. There are two potential problems, visits to F in an -move and a loop of -moves that visits F. e double the number of states and add an accepting sink state N 0 = h; (S f?; >g) [ faccg; (s 0 ;?); 0 ; (F f?g)[(sf>g)[faccgi. A sequence like : : : ; ((s;?); i); ((s 0 ; >); i+ 1); : : : in the run means that in the run of N between the appearance of (s; i) and (s 0 ; i + 1) there was an -move that visited F. Similarly? means that -moves (if occured) have not visited F (in [31,9] similar problems are solved in a similar way). Given a state s and an alphabet letter a, we dene NC s a the set of all states reachable from state s by a sequence of -moves reading letter a and one last forward/backward step. All states avoid the acceptance set F. 9(t 0 ; :::; t k ) 2 S + s.t. t 0 = s; >< (t NC s a = ((t;?); ) 2 ((S f?g) f 1; 1g) j ; 0) 2 (t j 1 ; a); 1 j k; t j =2 F; >: and (t; ) 2 (t k ; a) 9 >= >; In addition we dene ACa s the set of all states reachable from state s by a sequence of -moves reading letter a and one last forward/backward step. One of the states in the sequence is an accepting state. 9 9(t 0 ; :::; t k ) 2 S + s.t. t 0 = s; >< 9j > 0 s.t. t AC s a = ((t; >); ) 2 ((S f>g) f 1; 1g) j 2 F; >= 1 j k; (t j ; 0) 2 (t j 1 ; a) >: and (t; ) 2 (t k ; a) >; e also have to take care of situations where there is a loop of -moves that visits F. The boolean variable ACCEP T s a is set to 1 if such a sequence exists and to 0 otherwise. Formally, the variable ACCEP T s a is set to 1 i there exists a sequence (t 0 ; :::; t k ) 2 S + that satises all the following conditions. t 0 = s. There exist j and l such that 0 j l k, (t j ; 0) 2 (t k ; a) and t l 2 F. 16

17 For all j where 1 j k, we have (s j ; 0) 2 (s j 1 ; a) e use the two -closures and the variable dened above in the denition of the transition function of the 1NFA N 0. >< 0 ((s;?); a) = 0 f(acc; 1)g ACCEP Ta s = 1 ((s; >); a) = >: NCa s [ ACa s ACCEP T a s = 0 0 (Acc; a) = f(acc; 1)g Apparently, N 0 is -move free. Claim 6 L(N')=L(N) Proof. Suppose N accepts w. There exists an accepting run r of N on w. If a nite sequence of -moves appears in r we simply prune it. If that sequence contained a visit to F add > to the forward/backward move at the end of the sequence. If r ends in an innite sequence of -moves, this sequence has a nite prex (s i ; l); (s i+1 ; l); :::; (s i+p ; l) such that s i = s i+p and, as r is accepting, there is a visit to F in this prex. e take the prex of the run (s 0 ; 0); :::; (s i ; l) and add to it the innite sux (Acc; l + 1); (Acc; l + 2); :::. Finally, we add labels? to all unlabeled states. It is easy to see that the resulting run is a valid run of N 0. It is also an accepting run. If the run ends in a sux Acc! then it is clearly accepting. Otherwise, removing sequences of -moves replaces a nite number of visits to F by a state labeled by >. As the original run visited F innitely often, so does the run of N 0. Suppose N 0 accepts w. e append -moves as promised from the denition of NC and AC. If the run ends with an innite sequence of Acc we can add a loop visiting F. Innitely many occurrences of > ensure innitely many visits to F The Construction e have to record hidden visits to F. This is done by doubling the set of states. hile in the nite case the state set is S [ (S S), this time we also annotate the states by? and >. Hence Q = (S [ (S S)) f?; >g. A pair state labeled by > is a promise to visit the acceptance set. The state (s; t; >) means that in the run segment linking s to t there has to appear a state from F. A state (s; >) is displaying a visit to F in the zigzags connecting s to the previous singleton state. The initial state is q 0 = (s 0 ;?). 17

18 ith the same notation we solve the problem of a loop. e allow a transition from a singleton state to a sequence of pair states. One of the pairs promises a visit to F. The acceptance set is F 0 = (S f>g) [ (F f?g) and the transition function is dened as follows The transition at a singleton state Just like in the nite case we consider all possible sequences of states of length at most 2n 1 with same demands. 9 0 k < n >< (t R t a = ht 0 ; s 1 ; t 1 ; :::; s k ; t k i 0 ; 1) 2 (t; a) >= i < j; s i 6= s j and t i 6= t j >: i; (t i ; 1) 2 (s i ; a) >; Recall that a sequence (t 0 ; s 1 ); (t 1 ; s 2 ); :::; (t k 1 ; s k ); t k checks that there is a zigzag run segment linking t 0 to t k. e mentioned that t k is annotated with > in case this run segment has a visit to F. If t k is annotated with >, at least one of the pairs has to be annotated with >. Although more than one pair may visit F we annotate all other pairs by?. Hence for k 2 N we consider the sequences of? and > of length k + 1 in which if the last is > so is another one. Otherwise all are?. 9 >< R k = >: h 0; :::; k i 2 f?; >g k+1 If k = > then 9!i s.t. 0 i < k and i = > >= If k =? then 0 i < k; i =? >; This is, however, not enough. e have to consider also the case of a loop. The automaton has to guess that the run terminates with a loop when it reads the rst letter of w that is read inside the loop. The only states reading this letter inside the loop are backward states. e consider pairs of sequences of at most 2n states, where the last state in the two sequences is equal. This repetition closes the loop. In both sequences no two states in an even/odd position are equal. For example, in Figure 4, we see that in state t reading letter a 1, the alternating automaton guesses the sequence (t 0 ; s 1 ); (t 1 ; s 2 ) and the sequence (t 2 ; s 3 ); (t 3 ; s 2 ). The last state in both sequences is s 2. More formally, we demand that the rst state in the rst sequence be a successor of t ((t 1 0 ; 1) 2 (t; a)), that the rst state in the second sequence be a successor of the last state in the rst sequence ((t 2; 1) 2 0 (s1 ; a)), that k+1 tp i be a successor of s p i for p 2 f1; 2g ((t p i ; 1) 2 (s p i ; a)) and that the last state in the 1

19 t t 0 s 1 t 1 s 2 t 2 s 3 t 3 s 2 a 0 a 1 a 2 a 3 Fig. 4. A loop rst sequence be equal to the last state in the second sequence (s 1 k+1 = s 2 l+1). 9 0 k < n; 0 l < n (t 1 ; 1) 2 (t; a); 0 (t2; 1) 2 0 (s1 ; a) k+1 * >< ht 1 L t 0 a = ; s1; 1 t1; :::; 1 s1 k ; t1 k ; + s1 k+1i; i < j; s 1 i 6= s 1 j and t 1 i 6= t 1 >= j ht 2; 0 s2; 1 t2; :::; 1 s2 l ; t2 l ; s2 l+1i i < j; s 2 i 6= s 2 j and t 2 i 6= t 2 j i; p; (t p i ; 1) 2 (sp i ; a) >: s 1 k+1 = s >; 2 l+1 It is obvious that a visit to F has to occur within the loop. Hence we have to make sure that the run segment connecting one of the pairs in the second sequence visits F. Hence we annotate one of the pairs (t 2 0 ; s2 1); :::; (t 2 l ; s2 l+1) with >. One visit to F is enough hence all other pairs are annotated by?. L l = fh 0 ; :::; l i 2 f?; >g l+1 j 9!i s.t. i = >g The transition of A chooses a sequence in R t a [ L t a and a sequence of? and >. 19

20 ((t;?); a) = ((t; >); a) = _ (t 0 ; s 1 ; 0 ) ^ ::: ^ (t k 1 ; s k ; k 1 ) ^ (t k ; k ) R t a ;R k L t a ;L l 0 1 (t1; 0 s1;?) ^ ::: ^ 1 (t1 k ; s1 ;?)^ k+1 C A (t 2 ; 0 s2; 1 0) ^ ::: ^ (t 2 l ; s2 ; l+1 l) The transition at a pair state In this case the only dierence is the addition of? and >. The set R a (t;s) equal to the nite case. R (t;s) a = 9 0 k < n >< (t 0 ; 1) 2 (t; a) >= ht 0 ; s 1 ; t 1 ; :::; s k ; t k ; s k+1 i (s; 1) 2 (s k+1 ; a) i < j; s i 6= s j and t i 6= t j >: i; (t i ; 1) 2 (s i ; a) >; is In the transition of `top' states we have to make sure that a visit to F indeed occurs. If the visit occured in this stage the promise (>) can be removed (?). Otherwise the promise must be passed to one of the successors. 9 >< R s;t;k = >: h 0; :::; k i 2 f?; >g k+1 If s =2 F and t =2 F then 9!i s.t. i = > >= Otherwise 0 i k; i =? >; The transition of A chooses a sequence of states and a sequence of? and >. >< true If (s; 1) 2 (t; a) ((t; s;?); a) = >: (t 0 ; s 1 ;?) ^ ::: ^ (t k ; s k+1 ;?) Otherwise R (t;s) a true If (s; 1) 2 (t; a) and >< ((t; s; >); a) = (s 2 F or t 2 F ) (t >: 0 ; s 1 ; 0 ) ^ ::: ^ (t k ; s k+1 ; k ) Otherwise R (t;s) a ; R s;t;k 20

21 4.3 Proof of correctness The proof is just an elaboration on the proof of the nite case. In both directions we use similar constructions. e only have to give special attention to visits to the accepting set. As the proofs are almost identical we just highlight the points of dierence. Claim 7 L(N)=L(A) Proof. Given an accepting simple run of N on a word w of the form (s 0 ; 0); (s 1 ; i 1 ); ::: we annotate each pair by the place it took in the run of N. Thus, the run takes the form (s 0 ; 0; 0); (s 1 ; i 1 ; 1); :::. If the run does not end in a loop the construction in the nite case works. e have to add the symbols? and >. hen dealing with a node x in the run tree of A labeled by (s; ) tagged by (s; i; j). In the proof of the nite case we identied the triplets (s 1 ; i; j 1 ); :::; (s k ; i; j k ) and (t 0 ; i + 1; j + 1); :::; (t k ; i + 1; j k + 1) and labeled the successors of x with (t 0 ; s 1 ); :::; (t k 1 ; s k ); t k. If there is no visit to F between j + 1 and j k + 1 we add to these states?. Otherwise the visit was between j l +1 and j l+1 for some l (consider j = j 0 ), in this case we add > both to t k and to the pair (t l ; s l+1 ), to all other pairs we add?. hen dealing with a node x in the run tree of A labeled by (t; s; ) tagged (t; i; j) and (s; i 1; k). e identied the set of pairs (t 0 ; s 1 ); :::; (t k ; s k+1 ). In case =? we continue just like in the nite case. In case = > we put it there because there was a visit to F between j and k. This visit to F has to occur between t l and s l+1 for some l and we pass the obligation to this pair. At some point we reach a visit to F and then the promise is removed. e have now an innite run tree of A. All pair-labeled paths are still nite and there is one innite path labeled by singleton states. Since every occurrence of > on this path covers a nite number of visits to F we are ensured that > appears innitely often along this path. If the run ends in a loop we have to identify the rst letter of w read in this loop. Suppose this letter is i. e build the run tree of A as before until reaching the node x in level i labeled by a singleton state (s; ) tagged by (s; i; j 0 ). As letter i is visited in the loop there are innitely many visits to it. Denote these visits by (s 0 ; i; j 0 ); (s 1 ; i; j 1 ); (s 2 ; i; j 2 ); :::, all backward states. Let s 0 be the rst state in the sequence above that appears innitely often. Denote by (s 1 0 ; i; j1 0); : : : ; (s 1 m ; i; j1 m) the prex of the sequence until the rst occurrence of s 0. As the run is simple, there is no other state repeating twice in this prex. Similarly denote by (s 2 0 ; i; j2 0); : : : (s 2 p ; i; j2 p) the sequence of states 21

22 from the rst occurrence of s 0 (excluding the occurrence) to the second occurrence of s 0. Again, as the run is simple there has to be a visit to F between locations j 1 0 and jp 2 in the run of N and p n. Now denote t 1; : : : 0 t1 m 1 the successors of s 1; : : : ; 0 s1 m 1, t 2 0 the successor of s 1 m, and t 2; : : : ; 1 t2 p 1 the successors of s 2 ; : : : 1 s2 p 1. e add m+p successors to x and label them (t 1 ; 0 s1 1); : : : (t 1 ; m 1 s1 m) and (t 2; 0 s2 1); : : : ; (t 2 ; p 1 s2 p). Obviously, all the conditions required in L s w i are fullled by this pair of sequences. There exists some jh 2 for which there is a visit to F between locations jh 2 and j 2 h+1 in the run of N. e annotate the pair (t 2 h ; s2 h+1) by > and all other pairs by?. e tag a pair (t d ; s d+1) by (t d ; i; j d + 1) and (s d ; i; j d+1). In the other direction we apply the same recursive algorithm. If the accepting run tree of A is innite then we never return to but the run created is an accepting run of N. If the accepting run tree of A is nite we have to identify the point in the tree x labeled by a singleton state (s; ) under which there are no successors labeled by singleton states. In this point we identify the loop. There are two pair states below x labeled by (t 1 ; s;?) and (t 2 ; s; ). e start handling the successors of x until we nish handling the successor labeled (t 1 ; s;?). Then, we put aside the run of N built so far and call it r. Now we build a new run r 0 starting from the point we stopped. Since the run of A is nite the recursion ends and the run r 0 is nite. As a nal step we present r (r 0 )! as the new run of N. 2 Both in the nite and the innite case we separated the construction into two stages. Namely removing the zero steps and then transforming automata that take no -moves. In the nite case the rst stage did not increase the number of states. In the innite case the rst stage doubled the number of states and then squaring we get approximately n n states. e could actually unite the two stages of the construction into one stage. Such a construction includes the -moves in the denition of the sets R a and L a. e believe our construction is easier to understand, while improving our construction to include the modication is not so dicult. Transforming the 2NB into a 1AB in one stage results in an automaton with approximately 2n 2 + 2n states. Remark In both the nite and the innite cases, we get a 1-way alternating automaton with O(n 2 ) states and transitions of exponential size. Birget's construction also results in exponential-sized transitions [1]. Globerman and Harel use -moves in order to reduce the transition to polynomial size []. Their construction uses the reverse language and can not be applied to innite words. In Appendices B and C, we use -moves to change our construction so that it uses only polynomial-sized transitions. e note that the transition size does not aect the conversion from 1AB to 1NB. In the case of unary 22

23 alphabet, our construction, with -moves, gives a polynomial time algorithm for checking the emptiness of 2NB. For 2NFA a log space algorithm exists [27]. 4.4 Complementing the alternating automaton Complementing an 1AB is not as easy as complementing an 1AFA. In the nite case dualizing the transition function and the acceptance set is enough. In the innite case we can dualize the transition but instead of Buchi acceptance we have to use co-buchi acceptance. That is, states from the acceptance set have to appear only nitely often along every innite path [1]. Kupferman and Vardi [13] showed how to complement alternating automata using weak alternating automata. Given a 2NB N with n states, we constructed a 1AB A with O(n 2 ) states. If we implement the quadratic construction from [13] on A we get A 0, a 1AB with O(n 4 ) states accepting the complementary language of N. e show how to construct an 1AB with O(n 2 ) states whose language is the complement of N's language. e recall the proof in [13] and show how to avoid the quadratic price in our case. The following observations about runs of 1AC are taken from [13] with minor adjustments. Denition 9 [13] A tree run (T; r) is memoryless if for all x 1 ; x 2 2 T such that jx 1 j = jx 2 j and r(x 1 ) = r(x 2 ), we have that for all y 2 N, x 1 y 2 T i x 2 y 2 T and r(x 1 y) = r(x 2 y). Theorem 10 [7] If a co-buchi automaton accepts a word w, then there exists a memoryless accepting run on w. e can restrict our attention to memoryless run trees. Hence, the run tree (T; r) can be represented in the form of a directed acyclic graph G = (V; E) where V Q N and E S 1 i=0(q fig) (Q fi + 1g): V = f(v (x); jxj) j x 2 T g E = f((v (x); jxj); (V (y); jyj)) j x; y 2 T and y successor of x in T g Given a (possibly nite) DAG G 0 G. e dene a vertex (s; i) as eventually safe in G 0 i only nitely many vertices in G 0 are reachable from (s; i). e dene a vertex (s; i) as currently safe in G 0 i all the vertices in G 0 reachable from (s; i) are not members of F N. Now dene the inductive sequence: G 0 = G 23