Universal trees grow inside separating automata: Quasi-polynomial lower bounds for parity games

07/27/2018
by   Wojciech Czerwiński, et al.
0

Several distinct techniques have been proposed to design quasi-polynomial algorithms for solving parity games since the breakthrough result of Calude, Jain, Khoussainov, Li, and Stephan (2017): play summaries, progress measures and register games. We argue that all those techniques can be viewed as instances of the separation approach to solving parity games, a key technical component of which is constructing (explicitly or implicitly) an automaton that separates languages of words encoding plays that are (decisively) won by either of the two players. Our main technical result is a quasi-polynomial lower bound on the size of such separating automata that nearly matches the current best upper bounds. This forms a barrier that all existing approaches must overcome in the ongoing quest for a polynomial-time algorithm for solving parity games. The key and fundamental concept that we introduce and study is a universal ordered tree. The technical highlights are a quasi-polynomial lower bound on the size of universal ordered trees and a proof that every separating safety automaton has a universal tree hidden in its state space.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

08/30/2021

Beyond Value Iteration for Parity Games: Strategy Iteration with Universal Trees

Parity games have witnessed several new quasi-polynomial algorithms sinc...
10/11/2018

Parity games and universal graphs

This paper is a contribution to the study of parity games and the recent...
01/13/2020

A Universal Attractor Decomposition Algorithm for Parity Games

An attractor decomposition meta-algorithm for solving parity games is gi...
02/19/2019

Lower bounds on separation automata for Parity Games

Several recently developed quasi-polynomial time algorithms for Parity G...
01/29/2018

An Optimal Value Iteration Algorithm for Parity Games

The quest for a polynomial time algorithm for solving parity games gaine...
05/02/2022

Smaller Progress Measures and Separating Automata for Parity Games

Calude et al. have recently shown that parity games can be solved in qua...
12/17/2018

The complexity of mean payoff games using universal graphs

We study the computational complexity of solving mean payoff games. This...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 co-NP [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 co-UP [23], and computing winning strategies is in PLS, PPAD, and even in their subclass CLS [9, 10]. Parity games share this intriguing complexity-theoretic status with several other related problems, such as mean-payoff 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 mean-payoff 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 polynomial-time 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 long-standing 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 well-known 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 algorithm

for 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 worst-case complexity of influential algorithms that for many decades resisted rigorous analysis while performing outstandingly well in practice.

Current state-of-the-art.

It is a long-standing open question whether there is a polynomial-time algorithm for solving parity games [13]. The study of algorithms for solving parity games has been dominated for over two decades by algorithms whose run-time 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 quasi-polynomial-time algorithm using the novel idea of play summaries. Several other quasi-polynomial-time algorithms were developed soon after, including space-efficient progress-measure 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 quasi-polynomial 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 quasi-polynomial 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 quasi-polynomial 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 sub-quasi-polynomial 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 quasi-polynomial 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 (non-deterministic) safety automaton that separates from LimsupOdd has a number of states that is at least quasi-polynomial. Recall that in Section 2.4 we establish a quasi-polynomial 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 quasi-orders on the set of states, in which each quasi-order is a refinement of the quasi-order that follows it in the sequence. Such a sequence of linear quasi-orders 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 quasi-polynomial 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 quasi-polynomial algorithms for solving parity games [5, 25, 16, 27] may lead to further improvements to sub-quasi-polynomial algorithms. In other words, our quasi-polynomial lower bounds for universal trees and separators form a barrier that all existing approaches must overcome in the ongoing quest for a polynomial-time 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 worst-case performance guarantees of the state-of-the-art 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 worst-case run-time complexity. Those observations motivate the key technical question that we tackle in this section, namely whether the recent construction of quasi-polynomial universal trees by Jurdziński and Lazić [25] can be significantly improved to yield a sub-quasi-polynomial algorithms for solving parity games.

The main original technical contribution of this section is a negative answer to this question: we establish a quasi-polynomial 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 prefix-closed 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 ancestor-descendent 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.

[[12, 24]] Even has a winning strategy from every vertex in a parity game if and only if there is a progress measure on the game graph.

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 order-preserving 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 worst-case run-time 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 quasi-polynomial succinct progress measure lifting algorithm [25, Theorem 7]—can be stated as the following quasi-polynomial 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 quasi-polynomial 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 worst-case upper bounds on the run-time 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 quasi-polynomial.

The main technical result in this section is a quasi-polynomial 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 quasi-polynomial size, and hence the worst-case performance of progress measure lifting algorithms [24, 25] cannot be improved to sub-quasi-polynomial by designing smaller universal ordered trees.111The quasi-polynomial 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 infinite-word 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 under-approximations of the language because

Languages —that can be thought of as finitary under-approximations 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 (non-deterministic) 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 “multi-counter” 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 .

[[1, 3]] The safety automaton is a strong -separator.

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 non-deterministic automata in the separation approach to Sections 4.3 and 4.4, which is the only place where non-determinism 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 chained-product 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 chained-product 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 quasi-polynomial algorithms for parity games are underpinned by strong -separators. Secondly, our proof of the quasi-polynomial 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 quasi-polynomial 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 quasi-polynomial size, which provides evidence of significance of our main technical result: the quasi-polynomial 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 quasi-polynomial algorithms explicitly construct separating automata or other objects of (at least) quasi-polynomial 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 quasi-polynomial 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 quasi-polynomial 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 non-determinism, and in general, Proposition 3.4 does not hold for non-deterministic 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 “multi-counter” 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 non-leaf 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 quasi-polynomial -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 quasi-polynomial 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 .

[[5, 3]] The play summaries data structure of Calude et al. yields deterministic safety automata that are strong -separators of size .

4.3 Non-deterministic automata and the separation approach.

The possible usage of non-deterministic 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 non-determinism 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 chained-product 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 chained-product safety game is that in arbitrary non-deterministic automata it may be impossible to successfully resolve non-deterministic 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 well-known example of non-deterministic automata for which the chained-product game is equivalent to the original game is the class of good-for-games automata [22]. They have the desired property that the non-deterministic 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 non-deterministic 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 non-deterministic automaton  is a good-for-separation strong -separator if for every parity game  with at most  vertices and  priorities, in the chained-product game , there is a way to resolve the non-deterministic 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 non-deterministic automaton  is a good-for-separation 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 chained-product game . We note that the automata that can be derived using Lehtinen’s techniques [27] are good-for-separation and hence they are suitable for being used in the separation approach.

Note that our quasi-polynomial lower bound in Section 5 holds for all non-deterministic 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 (non-deterministic) 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 chained-product 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 good-for-separation 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 chained-product game has only a quasipolynomial number of vertices and a logarithmic number of priorities. Even if an unsophisticated algorithm—with run-time that is exponential in the number of priorities—is used to solve the chained-product game , the overall run-time is quasi-polynomial.

For every parity game , Lehtinen defines the corresponding register game , whose vertices consist of vertices of game  together with -sequences of the so-called 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 just-reset 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 automata-theoretic analogue of her construction in which we use non-determinism to model the ability to pick various resetting strategies.

For all positive numbers  and , such that  is even, we define the non-deterministic parity automaton  in the following way.

  • The set of states of  is the set of non-increasing -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 non-reset 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 chained-product 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 chained-product 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 good-for-separation -separators in the sense discussed in Section 4.3.

We stress that the quasi-polynomial 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 good-for-separation 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 chained-product 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 chained-product automaton is a safety good-for-separation 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 chained-product 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 chained-product 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.

Consider taking  to be the deterministic safety automaton  from Theorem 4.1. By Proposition 4.4, the chained-product automaton is a safety good-for-separation -separator. Moreover, if is based on the nearly optimal quasi-polynomial universal trees from Theorem 2.3 then the size of is .

5 Universal trees inside separating automata

The main result established in this section, and a main technical contribution of the paper, is the following quasi-polynomial lower bound on the size of all safety strong separators.

Every non-deterministic 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 (non-deterministic) 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 quasi-polynomial 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 tree-like 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 Tree-like structure.

A binary relation on a set is called a linear quasi-order 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 well-known 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 quasi-orders 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 tree-decomposition of is a sequence of linear quasi-orders on the set of non-rejecting states of such that:

  1. if is a transition in  then for all  such that .

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

  3. has a single equivalence class, containing all non-rejecting 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 tree-decomposition of , we say that is tree-like. 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 quasi-order , such that ,

  • the order between branching directions being equivalence classes of is when .

Notice that for a non-rejecting state of , there is a unique sequence where for every , is an equivalence class of containing . One can thus assign a non-rejecting 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 non-rejecting, 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 non-deterministic safety strong -separator is tree-like.