Parity Games: Zielonka's Algorithm in Quasi-Polynomial Time
PParity Games: Zielonka’s Algorithm inQuasi-Polynomial Time
Paweł Parys
Institute of Informatics, University of Warsaw, [email protected]
Abstract
Calude, Jain, Khoussainov, Li, and Stephan (2017) proposed a quasi-polynomial-time algorithmsolving parity games. After this breakthrough result, a few other quasi-polynomial-time algorithmswere introduced; none of them is easy to understand. Moreover, it turns out that in practice theyoperate very slowly. On the other side there is the Zielonka’s recursive algorithm, which is verysimple, exponential in the worst case, and the fastest in practice. We combine these two approaches:we propose a small modification of the Zielonka’s algorithm, which ensures that the running timeis at most quasi-polynomial. In effect, we obtain a simple algorithm that solves parity games inquasi-polynomial time. We also hope that our algorithm, after further optimizations, can lead to analgorithm that shares the good performance of the Zielonka’s algorithm on typical inputs, whilereducing the worst-case complexity on difficult inputs.
Theory of computation → Algorithmic game theory
Keywords and phrases
Parity games, Zielonka’s algorithm, quasi-polynomial time
Funding
Work supported by the National Science Centre, Poland (grant no. 2016/22/E/ST6/00041).
Acknowledgements
The author would like to thank Wojciech Czerwiński, Laure Daviaud, MarcinJurdziński, Eryk Kopczyński, Ranko Lazić, Karoliina Lehtinen, and Igor Walukiewicz for all thediscussions that preceded writing of this paper, and the anonymous reviewers of the previous versionof this paper for their valuable comments.
The fundamental role of parity games in automata theory, logic, and their applications toverification and synthesis is doubtless, hence it is pointless to elaborate on their importance.Let us only mention that the algorithmic problem of finding the winner in parity gamesis polynomial-time equivalent to the emptiness problem for nondeterministic automata oninfinite trees with parity acceptance conditions, and to the model-checking problem for modal µ -calculus [10]. It also lies at the heart of algorithmic solutions to the Church’s synthesisproblem [28]. The impact of parity games reaches relatively far areas of computer science,like Markov decision processes [11] and linear programming [15].It is a long-standing open question whether parity games can be solved in polynomial-time. Several results show that they belong to some classes “slightly above” polynomialtime. Namely, deciding the winner of parity games was shown to be in NP ∩ coNP [10],and in UP ∩ coUP [18], while computing winning strategies is in PLS , PPAD , and even intheir subclass
CLS [9]. The same holds for other kinds of games: mean-payoff games [35],discounted games, and simple stochastic games [7]; parity games, however, are the easiestamong them, in the sense that there are polynomial-time reductions from parity games tothe other kinds of games [18, 35], but no reductions in the opposite direction are known.Describing the algorithmic side of solving parity games, one has to start with the Zielonka’salgorithm [34], being an adaptation of an approach proposed by McNaughton to solve Mullergames [27]. This algorithm consists of a single recursive procedure, being simple and verynatural; one may say that it computes who wins the game “directly from the definition”. a r X i v : . [ c s . F L ] A p r Parity Games: Zielonka’s Algorithm in Quasi-Polynomial Time
Its running time is exponential in the worst case [14, 1, 16], but on many typical inputs itworks much faster. For over two decades researchers were trying to cutback the complexityof solving parity games, which resulted in a series of algorithms, all of which were eitherexponential [5, 30, 19, 33, 29, 2], or mildly subexponential [3, 21]. The next era cameunexpectedly in 2017 with a breakthrough result of Calude, Jain, Khoussainov, Li, andStephan [6] (see also [17, 23]), who designed an algorithm working in quasi-polynomialtime. This invoked a series of quasi-polynomial-time algorithms, which appeared soonafter [20, 13, 24]. These algorithms are quite involved (at least compared to the simplerecursive algorithm of Zielonka), and it is not so trivial to understand them.The four quasi-polynomial-time algorithms [6, 20, 13, 24], at first glance being quitedifferent, actually proceed along a similar line (as observed by Bojańczyk and Czerwiński [4]and Czerwiński et al. [8]). Namely, out of all the four algorithms one can extract a constructionof a safety automaton (nondeterministic in the case of Lehtinen [24], and deterministic inthe other algorithms), which accepts all words encoding plays that are decisively won byone of the players (more precisely: plays consistent with some positional winning strategy),and rejects all words encoding plays in which the player loses (for plays that are won by theplayer, but not decisively, the automaton can behave arbitrarily). This automaton does notdepend at all on the game graph; it depends only on its size. Having an automaton withthe above properties, it is not difficult to convert the original parity game into an equivalentsafety game (by taking a “product” of the parity game and the automaton), which can besolved easily—and all the four algorithms actually proceed this way, even if it is not statedexplicitly than such an automaton is constructed. As shown in Czerwiński et al. [8], allautomata having the aforementioned properties have to look very similar: their states have tobe leaves of some so-called universal tree; particular papers propose different constructions ofthese trees, and of the resulting automata (of quasi-polynomial size). Moreover, Czerwińskiet al. [8] show a quasi-polynomial lower bound for the size of such an automaton.In this paper we propose a novel quasi-polynomial-time algorithm solving parity games.It is obtained by applying a small modification to the Zielonka’s recursive algorithm; thismodification guarantees that the worst-case running time of this algorithm, being originallyexponential, becomes quasi-polynomial. The simplicity of the Zielonka’s algorithm remains inplace; we avoid complicated considerations accompanying all the previous quasi-polynomial-time algorithms. Another point is that our algorithm exploits the structure of parity gamesin a rather different way from the four previous quasi-polynomial-time algorithms. Indeed,the other algorithms construct automata that are completely independent from a particulargame graph given on input—they work in exactly the same way for every game graph of aconsidered size. The behaviour of our algorithm, in contrast, is highly driven by an analysisof the game graph given on input. In particular, although our algorithm is not faster thanquasi-polynomial, it does not fit to the “separator approach” in which a quasi-polynomiallower bound of Czerwiński et al. [8] exists.The running time of our algorithm is quasi-polynomial, and the space complexity isquadratic (more precisely, O ( n · h ), where n is the number of nodes in the game graph, and h is the maximal priority appearing there).Let us also mention the practical side of the world. It turns out that parity gamesare one of the areas where theory does not need to meet practice: the quasi-polynomial-time algorithms, although fastest in theory, are actually the slowest. The most exhaustivecomparison of existing algorithms was performed by Tom van Dijk [31]. In his Oink tool hehas implemented several algorithms, with different optimizations. Then, he has evaluatedthem on a benchmark of Keiren [22], containing multiple parity games obtained from model . Parys 3 checking and equivalence checking tasks, as well as on different classes of random games.It turns out that the classic recursive algorithm of Zielonka [34] performs the best, exaequo with the recent priority promotion algorithm [2]. After that, we have the strategyimprovement algorithm [33, 12], being a few times slower. Far later, we have the smallprogress measure algorithm [19]. At the very end, with a lot of timeouts, we have thequasi-polynomial-time algorithm of Fearnley, Jain, Schewe, Stephan, and Wojtczak [13]. Theother quasi-polynomial-time algorithms were not implemented due to excessive memoryusage.While developing the current algorithm, we hoped that it will share the good performancewith the Zielonka’s algorithm, on which it is based. Unfortunately, preliminary experimentshave shown that this is not necessarily the case. It turns out thaton random games our algorithm performs similarly to the slowest algorithms implementedin Oink;on crafted game families that are difficult for the Zielonka’s algorithm, our algorithm isindeed faster from it, but not dramatically faster;the only think that is optimistic is that on games with a very low number of prioritiesour algorithm performs similarly to the fastest algorithms.Because the empirical results of a direct implementation of the algorithm are completelyunsatisfactory, we do not include a full description of our experiments. Instead, we leave anefficient implementation for a future work. Beside of the discouraging outcomes, we believethat our idea, via further optimizations, can lead to an algorithm that is both fast in practiceand has a good worst-case complexity (see the concluding section for more comments). A parity game is played on a game graph between two players, called Even or Odd (shortenedsometimes to E and O ). A game graph consists ofa directed graph G , where we require that every node has at least one successor, andwhere there are no self-loops (i.e., edges from a node to itself);a labeling of every node v of G by a positive natural number π ( v ), called its priority ;a partition of nodes of G between nodes owned by Even and nodes owned by Odd.An infinite path in G is called a play , while a finite path in G is called a partial play . Thegame starts in a designated starting node. Then, the player to which the current nodebelongs, selects a successor of this node, and the game continues there. In effect, after afinite time a partial play is obtained, and at the end, after infinite time, this results in aplay. We say that a play v , v , . . . is winning for Even if lim sup i →∞ π ( v i ) is even (i.e., ifthe maximal priority seen infinitely often is even). Conversely, the play is winning for Odd iflim sup i →∞ π ( v i ) is odd.A strategy of player P ∈ { Even , Odd } is a function that maps every partial play thatends in a node of P to some its successor. Such a function says how P will play in everysituation of the game (depending on the history of that game). When a (partial) play π follows a strategy σ in every step in which player P is deciding, we say that π agrees with σ .A strategy σ is winning for P from a node v if every play that starts in v and agrees with σ is winning for P . While saying “player P wins from a node v ” we usually mean that P has awinning strategy from v . Let Win P ( G ) be the set of nodes of G from which P wins; it iscalled the winning region of P . By the Martin’s theorem [26] we know that parity games aredetermined: in every game graph G , and for every node v of G either Even wins from v , orOdd wins from v . In effect, Win E ( G ) and Win O ( G ) form a partition of the node set of G . Parity Games: Zielonka’s Algorithm in Quasi-Polynomial Time
During the analysis, we also consider games with other winning conditions. A winningcondition is a set of plays. The winning conditions of Even and Odd considered in paritygames are denoted LimsupEven and LimsupOdd, respectively. Beside of that, for every set S of nodes, let Safety( S ) be the set of plays that use only nodes from S .A dominion for Even is a set S of nodes such that from every v ∈ S Even wins the gamewith the condition LimsupEven ∩ Safety( S ); in other words, from every node of S he canwin the parity game without leaving S . Likewise, a dominion for Odd is a set S of nodessuch that from every v ∈ S Odd wins the game with the condition LimsupOdd ∩ Safety( S ).Notice that the whole Win P ( G ) is a dominion for P (where P ∈ { Even , Odd } ). Indeed, ifEven is going to win from some v ∈ Win E ( G ), the play cannot leave Win E ( G ) and enter anode v ∈ Win O ( G ), as then Odd could use his winning strategy from v and win the wholegame; here we use the fact that all suffixes of a play in LimsupEven are also in LimsupEven.For P = Odd the situation is symmetric. Before presenting our algorithm, we recall the standard Zielonka’s algorithm, as a reference.For a set of nodes N in a game graph G , and for a player P ∈ { Even , Odd } , we definethe attractor of N , denoted Atr P ( G, N ), to be the set of nodes of G from which P can forceto reach a node from N . In other words, Atr P ( G, N ) is the smallest set such that N ⊆ Atr P ( G, N ),if v is a node of P and some its successor is in Atr P ( G, N ), then v ∈ Atr P ( G, N ), andif v is a node of the opponent of P and all its successors are in Atr P ( G, N ), then v ∈ Atr P ( G, N ).Clearly
Atr P ( G, N ) can be computed in time proportional to the size of G . Algorithm 1
Standard Zielonka’s Algorithm procedure Solve E ( G, h ) . h is an even upper bound for priorities in G begin do begin N h = { v ∈ nodes ( G ) | π ( v ) = h } ; . nodes with the highest priority H = G \ Atr E ( G, N h ); . new game: reaching priority h → win W O = Solve O ( H, h − . in W O we lose before reaching priority h G = G \ Atr O ( G, W O ); . possibly N h ∩ Atr O ( G, W O ) = ∅ end while W O = ∅ end Algorithm 1 is the standard Zielonka’s algorithm. The procedure
Solve E ( G, h ) returns
Win E ( G ), the winning region of Even, if h is an even number that is greater or equal thanall priorities appearing in G . A procedure Solve O ( G, h ) is also needed; it is identical to
Solve E ( G, h ) except that the roles of E and O are swapped; it returns Win O ( G ), thewinning region of Odd. While writing G \ S , we mean the game obtained by removing from G all nodes in S , and all edges leading to nodes in S or starting from nodes in S . We usethis construct only when S is an attractor; in such a case, if all successors of a node v areremoved, then v is also removed (i.e., if all successors of v belong to an attractor, then v belongs to the attractor as well). In effect G \ S is a valid game graph (every its node has atleast one successor).We remark that the algorithm is presented in a slightly different way than usually.Namely, we use here a loop, while the usual presentation does not use a loop but rather . Parys 5 Win E ( G ) Win O ( G ) hhh h hhhhhhhhhh W O W O W O W O A A A A E Figure 1
The structure of winning regions in a parity game calls recursively
Solve E ( G \ Atr O ( G, W O ) , h ) at the end of the procedure. This is only asuperficial difference in the presentation, but is useful while modifying the algorithm in thenext section.The algorithm can be understood while looking at Figure 1. Let h be the highest priorityused in G ; assume that it is even. The game graph G can be divided into two parts: Win E ( G )and Win O ( G ). In Win E ( G ) we can distinguish the attractor of nodes with priority h (denoted A E ). Odd either loses inside Win E ( G ) \ A E , or enters A E , which causes that a node withpriority h is seen, and then the game continues in some node of Win E ( G ). The winningregion of Odd, Win O ( G ), can be divided into multiple parts. We have a part W O , whereOdd can win without seeing a node of priority h . Then, we have nodes of priority h fromwhich Even is forced to enter W O , and their attractor, denoted A . Then, we have a part W O , where Odd can ensure that the play is either winning for him inside W O or enters A ;in other words, from nodes of W O Odd can win while seeing h at most once. We also haveparts W iO for larger i , and corresponding attractors A i .While running the algorithm, this partition of G is not known, and has to be discovered.To this end, the algorithm assumes first (in the game H ) that all nodes of priority h arewinning for Even. The first call to Solve O ( H, h −
1) returns the set W O of nodes whereOdd wins without seeing a node of priority h . We then remove them from the game, togetherwith the attractor A . In the next step, Solve O ( H, h −
1) returns the set W O , and so on.At the end the whole Win O ( G ) becomes removed, and the procedure returns Win E ( G ). We now present a modification to Algorithm 1 that results in obtaining quasi-polynomialrunning time, in the worst case.The modification can be understood while looking again at Figure 1. The key observationis that, while
Win O ( G ) is of size at most n (where n is the number of nodes in G ), thenmost of its parts W iO are smaller. Namely, most of them have to be of size at most n , andonly one of them can be larger than n . We use this observation, and while looking for W iO ,we search for a winning region (for a dominion) of size at most n . Usually this is enough;only once it is not enough: one W iO can be larger than n and it will not be found if we onlylook for a set of size at most n . But when the algorithm finds no set of size at most n , wecan once search for W iO of an arbitrary size. After that, we know that all following sets W iO are again of size at most n . While going recursively, we notice that every W iO can be furthersubdivided in a similar way, while splitting on the priority h −
2. If | W iO | ≤ n , we again havethe property that most of the parts of W iO are of size at most n , and only one of them canbe larger than n . Parity Games: Zielonka’s Algorithm in Quasi-Polynomial Time
To exploit this observation, in the recursive calls we pass two precision parameters, p E and p O (one for every of the players), saying that we search for winning sets of size at most p E for Even, and at most p O for Odd. The modified procedure is presented as Algorithm 2.Again, one also needs a procedure Solve O , which is obtained from Solve E by literallychanging every E to O and vice versa . Algorithm 2
Quasi-Polynomial-Time Algorithm procedure Solve E ( G, h, p E , p O ) . p E , p O are new “precision” parameters begin if G = ∅ ∨ p E ≤ then return ∅ ; . we assume that there are no self-loops in G do begin N h = { v ∈ nodes ( G ) | π ( v ) = h } ; H = G \ Atr E ( G, N h ); W O = Solve O ( H, h − , b p O / c , p E ); . precision decreased G = G \ Atr O ( G, W O ); end while W O = ∅ N h = { v ∈ nodes ( G ) | π ( v ) = h } ; H = G \ Atr E ( G, N h ); W O = Solve O ( H, h − , p O , p E ); . we try once with the full precision G = G \ Atr O ( G, W O ); while W O = ∅ do begin N h = { v ∈ nodes ( G ) | π ( v ) = h } ; H = G \ Atr E ( G, N h ); W O = Solve O ( H, h − , b p O / c , p E ); . again, precision decreased G = G \ Atr O ( G, W O ); end return nodes ( G ); end We start the algorithm with p E = p O = n , where n is the number of nodes in G . In theprocedure we have now, in a sense, three copies of the previous procedure, corresponding tothree stages. In the first stage, in lines 5-10, we look for sets W iO of size at most b p O c . If thereturned set is empty, this may mean that the next W iO either is empty, or is of size greaterthan b p O c . Then, in lines 11-14, we once search for a set W iO of size at most p O (knowingthat if it is nonempty, then its size is greater than b p O c ). Finally, in the loop in lines 15-20,we again look for sets W iO of size at most b p O c (because we have already found a set of sizegreater than b p O c , all the remaining sets have size at most b p O c ). Let us analyze the complexity of our algorithm.First, we observe that the space complexity is O ( n · h ), where n is the number of nodes,and h is the maximal priority. Indeed, the depth of the recursion is at most h , and on everystep we only need to remember some sets of nodes.We now come to the running time. As it is anyway worse than the running time of theother quasi-polynomial-time algorithms, we do not aim in proving a very tight upper bound;we only prove that the running time is quasi-polynomial. . Parys 7 Let R ( h, l ) be the number of (nontrivial) executions of the Solve E and Solve O proceduresperformed during one call to Solve E ( G, h, p E , p O ) with b log p E c + b log p O c = l , and with G having at most n nodes (where n is fixed). We only count here nontrivial executions, that is,such that do not leave the procedure in line 4. Clearly R (0 , l ) = R ( h,
0) = 0. For h, l ≥ R ( h, l ) ≤ n · R ( h − , l −
1) + R ( h − , l ) . (1)Indeed, in Solve E after every call to Solve O we remove at least one node from G , with theexception of two such calls: the last call in line 8, and the last call ever. In effect, in lines 8and 18 we have at most n calls to Solve O with decreased precision (plus, potentially, the( n + 1)-th call with empty G , which is not included in R ( h, l )), and in line 13 we have onecall to Solve O with full precision. Notice that b log p O c (hence also l ) decreases by 1 in thedecreased-precision call.Using Inequality (1) we now prove by induction that R ( h, l ) ≤ n l · (cid:0) h + ll (cid:1) −
1. For h = 0and for l = 0 the inequality holds. For h, l ≥ R ( h, l ) ≤ n · R ( h − , l −
1) + R ( h − , l ) ≤ n · (cid:18) n l − · (cid:18) h − l − l − (cid:19) − (cid:19) + n l · (cid:18) h − ll (cid:19) − ≤ n l · (cid:18)(cid:18) h − ll − (cid:19) + (cid:18) h − ll (cid:19)(cid:19) − n l · (cid:18) h + ll (cid:19) − . In effect, R ( h, l ) ≤ n l · ( h + l ) l . Recalling that we start with l = 2 · b log n c , we see that thisnumber is quasi-polynomial in n and h . This concludes the proof, since obviously a singleexecution of the Solve E procedure (not counting the running time of recursive calls) costspolynomial time. We now justify correctness of the algorithm. This amounts to proving the following lemma. (cid:73)
Lemma 6.1.
Procedure
Solve E ( G, h, p E , p O ) returns a set W E such that for every S ⊆ nodes ( G ) ,if S is a dominion for Even, and | S | ≤ p E , then S ⊆ W E , andif S is a dominion for Odd, and | S | ≤ p O , then S ∩ W E = ∅ . Notice that in G there may be nodes that do not belong to any dominion smaller than p E or p O ; for such nodes we do not specify whether or not they are contained in W E .Recall that Win E ( G ) is a dominion for Even, and Win O ( G ) is a dominion for Odd. Thus,using Lemma 6.1 we can conclude that for p E = p O = n the procedure returns Win E ( G ),the winning region of Even.One may wonder why we use dominions in the statement of the lemma, instead of simplysaying that if | Win E ( G ) | ≤ p E , then Win E ( G ) ⊆ W E . Such a simplified statement, however,is not suitable for induction. Indeed, while switching from the game G to the game H (created in lines 7, 12, 17) the winning regions of Even may increase dramatically, because in H Odd is not allowed to visit any node with priority h . Nevertheless, the winning region ofEven in G , and any dominion of Even in G , remains a dominion in H (when restricted tonodes of H ). Parity Games: Zielonka’s Algorithm in Quasi-Polynomial Time
Before proving Lemma 6.1, let us observe two facts about dominions. In their statements P ∈ { Even , Odd } is one of the players, and P is his opponent. (cid:73) Fact 6.2. If S is a dominion for P in a game G , and X is a set of nodes of G , then S \ Atr P ( G, X ) is a dominion for P in G \ Atr P ( G, X ) . Proof.
Denote S = S \ Atr P ( G, X ) and G = G \ Atr P ( G, X ). By definition, fromevery node v ∈ S player P wins with the condition Limsup P ∩ Safety( S ) in G , usingsome winning strategy. Observe that using the same strategy he wins with the conditionLimsup P ∩ Safety( S ) in G (assuming that the starting node v is in S ). The strategyremains valid in G , because every node u of player P that remains in G has the samesuccessors in G as in G (conversely: if some of successors of u belongs to Atr P ( G, X ), then u also belongs to Atr P ( G, X )). (cid:74)(cid:73)
Fact 6.3. If S is a dominion for P in a game G , and X is a set of nodes of G suchthat S ∩ X = ∅ , then S is a dominion for P in G \ Atr P ( G, X ) (in particular S ⊆ nodes ( G \ Atr P ( G, X )) ). Proof.
Denote G = G \ Atr P ( G, X ). Suppose that there is some v ∈ S ∩ Atr P ( G, X ).On the one hand, P can guarantee that, while starting from v , the play stays in S (by thedefinition of a dominion); on the other hand, P can force to reach the set X (by the definitionof an attractor), which is disjoint from S . Thus such a node v could not exist, we have S ⊆ nodes ( G ).It remains to observe that from every node v ∈ S player P wins with the conditionLimsup P ∩ Safety( S ) also in the restricted game G , using the same strategy as in G . Indeed,a play in G following this strategy never leaves S , and the whole S remains unchanged in G . (cid:74) We are now ready to prove Lemma 6.1.
Proof of Lemma 6.1.
We prove the lemma by induction on h . Consider some executionof the procedure. By G i , N ih , H i , W iO we denote values of the variables G, N h , H, W O justafter the i -th call to Solve O in one of the lines 8, 13, 18; in lines 9, 14, 19 we create G i +1 out of G i and W iO . In particular G equals the original game G , and at the end we return nodes ( G m +1 ), where m is the number of calls to Solve O .Concentrate on the first item of the lemma: fix an Even’s dominion S in G (i.e., in G )such that | S | ≤ p E . Assume that S = ∅ (for S = ∅ there is nothing to prove). Notice firstthat a nonempty dominion has at least two nodes (by assumption there are no self-loopsin G , hence every play has to visit at least two nodes), thus, because S ⊆ nodes ( G ) and | S | ≤ p E , we have that G = ∅ and p E >
1. It means that the procedure does not return inline 4. We thus need to prove that S ⊆ nodes ( G m +1 ).We actually prove that S is a dominion for Even in G i for every i ∈ { , . . . , m + 1 } ,meaning in particular that S ⊆ nodes ( G i ). This is shown by an internal induction on i . Thebase case ( i = 1) holds by assumption. For the induction step, consider some i ∈ { , . . . , m } .By the induction assumption S is a dominion for Even in G i , and we need to prove that it isa dominion for Even in G i +1 .Consider S i = S ∩ nodes ( H i ). Because S i = S \ Atr E ( G i , N ih ), by Fact 6.2 the set S i is a dominion for Even in H i = G i \ Atr E ( G i , N ih ), and obviously | S i | ≤ | S | ≤ p E . By theassumption of the external induction (which can be applied to Solve O , by symmetry) itfollows that S i ∩ W iO = ∅ , so also S ∩ W iO = ∅ (because W iO contains only nodes of G i , while . Parys 9 S \ S i contains no nodes of G i ). Thus, by Fact 6.3 the set S is a dominion for Even in G i +1 = G i \ Atr O ( G i , W iO ). This finishes the proof of the first item.Now we prove the second item of the lemma. To this end, fix some Odd’s dominion S in G such that | S | ≤ p O . If p E ≤
1, we return W E = ∅ (line 4), so clearly S ∩ W E = ∅ .The interesting case is when p E ≥
2. Denote S i = S ∩ nodes ( G i ) for all i ∈ { , . . . , m + 1 } ;we first prove that S i is a dominion for Odd in G i . This is shown by induction on i . Thebase case of i = 1 holds by assumption, because G = G and S = S . For the inductionstep, assume that S i is a dominion for Odd in G i , for some i ∈ { , . . . , m } . By definition G i +1 = G i \ Atr O ( G i , W iO ) and S i +1 = S i \ Atr O ( G i , W iO ), so S i +1 is a dominion for Oddin G i +1 by Fact 6.2, which finishes the inductive proof.For i ∈ { , . . . , m } , let Z i be the set of nodes (in S i \ N ih ) from which Odd wins with thecondition LimsupOdd ∩ Safety( S i \ N ih ) in G i (that is, where Odd can win without seeingpriority h —the highest even priority). Let us observe that if S i = ∅ then Z i = ∅ ( ♣ ). Indeed,suppose to the contrary that Z i = ∅ , and consider an Odd’s strategy that allows him towin with the condition LimsupOdd ∩ Safety( S i ) in G i , from some node v ∈ S i . Because v Z i , this strategy in not winning for the condition LimsupOdd ∩ Safety( S i \ N ih ), soEven, while playing against this strategy, can reach a node v in N ih (as he cannot violatethe parity condition nor leave S i ). For the same reason, because v Z i , Even can continueand reach a node v in N ih . Repeating this forever, Even gets priority h (which is even andis the highest priority) infinitely many times, contradicting the fact that the strategy waswinning for Odd.Observe also that from nodes of Z i Odd can actually win with the condition LimsupOdd ∩ Safety( Z i ) in G i , using the strategy that allows him to win with the condition LimsupOdd ∩ Safety( S i \ N ih ). Indeed, if a play following this strategy enters some node v , then from thisnode v Odd can still win with the condition LimsupOdd ∩ Safety( S i \ N ih ), which means thatthese nodes belongs to Z i . It follows that Z i is a dominion for Odd in G i . Moreover, because Z i ∩ N ih = ∅ , from Fact 6.3 we have that Z i is a dominion for Odd in H i = G i \ Atr E ( G i , N ih ).Let k be the number of the call to Solve O that is performed in line 13 (calls number1 , . . . , k − k + 1 , . . . , m are performed in line 18).Recall that W iO is the set returned by a call to Solve O ( H i , h − , p iO , p E ), where p kO = p O ,and p iO = b p O c if i = k . From the assumption of the external induction, if | Z i | ≤ b p O c or if i = k (since Z i ⊆ S i ⊆ S and | S | ≤ p O , clearly | Z i | ≤ p O ), we obtain that Z i ⊆ W iO ( ♠ ).We now prove that | S k +1 | ≤ b p O c . This clearly holds if S k − = ∅ , because S k +1 ⊆ S k ⊆ S k − . Suppose thus that S k − = ∅ . Then Z k − = ∅ , by ( ♣ ). On the otherhand, W k − O = ∅ , because we are just about to leave the loop in lines 5-10 (the k -thcall to Solve O is in line 13). By ( ♠ ), if | Z k − | ≤ b p O c , then Z k − ⊆ W k − O , whichdoes not hold in our case. Thus | Z k − | > b p O c . Because W k − O = ∅ , we simply have G k = G k − , and S k = S k − , and Z k = Z k − . Using ( ♠ ) for i = k , we obtain that Z k ⊆ W kO , and because S k +1 = S k \ Atr O ( G k , W kO ) ⊆ S k \ W kO ⊆ S k \ Z k we obtain that | S k +1 | ≤ | S k | − | Z k | ≤ p O − ( b p O c + 1) ≤ b p O c , as initially claimed.If k = m , we have Z m ⊆ W mO by ( ♠ ). If k + 1 ≤ m , we have S m ⊆ S k +1 (our procedureonly removes nodes from the game) and Z m ⊆ S m , so | Z m | ≤ b p O c by the above paragraph,and also Z m ⊆ W mO by ( ♠ ). Because after the m -th call to Solve O the procedure ends,we have W mO = ∅ , so also Z m = ∅ , and thus S m = ∅ by ( ♣ ). We have S m +1 ⊆ S m , so S m +1 = S ∩ nodes ( G m +1 ) = ∅ . This is exactly the conclusion of the lemma, since the setreturned by the procedure is nodes ( G m +1 ). (cid:74) To the list of the four existing quasi-polynomial-time algorithms solving parity games, wehave added a new one. It uses a rather different approach: it analyses recursively the gamegraph, like the Zielonka’s algorithm.Notice that the number of recursive calls in our algorithm may be smaller than in theoriginal Zielonka’s algorithm, because of the precision parameters, but it may also be larger.Indeed, while
Solve E in the original Zielonka’s algorithm stops after the first time when arecursive call returns ∅ , in our algorithm the procedure stops after the second time when arecursive call returns ∅ .The algorithm, as is, turns out not to be very efficient in practice. Beside of that, webelieve that it can serve as a good starting point for a more optimized algorithm. Overthe years, some optimizations to the Zielonka’s algorithm were proposed. For example, Liu,Duan, and Tian [25] replace the loop guard W O = ∅ by W O = Atr O ( G, W O ) (which ensuresthat W O will be empty in the next iteration of the loop). Verver [32] proposes to checkwhether Atr E ( G, N h ) contains all nodes of priority h −
1, and if so, to extend N h by nodesof the next highest Even priority (i.e., h − p O and p E to | G | at the beginning of everyrecursive call.Another idea is to extend the recursive procedure so that it will return also a Booleanvalue saying whether the returned set surely equals the whole winning region (i.e., whetherthe precision parameters have not restricted anything). If while making the recursive callwith smaller precision (line 8) the answer is positive, but the returned set W O is empty, wecan immediately stop the procedure, without making the recursive call with the full precision(line 13).One can also observe that the call to Solve O in line 13 (with the full precision) gets thesame subgame H as the last call to Solve O in line 8 (with decreased precision). A veryrough idea is to make some use of the computations performed by the decreased-precisioncall during the full-precision call.We leave implementation and evaluation of the above (and potentially some other)optimizations for a future work. References Massimo Benerecetti, Daniele Dell’Erba, and Fabio Mogavero. Robust exponential worstcases for divide-et-impera algorithms for parity games. In Patricia Bouyer, Andrea Orlandini,and Pierluigi San Pietro, editors,
Proceedings Eighth International Symposium on Games,Automata, Logics and Formal Verification, GandALF 2017, Roma, Italy, 20-22 September2017. , volume 256 of
EPTCS , pages 121–135, 2017. doi:10.4204/EPTCS.256.9 . Massimo Benerecetti, Daniele Dell’Erba, and Fabio Mogavero. Solving parity games viapriority promotion.
Formal Methods in System Design , 52(2):193–226, 2018. doi:10.1007/s10703-018-0315-1 . Henrik Björklund and Sergei G. Vorobyov. A combinatorial strongly subexponential strategyimprovement algorithm for mean payoff games.
Discrete Applied Mathematics , 155(2):210–229,2007. doi:10.1016/j.dam.2006.04.029 . Mikołaj Bojańczyk and Wojciech Czerwiński. An automata toolbox, February 2018. URL: . . Parys 11 Anca Browne, Edmund M. Clarke, Somesh Jha, David E. Long, and Wilfredo R. Marrero.An improved algorithm for the evaluation of fixpoint expressions.
Theor. Comput. Sci. ,178(1-2):237–255, 1997. doi:10.1016/S0304-3975(96)00228-9 . Cristian S. Calude, Sanjay Jain, Bakhadyr Khoussainov, Wei Li, and Frank Stephan. Decidingparity games in quasipolynomial time. In Hamed Hatami, Pierre McKenzie, and ValerieKing, editors,
Proceedings of the 49th Annual ACM SIGACT Symposium on Theory ofComputing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017 , pages 252–263. ACM,2017. doi:10.1145/3055399.3055409 . Anne Condon. The complexity of stochastic games.
Inf. Comput. , 96(2):203–224, 1992. doi:10.1016/0890-5401(92)90048-K . Wojciech Czerwiński, Laure Daviaud, Nathanaël Fijalkow, Marcin Jurdziński, Ranko Lazić,and Paweł Parys. Universal trees grow inside separating automata: Quasi-polynomial lowerbounds for parity games. In Timothy M. Chan, editor,
Proceedings of the Thirtieth AnnualACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, California, USA,January 6-9, 2019 , pages 2333–2349. SIAM, 2019. doi:10.1137/1.9781611975482.142 . Constantinos Daskalakis and Christos H. Papadimitriou. Continuous local search. In DanaRandall, editor,
Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on DiscreteAlgorithms, SODA 2011, San Francisco, California, USA, January 23-25, 2011 , pages 790–804.SIAM, 2011. doi:10.1137/1.9781611973082.62 . E. Allen Emerson, Charanjit S. Jutla, and A. Prasad Sistla. On model checking for the µ -calculus and its fragments. Theor. Comput. Sci. , 258(1-2):491–522, 2001. doi:10.1016/S0304-3975(00)00034-7 . John Fearnley. Exponential lower bounds for policy iteration. In Samson Abramsky, CyrilGavoille, Claude Kirchner, Friedhelm Meyer auf der Heide, and Paul G. Spirakis, editors,
Au-tomata, Languages and Programming, 37th International Colloquium, ICALP 2010, Bordeaux,France, July 6-10, 2010, Proceedings, Part II , volume 6199 of
Lecture Notes in ComputerScience , pages 551–562. Springer, 2010. doi:10.1007/978-3-642-14162-1_46 . John Fearnley. Efficient parallel strategy improvement for parity games. In Rupak Majumdarand Viktor Kuncak, editors,
Computer Aided Verification - 29th International Conference,CAV 2017, Heidelberg, Germany, July 24-28, 2017, Proceedings, Part II , volume 10427 of
Lecture Notes in Computer Science , pages 137–154. Springer, 2017. doi:10.1007/978-3-319-63390-9_8 . John Fearnley, Sanjay Jain, Sven Schewe, Frank Stephan, and Dominik Wojtczak. An orderedapproach to solving parity games in quasi polynomial time and quasi linear space. In HakanErdogmus and Klaus Havelund, editors,
Proceedings of the 24th ACM SIGSOFT InternationalSPIN Symposium on Model Checking of Software, Santa Barbara, CA, USA, July 10-14, 2017 ,pages 112–121. ACM, 2017. doi:10.1145/3092282.3092286 . Oliver Friedmann. Recursive algorithm for parity games requires exponential time.
RAIRO -Theor. Inf. and Applic. , 45(4):449–457, 2011. doi:10.1051/ita/2011124 . Oliver Friedmann, Thomas Dueholm Hansen, and Uri Zwick. Subexponential lower bounds forrandomized pivoting rules for the simplex algorithm. In Lance Fortnow and Salil P. Vadhan,editors,
Proceedings of the 43rd ACM Symposium on Theory of Computing, STOC 2011, SanJose, CA, USA, 6-8 June 2011 , pages 283–292. ACM, 2011. doi:10.1145/1993636.1993675 . Maciej Gazda.
Fixpoint Logic, Games, and Relations of Consequence . PhD thesis, EindhovenUniversity of Technology, 2016. URL: https://pure.tue.nl/ws/files/16681817/20160315_Gazda.pdf . Hugo Gimbert and Rasmus Ibsen-Jensen. A short proof of correctness of the quasi-polynomialtime algorithm for parity games.
CoRR , abs/1702.01953, 2017. arXiv:1702.01953 . Marcin Jurdziński. Deciding the winner in parity games is in UP ∩ co-UP. Inf. Process. Lett. ,68(3):119–124, 1998. doi:10.1016/S0020-0190(98)00150-1 . Marcin Jurdziński. Small progress measures for solving parity games. In Horst Reicheland Sophie Tison, editors,
STACS 2000, 17th Annual Symposium on Theoretical Aspects of
Computer Science, Lille, France, February 2000, Proceedings , volume 1770 of
Lecture Notes inComputer Science , pages 290–301. Springer, 2000. doi:10.1007/3-540-46541-3_24 . Marcin Jurdziński and Ranko Lazić. Succinct progress measures for solving parity games. In , pages 1–9. IEEE Computer Society, 2017. doi:10.1109/LICS.2017.8005092 . Marcin Jurdziński, Mike Paterson, and Uri Zwick. A deterministic subexponential algorithmfor solving parity games.
SIAM J. Comput. , 38(4):1519–1532, 2008. doi:10.1137/070686652 . Jeroen J. A. Keiren. Benchmarks for parity games. In Mehdi Dastani and Marjan Sirjani,editors,
Fundamentals of Software Engineering - 6th International Conference, FSEN 2015Tehran, Iran, April 22-24, 2015, Revised Selected Papers , volume 9392 of
Lecture Notes inComputer Science , pages 127–142. Springer, 2015. doi:10.1007/978-3-319-24644-4_9 . Bakhadyr Khoussainov. A brief excursion to parity games. In Mizuho Hoshi and ShinnosukeSeki, editors,
Developments in Language Theory - 22nd International Conference, DLT 2018,Tokyo, Japan, September 10-14, 2018, Proceedings , volume 11088 of
Lecture Notes in ComputerScience , pages 24–35. Springer, 2018. doi:10.1007/978-3-319-98654-8_3 . Karoliina Lehtinen. A modal µ perspective on solving parity games in quasi-polynomialtime. In Anuj Dawar and Erich Grädel, editors, Proceedings of the 33rd Annual ACM/IEEESymposium on Logic in Computer Science, LICS 2018, Oxford, UK, July 09-12, 2018 , pages639–648. ACM, 2018. doi:10.1145/3209108.3209115 . Yao Liu, Zhenhua Duan, and Cong Tian. An improved recursive algorithm for parity games. In , pages 154–161. IEEE Computer Society, 2014. doi:10.1109/TASE.2014.24 . Donald A. Martin. Borel determinacy.
The Annals of Mathematics , 102(2):363–371, 1975. Robert McNaughton. Infinite games played on finite graphs.
Ann. Pure Appl. Logic , 65(2):149–184, 1993. doi:10.1016/0168-0072(93)90036-D . Michael Oser Rabin.
Automata on Infinite Objects and Church’s Problem . American Mathe-matical Society, Boston, MA, USA, 1972. Sven Schewe. Solving parity games in big steps.
J. Comput. Syst. Sci. , 84:243–262, 2017. doi:10.1016/j.jcss.2016.10.002 . Helmut Seidl. Fast and simple nested fixpoints.
Inf. Process. Lett. , 59(6):303–308, 1996. doi:10.1016/0020-0190(96)00130-5 . Tom van Dijk. Oink: An implementation and evaluation of modern parity game solvers.In Dirk Beyer and Marieke Huisman, editors,
Tools and Algorithms for the Constructionand Analysis of Systems - 24th International Conference, TACAS 2018, Held as Part of theEuropean Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki,Greece, April 14-20, 2018, Proceedings, Part I , volume 10805 of
Lecture Notes in ComputerScience , pages 291–308. Springer, 2018. doi:10.1007/978-3-319-89960-2_16 . Maks Verver. Practical improvements to parity game solving. Master’s thesis, Universityof Twente, 2013. URL: http://essay.utwente.nl/64985/1/practical-improvements-to-parity-game-solving.pdf . Jens Vöge and Marcin Jurdziński. A discrete strategy improvement algorithm for solvingparity games. In E. Allen Emerson and A. Prasad Sistla, editors,
Computer Aided Verification,12th International Conference, CAV 2000, Chicago, IL, USA, July 15-19, 2000, Proceedings ,volume 1855 of
Lecture Notes in Computer Science , pages 202–215. Springer, 2000. doi:10.1007/10722167_18 . Wiesław Zielonka. Infinite games on finitely coloured graphs with applications to automataon infinite trees.
Theor. Comput. Sci. , 200(1-2):135–183, 1998. doi:10.1016/S0304-3975(98)00009-7 . Uri Zwick and Mike Paterson. The complexity of mean payoff games on graphs.
Theor.Comput. Sci. , 158(1&2):343–359, 1996. doi:10.1016/0304-3975(95)00188-3doi:10.1016/0304-3975(95)00188-3