A Recursive Approach to Solving Parity Games in Quasipolynomial Time

Zielonka's classic recursive algorithm for solving parity games is perhaps the simplest among the many existing parity game algorithms. However, its complexity is exponential, while currently the state-of-the-art algorithms have quasipolynomial complexity. Here, we present a modification of Zielonka's classic algorithm that brings its complexity down to $n^{O\left(\log\left(1+\frac{d}{\log n}\right)\right)}$, for parity games of size $n$ with $d$ priorities, in line with previous quasipolynomial-time solutions.


Introduction
A parity game is an infinite two-player game in which Even and her opponent Odd build an infinite path along the edges of a graph labelled with integer priorities. Even's goal is for the highest priority seen infinitely often on this path to be even, while Odd tries to stop her.
Parity games are a central tool in automata theory, logic, and their applications to verification. In particular, the model-checking problem for the modal µ calculus [EJS01] and the synthesis problem for LTL [PR89] reduce to solving parity games. Solutions to parity games have also influenced work on ω-word automata translations [BL18,DJL19], linear optimisation [Fri11b,FHZ11] and stochastic planning [Fea10].
The complexity of solving parity games, that is, deciding which player has a winning strategy, is a long standing open problem. The problem is known to be both in UP and coUP [Jur98] but a polynomial algorithm remains, so far, out of reach. In 2017 Calude et al. published the first quasipolynomial-time algorithm [CJK + 17], which was followed by several alternative algorithms [JL17,Leh18], variations and improvements thereupon [FJdK + 19, Par20,DJT20]. The progress-measure approach [JL17] is based on succinct encodings of classical progress measures, while the register-game approach [Leh18] is based on a relatively involved analysis of the structure of winning strategies in parity games.
In this paper we present a quasipolynomial-time parity-game algorithm based on Zielonka's classic recursive algorithm. Zielonka's algorithm [Zie98], based on McNaughton's algorithm for solving Muller games [McN93], is perhaps the (conceptually) simplest parity game algorithm to date. Despite its exponential worst-case complexity, it is also one of the most performant algorithms in practice [vD18]. Here we show how to adapt this algorithm to make its worst-case complexity quasipolynomial. Our algorithm, its correctness proof, and complexity analysis are all remarkably simple. Its runtime complexity is roughly in line with previous quasipolynomial-time algorithms.
Our key insight is that, instead of each recursive call solving a subgame, we use a weakened induction hypothesis, which postulates that each call should return a partition that separates the small dominions of both players, up to a size specified by a pair of parameters. Generalising the observation that only one dominion can be larger than half the arena, we then use these parameterised calls to build an algorithm that only makes a quasipolynomial number of calls, but still finds the winning regions of each player.
The time complexity of our algorithm, which is in n O log 1+ d log n for games with n vertices and d priorities, is similar to the complexity of previous quasipolynomial-time algorithms. This also provides fixed-parameter tractability when d, the number of priorities, is treated as the parameter, as well as a polynomial bound for the common case where the number of priorities is logarithmic in the number of states. In a fine grained comparison our algorithm (similarly to the original Zielonka's algorithms, on which it is based) operates symmetrically, going through every priority, rather than just half of them (as in previous quasipolynomial-time algorithms), meaning that the O 1 + log d log n in the exponent hides a factor of 2. Thus, a very careful analysis still reveals a small gap, when compared to previous quasipolynomial-time algorithms.
We provide two versions of our algorithm. One has better worst-case complexity (outlined above), while the other turns out to be somewhat better in practice. We evaluate both versions against Zielonka's classic algorithm, which, despite its exponential worst-case behaviour, is in most cases faster than our quasipolynomial-time versions. In line with the theory, both our algorithms outperform Zielonka's algorithm on the families of games designed to exhibit its exponential worst-case behaviour.
We also briefly comment on the relationship between this recursive algorithm and universal trees, but refer the reader to Jurdziński and Morvan's work [JM20] for a more thorough analysis, which also addresses the symbolic implementation of recursive algorithms. This is a journal version of Parys' paper [Par19], in which he turns Zielonka's exponentialtime algorithm into a quasipolynomial-time one; additionally, it includes theoretical improvements suggested by Lehtinen, Schewe, and Wojtczak [LSW19], which bring the complexity of the algorithm down to roughly match the state of the art.

Preliminaries
A parity game is a two-player game between players Even and Odd played on a game graph defined as a tuple G = (V, V E , E, π), where (V, E) is a finite directed graph in which every vertex has at least one successor; its vertices are labelled with positive integer priorities by π : V → {1, 2, . . . , d} (for some d ∈ N), and partitioned between vertices V E belonging to Even and vertices V O = V \ V E belonging to Odd. As usual for directed graphs, we forbid self-loops (i.e., edges from a vertex to itself). We sometimes abbreviate Even and Odd to E and O, we use the symbol ℘ for a player (either Even or Odd), and we write℘ for the opponent of ℘.
A play ρ is an infinite path through the game graph. It is winning for Even if the highest priority occurring infinitely often on it is even; otherwise it is winning for Odd. We write ρ[i] for the i th vertex in ρ (zero based) and ρ[0, j] for its prefix of length j + 1.
A strategy from a vertex v for a player ℘ is a function that • takes any prefix of a play starting in v and ending in a vertex that belongs to ℘, and • returns one of successors of the latter vertex.
A strategy σ from v for Even (Odd) agrees with a play ρ if and σ agrees with a finite path, if it agrees with some infinite play extending the path). A strategy for a player is winning if it agrees only with plays winning for that player. Parity games are determined: from every vertex, one of the two players has a winning strategy [Mar75].
The winning region of a player ℘ is the set of vertices from which ℘ has a winning strategy. We are interested in the problem of computing, given a parity game G, the winning regions of each player.
Given a set of vertices G ⊆ V , we can consider a subgame of G induced by G, which is obtained simply by restricting all components of G to G. Notice, however, that not every set G induces a valid subgame: every vertex in G should have at least one successor in G. In the sequel, we often write "the subgame G" instead of the more precise "the subgame of G induced by G". For the definitions below, we assume some set G ⊆ V inducing a subgame of G.
A dominion of a player ℘ in a subgame G is a set of vertices D ⊆ G such that from every vertex v ∈ D the player ℘ has, in the subgame G, a winning strategy that agrees only with plays staying forever in D.
Given a set S ⊆ G, the ℘-attractor of S in the subgame G, written Attr ℘ (S, G), is the set of vertices from which the player ℘ has a strategy in G that agrees only with plays reaching S. A set S ⊆ G is ℘-closed in the subgame G if Attr℘(G \ S, G) = G \ S. More concretely, this means that ℘ can ensure to stay inside S: every vertex of ℘ in S has at least one successor in S, and every vertex of℘ in S has no successor in G \ S.
Observe that the set G \ Attr ℘ (S, G), for any S ⊆ G, always induces a subgame: if all successors of a vertex belong to Attr ℘ (S, G), then this vertex belongs there as well. Observe also that every dominion of ℘ is ℘-closed, and that the winning region of ℘ is a dominion of ℘.
We use the following simple lemmata to prove correctness of our algorithm: Lemma 2.1. Let D be a dominion of a player ℘ in a subgame G, and let X ⊆ G. If D does not intersect with X, then D is also a dominion of ℘ in G \ Attr℘(X, G).
Proof. By the definition of a dominion, from every vertex v ∈ D player ℘ has a winning strategy that agrees only with plays staying in D. Observe that a play agreeing with such a strategy cannot reach a vertex in the℘-attractor of X, because from such a vertex the opponent can force to leave D and enter X. Thus, the same strategies (after restricting them appropriately) witness that D is also a dominion in the smaller subgame; in particular D does not intersect with Attr℘(X, G).
Lemma 2.2. Let D be a dominion of a player ℘ in a subgame G, and let X ⊆ G be℘-closed in G. Then D ∩ X is a dominion of ℘ in X.
Proof. Because X is℘-closed in G, no vertex of ℘ in D ∩ X has a successor in G \ X. In consequence, strategies that witness D being a dominion of ℘ in G, after restricting them appropriately, witness D ∩ X being a dominion of ℘ in X.
Lemma 2.3. If all priorities in a non-empty dominion D of a player ℘ are at most d , and d is not of ℘'s parity, then D contains a non-empty sub-dominion C without vertices of priority d .
Proof. Fix a strategy σ for ℘ from some vertex v 0 ∈ D that is winning and agrees only with plays staying in D. To C we take all vertices v of D such that • there exists a finite path ρ v that ends in v and agrees with σ, and • there is no finite path ρ that extends ρ v , agrees with σ, and ends in a vertex of priority d (in particular, v itself is not of priority d ). Such a set C is nonempty; otherwise, it would be easy to construct a play that agrees with σ and visits priority d infinitely often (start from v 0 , continue to a vertex of priority d , which is possible because v 0 ∈ C, continue to an arbitrary successor v 1 , continue to a vertex of priority d , which is possible because v 1 ∈ C, and so on). Then, for a vertex v ∈ C we consider a strategy σ v such that σ v (ρ) = σ(ρ v · ρ) for all plays ρ starting in v; this strategy is winning for ℘ (if σ v agrees with a play ρ, then σ agrees with ρ v · ρ, and hence both these plays are winning) and agrees only with plays staying in C (by the definition of C).

A first quasipolynomial-time version
In this section we present our first quasipolynomial-time algorithm solving parity games. Informally, we refer to it as the Liverpool variant, since it is (close to) an algorithm introduced by Lehtinen, Schewe, and Wojtczak [LSW19], working at University of Liverpool.
We remark that, historically, the Liverpool variant came after the Warsaw variant, presented in the next section. We present the Liverpool variant first, as the "main variant", because it has better theoretical complexity and because we think that it is more elegant.
3.1. The algorithm. First, recall Zielonka's classic recursive algorithm. Each iteration first identifies the set N d of vertices of the highest priority, which we can assume to be even as the odd case is symmetric, and the E-attractor of N d . It then makes a recursive call to solve the rest of the game, which has one fewer priority. Odd's winning region in this subgame, as well as its O-attractor, is winning for Odd in the whole game, and is considered solved. The algorithm then iterates on the remaining arena, which is smaller than the original arena, until no more winning region for Odd is found, and the rest of the arena can be declared winning for Even. The depth of the recursion is bounded by the number of priorities, while To make this algorithm quasipolynomial-time, we weaken and parameterise the inductive guarantees of recursive calls. Instead of expecting a recursive call to solve a subgame, we ask that it provides a partition of the subgame into two regions, one which contains all of Odd's dominions of size up to a given parameter, and one which contains all of Even's dominions of size up to another parameter. These two parameters determine the precision of the recursive call; if they are both the size of the whole subgame, this corresponds to solving it entirely.
Using three recursive calls, our algorithm consecutively computes three regions, G \ G 1 , G 1 \ G 2 , and G 2 \ G 3 , which, together, contain all Odd's dominions of size up to the first parameter and no Even's dominion of size up to the second parameter. The first and the third region are based on calls that use half the precision parameter for Odd's dominions, and only the second region is computed using the full precision. Correctness of the algorithm hinges on proving that G \ G 1 and G 1 \ G 2 together cover already over the half of any small Odd's dominion, and hence the last call handles correctly what is left.
We present Solve E (G, d, p E , p O ), which, given a subgame G with priorities up to an even number d, returns a set of vertices containing all of Even's small dominions (of size up to p E ) and not intersecting any of Odd's small dominions (of size up to p O ). The dual, Remark 3.1. In Lehtinen, Schewe, and Wojtczak [LSW19], Line 3 of the above algorithm was replaced by We can see, however, that the call to Attr O in this expression adds no new vertices, meaning that such a line computes exactly the same set G 1 as our Line 3. Indeed, below, in Lemma 3.2, we show that the set returned by where d is even and not smaller than the maximal priority in G, returns a set that where d is odd and not smaller than the maximal priority in G, returns a set that Proof. The proof is by induction on the sum d+p E +p O . We present only the part concerning , as the other part is similar. When G = ∅ or p O ≤ 1, the whole G returned in Line 2 clearly satisfies the thesis: there exist no Odd's dominions of size 1. We proceed with G = ∅ and p O > 1.
We first show Item (i). By the induction hypotheses we know that G 1 is E-closed in G (which, in particular, allows us to use G 1 as a subgame in Line 5) and that Next, we show Item (ii), saying that the set returned by Solve E (G, d, p E , p O ) contains all Even's dominions of size up to p E . Let D be such a dominion. According to the induction hypothesis, D is contained in G 1 , and it is, moreover, an Even's dominion in H is an Even's dominion in H (cf. Lemma 2.2) and therefore, from the induction hypothesis, neither D nor D (containing additionally only vertices not in H) intersects with W O . In consequence, D is a dominion in G 2 (cf. Lemma 2.1) and, by the induction hypothesis, it is contained in the returned set G 3 .
We proceed with showing Item (iii), saying that the set returned by Solve E (G, d, p E , p O ) does not intersect with Odd's dominions of size up to p O . Let D be such a dominion, let S be the union of Odd's dominions of size up to p O /2 in the subgame induced by D, and let A be the O-attractor of S in this subgame.
Because D is O-closed in G (i.e., Even cannot force to leave D), A is contained in the O-attractor of S in the whole G. For the same reason, every Odd's dominion in the subgame D is an Odd's dominion in the whole G. Thus, by the induction hypothesis, S does not intersect with G 1 . Since (again by the induction hypothesis) We consider the case of A = D. Notice that D is a dominion not only in the whole G, but also in the subgame induced by D. In consequence, D \ A is a dominion in the subgame induced by D \ A (cf. Lemma 2.2; D \ A is E-closed in D). It contains a nonempty Odd's dominion C without vertices of priority d (cf. Lemma 2.3). The union C ∪ A is an Odd's dominion in D: inside C Odd has a winning strategy, which is valid as long as the play does not leave D \ A entering A; in A \ S Odd uses his strategy to reach S, and in S he uses his strategy from one of the small dominions covering S.
Note that the proof of Item (i) above also shows that is of size greater than p O /2 . So, by the induction hypothesis, D ∩ G 2 does not intersect with the returned set G 3 . The same holds for the whole D, because G 3 ⊆ G 2 .
3.3. Analysis. Let R(d, ) be the maximal number of calls to Solve E and Solve O performed during an execution of if d is odd, where = log p E + log p O (in this paper, log denotes the binary logarithm). We assume that p E ≥ 1 and p O ≥ 1.
An induction on + d shows that R(d, ) ≤ 2 +1 · d+ − 1. Indeed, if d = 0 (implying G = ∅) or = 0 (implying p E = p O = 1), then the execution finishes immediately, so R(d, ) = 1 ≤ 2 +1 · d+ − 1. For positive d and we have where 1 counts the main call itself, 2 · R(d, − 1) counts calls performed while executing Lines 3 and 8, and R(d − 1, ) counts calls performed while executing Line 6. Then, applying the induction hypothesis, we obtain that We now apply the inequality k ≤ ek for k = d + , obtaining Recall that while solving a parity game with n vertices, we start with p E = p O = n, that is, with = 2 · log n . One can check that the above function is increasing, meaning that we can replace by 2 · log n. We obtain that Observe that the cost of each call, excluding the cost of further calls performed recursively, is dominated by the attractor construction in Lines 5 and 7, which is linear in the number of edges in the game. We can also estimate log e ≤ 1.45.
Regarding the space complexity, we notice that the recursion has depth O(log n), and at each level of recursion we only need to store some sets of vertices of size O(n). The complexity is summarised in the following theorem: Theorem 3.3. Algorithm 1 computes winning regions in a given parity game. For a parity game with n vertices, m edges, and maximal priority d, its memory usage is in O(m+n·log n), and its running time is in The complexity result can be reformulated as follows: • When d = o(log n), the component d 2·log n converges to 0, meaning that the complexity becomes O m · n 4.9 (for n large enough we have that log 1 + d 2·log n ≤ 1.45 − log e). • This implies that our algorithm is an fpt-algorithm when d is treated as a parameter.

A variation
We now present Algorithm 2, the original algorithm of Parys [Par19], as a variation, which we refer to as the Warsaw version.
In Algorithm 1 there is one "central" call to Solve O for a subgame with less priorities, with unchanged precision parameters. This call is surrounded by two calls to Solve E , where we do not decrease the number of priorities, but we divide the precision parameter p O by 2. While executing each of these calls, we perform one call to Solve O for a subgame with less priorities, with p O divided by 2, which is now surrounded by two calls to Solve E for p O divided by 4. Thus, while looking at calls to Solve O for subgames with less priorities, we see that there is one central call with unchanged p O ; it is surrounded by two call with p O divided by 2; each of them is surrounded by two call with p O divided by 4, surrounded, in turn, by calls with p O divided by 8, and so on (this ends when the result of the division becomes smaller than 2).
In the variation, which we now present, this structure of recursive calls to Solve O is modified: we again perform one call with unchanged p O , but this time all the surrouning recursive calls use p O divided by 2 (not by powers of 2).
The variation is closer to the classic recursive algorithms, using only calls to games with less priorities. As a consequence, the number of calls is not capped (beyond the trivial cap of up to n calls for games with n vertices), but all calls refer to sub-games with reduced maximal priority, while all but one asks for lesser guarantees. We remark that, although the correctness proofs of Algorithms 1 and 2 are quite similar, there is also a lot of differences in details. For readability reasons, we have choosen to leave the two proofs independent. Proof. The proof is by induction on the sum d+p E +p O . We present only the part concerning Solve E (G, d, p E , p O ), as the other part is similar. When G = ∅ or p E ≤ 1, the empty set returned in Line 2 clearly satisfies the thesis: there exist no Even's dominions of size 1. We proceed with G = ∅ and p E > 1. Before starting, we remark that the loops terminate, as G shrinks in size in all iterations but the last one of each loop.
We first show Item (i), saying that the set returned by Solve E (G, d, p E , p O ) contains all Even's dominions of size up to p E . Let D be such a dominion.
For each repetition of the body of the repeat (Lines 4-7) and while (Lines 12-15) loops, as well as for Lines 9-10, we have the following inductive argument. Initially, D is an Even's dominion in G. Since H is O-closed in G, the intersection D of D and H is an Even's dominion in H (cf. Lemma 2.2) and therefore, from the induction hypothesis, neither D nor D (containing additionally only vertices not in H) intersects with the set W O (computed in Line 6/9/14). In consequence, D is a dominion in the newly computed set G in Line 7/10/15 (cf. Lemma 2.1).
From this argument it follows that D is contained in the set G when it is returned in Line 17.
We proceed with showing Item (ii), saying that the set returned by Solve E (G, d, p E , p O ) does not intersect with Odd's dominions of size up to p O . Let D be such a dominion.
For each repetition of the body of the repeat (Lines 4-7) and while (Lines 12-15) loops, as well as for Lines 9-10, we have the following inductive argument. Initially, D ∩ G is an Odd's dominion in G. Due to Lemma 2.2, D ∩ G is then again an odd dominion in G after execution of Line 7/10/15 (independent of how the respective set W O is calculated).
We now assume for contradiction that the intersection of D and G is non-empty in Line 17, and therefore that this intersection is non-empty throughout the whole execution of the procedure.
To establish the contradiction, we first observe that, in the last iteration of the repeat loop, W O is empty. By Lemma 2.3, the intersection of D and G, being non-empty, contains a nonempty Odd's dominion C in G without vertices of priority d and, by Lemma 2.1, C is an Odd's dominion in the subgame H = G \ Attr E (N d , G) computed in Line 5. As W O is empty, C (as well as its superset H) must be of size greater than p O /2 , as C would otherwise be contained in the empty set W O by the induction hypothesis.
As the set H from Line 5 is re-used in Line 9, it therefore contains the same Odd's dominion C. By the induction hypothesis, C is also contained in the region W O computed in Line 9. The intersection of D and the remaining game G produced in Line 10 is of size at most p O − ( p O /2 + 1) ≤ p O /2 , because all vertices in C are removed from G at that point.
Then, the same argument as for the repeat loop ensures that when the while loop finishes, the intersection of D and G contains an Odd's dominion C of size greater than p O /2 . This leads to a contradiction with the upper bound on the size of D ∩ G established in the previous paragraph. An induction on + d shows that R(d, ) ≤ 2 · n · d+ − 1, where n ≥ 1 is the number of vertices in the considered game G. Indeed, if d = 0 (implying G = ∅) or = 0 (implying p E = p O = 1), then the execution finishes immediately, so R(d, ) = 1 ≤ 2 · n · d+ − 1. For positive d and we have where 1 counts the main call itself, n · R(d − 1, − 1) counts calls performed while executing Lines 6 and 14, and R(d − 1, ) counts calls performed while executing Line 9. The calls with reduced parameters (Lines 6 and 14) are always done with games of decreasing size, and there is no game of size 1; thus, there is at most n of these calls (for games of size n, n − 1, . . . , 2 and then 0). Then, applying the induction hypothesis to the above formula, we obtain that We now apply the inequality k ≤ ek for k = d + , obtaining Recall that while solving a parity game with n vertices, we start with p E = p O = n, that is, with = 2 · log n . One can check that the above function is increasing, meaning that we can replace by 2 · log n. We obtain that This time, to each call to the procedure we associate the cost of the two attractor constructions, preceding and following this call. In consequence, the cost allocated to each call is again linear in the number of edges. Estimating log e ≤ 1.45, we obtain the following theorem: Theorem 4.2. Algorithm 2 computes winning regions in a given parity game. For a parity game with n vertices, m edges, and maximal priority d, its memory usage is in O(m+n·log n), and its running time is in The last equality above holds under the assumption d ≤ n. This is a reasonable assumption: clearly there are at most d different priorities, and they can be renumbered so that only consecutive numbers, from 1 to some upper bound, are used.
The main difference between the complexity here and in Section 3 is that here we have log n in the exponent. This means that the algorithm does not speed up in the common case where the number of priorities is significantly smaller than the number of vertices.

Optimisations
In this section we present some optimisations that can be applied to Algorithms 1 and 2. They do not improve the theoretical complexity, but they may (and actually they do) speed up the algorithm in practice, on some inputs. The check can be implemented by returning and using a "dirty" flag that marks whether the "p O ≤ 1" condition has been true in any of the sub-routines. For the basic version of the algorithm, at every step we were considering a nonempty Odd's dominion C in the subgame D ∩ G, not containing vertices of priority d. Now, instead of choosing such a dominion C arbitrarily, we should take the greatest one (it exists, because the union of two dominions is a dominion). This maximality implies that if C is strictly smaller than D ∩ G, then Attr O (C, D ∩ G) contains a vertex of the maximal priority d. Indeed, note that Attr O (C, D ∩ G) is itself an Odd's dominion in D ∩ G; thus it either equals C or contains a vertex of priority d. In the latter case we are done. In the former case, there is a nonempty dominion C in (D ∩ G) \ C, not containing vertices of priority d; the union C ∪ C is an Odd's dominion in D ∩ G, contradicting the maximality of C.
Having this, we observe as previously that if |C| ≤ p O /2 , then C is included in W O and thus removed from G. Moreover, if C does not cover the whole D ∩ G, then so the current loop continues. If |C| > p O /2 , then the repeat loop may finish without removing the whole C from G, and the remaining part of C is removed from G by the full precision call in Lines 9-10 (since clearly |C| ≤ p O ). After that, in the while loop, we always have |C| ≤ |D ∩ G| ≤ p O /2 , which, by the above, guarantees removal of all remaining vertices of D.

Evaluation
Our evaluation focuses on the performance of the presented algorithms on random parity games on the one hand and on so-called worst-case families on the other hand. In a nutshell, the results are without great surprises. On random games, which usually don't present much of a challenge for Zielonka's algorithm, its quasipolynomial-time variations are in general orders of magnitude slower. The exception is games that can be solved in very few iterations by Zielonka, such as random high-degree games, which seem to be solvable by the Warsaw quasipolynomial-time algorithm in just as few iteration. Furthermore, the Liverpool quasipolynomial-time algorithm, which has the best worst-case complexity, reliably requires more iterations than the Warsaw version, which has a higher worst-case complexity. On the families designed to trigger worst-case complexity in Zielonka's algorithm [Fri11b,BDM20,Gaz16], the story is different. By game-size 54, both quasipolynomial-time algorithms require fewer iterations than the standard recursive algorithm, and the difference in performance from then on grows at an exponential rate. On these families of worst-case games, as the theory predicts, the algorithm with better worst-case behaviour indeed requires fewer iterations.
6.1. Implementation. We have implemented the two algorithms presented in the paper, using all the optimisations from Section 5. For comparison, we have also implemented standard Zielonka's algorithm, where we apply Optimisation 5 from Section 5 (i.e., we use " for the condition of a loop). Our implementation involves the Oink framework [vD18] to read files with games and to confirm correctness of our solutions, but apart from that the implementation is independent.
To compare performance of the three algorithms, we use the number of iterations. Because the most costly operation in the procedure is the computation of an attractor, as a single iteration we count the fragment of code where an attractor for one player is computed, a subprocedure is called, and an attractor for the other player is computed (the first computation of an attractor is not present in Lines 9-10 of Algorithm 2, but anyway we count these two lines as an iteration). Note, however, that iterations are exactly the places where a subprocedure is called, so the number of iterations is actually equal to the number of recursive calls, minus one.
With the number of iterations as a convenient running time measure, our evaluation becomes independent from low-level optimisations or from a choice of hardware.
The implementations, together with detailed results of the evaluation, are available at https://github.com/pparys/qpt-parity.

Benchmarks.
Constructed parity games. Friedmann [Fri11a] was the first to show an exponential lower bound to the running time of Zielonka's recursive algorithm. Since then, several families designed to trigger worst-case behaviour in recursive algorithms have been proposed: some are more robust [BDM20], in the sense that they also provide lower bounds for many variations and optimisations of the standard algorithm; others provide stronger lower bounds [Gaz16]. Since here we do not study optimisation strategies, we choose to present the performance of our algorithm on Gazda's family of games, which provide the strongest lower bound we are aware of to date, namely Ω(2 n 3 ) [Gaz16]. From our observations, this is representative Random parity games. We use the PG-solver tools [FL14] to generate random parity games.
We study the algorithms both on games with high vertex degree and with low vertex degree. Overall, we have run our algorithms on 320 random games of sizes ranging from 100 to 2000; the number of priorities always corresponds to the number of vertices. For random games, the game size is a poor predictor of how many iterations are needed-for instance, in our sample, Zielonka's algorithm solves more random games with high degree of size 2000 than of size 200 in two iterations-we therefore don't report the sizes of the sample games in our graphs.
6.3. Results. We compare the implementations of the three algorithms, with all the optimisations from Section 5 included. We use the number of iterations required by each algorithm as a proxy for their performance. Random parity games. The size of randomly generated games does not generally predict the performance of the algorithms. On games of high degree, the algorithms agree on the relative difficulty of games; see Figure 2. Both Zielonka's algorithm and the Warsaw quasipolynomial-time version consistently solve these games in under 15 iterations, while the Liverpool version needs one to two orders of magnitude more iterations. The reason why the Warsaw version behaves like Zielonka's algorithm in this case is that differences only start if the recursion depth of the algorithms exceeds the logarithm of the game size; here the Warsaw version never runs out of bound, its call structure is the same as Zielonka's. On random games of low degree, see Figure 3, the two quasipolynomial-time versions only broadly tend to agree with Zielonka's algorithm on the relative difficulty of games. Again, the Warsaw quasipolynomial-time version seems to match Zielonka's algorithm on the easiest games, namely those that Zielonka's algorithm solves in under 15 iterations. However, in general both the Warsaw and Liverpool version require several orders of magnitude more iterations and the Warsaw version consistently outperforms the Liverpool version throughout.

Conclusion
We have presented two quasipolynomial-time algorithms solving parity games, working recursively. The main advantage of our recursive approach over previous quasipolynomialtime algorithms solving parity games lies in its simplicity: we perform a small modification of the straightforward Zielonka's algorithm. Our original hope was that, in practice, the quasipolynomial-time algorithms can be as fast as standard Zielonka's algorithm on typical inputs, while being faster (quasipolynomial instead of exponential) on worst-case inputs. This turned out to be only partially true: although our algorithms are not dramatically slower, a significant slowdown is visible (except for the Warsaw variant, in case of a really small number of iterations).
Czerwiński et al. [CDF + 19] argue that previous quasipolynomial-time algorithms solving parity games [CJK + 17, JL17, Leh18, FJdK + 19] are instances of a so-called separator approach. Then, they prove that every algorithm accomplishing this approach has to follow a structure of a universal tree (a tree into which every tree of a given size can be embedded), and they show a quasipolynomial lower bound for the size of such a tree-hence also for the running time of the algorithm. Our algorithms, on the one hand, are of a different style; they cannot be seen as instances of the separator approach, hence the lower bound does not apply to them. On the other hand, however, one can see that the trees of recursive calls in our two algorithms follow two particular constructions of universal trees. Furthermore, Jurdziński and Morvan [JM20] generalise our algorithms to a generic algorithm parameterised by a universal tree (any universal tree gives a correct algorithm, while our two variants are obtained by using particular universal trees). Arnold, Niwiński, and Parys [ANP21] show a similar generalisation, from a slightly different perspective of fixed-point evaluation; they also prove that universal trees are persistently present in their approach, resulting in a quasipolynomial lower bound for the number of recursive calls.
Finally, let us mention a recent result of Jurdziński, Morvan, Ohlmann, and Thejaswini [JMOT20]: they design an algorithm solving parity games that is symmetric (like our recursive algorithms), but simultaneously works in time proportional to the size of one universal tree, not to the size of a product of two such trees (thus the logarithm in the exponent is not multiplicated by 2, unlike for our Liverpool variant).