On the complexity of parity games

Parity games underlie the model checking problem for the modal µ-calculus, the complexity of which remains unresolved after more than two decades of intensive research. The community is split into those who believe this problem - which is known to be both in NP and coNP - has a polynomial-time solution (without the assumption that P = NP) and those who believe that it does not. (A third, pessimistic, faction believes that the answer to this question will remain unknown in their lifetime.) 
 
In this paper we explore the possibility of employing Bounded Arithmetic to resolve this question, motivated by the fact that problems which are both NP and coNP, and where the equivalence between their NP and coNP description can be formulated and proved within a certain fragment of Bounded Arithmetic, necessarily admit a polynomial-time solution. While the problem remains unresolved by this paper, we do proposed another approach, and at the very least provide a modest refinement to the complexity of parity games (and in turn the µ-calculus model checking problem): that they lie in the class PLS of Polynomial Local Search problems. This result is based on a new proof of memoryless determinacy which can be formalised in Bounded Arithmetic. 
 
The approach we propose may offer a route to a polynomial-time solution. Alternatively, there may be scope in devising a reduction between the problem and some other problem which is hard with respect to PLS, thus making the discovery of a polynomial-time solution unlikely according to current wisdom.


INTRODUCTION
Infinite two-player games played on finite directed graphs play an important role in various problems within the field of verification of systems, specifically with regard to automata theory, modal and temporal logics, and monadic second-order logics [1].Of particular interest are socalled parity games, in which each node of the graph is owned by one of the two players and labelled by some nonnegative integer.There is at least one outgoing edge from every node, and a play consists of moving a token from some initial node along an infinite path through this graph, with the token moved from each node by the player owning that node along an outgoing edge of their choosing.One of the two players tries to ensure that the minimal label encountered infinitely often in the path is even, and is declared to be the winner in such a play; otherwise the other player is declared to be the winner.
Following Stirling [2], we will assume (without loss of generality) that: • no two nodes have the same label; that is, we can associate the set of nodes with a finite subset of the natural numbers; and • the nodes owned by the player seeking to ensure that the minimal label encountered infinitely often is even are precisely those nodes with even labels.
In this way, the winner of a play is the owner of the smallest node which is encountered infinitely often.With little thought it can be realised that any parity game can be transformed into an equivalent such simple graph game without substantially increasing the size of the underlying graph (in fact, by no more than a linear factor).
The determinacy of parity games -ie, the fact that one of the two players has a winning strategy in any parity game -follows from the determinacy of the far more general Borel Games as established by Martin [3].Furthermore, the problem of deciding which of the two players has a winning strategy in any parity game is polynomial-time equivalent to the emptiness problem for alternating tree automata as well as the model checking problem for the µ-calculus [4].For this reason, there has been much interest in devising efficient algorithms for determining who has the winning strategy in parity games.
This task is made simpler by the realisation that parity games satisfy memoryless determinacy, which is to say that a winning strategy exists for one of the two players which is strictly positional: the fortunate player in possession of the winning strategy can decide in advance what move to make from each node which they own.They need not consider the history of the play at the time of the move, and they can even reveal this strategy to their opponent at the start of play.This realisation is easily -if somewhat inaccurately -motivated: since the winning condition is concerned solely with which nodes appear infinitely often in a play, the nodes which have appeared in the finite history of a play are of no consequence, and there is no reason to choose different outgoing edges from a given node each time it is encountered.This intuition suffices for an undergraduate Computer Science lecture, particularly in light of the complexity of the formal proofs that have been devised, but apart from its informality, it is generally unsound (when considering more complicated winning conditions).
Emerson [5] outlined the first formal proof of memoryless determinacy for parity games, with further proofs given by Emerson and Jutla [4], McNaughton [6] and Zielonka [7].Somewhat earlier, Ehrenfeucht and Mycielski [8] demonstrated memoryless determinacy for the related mean payoff games.More recently, Bj örklund et al. [9] have devised an elegant and elementary proof of memoryless determinacy of parity, and mean payoff, games based on induction over the size of such games.In actual fact, they prove memoryless determinacy for a finite variant of parity games, and relate this directly to the same property of the standard infinite version.
Once memoryless determinacy of parity games is established, it becomes immediately apparent that the problem of determining if one of the players has a winning strategy for a given parity game is in NP: guess a positional winning strategy for this player, and verify that this strategy is indeed a winning strategy.This verification relies on simply confirming that -assuming the player uses this supposed winning strategy -the other player cannot force a loop through the graph in which this other player owns the smallest node in the loop: such a loop would allow this other player to win the game; and such a loop would have to exist in order for this other player to win.
The next equally clear observation is that the problem is also in coNP, due to the symmetric roles of the two players.Being in NP ∩ coNP then naturally leads to the question as to whether this problem can in fact be solved in polynomial time.However, all efforts to find such an efficient algorithm have proved futile; the tightest known bound, a slight improvement to the above due to Jurdzi ński [10], is that the problem lies in UP ∩ coUP.Jurdzi ński et al. [11] have, however, devised a subexponential algorithm for the problem.
One further observation can be usefully made at this point: the decision problem of determining who has the winning strategy in a parity game is equivalent with respect to polynomial-time reducibility to the search problem of determining a memoryless winning strategy.The reduction in one direction is obvious: if we can compute a winning strategy in polynomial time, then we can immediately determine to whom it belongs.For the other direction, we assume that we have an algorithm for determining who has a winning strategy in a parity game, and show how to use this to compute such a strategy.Specifically, for each node from which its owner has a winning strategy, we repeatedly remove outgoing edges until we find one whose removal results in that player no longer having a winning strategy (which may well be the last outgoing edge available).
This edge represents an appropriate move for this player to make as part of the winning strategy.This equivalence with respect to polynomial-time reducibility allows us to make a statement about the decision problem by studying the search problem, which we will do in the following.
Bounded Arithmetic is a logical framework suitable for reasoning about polynomial-sized objects based on various restrictions on the use of induction.As we will employ it, Bounded Arithmetic has been introduced by Buss [12] who established the first elegant connections between Bounded Arithmetic theories and computational complexity classes.Where other logical frameworks like descriptive complexity are naturally related to decision problems, Bounded Arithmetic directly connects to search problems and (multi-)functions.It is well-known that one can always reduce a search problem to a related decision problem which often produces a polynomially-equivalent decision problem.But in general, this may not be the case [13].An important class of search problems are total NP search problem in the sense of Beame et al. [13].They are given by a binary, polynomial time computable relation R which is polynomially balanced, ie.any pair (x, y) satisfying R has the property that |y| ≤ |x| O (1) , and total, ie. for any x there is a y with R(x, y).The search task is for a given input x to find y with R(x, y).The combinatorial principles guaranteeing totality allow NP search problems to be grouped into complexity classes for search problems (see [13] for a discussion of this).Johnson et al. [14] introduced, amongst others, one such class called Polynomial Local Search (PLS).PLS consists essentially of optimisation problems for which polynomial-time local-search heuristics exist.
We have already pointed out that the problem of determining who has the winning strategy from a node in a parity game is equivalent with respect to polynomial-time reducibility to the problem of determining a memoryless winning strategy which stores for each node the winning move (for the player who wins from that node).The latter is a typical example of a total NP search problem in the above sense, which we denote by MEMDET: Given a graph G, find a positional winning strategy for G.
In Bounded Arithmetic, the combinatorial principle to prove totality of search problems, which is directly at hand, is induction.The meta-theory of Bounded Arithmetic then puts the search problem into a related complexity class.In particular, we will utilise the following well-known theorems for Bounded Arithmetic: Buss [12] has shown that the NP search problems whose totality can be shown using induction of polynomial length on NP properties (a theory denoted S 1 2 ) can already be solved in polynomial time.This means that if memoryless determinacy would be provable in this theory, then determining who has the winning strategy in a parity game would necessarily be a polynomial-time problem.Buss and Krajíček [15] have (implicitly) shown that the NP search problems whose totality can be shown using induction of polynomial length on NP NP properties (a theory denoted S 2  2 ) are in PLS.We will utilise the latter theorem, together with a new proof of memoryless determinacy which can be formalised in S 2  2 , to show that the problem of computing a positional winning strategy in a simple graph game is in PLS.
The reminder of this paper is structured as follows.In the next three sections we formalise the above discussion.Specifically, in section 2 we formally define simple graph games, the variant of parity games that we study; in section 3 we formally define strategies and related notions as well as formally state the memoryless determinacy theorem; and in section 4 we provide a brief introduction to the bounded arithmetic which we employ.In section 5 we carefully present a proof of memoryless determinacy within bounded arithmetic, ending with the corollary which is the main result of the paper, placing the problem in PLS.Finally in the concluding section 6 we reflect on our achievements.

SIMPLE GRAPH GAMES
In this section we provide the formal definitions of the simple graph games which we shall study, which are played between two players P 0 and P 1 .As noted above, these are equivalent to parity games as typically defined in the literature.

Definition 2.1 (Graph Games
2. E ⊆ V × V is the set of possible moves.
3. In graph-theoretic terms, V is the set of nodes, and E the set of edges of graph G.They have to satisfy in addition that at least one edge is leaving each node.
We let G n be the collection of all graph games of size n, and use G = (V 0 , V 1 , E) to range over G n .Finally, for v ∈ V i we say that player P i owns v.

Definition 2.2 (Playing and Winning
The winner of a play is the player owning the least node which is visited infinitely often in the play.

MEMORYLESS DETERMINACY
Instead of defining strategies for a particular player, we will consider general strategies and ignore the moves of the opposite player.
For a strategy σ we let σ i := σ V i denote the restriction of σ to the moves of player P i .Definition 3.2.If σ is a pre-strategy for G, then G σ denotes the subgraph of G in which the moves from the nodes of dom(σ) are fixed by σ.Lemma 3.3.P i wins from v in G using strategy σ iff the least node in any cycle reachable from v in G σ i is owned by P i .
Proof.If a cycle is reachable from v in G σ i in which the least node is owned by P 1−i , then P 1−i can use this cycle to win the game.Conversely, if P 1−i has a winning play from v in G when P i uses strategy σ, then the least node which appears infinitely often in this play is owned by P 1−i and must eventually be the least node which appears on a cycle from that node to itself in the play.Definition 3.4.Let win i (σ, G, v) denote that σ is a strategy in G, v ∈ V, and every cycle reachable from v in G σ i is won by P i (ie, the least node on the cycle is owned by P i ).

Definition 3.5 (Winning Positions). Let
be the set of nodes from which player P i can force a win using σ, and be the set of nodes from which P i can force a win using some strategy.
Observe that although win i (σ, G, v) and W i (G, σ) are defined for arbitrary strategies σ, ie. for total maps σ : V → V, the behaviour of σ on V 1−i is totally irrelevant by definition of win i and W i .Thus, we could have defined them equally well for partial strategies σ with dom(σ) = V i .

Visions of Computer Science
Again we point out that, due to our definition of win i (σ, G, v), (∃σ) det(G, σ) describes classical memoryless determinacy: from any given node, one of the two players has a positional winning strategy regardless of the strategy (memoryless or not) of the other player .
The problem of determining win i (σ, G, v), relying only on checking cycles, is clearly in P.

BOUNDED ARITHMETIC
In this section we briefly review basic definitions and results of Bounded Arithmetic which are necessary for the understanding of our paper.For a full introduction we refer the interested reader to Buss [12].
Bounded Arithmetic as defined in [12] is a collection of theories formulated in a language of arithmetic over first-order logic with equality.The language L BA of Bounded Arithmetic is given by the following set of non-logical symbols: The first four symbols denote, in their standard interpretation over the natural numbers N, the constant zero, the unary successor function, addition and multiplication; |x| computes the length of the binary representation of x; the binary "shift right" function x#y, which computes 2 |x|•|y| .produces polynomial growth rate; and the final symbol denotes the "less than or equal" relation.To smoothen our presentation we allow some further non-logical symbols denoting further polynomial-time computable functions.This is unproblematic as our base theory can define all polynomial-time computable function-Buss [12] has shown that such an extension of the language is conservative.The additional function symbols we will use are • −, (x) y , , * , * * , lh These denote the arithmetical minus function x • − y = max(0, x − y) and functions to manipulate sequences.We assume some feasible sequence coding as defined, e.g., in [12] which assigns a single number to a sequence of numbers.Then (x) y denotes the yth element in sequence x, denotes the code of the empty sequence, x * y denotes the function which appends number x to sequence y, x * * y denotes concatenation of two sequences x and y, and lh(x) denotes the length of the sequence x.
Terms and formulae over L BA are defined as usual for first-order logic, using the logical symbol "=" for equality and logical connectives ¬, ∧, ∨, →, ∀, ∃ for negation, conjunction, disjunction, implication, and first-order universal and existential quantification.
Among the first-order formulae built over L BA , so called bounded formulae play an important role.Bounded quantifiers can be introduced as abbreviations as follows: (∀x ≤ t)A abbreviates (∀x)(x ≤ t → A) and where t is a term of the language not containing x. Bounded formulae are then formulae in which all quantifiers are bounded, while sharply bounded formulae are bounded formulae in which all bounded quantifiers are of the form (∀x ≤ |t|) or (∃x ≤ |t|).
Buss [12] has introduced classes of bounded formulae Σ b i and Π b i which correspond to the complexity classes Σ p i and Π p i in the polynomial-time hierarchy.For an exact definition we refer the reader to Buss [12, p.20]; we will only use the following observations: • Formulae of the form (∃x 1 ≤ s 1 )ϕ(x 1 ) for sharply bounded ϕ are in Σ b 1 .• Formulae of the form (∀x 1 ≤ s 1 )(∃x 2 ≤ s 2 )ϕ(x 1 , x 2 ) for sharply bounded ϕ are in Π b 2 .
Bounded Arithmetic theories are defined by stating axioms defining the non-logical symbols plus some axiom scheme -the latter being responsible for the strength of the theory.Buss [12] has defined a set BASIC of open formulae defining non-logical symbols which can be extended to define also our additional non-logical symbols.The induction used in Bounded Arithmetic is given as a restriction of the usual induction given by For a set of formulae Φ, we use Φ-LIND to denote the set of formulae of the form where ϕ ∈ Φ.The theories of Bounded Arithmetic are then built by picking a set of formulae and an induction scheme, and forming the theory BASIC + all instances of induction for formulae from the chosen set.From all possible choices, we will use the following: In essence, theory S 1 2 expresses reasoning with polynomial-sized objects using induction on NP properties of polynomial length, while theory S 2  2 expresses reasoning with polynomial-sized objects using induction on NP NP properties of polynomial length.
Buss [12] has also shown that certain different induction schemes are equivalent.In particular, we have the following: Theorem 4.1 (Buss [12]).S 2  2 and BASIC + Π b 2 -LIND prove the same formulae.

Definable functions and search problems
Definable functions and search problems form an important notion for Bounded Arithmetic as they provide the link between theories and complexity classes.A function is said to be Σ b 1 -definable in theory T if there is a Σ b 1 -formula ϕ defining the graph of the function such that the unique existence of the value depending on its arguments can be proven in T .A predicate or formula is said to be ∆ b 1 -definable in T if there is a Σ b 1 -formula and a Π b 1 -formula which both define the predicate and whose equivalence can be shown in T .Theorem 4.2 (Buss [12]).The Σ b 1 -definable functions in S 1 2 coincide with FP, the class of functions computable in polynomial time.The ∆ b 1 -definable predicates in S 1 2 are exactly those in P, the class of predicates decidable in polynomial time.
Let R be a total NP search problem.We say that R is ∆ b 1 -definable in a theory T iff there exists a formula ϕ which is ∆ b 1 -definable in T such that T proves the totality of R via ϕ, i.e.

T (∀x)(∃y)ϕ(x, y).
A multi-function is said to be Σ b 1 -definable in theory T if there is a Σ b 1 -formula ϕ defining the graph of the multi-function, such that the existence of the value depending on its arguments can be proven in T .

Visions of Computer Science
Theorem 4.3 (Buss,Krajíček [15]).The Σ b 1 -definable multi-functions in S 2 2 are exactly the projection of problems in PLS.
In terms of search problems, one can extract from the proof of this theorem that the ∆ b 1 -definable total search problems in S 2 2 are exactly the problems in PLS.

PROVING MEMORYLESS DETERMINACY IN BOUNDED ARITHMETIC
In this section, we prove the main results of our paper.Our goal is to formalise a proof of Memoryless Determinacy in Bounded Arithmetic in order to obtain some new information about the complexity of the NP search problem MEMDET.For this, we first discuss how simple graph games and the definitions surrounding them can be formalised in Bounded Arithmetic.As we have sequence coding and decoding at hand as function symbols in Bounded Arithmetic, we can literally translate Definitions 2.1 and 3.1 to obtain the following formulae in L BA : GraphGame(G) is the sharply bounded formula expressing that lh(G) = 4 and that , where sets of vertices and edges are stored in some canonical way as sequences.We can also define the set of nodes and the size of a graph as terms in L BA by defining the nodes of G to be (G) 0 * * (G) 1 , and the size of G, size(G), to be |(G) 3 |.We define last(x) as the term (x) lh(x) • −1 , and member(x, y) as the formula (∃z < |y|) x = (y) z .Here, |y| is sufficient as lh(y) ≤ |y| follows immediately from the axioms of Bounded Arithmetic.
"Partial maps from V to V" can be formalised as sequences of pairs, and we immediately have the following sharply bounded formulae: • PreStrategy(G, σ) denotes that σ is a pre-strategy for G; • Strategy(G, σ) denotes that σ is a strategy for G; It is obvious that S 1 2 can prove that formulae StrategyRestriction(G, σ, i, µ) and GraphRestriction(G, σ, G ) define graphs of functions, ie. that µ in the former and G in the latter can be shown to exist uniquely in S 1  2 .
A bit more interesting is the formalisation of win i (σ, G, v) according to Definition 3.4.As we know that reachability in graphs is polynomial-time computable, it is easy to translate this Definition into Bounded Arithmetic.But this time we cannot simply translate it as a sharply bounded formula, but have to use the full polynomial-time expressivity available in S 1 2 .We proceed as follows: • preReach(G, v, L) denotes that if GraphGame(G) then L is a sequence of length size(G)+1 with (L) 0 = v and (L) i+1 is (L) i plus all nodes in G which can be reached in one step from (L) i , and L=∅ otherwise; and • Reach(G, v, w) denotes (∃L)(preReach(G, v, L) ∧ member(w, last(L))) .
We are omitting here and in the following bounds to quantifiers if it is obvious how they can be defined.It is not hard to see that S 1 2 can prove that preReach(G, v, L) defines the graph of a function computing L on input G and v. Thus, Reach(G, v, w) ↔ (∀L)(preReach(G, v, L) → member(w, last(L))) .
• preWin i (G, σ, S) denotes that if GraphGame(G) and Strategy(G, σ) then S is a sequence of length size(G) and (S) j is G σ i with all nodes < j eliminated, and S=∅ otherwise; and

Visions of Computer Science
As before, S 1 2 can prove that preWin i (G, σ, S) defines the graph of a function computing S, and thus win i is ∆ b 1 in S 1 2 .
Using these formalisations we can try to carry out in Bounded Arithmetic the proof of Memoryless Determinacy as given by Bj örklund et al. [9].But we immediately run into troubles, as this proof builds on general (memory-dependent) strategies which are exponential-sized objects in the size of the input graph.Therefore, this proof cannot be formalised in Bounded Arithmetic, and we have to give a new proof which avoids general strategies.We start by stating without proof two basic lemmas.
Lemma 5.1.Playing according to a winning strategy never leaves the winning set.In other words, if σ is a winning strategy for P i , then there are no edges leaving W i (G, σ) in G σ i .
Lemma 5.2.Let σ and σ be strategies in G.For v ∈ V and i = 0, 1 define That is, the strategy σ i σ derived from σ and σ is at least as successful for P i as either of σ and σ .
With this we are ready to present our new proof of memoryless determinacy.Proof.We prove the theorem by induction on k ≤ n 2 over the formula Here, lh(E) is a canonical way to express the number of edges in G. Let G ∈ G n with lh(E) = k.
By the induction hypothesis we know Let W i := W i (G).Using Lemma 5.2 (repeatedly) we can find one strategy σ such that W 0 = W 0 (G, σ) and W 1 = W 1 (G, σ), in the following way: By definition, for each v ∈ W i there is some strategy σ v such that win i (σ v , G, v).By repeatedly applying Lemma 5.2 we can combine these to obtain one strategy σ 0 such that W 0 ⊆ W 0 (G, σ 0 ).By definition of W 0 (G) we obviously have W 0 (G, σ 0 ) ⊆ W 0 (G).Hence W 0 = W 0 (G, σ 0 ).Similar, we obtain some σ 1 such that W 1 = W 1 (G, σ 1 ).We now define σ as σ 0 on V 0 and σ 1 otherwise: Then we obviously have that W 0 = W 0 (G, σ) and what we have to show is that, in fact, U = ∅.
Assume for the sake of contradiction that U = ∅.We observe that by Lemma 5.1, there are no edges from U ∩ V i to W i .We also obverve that there are no self-loops in U, that is, u → u / ∈ E for all u ∈ U. (I) Suppose there are u, w ∈ U, u > w such that u → w is the only edge in G leaving u, as shown in Figure 1.In this case let us drop the edge u → w, identify u with w and rename this identified node w.By the induction hypothesis there exists σ with det(G , σ ); we extend σ to σ on G in the obvious way.W.l.o.g., we assume that w ∈ W 0 (G , σ ).As w / ∈ W 0 (G, σ), there must be a cycle reachable from w in G σ0 won by P 1 .But essentially the same cycle is reachable from w in G σ 0 and also won by P 1 -giving us our desired contradiction.
(II) Suppose now that for all u, w ∈ U with u > w, if u → w is in G, then there is another edge u → w in G with w = w .

Let
u := max U is not a winning position.Thus u → w ∈ E for some w ∈ U, hence w ∈ U , and hence U = ∅.Let x := min U .W.l.o.g., we assume that x ∈ V 0 .Fix y ∈ U with y > x and y → x ∈ E, and some z ∈ V different from x with y → z ∈ E. That is, we are in the situation displayed in Figure 2.
If P 1 wins in G from x using σ , then P 1 also wins in G from x using σ , as y → x does not affect the choices of P 0 -contradiction.
Thus, P 0 wins in G from x using σ .As x ∈ U, P 0 does not win from x in G using σ .Thus, there is a cycle reachable from x in G σ 0 won by P 1 .As this situation does not exists in G , the cycle has to include y → x.Also, it has to leave U, as otherwise the least node would be x and the cycle won by P 0 .It cannot reach W 0 , so it has to reach W 1 .But then W 1 is reachable from x in G σ 0contradiction.
(II.b) Assume y ∈ V 0 .Let G be obtained from G by dropping the edge y → z, cf. Figure 4.By the induction hypothesis there exists some σ such that det(G , σ ).W.l.o.g.(by Lemma 5.2) beneficial, as the obtained algorithm would not directly deal with game graphs, but with proof-theoretic notions like witnessing formulas for sequents of Bounded Arithmetic formulas.Furthermore, this would hide any further observations that might be made about the complexity of parity games based on results from Bounded Arithmetic.
To the best of our knowledge, this is the first result which classifies the search problem MEMDET by relating it to PLS.V öge and Jurdzi ński [16] present a discrete strategy improvement algorithm which is closest in spirit to a PLS algorithm for the problem.However, their algorithm is based on a non-deterministic operator Improve, which poses the most obvious of many challenges faced in considering whether or not this algorithm can be turned into a PLS-description.
The previous paragraph notwithstanding, one of the anonymous referees brought to our attention an unpublished report from 2004 [17] which, in a way not advertised by its title, announces the result that parity games lies inside PLS.Indeed, the further claim that parity games are not PLScomplete is made.We have not had the opportunity to verify the validity of the argument presented in this 78-page technical report (though we do not lack confidence in its authors).However, the techniques used there are vastly different to ours; even in light of this earlier yet unpublished announcement, there is still the merit in the present manuscript in introducing Bounded Arithmetic as a tool against the problem of establishing the complexity of parity games.