1 Introduction
1.1 Parity games.
A parity game
is played on a directed graph by two players who are called Even and Odd. A play starts at a designated vertex and then the players move by following outgoing edges forever, thus forming an infinite path. Every vertex of the graph is owned by one of the two players and it is always the owner of the vertex who moves by following an outgoing edge from the current vertex to the next one.
This completes the description of the dynamics of a play, but how do we declare the winner of an infinite path formed in this way? For this, we need to inspect positive integers that label all edges in the graph, which we refer to as edge priorities, or simply priorities. Player Even is declared the winner of a play if the highest priority that occurs infinitely many times is even, and otherwise player Odd wins; equivalently, the winner is the parity of the limsup (limes superior) of the priorities that occur in the play.
The principal algorithmic problem studied in the context of parity games is deciding the winner: given a game graph as described above and a starting vertex, does player Even have a winning strategy—a recipe for winning every play starting from the designated vertex, no matter what edges her opponent Odd follows whenever it is his turn to move.
Determinacy and complexity.
A positional strategy for Even is a set of edges that go out of vertices she owns—exactly one such edge for each of her vertices; Even uses such a strategy by always—if the current vertex is owned by her—following the unique outgoing edge that is in the strategy. Note that when Even uses a positional strategy, her moves depend only on the current vertex—they are oblivious to what choices were made by the players so far. A basic result for parity games that has notable implications is their positional determinacy [12, 28]: for every starting vertex, exactly one of the players has a winning strategy and hence the set of vertices is partitioned into the winning set for Even and the winning set for Odd; moreover, each player has a positional strategy that is winning for her from all starting vertices in her winning set.
An important corollary of positional determinacy is that deciding the winner in parity games is well characterized, i.e., it is both in NP and in coNP [13]. Several further complexity results suggest that it may be difficult to provide compelling evidence for hardness of solving parity games: deciding the winner is known to be also in UP and in coUP [23], and computing winning strategies is in PLS, PPAD, and even in their subclass CLS [9, 10]. Parity games share this intriguing complexitytheoretic status with several other related problems, such as meanpayoff games [33], discounted games, and simple stochastic games [8], but they are no harder than them since there are polynomial reductions from parity games to meanpayoff games, to discounted games, and to simple stochastic games [23, 33].
Significance and impact.
Parity games play a fundamental role in automata theory, logic, and their applications to verification and synthesis. Specifically, the algorithmic problem of deciding the winner in parity games is polynomialtime equivalent to the model checking in the modal calculus and to checking emptiness of automata on infinite trees with parity acceptance conditions [13], and it is at the heart of algorithmic solutions to the Church’s synthesis problem [29].
The impact of parity games goes well beyond their place of origin in automata theory and logic. We illustrate it by the resolutions of two longstanding open problems in stochastic planning and in linear programming, respectively, that were directly enabled by the ingenious examples of parity games given by Friedmann [18], on which the strategy improvement algorithm [32] requires exponentially many iterations. Firstly, Fearnley [15] has shown that Friedmann’s examples can be adapted to prove that Howard’s policy iteration
algorithm for Markov decision processes (MDPs) requires exponentially many iterations. Policy iteration has been wellknown and widely used in stochastic planning and AI since 1960’s, and it has been celebrated for its fast termination: until Fearnley’s surprise result, no examples were known for which a superlinear number of iterations was necessary. Secondly, Friedmann, Hansen, and Zwick
[19] have adapted the insights from the lower bounds for parity games and MDPs to prove that natural randomized pivoting rules in the simplex algorithmfor linear programming may require subexponentially many iterations. The following quote from the full version of Friedmann et al.
[19] highlights the role that parity games (PGs) played in their breakthrough:“our construction can be described and understood without knowing about PGs. We would like to stress, however, that most of our intuition about the problem was obtained by thinking in terms of PGs. Thinking in terms of MDPs seems harder, and we doubt whether we could have obtained our results by thinking directly in terms of linear programs.”
In both cases, Friedmann’s examples of parity games and their analysis have been pivotal in resolving the theoretical worstcase complexity of influential algorithms that for many decades resisted rigorous analysis while performing outstandingly well in practice.
Current stateoftheart.
It is a longstanding open question whether there is a polynomialtime algorithm for solving parity games [13]. The study of algorithms for solving parity games has been dominated for over two decades by algorithms whose runtime was exponential in the number of distinct priorities [14, 4, 31, 24, 32, 30], or mildly subexponential for large number of priorities [2, 26]. The breakthrough came in 2017 from Calude et al. [5] who gave the first quasipolynomialtime algorithm using the novel idea of play summaries. Several other quasipolynomialtime algorithms were developed soon after, including spaceefficient progressmeasure based algorithms of Jurdziński and Lazić [25] and of Fearnley, Jain, Schewe, Stephan, and Wojtczak [16], and the algorithm of Lehtinen [27], based on her concept of register games.
1.2 The separation approach.
Bojańczyk and Czerwiński [3, Section 3] have observed that the main technical contribution of Calude et al. [5] can be elegantly phrased using concepts from automata theory. They have pointed out that in order to reduce solving a parity game of size at most to solving a conceptually and algorithmically much simpler safety game, it suffices to provide a finite safety automaton that achieves the task of separating two sets and of infinite words that describe plays on graphs of size at most that are decisively won by the respective two players. For encoding plays in parity games, they use words in which every letter is a pair that consists of a vertex and a priority. The definition of such a word being decisively won by a player that was proposed by Bojańczyk and Czerwiński is that the biggest priority that occurs on every cycle—an infix in which the first vertex and the vertex immediately following the infix coincide—is of her parity. Concerning separation, for two disjoint languages and , we say that a language separates from if and , and we say that an automaton is a separator of two languages if the language of words recognized by separates them. The main technical contribution of Calude et al. [5] can then be stated as constructing separators—of quasipolynomial size—of the languages and .
Note that a separator of and has a significantly easier task than a recognizer of exactly the set LimsupEven of words that are won by Even—that is required to accept all words in LimsupEven, and to reject all words in LimsupOdd, the set of all words that are won by Odd. Instead, a separator may reject some words won by Even and accept some words won by Odd, as long as it accepts all words that are decisively won by Even, and it rejects all words that are decisively won by Odd.
What Calude et al. [5] exploit is that if one of the players uses a positional winning strategy then all plays are indeed encoded by words that are won decisively by her, no matter how the opponent responds. The formalization of Bojańczyk and Czerwiński [3] is that—using positional determinacy of parity games [12, 28]—in order to solve a parity game of size at most , it suffices to solve a strategically and algorithmically much simpler safety game that is obtained as a simple chained product of the parity game and a safety automaton that is a separator of and .
1.3 Our contribution.
Our main conceptual contributions include making explicit the notion of a universal ordered tree and unifying all the existing quasipolynomial algorithms for parity games [5, 25, 20, 16, 27] as instances of the separation approach proposed by Bojańczyk and Czerwiński [3].
We point out that it is exactly the universality property of an ordered tree that makes it suitable for serving as a witness search space in progress measure lifting algorithms [24, 1, 30, 25, 11], and that the running time of such algorithms is dictated by the size of the universal tree used. In particular, by proving a quasipolynomial lower bound on the size of universal trees in Section 2.4, we rule out the hope for improving progress measure lifting algorithms to work in subquasipolynomial time by finding smaller universal trees. As our other main technical results in Section 5 show, however, universal trees are fundamental not only for progress measure lifting algorithms, but for all algorithms that follow the separation approach.
We argue that in the separation approach, it is appropriate to slightly adjust the choice of languages to be separated, from and proposed by Bojańczyk and Czerwiński [3] to the more suitable and (see Section 3.1 for the definitions). We also verify, in Section 4, that all the three distinct techniques of solving parity games in quasipolynomial time considered in the recent literature (play summaries [5, 20, 16], progress measures [25], and register games [27]) yield separators for languages and LimsupOdd, which (as we argue in Section 3.2) makes them suitable for the separation approach.
The main technical contribution of the paper, described in Sections 2.4 and 5 is a proof that every (nondeterministic) safety automaton that separates from LimsupOdd has a number of states that is at least quasipolynomial. Recall that in Section 2.4 we establish a quasipolynomial lower bound on the size of universal trees. Then, in Section 5, our argument is based on proving that in every separating automaton as above, one can define a sequence of linear quasiorders on the set of states, in which each quasiorder is a refinement of the quasiorder that follows it in the sequence. Such a sequence of linear quasiorders can be naturally interpreted as an ordered tree in which every leaf is populated by at least one state of the automaton. We then also prove that the ordered tree must contain a universal ordered tree, and the main result follows from the earlier quasipolynomial lower bound for universal trees.
Another technical highlight, presented in Section 4.1, is a construction of a separator from an arbitrary universal tree, which together with the lower bound in Section 5 implies that the sizes of smallest universal trees and of smallest separators coincide. The correctness of the construction relies on existence of progress measures that map from vertices of game graphs into leaves of universal trees, and that witness winning strategies.
The significance of our main technical results is that they provide evidence against the hope that any of the existing technical approaches to developing quasipolynomial algorithms for solving parity games [5, 25, 16, 27] may lead to further improvements to subquasipolynomial algorithms. In other words, our quasipolynomial lower bounds for universal trees and separators form a barrier that all existing approaches must overcome in the ongoing quest for a polynomialtime algorithm for solving parity games.
2 Progress measures and universal trees
Progress measures are witnesses of winning strategies that underpin the design of the small progress measure lifting algorithm [24]. For nearly two decades, this algorithm and its variants [1, 30, 6, 25, 11] have been consistently matching or beating the worstcase performance guarantees of the stateoftheart algorithms for solving parity games.
In this section we introduce the notion of universal ordered trees and we point out how the universality property uniformly justifies the correctness of progress measure lifting algorithms, and that the size of universal trees used in such algorithms drives their worstcase runtime complexity. Those observations motivate the key technical question that we tackle in this section, namely whether the recent construction of quasipolynomial universal trees by Jurdziński and Lazić [25] can be significantly improved to yield a subquasipolynomial algorithms for solving parity games.
The main original technical contribution of this section is a negative answer to this question: we establish a quasipolynomial lower bound on the size of universal trees that nearly matches (up to a small polynomial factor) the upper bound of Jurdziński and Lazić. This dashes the hope of obtaining a significantly faster algorithm for solving parity games by constructing smaller universal trees and running the progress measure algorithm on them.
2.1 Game graphs and strategy subgraphs.
Throughout the paper, we write for the set of vertices and for the set of edges in a parity game graph, and we use to denote the numbers of vertices. For every edge , its priority is a positive integer, and we use to denote the smallest even number that priority of no edge exceeds. Without loss of generality, we assume that every vertex has at least one outgoing edge. We say that a cycle in a game graph is even if the largest edge priority that occurs on it is even; otherwise it is odd.
Recall that a positional strategy for Even is a set of edges that go out of vertices she owns—exactly one such edge for each of her vertices. The strategy subgraph of a positional strategy for Even is the subgraph of the game graph that includes all outgoing edges from vertices owned by Odd and exactly those outgoing edges from vertices owned by Even that are in the positional strategy. Observe that the set of plays that arise from Even playing her positional strategy is exactly the set of all plays in the strategy subgraph. Moreover, note that every cycle in the strategy subgraph of a positional strategy for Even that is winning for her is even: otherwise, by repeating an odd cycle indefinitely, we would get a play that is winning for Odd. Further overloading terminology, we say that a (parity game) graph is even if all cycles in it are even.
2.2 Ordered trees and progress measures.
An ordered tree is a prefixclosed set of sequences of a linearly ordered set. We refer to such sequences as tree nodes, we call the elements of such sequences branching directions, and we use the standard ancestordescendent terminology for nodes. For example: node is the root of a tree; node is the child of the root that is reached from the root via the branching direction ; node is the parent of node ; nodes , , and are ancestors of node ; and nodes and are descendants of nodes and . Moreover, a node is a leaf if it does not have any descendants. All nodes in an ordered tree are linearly ordered by the lexicographic order on sequences that is induced by the assumed linear order on the set of branching directions. For example, we have , and if . The depth of a node is the number of elements in the eponymous sequence, the height of a tree is the maximum depth of a node in it, and the size of a tree is the number of its leaves.
A tree labelling of a parity game is a mapping from the vertices in the game graph to leaves in an ordered tree of height ; for convenience and without loss of generality we assume that every leaf has depth . We write to denote such a leaf, and for every priority , , we define its truncation to be the sequence if is odd, and if is even. We say that a tree labelling of the game is a progress measure if the following progress condition holds for every edge in the strategy subgraph of some positional strategy for Even:

if is even then ;

if is odd then .
We recommend inspecting the (brief and elementary) proof of [25, Lemma 2], which establishes that every cycle in the strategy subgraph whose all edges satisfy the progress condition is even. It gives a quick insight into the fundamental properties of progress measures and it shows the easy implication in the following theorem that establishes progress measures as witnesses of winning strategies in parity games.
2.3 Finding tree witnesses on universal trees.
It is a straightforward but fruitful observation of Jurdziński and Lazić [25] that a progress measure on a game graph with vertices and at most distinct edge priorities is a mapping from the vertices in the game graph to nodes in an ordered tree of height at most and with at most leaves (all subtrees that no vertex is mapped to can be pruned). It motivates the fundamental concept that we introduce in this section—universal trees.
An universal (ordered) tree is an ordered tree, such that every ordered tree of height at most and with at most leaves can be isomorphically embedded into it; in such an embedding, the root of the tree must be mapped onto the root of the universal tree, and the children of every node must be mapped—injectively and in an orderpreserving way—onto the children of its image.
The following proposition follows directly from the above “straightforward but fruitful” observation and the definition of a universal tree.
[[25]] Every progress measure on a graph with vertices and with at most priorities can be seen as a map into an universal tree. We offer the following interpretation of the small progress measure lifting [24] and the succinct progress measure lifting [25] algorithms, highlighting the central role played in them by the concept of universal trees that we introduce here. Both algorithms perform an iterative search for a progress measure (a witness for a winning strategy for Even), and their search spaces are limited by restricting the labels considered in candidate tree labellings to leaves in specific universal trees. Where the two algorithms differ is the universal trees they use: in the former algorithm it is the full ary tree of height , and in the latter it is an ordered tree of height in which the branching directions are bit strings, where for every node, the total number of bits used in all its branching directions is bounded by .
We observe that what is common for both algorithms is that their correctness relies precisely on the universality property of the ordered tree from which the candidate labels are taken from. Indeed, if there is a witness for a winning strategy for Even in the form of a progress measure (whose existence is guaranteed by Theorem 2.2), then by Proposition 2.3, it suffices to look for one that uses only leaves of a universal tree as labels. The original papers [24, 25] contain the technical details of the iterative scheme that both algorithms use. Here, we highlight the following two key insights about the design and analysis of those algorithms:

each algorithm computes a sequence of tree labellings that is monotonically increasing (w.r.t. the pointwise lexicographic order), while maintaining the following invariant: the current labelling is pointwise lexicographically smaller than or equal to every progress measure;

the worstcase runtime bound for the algorithm is determined (up to a small polynomial factor) by the size of the universal tree used.
Using our interpretation of the progress measure lifting algorithms and the terminology of universal trees, the small progress measure lifting algorithm [24] is using a tree whose universality is straightforward, and whose size——is exponential in the number of priorities. On the other hand, the main technical contribution of Jurdziński and Lazić—that yields their quasipolynomial succinct progress measure lifting algorithm [25, Theorem 7]—can be stated as the following quasipolynomial upper bound on the size of universal trees.
[[25, Lemmas 1 and 6]] For all positive integers and , there is an universal tree with at most quasipolynomial number of leaves. More specifically, the number of leaves is at most , which is polynomial in if ; it is if ; and—more crudely—it is always . A natural question then arises, whether one can significantly improve the worstcase upper bounds on the runtime complexity of solving parity games by designing significantly smaller universal trees. We give a negative answer to this question in the next section.
2.4 Smallest universal trees are quasipolynomial.
The main technical result in this section is a quasipolynomial lower bound on the size of universal ordered trees that matches the upper bound in Theorem 2.3 up to a small polynomial factor. It follows that the smallest universal ordered trees have quasipolynomial size, and hence the worstcase performance of progress measure lifting algorithms [24, 25] cannot be improved to subquasipolynomial by designing smaller universal ordered trees.^{1}^{1}1The quasipolynomial lower bound on the size of universal trees has appeared in the technical report [17], which is subsumed by this paper.
For all positive integers and , every universal tree has at least leaves, which is at least provided that . This lower bound result shares some similarities with a result of Goldberg and Lifschitz [21], which is for universal trees of a different kind: the height is not bounded and the trees are not ordered.
First, we give a derivation of the latter bound from the former; we show that
provided that . We start from the inequality applied to the binomial coefficient , and take the of both sides. This yields
where the second inequality follows since , and the third by the assumption that .
To prove the first bound, we proceed by induction and show that any universal tree has at least leaves, where
, and .
The bounds are clear for or .
Let be a universal tree, and . We claim that the number of nodes at depth of degree greater than or equal to is at least .
Let be the subtree of obtained by removing all leaves and all nodes at depth of degree less than : the leaves of the tree have depth exactly .
We argue that is universal. Indeed, let be a tree with leaves all at depth . To each leaf of we append children, yielding the tree which has leaves all at depth . Since is universal, the tree embeds into . Observe that the embedding induces an embedding of into , since the leaves of have degree in , hence are also in .
Let be the number of nodes at depth with degree exactly . So far we proved that the number of nodes at depth of degree greater than or equal to is at least , so
Thus the number of leaves of is
It remains to prove that
(1) 
Define for and . Then we have
To obtain a lower bound on we define by
so that . We verify by induction that , which follows from Pascal’s identity
This implies that , from which (1) follows.
3 The separation approach
3.1 Languages of play encodings.
The outcome of the two players interacting in a parity game by making moves is an infinite path in the game graph. We encode such infinite paths as infinite words over the alphabet in a natural way: each move—in which an edge is followed—is encoded by the letter , i.e., the priority of edge .
We write for the set of infinite words in which the biggest number that occurs infinitely many times is even, and we write for the set of infinite words in which that number is odd. Observe that sets and form a partition of the set of all infinite words over the alphabet . As intended, an infinite play in a parity game graph (of arbitrary size) with edge priorities not exceeding is winning for Even if and only if the infiniteword encoding of the play is in .
Recall that a (parity game) graph is called even if every cycle in it is even (i.e., the highest priority that occurs on the cycle is even). For all positive integers and , we define the language to consist of infinite words that encode an infinite path in an even graph with at most vertices and priorities. The languages can be thought of as finitary underapproximations of the language because
Languages —that can be thought of as finitary underapproximations of the language —are defined in an analogous way.
3.2 Safety automata and games.
The fundamental and simple model that the statement of our main technical result formally refers to is a (nondeterministic) safety automaton. Superficially, it closely resembles the classic model of finite automata: each safety automaton has a finite set of states, a designated initial state, and a transition relation. (Without loss of generality, we assume that the transition relation is total, i.e., for every state and letter , there is at least one state , such that the triple is in the transition relation.) The differences between our model of safety automata and the classic model of finite automata with designated accepting states are as follows:

safety automata are meant to accept or reject infinite words, not finite ones;

a safety automaton does not have a designated set of accepting states; instead it has a designated set of rejecting states;

a safety automaton accepts an infinite word if there is an infinite run of the automaton on the word in which no rejecting state ever occurs; otherwise it rejects the infinite word.
We say that a safety automaton is deterministic if the transition relation is a function: for every state and letter , there is a unique state , such that the triple is a transition.
Finally, we define the elementary concept of safety games, which are played by two players on finite directed graphs in a similar way to parity games, but the goals of the players are simpler than in parity games: the safety player wins if a designated set of unsafe vertices is never visited, and otherwise the opponent (sometimes called the reachability player) wins.
3.3 Safety separating automata.
For positive integers and , we say that an automaton is an separator if it is a separator of and ; and we say that it is a strong separator if it is a separator of and . Note that if an automaton is a strong separator then it is also an separator, but not every separator is strong.
To illustrate the concept of a (strong) separator, we present a simple “multicounter” strong separator that is implicit in the work of Bernet et al. [1]. We define the automaton that, for every odd priority , , keeps a counter that stores the number of occurrences of priority since the last occurrence of a priority larger than (even or odd). It is a safety automaton: it rejects a word immediately once the integer stored in any of the counters exceeds .
In fact, instead of “counting up” (from to ), we prefer to “count down” (from to ), which is equivalent, but it aligns better with the definition of progress measures. More formally, we define the deterministic safety automaton in the following way:

the set of states of is the set of sequences , such that is an integer such that for every odd , ; and it also contains an additional rejecting state ;

the initial state is ;

the transition function is defined so that for all , and is equal to:

if is even,

if is odd and ,

if is odd and .

Note that the size of automaton is .
Firstly, we argue that if the unique run of on an infinite word contains an occurrence of the rejecting state then the word is not in . Indeed, the only reason for the unique run of to reach the rejecting state is that the state reached after reading some prefix of the word is with for an odd , and is subsequently read. For this to happen, there must be a suffix of the prefix in which there are occurrences of priority and no priority higher than occurs, and the currently read letter is the st occurrence of priority in the prefix. We argue that if the input word is an encoding of an infinite play in an even graph with at most vertices then—by the pigeonhole principle—there is a cycle in the graph in which the highest priority is , which contradicts the assumption that the graph was even. It follows that the infinite word is not in .
Secondly, we argue that if a word is in then the unique run of on the word contains an occurrence of the rejecting state. Consider an infinite suffix of the word in which all priorities occur infinitely many times. Unless the unique run reached the rejecting state on the corresponding prefix already, let be the state reached in the unique run at the end of the prefix. By the assumption that the word is in , the highest priority that occurs in the suffix is odd and it occurs infinitely many times. Take the shortest prefix of the suffix in which the highest priority occurs times. The unique run of on the original infinite word reaches the rejecting state upon reading that prefix.
3.4 The separation approach.
We now explain how safety separating automata allow to reduce the complex task of solving a parity game to the (conceptually and algorithmically) straightforward task of solving a safety game, by exploiting positional determinacy of parity games. This is the essence of the separation approach that implicitly underpins the algorithms of Bernet, Janin, and Walukiewicz [1] and of Calude et al. [5], as formalized by Bojańczyk and Czerwiński [3, Chapter 3]. Here, we only consider the simple case of deterministic automata. We postpone the discussion of using nondeterministic automata in the separation approach to Sections 4.3 and 4.4, which is the only place where nondeterminism seems to be needed.
Given a parity game with at most vertices and priorities up to , and a deterministic safety automaton with input alphabet , we define a safety game as the chained product , in which

the dynamics of play and ownership of vertices is inherited from the parity game ;

the automaton is fed the priorities of the edges corresponding to the moves made by the players;

the safety winning condition is the safety acceptance condition of the automaton .
If is a parity game with vertices and priorities up to , and if is a deterministic safety separator, then Even has a winning strategy in if and only if she has a winning strategy in the chainedproduct safety game .
If Even has a winning strategy in the parity game then—by positional determinacy [12, 28]—she also has one that is positional. We argue that if Even uses such a positional winning strategy in when playing the chainedproduct game , then she also wins the latter. Indeed, the strategy subgraph of the positional winning strategy for Even in is an even graph with at most vertices, and hence all words that are fed to the automaton are in , and hence they are accepted by .
Otherwise, Odd has a positional winning strategy in , and it can be transferred to a winning strategy for him in in the same way as we argued for Even above.
In the rest of the paper, we focus on strong separators for two reasons. Firstly—as described in Section 4—all the known quasipolynomial algorithms for parity games are underpinned by strong separators. Secondly, our proof of the quasipolynomial lower bound in Section 5 only applies to strong separators.
4 Separating automata everywhere
In this section we argue that the three distinct techniques that have been developed so far for designing quasipolynomial algorithms for solving parity games can be unified as instances of the separation approach introduced in the previous section. The main unifying aspect that we highlight in this section is that all the three approaches yield constructions of separating automata of quasipolynomial size, which provides evidence of significance of our main technical result: the quasipolynomial lower bound on the size of separators (Theorem 5) forms a barrier that all of those approaches need to overcome in order to further significantly improve the known complexity of solving parity games. We note that, in contrast to the results of Calude et al. [5] and Lehtinen [27], not all of the proposed quasipolynomial algorithms explicitly construct separating automata or other objects of (at least) quasipolynomial size [25, 16], but in the worst case, they too enumerate structures that form the states of the related separating automata (leaves in a universal tree and play summaries, respectively).
In Section 4.1 we generalize the simple separator described in Section 3.3 to a construction that creates strong separators from arbitrary universal trees. This result implies that the main combinatorial structure underlying all the progress measure lifting algorithms [24, 1, 30, 6], including the quasipolynomial succinct progress measure lifting of Jurdziński and Lazić [25, 11], is intimately linked to the separation approach. In Section 4.2, we briefly discuss the observation of Bojańczyk and Czerwiński [3] that Calude et al.’s [5] play summaries construction can be straightforwardly interpreted as defining a separating automaton; we refer the reader to their very readable technical exposition. Finally, in Sections 4.3 and 4.4, we discuss how to adapt the separation approach to also encapsulate the most recent quasipolynomial algorithm for solving parity games by Lehtinen [27], based on register games. This requires care because, unlike the constructions based on play summaries and universal trees, separating automata that underpin Lehtinen’s reduction from parity games to register games seem to require nondeterminism, and in general, Proposition 3.4 does not hold for nondeterministic automata.
4.1 Separating automata from universal trees.
For positive integers and , such that is even, let be the set of leaves in an universal tree. The definition of the deterministic safety automaton bears similarity to the definition of the simple “multicounter” separator from Section 3.3. Again, the states are sequences of “counters”, but the “counting down” is done in a more abstract way than in , using instead the natural lexicographic order on the nodes of the universal tree.
More formally, we define a deterministic safety automaton in the following way:

the set of states of is the set of leaves in the universal tree together with an additional state;

the initial state is the largest leaf (in the lexicographic tree order) and the only rejecting state is ;

the transition function is defined so that for all , and if then is equal to:

the largest leaf such that if is even,

the largest leaf such that if is odd,

if is odd and no such leaf exists.

Remark 4.1
Let be an ordered tree in which all the leaves have depth and every nonleaf node has exactly children; note that is trivially an universal tree. An instructive exercise that we recommend is to compare the structures of the automaton based on the universal tree and of the simple separating automaton from Section 3.3.
For every universal tree, the safety automaton is a strong separator.
First we prove that if an infinite word is in then it is accepted by the safety automaton . Let be an even graph with at most vertices and priorities up to , in which occurs as an encoding of an infinite path; let be the sequence of vertices in the infinite path in . By Theorem 2.2 and Proposition 2.3, there is a progress measure that maps vertices in into the set of leaves in the universal tree. Consider the unique run of on the word , where is the initial state of and we have for all positive integers . By the definition of the initial state in , we have that , and the definition of the transition function of allows to establish—by a straightforward induction on —that for all positive integers . It follows that the run never reaches the state, and hence the run is accepting.
Now we argue that for every infinite word in , the unique run of on it eventually reaches the state. Our argument is a generalization of the corresponding one in the proof of Proposition 3.3. Consider an infinite suffix of the word in which all priorities occur infinitely many times. Unless the unique run reached the rejecting state on the corresponding prefix already, let be the state reached in the unique run at the end of the prefix. Let be the highest priority that occurs in ; by the assumption that is in , the priority is odd. Let be the unique run of on : for every positive integer , we have . Note that is a suffix of the unique run of on . By the definition of the transition function of , if and are not equal to the state then , and if then . Therefore, unless for some positive integer , there is an infinite subsequence of whose truncations form a strictly decreasing sequence, which contradicts finiteness of the set of states of .
The following can be obtained by using the nearly optimal quasipolynomial universal trees from Theorem 2.3 in the construction of the automaton .
There are deterministic safety automata that are strong separators of size .
4.2 Separating automata from play summaries.
Bojańczyk and Czerwiński [3, Chapter 3] give an accessible exposition of how the breakthrough result of Calude et al. [5] can be viewed as a construction of a deterministic automaton of quasipolynomial size that separates from , which implies separation of from .
One superficial difference between our exposition of separators and theirs is that we use the model of safety automata, while they consider the dual model of reachability automata instead. (In reachability automata, an infinite word is accepted if and only if one of the designated accepting states is reached; otherwise it is rejected.) If, in Bojańczyk and Czerwiński’s construction, we swap the roles of players Even and Odd, and we make the accepting states rejecting, we get a safety automaton that separates from .
4.3 Nondeterministic automata and the separation approach.
The possible usage of nondeterministic automata in the separation approach to solving parity games is less straightforward. First of all, the game dynamics needs to be modified to explicitly include the choices that resolve nondeterminism in every step. We give the power to make those choices to Even, but this extra power does not suffice to make her win the chainedproduct game whenever she has a winning strategy in the original parity game. The reason for this failure in transferring winning strategies from the parity game to the chainedproduct safety game is that in arbitrary nondeterministic automata it may be impossible to successfully resolve nondeterministic choices at a position in the input word without knowing the letters at the later positions. In the game, however, the play is a result of the future choices of both the player and her opponent, and the former cannot predict the latter.
A wellknown example of nondeterministic automata for which the chainedproduct game is equivalent to the original game is the class of goodforgames automata [22]. They have the desired property that the nondeterministic choices of the automaton can always be resolved based only on the letters in the word at the positions up to the current one, thus making it possible to continue constructing an accepting run for all words accepted by the nondeterministic automaton that have the word read so far as a prefix.
We consider a weaker property than the one mentioned above, one that is sufficient for strategy transfer in the context of the separation approach. We say that a nondeterministic automaton is a goodforseparation strong separator if for every parity game with at most vertices and priorities, in the chainedproduct game , there is a way to resolve the nondeterministic choices of based only on the prefix of the play so far, in such a way that a construction of an accepting run can be continued for all words in (but not necessarily for all the words accepted by ).
More formally, a nondeterministic automaton is a goodforseparation strong separator if it rejects every word in , and for every even game with vertices and priorities up to , there is a winning strategy for Even in the chainedproduct game . We note that the automata that can be derived using Lehtinen’s techniques [27] are goodforseparation and hence they are suitable for being used in the separation approach.
Note that our quasipolynomial lower bound in Section 5 holds for all nondeterministic strong separators, regardless of their suitability for strategy transfer and for solving parity games using the separation approach.
4.4 Separating automata from register games.
First, we recall the definition of a (nondeterministic) parity automaton. Like safety automata, parity automata process infinite words, but instead of having designated rejecting states, every transition has a priority, which is a positive integer. The set of transitions consists of tuples of the form : such a transition has priority , and when reading a letter in state , the automaton moves to state . We say that a run of a parity automaton on an infinite word is accepting if the highest transition priority that occurs infinitely often is even; otherwise it is rejecting. The automaton recognizes the language of all words on which it has an accepting run. The following observation is straightforward. For every positive integer , there is a deterministic parity automaton , with state and priorities, that recognizes the language . Indeed, it suffices to equip the transition relation with transitions , where is the unique state of , for all . Observe that recognizing the language implies being a strong separator for all positive integers : a much stronger property than being a strong separator for some positive integer . Since the automaton is deterministic, it is in principle suitable for the separation approach applied to games with distinct priorities. Note, however, that using it brings no tangible benefit for solving parity games: the chainedproduct game has as few vertices as the original game , but its number of distinct priorities is no smaller.
We argue that the key technical result in the recent work of Lehtinen [27] can be interpreted as proving the following theorem. [[27]] For all positive integers and , there is a goodforseparation parity automaton , with at most states and priorities, that is a strong separator. Note that this theorem does indeed bring tangible benefits for solving parity games (via the separation approach) because if a parity game has vertices and priorities, then the chainedproduct game has only a quasipolynomial number of vertices and a logarithmic number of priorities. Even if an unsophisticated algorithm—with runtime that is exponential in the number of priorities—is used to solve the chainedproduct game , the overall runtime is quasipolynomial.
For every parity game , Lehtinen defines the corresponding register game , whose vertices consist of vertices of game together with sequences of the socalled registers that hold priorities, i.e., numbers from the set . The game is played on a copy of in the usual way, additionally at her every move player Even is given a chance—but not an obligation—to “reset” one of the registers, and each register always holds the biggest priority that has occurred since it was last reset.
What needs explaining is what “resetting a register” entails. When the register at position is reset, then the next register sequence is , that is registers at positions to are promoted to positions to , respectively, and the justreset register is now at position and it has value . Moreover—and very importantly for Lehtinen’s construction—resetting the register at position causes the even priority to occur in game if the value in the register was even, and the odd priority otherwise. If, instead, Even decides not to reset any register then the odd priority occurs.
Lehtinen’s main technical result is that the original parity game and the register game have the same winners. She proves it by arguing that if Even has a (positional) winning strategy in then she has a strategy of resetting registers in so that she again wins the parity condition (albeit with the number of priorities reduced from an arbitrarily large in to only in ). Our approach is to separate the graph structure from Lehtinen’s mechanism to capture the original parity winning condition using registers. We now define an automatatheoretic analogue of her construction in which we use nondeterminism to model the ability to pick various resetting strategies.
For all positive numbers and , such that is even, we define the nondeterministic parity automaton in the following way.

The set of states of is the set of nonincreasing sequences of “registers” that hold numbers in . The initial state is .

For every state and letter , we define the update of by to be the state , where is the smallest such that .

For every state and for every , , we define the reset of to be the state .

For every state and letter , there is a transition of priority in the transition relation, and where is the update of by ; we call this a nonreset transition.

For every state , letter , and for every , , if is the update of by and is even, then there is a transition of priority in the transition relation, where is the reset of . We say that this transition is an even reset of register .

For every state , letter , and for every , , if is the update of by and is odd, then there is a transition of priority in the transition relation, where is the reset of . We say that this transition is an odd reset of register .
The states of are monotone sequences of length , consisting of positive integers no larger than , and hence their number is bounded by , which is . We note that the register game that Lehtinen constructs from a parity game is essentially the same as the chainedproduct game .
The proof that the parity automaton is a strong separator can be obtained by adapting Lehtinen’s proofs showing that the register index of a parity game with vertices is at most [27, Theorem 4.7] and that a winning strategy for Odd in a parity game yields a winning strategy for him in the corresponding register game [27, Lemma 3.3]. We refer an interested reader to Lehtinen’s paper for the details. We note, however, that the strategy for resetting registers in the register game (and hence also in the chainedproduct game ) that Lehtinen constructs in the proof of [27, Theorem 4.7] depends only on the current content of the registers and the current vertex in the game. This property implies that the automata are goodforseparation separators in the sense discussed in Section 4.3.
We stress that the quasipolynomial lower bound for the size of strong separators that we establish in Section 5 applies to safety automata, but not to parity automata such as .
On the other hand, we argue that the parity automata can be turned into goodforseparation safety separators by taking a chained product with other deterministic safety separators. Let be a parity automaton over the alphabet and with transition priorities, and let be a safety automaton over the alphabet . Consider the following chainedproduct automaton .

The set of states is the set of pairs , where is a state of and is a state of . The initial state is the pair of the initial states of the two automata. A state is rejecting if is rejecting in .

If is a transition in , where is the letter read by the transition and is the priority of the transition, and if is a transition in (for deterministic automata, we often write instead), then is a transition in .
Let be the number of states in the parity register automaton and let be an upper bound on its priorities.
If is a deterministic safety strong separator then the chainedproduct automaton is a safety goodforseparation strong separator.
Let be an even graph with vertices and priorities up to . Careful inspection of Lehtinen’s proof of [27, Theorem 4.7] reveals that Even has a positional winning strategy in the chainedproduct game . Note that the strategy subgraph of that strategy is even, and that it has at most vertices and priorities up to . Since is a deterministic separator, on every path in the unique run of on the sequence of priorities that occur on the path is accepting. It follows that in the game , using strategy on the component guarantees that Even always wins, and hence Even has a winning strategy in the equivalent game .
On the other hand, every word in is rejected by because it is a strong separator. It follows that in every run of on such a word, the highest transition priority that occurs infinitely often is odd. In other words, in every run of the chainedproduct automaton on such a word, the word over the alphabet that is fed into the automaton is in , and hence it is rejected because is a strong separator.
5 Universal trees inside separating automata
The main result established in this section, and a main technical contribution of the paper, is the following quasipolynomial lower bound on the size of all safety strong separators.
Every nondeterministic safety strong separator has at least states, which is at least . Since the currently known quasipolynomial time algorithms for solving parity games implicitly or explicitly construct a separating automaton [5, 25, 16, 27], the size of which dictates the complexity, this result explains in a unified way the quasipolynomial barrier. Moreover, our proof of the theorem pinpoints universal trees as the underlying combinatorial structure behind all the recent algorithms, by establishing that there is an universal tree hiding in the set of states of every safety strong separator.
If is a (nondeterministic) safety strong separator then there is an injective mapping from the leaves of some universal tree into the states of . Note that Theorem 5 follows from Lemma 5 by applying Therem 2.4—our quasipolynomial lower bound for universal trees, because .
We prove Section 5 in two steps. In the first step, we show that every safety strong separator has a treelike structure (Section 5.1). Then, assuming this special structure, we prove that there is a universal tree whose leaves can be injectively mapped into the set of states of (Section 5.2).
5.1 Treelike structure.
A binary relation on a set is called a linear quasiorder if it is reflexive, transitive, and total (i.e. such that for all either , or , or both). If and , then we write . An equivalence class of is a maximal set such that and for all . It is wellknown that the equivalence classes of form a partition of and given two equivalence classes and , there exist and such that if and only if for all and , . When this is the case, it is denoted by , and when additionally .
Given two linear quasiorders and , we write if for all , implies . In that case, any equivalence class of is formed with a partition of equivalence classes of . In other words, an equivalence class of is included in a unique equivalence class of and disjoint from the other ones.
For an automaton over the alphabet , a treedecomposition of is a sequence of linear quasiorders on the set of nonrejecting states of such that:

if is a transition in then for all such that .

if is a transition in and is odd then for all such that .

has a single equivalence class, containing all nonrejecting states of .
In other words, reading a priority cannot cause an increase with respect to orders with indices greater than it, and additionally reading an odd priority necessarily causes a decrease with respect to orders whose indices are smaller than or equal to this priority. If there is a treedecomposition of , we say that is treelike. Given a tree decomposition of , we define the tree of , denoted , as follows (recall the notation for ordered trees from Section 2.2):

nodes of the are sequences , where is odd, , and where every branching direction is an equivalence class of the quasiorder , such that ,

the order between branching directions being equivalence classes of is when .
Notice that for a nonrejecting state of , there is a unique sequence where for every , is an equivalence class of containing . One can thus assign a nonrejecting state to the corresponding leaf in such a way that for every odd priority , if and only if the truncation of the leaf assigned to is smaller in the lexicographic order than the truncation of the leaf assigned to .
An automaton is accessible if for every state there exists a run from an initial state to , and moreover, if is nonrejecting, there exists such a run which does not go through any rejecting state. The first of the two steps of the proof of Section 5 can be summarized by the following lemma.
Every accessible nondeterministic safety strong separator is treelike.
Comments
There are no comments yet.