An Exponential Lower Bound for the Latest Deterministic Strategy Iteration Algorithms

This paper presents a new exponential lower bound for the two most popular deterministic variants of the strategy improvement algorithms for solving parity, mean payoff, discounted payoff and simple stochastic games. The first variant improves every node in each step maximizing the current valuation locally, whereas the second variant computes the globally optimal improvement in each step. We outline families of games on which both variants require exponentially many strategy iterations.


INTRODUCTION
In this paper, we study lower bounds for strategy improvement algorithms for solving parity games, mean payoff games, discounted payoff games as well as simple stochastic games.These are two-player games of perfect information played on directed graphs, and are related by a chain of polynomial-time reductions.
Parity games can be reduced to mean payoff games [Pur95], mean payoff games to discounted payoff games, and the latter ones to simple stochastic games [ZP96].Solving games of any of these classes is one of the few combinatorial problems that belongs to the complexity class NP ∩ coNP and that is not (yet) known to belong to P [EJS93,Con92].It has also been shown that solving parity games as well as mean and discounted payoff games belongs to UP ∩ coUP [Jur98].
We mainly consider parity games in this paper.They are played on a directed graph that is partitioned into two node sets associated with the two players; the nodes are labeled with natural numbers, called priorities.A play in a parity game is an infinite sequence of nodes whose winner is determined by the parity of the highest priority that occurs infinitely often, giving parity games their name.
The reason why parity games seem to be the most appropriate class of games, when trying to construct a worst-case family for one of the four classes, is that the effect of each node in a parity game is very clear: a higher priority dominates all lower priorities (in a play), no matter how many there are.By showing that the strategy iteration on our family of parity games directly corresponds to the strategy iteration that solves the other classes of games, we get the lower bounds for these by applying the standard reductions to our games.
Parity games occur in several fields of theoretical computer science, e.g. as solution to the problem of emptiness of tree automata [GTW02,EJ91] or as algorithmic backend to the model checking problem of the modal µ-calculus [EJS93,Sti95].
There are many algorithms that solve parity games, such as the recursive decomposing algorithm due to Zielonka [Zie98] and its recent improvement by Jurdziński, Paterson and Zwick [JPZ06], the small progress measures algorithm due to Jurdziński [Jur00] with its recent improvement by Schewe [Sch07], the model-checking algorithm due to Stevens and Stirling [SS98] and finally the two strategy improvement algorithms by Vöge and Jurdziński [VJ00] and Schewe [Sch08].
All mentioned algorithms except for the two deterministic subexponential algorithms [JPZ06,Sch07] and except for the two strategy improvement algorithms have been shown to have a superpolynomial or exponential worst-case runtime complexity at best [Jur00,Fri10b,Fri10a].The currently best known upper bound on the deterministic solution of parity games is O(|E| • |V | 1 3 |ranΩ| ) due to Schewe's big-step algorithm [Sch07].
The strategy improvement, strategy iteration or policy iteration technique is the most general approach that can be applied as a solving procedure for all of these game classes.It was introduced by Howard [How60] for solving problems on Markov decision processes and has been adapted by several other authors for solving nonterminating stochastic games [HK66], simple stochastic games [Con92], discounted and mean payoff games [Pur95,ZP96] as well as parity games [VJ00].
Strategy iteration is an algorithmic scheme that is parameterized by an improvement policy which basically defines how to select a successor strategy in the iteration process.There are two major kinds of improvement policies: deterministic and randomized approaches; we will investigate deterministic approaches in this paper.
For discounted payoff games, there is the deterministic algorithm due to Puri [Pur95] that can also be used to solve mean payoff games as well as parity games by reduction [ZP96,VJ00].Vöge and Jurdziński's improvement algorithm is a refined version of Puri's on parity games that omits the use of high-precision rational numbers; there are at least two reasonable improvement policies for the Vöge-Jurdziński procedure appearing in the literature such as the standard locally optimizing policy and Schewe's globally optimizing policy.
An example has been known for some time for which a sufficiently poor choice of a singleswitch policy causes an exponential number of iterations of the strategy improvement algorithm [BV07], but there have been no games known so far on which the policies due to Vöge/Jurdziński or Schewe require more than linearly many iterations.
In this paper, we particularly investigate the locally optimizing policy -which is, by far, the most natural choice for a multi-switching improvement policy -for solving parity games as it is applied by default in the original paper of Vöge and Jurdziński.We present a family of games comprising a linear number of nodes and a quadratic number of edges such that the strategy improvement algorithm using this policy requires an exponential number of iterations on them.We explain how these games can be refined in such a way that they only comprise a linear number of edges resulting in an undeniable exponential lower bound.Additionally, we describe what parts of the games have to be altered in order to get a family that results in exponentially many iterations when solved by Schewe's strategy improvement algorithm.
Finally, we show that the parity game strategy iteration on our games directly corresponds to the strategy iteration that solves the associated mean payoff, discounted payoff as well as simple stochastic games, resulting in an exponential lower bound for the standard strategy improvement algorithms for all of these game classes.
Section 2 defines the basic notions of parity games and some notations that are employed throughout the paper.Section 3 recaps the strategy improvement algorithm by Vöge and Jurdziński; we define the two considered improvement policies in Section 4. In Section 5, we define a subclass of parity games called sink games that allows us to relate the lower bounds for parity games to the other games classes.Section 6 presents a family of games on which the locally improving algorithm requires an exponential number of iterations.We discuss some improvements of the family in Section 7. In Section 8, we consider the modifications that have to be applied to our construction to obtain a lower bound for the globally optimizing policy.In Section 9, we show how to transfer the lower bounds to mean payoff, discounted payoff and simple stochastic games.

PARITY GAMES
A parity game is a tuple G = (V, V 0 , V 1 , E, Ω) where (V, E) forms a directed graph whose node set is partitioned into and Ω : V → N is the priority function that assigns to each node a natural number called the priority of the node.We assume the graph to be total, i.e. for every v ∈ V there is a w ∈ V s.t.(v, w) ∈ E.
In the following we will restrict ourselves to finite parity games.W.l.o.g.we assume Ω to be injective, i.e. there are no two different nodes with the same priority.
We also use infix notation vEw instead of (v, w) ∈ E and define the set of all successors of v as vE := {w | vEw}.The size |G| of a parity game G = (V, V 0 , V 1 , E, Ω) is defined to be the cardinality of E, i.e. |G| := |E|; since we assume parity games to be total w.r.t.E, this is a reasonable way to measure the size.
The game is played between two players called 0 and 1: starting in a node v 0 ∈ V , they construct an infinite path through the graph as follows.If the construction so far has yielded a finite sequence v 0 . . .v n and v n ∈ V i then player i selects a w ∈ v n E and the play continues with v 0 . . .v n w.
Every play has a unique winner given by the parity of the greatest priority that occurs infinitely often.The winner of the play v 0 v 1 v 2 . . . is player i iff max{p | ∀j ∈ N ∃k ≥ j : Ω(v k ) = p} ≡ 2 i (where i ≡ k j holds iff |i − j| mod k = 0).That is, player 0 tries to make an even priority occur infinitely often without any greater odd priorities occurring infinitely often, player 1 attempts the converse.
We depict parity games as directed graphs where nodes owned by player 0 are drawn as circles and nodes owned by player 1 are drawn as rectangles; all nodes are labeled with their respective priority, and -if needed -with their name.
A strategy for player i is a -possibly partial -function σ : V * V i → V , s.t. for all sequences v 0 . . .v n with v j+1 ∈ v j E for all j = 0, . . ., n − 1, and all v n ∈ V i we have: Intuitively, conforming to a strategy means to always make those choices that are prescribed by the strategy.A strategy σ for player i is a winning strategy in node v if player i wins every play that begins in v and conforms to σ.
A strategy σ for player i is called positional if for all v 0 . . .v n ∈ V * V i and all w 0 . . .
That is, the choice of the strategy on a finite path only depends on the last node on that path.
With G we associate two sets W 0 , W 1 ⊆ V ; W i is the set of all nodes v s.t.player i wins the game G starting in v.Here we restrict ourselves to positional strategies because it is well-known that a player has a (general) winning strategy iff she has a positional winning strategy for a given game.In fact, parity games enjoy positional determinacy meaning that for every node v in the game either v ∈ W 0 or v ∈ W 1 [EJ91].Furthermore, it is not difficult to show that, whenever player i has winning strategies σ v for all v ∈ U for some U ⊆ V , then there is also a single strategy σ that is winning for player i from every node in U .
The problem of solving a parity game is to compute W 0 and W 1 as well as corresponding winning strategies σ 0 and σ 1 for the players on their respective winning regions.
A strategy σ for player i induces a strategy subgame Such a subgame G| σ is basically the same game as G with the restriction that whenever σ provides a strategy decision for a node u ∈ V i , all transitions from u but σ(u) are no longer accessible.The set of strategies for player i is denoted by S i (G).

STRATEGY IMPROVEMENT
We briefly recap the basic definitions of the strategy improvement algorithm.For a given parity game The set of even resp.odd priority nodes is defined to be The relevance ordering < on V is induced by Ω: v < u : ⇐⇒ Ω(v) < Ω(u); additionally one defines the reward ordering ≺ on V by v ≺ u : ⇐⇒ rew G (v) < rew G (u).Note that both orderings are total due to injectivity of the priority function.
Let π be a path σ be a strategy for player i.We say that π conforms to σ iff for every j with π(j) ∈ V i we have σ(π(j)) = π(j + 1).
Let v be a node, σ be a positional player 0 strategy and τ be a positional player 1 strategy.Starting in v, there is exactly one path π σ,τ,v that conforms to σ and τ .Since σ and τ are positional strategies, this path can be uniquely written as follows.
with v 1 = v, v i = w 1 for all 1 ≤ i ≤ k and Ω(w 1 ) > Ω(w j ) for all 1 < j ≤ l.Note that the uniqueness follows from the fact that all nodes on the cycle have different priorities and we choose w 1 to be the node with highest priority.
Discrete strategy improvement relies on a more abstract description of such a play π σ,τ,v .In fact, we only consider the dominating cycle node w 1 , the set of more relevant nodes -i.e.all v i > w 1 -on the path to the cycle node, and the length k of the path leading to the cycle node.More formally, the node valuation of v w.r.t.σ and τ is defined as follows.
Given a node valuation ϑ, we refer to w 1 as the cycle component, to {v i > w 1 | 1 ≤ i ≤ k} as the path component, and to k as the length component of ϑ.
In order to compare node valuations with each other, we introduce a total ordering on the set of node valuations.For that reason, we need to define a total ordering ≺ on the second component of node valuations -i.e. on subsets of V -first.To compare two different sets M and N of nodes, we order all nodes lexicographically w.r.t. to their relevance and consider the first position in which the two lexicographically ordered sets differ, i.e. there is a node v ∈ M and a node w ∈ N with v = w s.t.u ∈ M iff u ∈ N for all u > v and all u > w.Now N is better than M iff v ≺ w, i.e. the set which gives the higher reward in the first differing position is superior to the other set.
In other words, to determine which set of nodes is better w.r.t.≺, one considers the node with the highest priority that occurs in only one of the two sets.The set owning that node is greater than the other if and only if that node has an even priority.More formally: where M N denotes the symmetric difference of both sets.
Now we are able to extend the total ordering on sets of nodes to node valuations The motivation behind this ordering is a lexicographic measurement of the profitability of a positional play w.r.t.player 0: the most prominent part of a positional play is the cycle in which the plays eventually stays, and here it is the reward ordering on the dominating cycle node that defines the profitability for player 0. The second important part is the loopless path that leads to the dominating cycle node.Here, we measure the profitability of a loopless path by a lexicographic ordering on the relevancy of the nodes on path, applying the reward ordering on each component in the lexicographic ordering.Finally, we consider the length, and the intuition behind the definition is that, assuming we have an even-priority dominating cycle node, it is better to reach the cycle fast whereas it is better to stay as long as possible out of the cycle otherwise.More formally: Given a player 0 strategy σ, it is our goal to find a best response counterstrategy τ that minimizes the associated node valuations.A strategy τ is an optimal counterstrategy w.r.t.σ iff for every opponent strategy τ and for every node v we have: It is well-known that an optimal counterstrategy always exists and that it is efficiently computable.

Lemma 3.1 ([VJ00]
).Let G be a parity game and σ be a player 0 strategy.An optimal counterstrategy for player 1 w.r.t.σ exists and can be computed in polynomial time.
A fixed but arbitrary optimal counterstrategy will be denoted by τ σ from now on.The associated game valuation Ξ σ is a map that assigns to each node the node valuation w.r.t.σ and τ σ : Game valuations are used to measure the performance of a strategy of player 0: for a fixed strategy σ of player 0 and a node v, the associated valuation essentially states which is the worst cycle that can be reached from v conforming to σ as well as the worst loopless path leading to that cycle (also conforming to σ).
We also write v ≺ σ u to compare the Ξ σ -valuations of two nodes, i.e. to abbreviate A run of the strategy improvement algorithm can be expressed by a sequence of improving game valuations; a partial ordering on game valuations is quite naturally defined as follows: A valuation Ξ σ can be used to create a new strategy of player 0. The strategy improvement algorithm is only allowed to select new strategy decisions for player 0 occurring in the improvement arena Thus all edges performing worse than the current strategy are removed from the game.A strategy σ is improvable iff there is a node v ∈ V 0 , a node u ∈ V with vEu s.t.σ(v) ≺ σ u.
An improvement policy now selects a strategy for player 0 in a given improvement arena.More formally: an improvement policy is a map I G : S 0 (G) → S 0 (G) fulfilling the following two conditions for every strategy σ.
(1) For every node v ∈ V 0 it holds that (v, We say that an edge (v, u) is an improving edge w.r.t.
Jurdziński and Vöge proved in their work that every strategy that is improved by an improvement policy can only result in strategies with valuations strictly better than the valuation of the original strategy.

Theorem 3.2 ([VJ00]
).Let G be a parity game, σ be an improvable strategy and I G be an improvement policy.We have If a strategy is not improvable, the strategy iteration procedure comes to an end and the winning sets for both players as well as associated winning strategies can be easily derived from the given valuation.

Theorem 3.3 ([VJ00]
).Let G be a parity game and σ be a non-improvable strategy.Then the following holds: (3) σ is a winning strategy for player 0 on W 0 (4) τ σ is a winning strategy for player 1 on W 1 (5) σ is ¢-optimal The strategy iteration starts with an initial strategy ι G and runs for a given improvement policy I G as outlined in the pseudo-code of Algorithm 1.

IMPROVEMENT POLICIES
There are two major deterministic improvement policies that we consider here, namely the locally optimizing policy due to Jurdziński and Vöge [VJ00] and the globally optimizing policy by Schewe [Sch08].
The locally optimizing policy I loc G selects a most profitable strategy decision in every point with respect to the current valuation.More formally, it holds for every strategy σ, every player 0 node v and every w ∈ vE that w σ I loc G (σ)(v).Lemma 4.1 ([VJ00]).The locally optimizing policy can be computed in polynomial time.
This policy is generally considered to be the most natural choice, particularly because it directly corresponds to the canonical versions of strategy iteration in related parts of game theory like discounted payoff games or simple stochastic games.We will present a family of games on which the algorithm parameterized with this policy requires exponentially many iterations.
The globally optimizing policy I glo G on the other hand computes a globally optimal successor strategy in the sense that the associated valuation is the best under all allowed successor strategies.More formally, given a parity game G, an improvable strategy σ and the improved strategy σ * = I glo G (σ), we have for an arbitrary strategy σ in the arena A G,σ that Ξ σ ¢ Ξ σ * .
The policy can be interpreted as providing strategy improvement with a one-step lookahead; it computes the optimal strategy under all possible strategies that can be reached by a single improvement step.
The interested reader is pointed to Schewe's paper [Sch08] for all the details on how to effectively compute the optimal strategy update.
We will also explain how to adapt the presented family of games in order to enforce exponentially many strategy iterations on them when parameterized with the globally optimal policy.
Vöge mentions without proof in his thesis that there is an improvement policy that requires at most |V | many iterations to find its fixed point.We find this fact to be quite remarkable and give a short proof of it in the following.

Lemma 4.3 ([Vög00]
).Let G be a parity game.There is an improvement policy I lin G s.t. the strategy improvement algorithm requires at most |V | many iterations.
Proof.Let G = (V, V 0 , V 1 , E, Ω) be a parity game and let σ * be a ¢-optimal strategy.We define the improvement policy I lin G as follows.
We will show that I lin G is indeed an improvement policy and that the strategy iteration parameterized with I lin G requires at most |V 0 | iterations on G in one go by verifying that Let σ be a strategy s.t.m(σ) V 0 .Since m(σ) ⊆ m(I lin G (σ)) holds by definition, we simply need to show that there is at least one node v ∈ V 0 with σ It is easy to see that A G ,σ ⊆ A G,σ and also that σ * is a ¢-optimal strategy w.r.t.G .As σ is not optimal, there must be at least one proper improvement edge (v, w) ∈ A G ,σ .By definition of G , it follows that σ(v) = w and σ * (v) = w.
One may be misled to combine the existence of an improvement policy I lin G that enforces at most linearly many iterations with the existence of the improvement policy I glo G that selects the optimal successor strategy in each iteration, in order to propose that I glo G should also enforce linearly many iterations in the worst case.
The reason why this proposition is incorrect lies in the intransitivity of optimality of strategy updates.Although it is true that I lin G (σ) ¢ I glo G (σ) for every strategy σ, this is not necessarily the case for iterated applications, i.e.I lin does not necessarily hold for all strategies σ.

SINK GAMES
Every approach trying to construct a game family of polynomial size that requires super-polynomially many iterations to be solved by strategy iteration (no matter which policy the algorithm is parameterized with), needs to focus on the second component of game valuations: there are only linearly many different values for the first and third component while there are exponentially many for the second.
Particularly, as there are at most linearly many different cycle nodes that can occur in valuations during a run, there is no real benefit in actually using different cycle nodes.Hence our basic layout of a game exploiting exponential behavior consists of a complex structure leading to one single loop -the only cycle node that will occur in valuations (such structures can easily be identified by preprocessing, but obviously it is not very difficult to obfuscate the whole construction without really altering its effect on the strategy iteration).In this setting, the strategy iteration algorithm is just improving the paths leading to the cycle node.
More formally: we call a parity game G (in combination with an initial strategy ι G ) a 1-sink game iff the following two properties hold: (1) Sink Existence: there is a node v * (called the 1-sink of G) with v * Ev * and Ω(v * ) = 1 reachable from all nodes; also, there is no other node w with Ω(w) ≤ Ω(v * ).
(2) Sink Seeking: for each player 0 strategy σ with Ξ ι G ¢ Ξ σ and each node w it holds that the cycle component of Ξ σ (w) equals v * .Obviously, a 1-sink game is won by player 1.Note that comparing node valuations in a 1-sink game can be reduced to comparing the path components of the respective node valuations, for two reasons.First, the cycle component remains constant.Second, the path-length component equals the cardinality of the path component, because all nodes except the sink node are more relevant than the cycle node itself.In the case of a 1-sink game, we will therefore identify node valuations with their path component.
It is fairly easy to prove that a game is a 1-sink game indeed.One simply has to check that the sink existence property holds by looking at the graph, that the game is completely won by player 1, and that the 1-sink is the cycle component of all nodes of the initial strategy.
Lemma 5.1.Let G be a parity game fulfilling the sink existence property w.r.t.v * .G is a 1-sink game iff G is completely won by player 1 (i.e.W 1 = V ) and for each node w it holds that the cycle component of Ξ ι G (w) equals v * .
Proof.The "only-if"-part is trivial.For the "if"-part, we need to show that the sink seeking-property holds.Let σ be a player 0 strategy with Ξ ι G ¢ Ξ σ , w be an arbitrary node and u be the cycle component of Ξ σ (w).Due to the fact that G is completely won by player 1, u has to be of odd priority.Also, since Ξ ι G ¢ Ξ σ , it holds that Ω(u) ≤ Ω(v * ) implying u = v * by the sink existenceproperty.
There is another reason why 1-sink games are an interesting subclass of parity games: we will see later that the strategy iteration on a discounted payoff game that has been induced by the canonic reduction from a 1-sink parity game, directly corresponds to the strategy iteration on the original 1-sink parity game.This connection between discounted payoff games and 1-sink parity games allows us to directly transfer the lower bound to discounted payoff games.

LOWER BOUND FOR THE LOCALLY OPTIMIZING POLICY
The lower bound construction for the locally optimizing policy is a family of 1-sink parity games that implement a binary counter.In order to reduce the overall complexity of the games, our construction relies on unbounded edge outdegree, yielding a quadratic number of edges in total.We will discuss in the next section how the number of edges can be reduced to a linear number and even how to get binary outdegree.
The implementation of the binary counter is based on a structure called simple cycles that allows us to encode a single bit state in a given strategy σ.By having n such simple cycles, we can represent every state of an n-bit binary counter.In order to allow strategy improvement the transitions of the binary counter, we need to embed the simple cycles in a more complicated structure called cycle gadget, connect the cycle gadgets of the different bits with each other, and with an additional structure called deceleration lane.
This section is organized as follows.First, we consider the three gadgets that will be used in our lower bound construction, namely simple cycles, the deceleration lane and cycle gates.Then, we present the full construction of our lower bound family and give a high-level description of strategy iteration on these games.Finally, we prove that strategy iteration on the games indeed follows the high-level description.
For the presentation of the gadgets, we assume the context of a 1-sink parity game.The labelings and priorities of the gadgets will match the final priorities of the lower bound family.
Gadgets consist of three kinds of nodes: input nodes, output nodes and internal nodes.Input nodes are nodes that will have incoming edges from outside of the gadget, output nodes will have outgoing edges to the outside of the gadget and internal nodes will not be directly connected to the outside of the gadget.
In the context of 1-sink game G and a strategy σ, we will sometimes say that a node v reaches a node w to denote the fact that w lies on the path π σ,τσ,v .
6.1.Simple Cycles.The binary counter will contain a representation of n bits that are realized by n instances of a gadget called a cycle gate.The most important part of a cycle gate is the simple cycle that we will introduce first.We fix some index i for the simple cycle gadget for the sake of this subsection in order to have consistent node labelings.
A simple cycle consists of one player 0 controlled internal node d i that is connected to a set of external nodes D i in the rest of the graph, and one player 1 controlled input node e i .The node e i itself is connected to d i (therefore the name simple cycle) and to one output node h i ∈ D i .We note that all e i nodes are the only player 1 controlled nodes with real choices in the complete lower bound construction.
All priorities of the simple cycle are based on an odd priority p i .Intuitively, the p i is considered to be a very small priority compared to the priorities of the other nodes in the external graph that the simple cycle is connected to.We will implicitly assume this in the following.
See Figure 1 for a simple cycle of index 1 with p 1 = 3.The players, priorities and edges are described in Table 1.
Table 1: Description of the Simple Cycle Given a strategy σ, we say that the cycle is closed iff σ(d i ) = e i and open otherwise.A closed cycle corresponds to a bit which is set while an open cycle corresponds to an unset bit.
The main idea now is to assign priorities to the simple cycle in such a way that the simple cycle is won by player 0, i.e. the most relevant node on the cycle needs to have an even priority.This has important consequences for the behaviour of the player 1 controlled node.
First, assume that σ(d i ) = e i .The optimal counter-strategy here is τ σ (e i ) = h i , since otherwise player 0 would win the cycle which is impossible with G being a 1-sink game.Player 0 is therefore able to force player 1 to move out of the cycle; in other words, setting a bit corresponds to forcing player 1 out of the cycle.In a set bit, the valuation of Second, assume that σ(d i ) = w for some w ∈ D i , and that w ≺ σ h i .It follows that ), but updating to e i would yield a much greater reward than just Ξ σ (e i ) (namely Ξ σ (h i ) ∪ {e i } by forcing player 1 to leave the cycle).
Assume now that w ∈ D i with w ≺ σ w but w ≺ σ h i .Obviously, w and e i are improving nodes for d i , but e i ≺ σ w , hence by the locally improving policy, player 0 switches to w although e i might give a much better valuation.In other words, by moving to d i , the player 1 node hides the fact that there is a highly profitable node on the other side.
We formalize the behaviour of the simple cycle in two lemmas.The first describes the valuation of e i depending on the state of the simple cycle and the second explains the switching behaviour of the player 0 controlled node.The claimed result can easily be obtained by tracing the paths that the strategies take through the gadget, and then comparing valuations.Lemma 6.1.Let σ be a strategy.The following holds: Lemma 6.2.Let σ be a strategy and w = max ≺σ D i .Let σ = I loc (σ).The following holds: Open simple cycles have the important property that we can postpone closing them by supplying them with new nodes w ∈ D i in each iteration s.t.σ(d i ) ≺ σ w.We will use this property in the construction of our binary counter.Since we do not want to set all bits at the same time, rather one by one, we need to make sure that unset bits which are not supposed to be set remain unset for some time (more precisely, until the respective bit represents the least unset bit), and this will be realized AN EXPONENTIAL LOWER BOUND FOR THE LATEST DETERMINISTIC STRATEGY ITERATION ALGORITHMS 11 by this property.The device that supplies us with new best-valued external nodes in each iteration is called deceleration lane and will be described next.

Deceleration Lane.
A deceleration lane has several, say m, input nodes and some output nodes, called roots.The lower bound construction will only require a deceleration lane with two roots s and r, however, it would be easy to generalize the construction of deceleration lanes to an arbitrary number of roots.
More formally, a deceleration lane consists of m internal nodes t 1 , . .., t m , one additional internal node c, m input nodes a 1 , . .., a m and two output nodes s and r, called roots of the deceleration lane.
All priorities of the deceleration lane are based on some odd priority p.We assume that all root nodes have a priority greater than p + 2m + 1. See Figure 2 for a deceleration lane with m = 6 and p = 15.The players, priorities and edges are described in Table 2.

Node Player
Priority Successors  A deceleration lane serves the following purpose.Assume that one of the output nodes, say r, has the better valuation compared to the other root node, and assume further that this setting sustains for some iterations.
The input nodes, say a 1 , . . ., a m , now serve as an entry point, and all reach the best valued root r -by some internal nodes.The valuation ordering of all input nodes depends on the iteration: at first, a 1 has a better valuation than all other input nodes.Then, a 2 has a better valuation than all other input nodes and so on.
This process continues until the other output node, say s, has a better valuation than r.Within the next iteration, the internal nodes perform a resetting step s.t.all input nodes eventually reach the new root node.One iteration after that, a 1 has the best valuation compared to all other input nodes again.
In other words, by giving one of the roots, say s, a better valuation than another root, say r, it is possible to reset and therefore reuse the lane again.In fact, the lower bound construction will use a deceleration lane with two roots s and r, and will employ s only for resetting, i.e. after some iterations with r σ s, there will be one iteration with s σ r and right after that again r σ s.
From an abstract point of view, we describe the state of a deceleration lane by which of the two roots is chosen and by how many t i nodes are already moving down to c. Formally, we say that σ is in deceleration state (x, j) (where x ∈ {s, r} and 0 for all 1 < i < j, and (4) σ(t i ) = x for all j ≤ i.We say that the deceleration lane is rooted in x if σ is in state (x, * ), and that the index is i if σ is in state ( * , i).Whenever a strategy σ is in state (x, i), we define root(σ) = x and ind (σ) = i.In this case, we say that the strategy is well-behaved.
We formalize the behaviour of the deceleration lane in two lemmas.The first describes the ordering of the valuations of the input nodes depending on the state (x, i) of the deceleration lane: (1) if the ordering of the root nodes changes, all input nodes have a worse valuation than the better root, and (2) otherwise the best valued input node is a i−1 .The second explains the switching behaviour of the player 0 controlled nodes: (1) if the ordering of the root node changes, than the whole lane resets, and (2) otherwise the lane assembles further, providing a new best-valued input node.Lemma 6.3.Let σ be a strategy in deceleration state (x, i).Let x denote the other root.Then (1) x ≺ σ x implies a j ≺ σ x for all j ("resetting results in unprofitable lane"). (2 Lemma 6.4.Let σ be a strategy that is in deceleration state (x, i).Let x denote the other root.Let σ = I loc (σ).Then (1) x ≺ σ x implies that σ is in state (x, 1) ("lane resets").
The main purpose of a deceleration lane is to absorb the update activity of other nodes in such a way that wise (i.e.edges that will result in much better valuations after switching and reevaluating) strategy updates are postponed.Consider a node for instance that has more than one proper improving switch; the locally optimizing policy will select the edge with the best valuation to be switched.In order to prevent that one particular improving switch is applied for some iterations, one can connect the node to the input nodes of the deceleration lane.
The particular scenario in which we will use the deceleration lane are simple cycles as described in the previous subsection.We will connect the simple cycles encoding the bits of our counter to the deceleration lane in such a way, that lower cycles have less edges entering the deceleration lane.This construction ensures that lower open cycles (representing unset bits) will close (i.e.set the corresponding bit) before higher open cycles (representing higher unset bits) have their turn to close.6.3.Cycle Gate.The simple cycles will appear in a more complicated gadget, called cycle gate.We will have n different cycle gates in the game number n of the lower bound family, hence we fix some index i for the cycle gate gadget for the sake of this subsection in order to have consistent node labelings.
Formally, a cycle gate consists of two internal nodes e i and h i , two input nodes f i and g i , and two output nodes d i and k i .The output node d i will be connected to a set of other nodes D i in the game graph, and k i to some other set K i as well.The two nodes d i and e i form a simple cycle as described earlier.
All priorities of the cycle gate are based on two odd priorities p i and p i .See Figure 3 for a cycle gate of index 1 with p 1 = 3 and p 1 = 33.The players, priorities and edges are described in Table 3.The main idea behind a cycle gate is to have a pass-through structure controlled by the simple cycle that is either very profitable or quite unprofitable.The pass-through structure of the cycle gate has one major input node, named g i , and one major output node, named k i .The input node is controlled by player 0 and connected via two paths with the output node; there is a direct edge and a longer path leading through the interior of the cycle gate.

Node Player Priority Successors
However, the longer path only leads to the output node if the simple cycle, consisting of one player 0 node d i and one player 1 node e i , is closed.In this case, it is possible and profitable to reach the output node via the internal path; otherwise, this path is not accessible, and hence, the input node has to select the unprofitable direct way to reach the output node.
We will have one additional input node, named f i , that can only access the path leading through the interior of the cycle gate, for the following purpose.Assume that the simple cycle has just been closed and now the path leading through the interior becomes highly profitable.Hence, the next switching event to happen will be the node g i switching from the direct path to the path through the interior.However, it will be useful to be able to reach the highly profitable path from some parts of the outside graph one iteration before it is accessible via g i .For this reason, we include an additional input node f i that immediately accesses the interior path.
We say that a cycle gate is closed resp.open iff the interior simple cycle is closed resp.open.Similarly, we say that a cycle gate is accessed resp.skipped iff the access control node g i moves through the interior (σ From an abstract point of view, we describe the state of a cycle gate by a pair (β i (σ), α i (σ)) ∈ {0, 1} 2 .The first component describes the state of the simple cycle, and the second component gives the state of the access control node.Formally, we have the following.
We formalize the behaviour of the cycle gate in two lemmas.The first describes the valuation of all important nodes of the cycle gate, using our knowledge of simple cycles of Lemma 6.1.The second explains the switching behaviour of the access control node.The behaviour of the simple cycle contained in the cycle gate is described by Lemma 6.2.Lemma 6.5.Let σ be a strategy.Then (1) Lemma 6.6.Let σ be a strategy and σ = I loc (σ).
(1) If gate i is σ-closed, then gate i is σ -accessed ("closed gates will be accessed").
(2) If gate i is σ-open and σ(d i ) ≺ σ h i , then gate i is σ -skipped ("open gates with unprofitable exit nodes will be skipped").
open gates with profitable exit nodes will be accessed").
The last two items of Lemma 6.6 are based on the uniqueness of priorities in the game, implying that there are no priorities between f i and h i .We will use cycle gates to represent the bit states of a binary counter: unset bits will correspond to cycle gates with the state (0, 0), set bits to the state (1, 1).Setting and resetting bits therefore traverses more than one phase, more precisely, from (0, 0) over (1, 0) to (1, 1), and from the latter AN EXPONENTIAL LOWER BOUND FOR THE LATEST DETERMINISTIC STRATEGY ITERATION ALGORITHMS 15 again over (0, 1) to (0, 0).Particularly, it can be observed that the second component of the cycle gate states switches one iteration after the first component in both cases.6.4.Lower Bound Construction.In this subsection, we provide the complete construction of the lower bound family.It essentially consists of a 1-sink x, a deceleration lane of length 2n that is connected to the two roots s and r, and n cycle gates.The simple cycles of the cycle gates are connected to the roots and to the deceleration lane with the important detail, that lower cycle gates have less edges to the deceleration lane.This construction ensures that lower open cycle gates will close before higher open cycle gates.
The output node of a cycle gate is connected to the 1-sink and to the g * -input nodes of all higher cycle gates.The s root node is connected to all f * -input nodes, the r root node is connected to all g * -input nodes.
We now give the formal construction.The games are denoted by The sets of nodes are The players, priorities and edges are described in Table 4.The game G 3 is depicted in Figure 4.

Node Player
Priority Successors As an initial strategy we select the following ι Gn .It will correspond to the global counter state in which no bit has been set.
Note that ι Gn particularly is well-behaved.Hence, by Lemma 6.4(3) we know that all strategies that will occur in a run of the strategy improvement algorithm will be well-behaved.We will see in the next section, how the family G n can be refined in such a way that it only comprises a linear number of edges.The reason why we present the games with a quadratic number of edges first is that the refined family looks even more confusing and obfuscates the general principle.
(1) The game G n is completely won by player 1.
(2) x is the 1-sink of G n and the cycle component of Ξ ι Gn (w) equals x for all w.
(1) Note that the only nodes owned by player 1 with an outdegree greater than 1 are e 1 ,. ..,e n .
Consider the player 1 strategy τ which selects to move to h i from e i for all i.Now it is the case that G n | τ contains exactly one cycle that is eventually reached no matter what player 0 does, namely the self-cycle at x which is won by player 1.
(2) The self-cycle at x obviously is the 1-sink since it can be reached from all other nodes and has the smallest priority 1.Since xEx is the only cycle won by player 1 in G n | ι Gn , x must be the cycle component of each node valuation w.r.t.ι Gn .
By Lemma 5.1 it follows that G n is a 1-sink game, hence it is safe to identify the valuation of a node with its path component from now on.From the most abstract point of view, our lower bound construction performs counting on B n .However, the increment of a global bit state requires more than one strategy iteration, more precisely four different phases that will be described next (with one phase of dynamic length).
Every phase is defined w.r.t. a given global counter state b ∈ B n .Let b ∈ B n be a global bit state different from 1 n .
An abstract counter performs the increment from b to b ⊕ 1 by computing b[µb → 1][j<µb → 0], i.e. by setting bit µb and by resetting all lower bits j<µb.In the context of the games, we start in phase 1 corresponding to b, and then proceed to phase 2 and phase 3 corresponding to b[µb → 1], from phase 3 to phase 4 corresponding to b[µb → 1][j < µb → 0], and finally from phase 4 to phase 1 again.The transition from phase 2 to phase 3 and from phase 4 to phase 1 handles the correction of the internal structure connecting the cycles with each other.
For the sake of this subsection, let σ be a strategy and b ∈ B n be a global counter state.All phases will be defined w.r.t.σ and b ∈ B n .Let σ = I loc (σ).
To keep everything as simple as possible and to be able to prove all the lemmas without considering special cases, we will assume that b is different from 0 n and that the two highest bits in b are zero and remain zero, i.e. we will only use the first n − 2 bits for counting.Note however, that every bit works as intended in the counter.
Recall that every strategy σ occurring will be well-behaved.In addition to the deceleration lane and the cycle gates, we have two more structures that are controlled by a strategy σ, namely the two roots r and s, and the cycle gate output nodes k i .We write σ(r) = i to denote that σ(r) = g i , and σ(r) = n + 1 if σ(r) = x; we write σ(s) = i to denote that σ(s) = f i , and σ(s We also use a more compact notation for the strategy decision of d i -nodes of open cycles.We write Recall that we say that a strategy σ is rooted in s or r, if every path in the deceleration lane conforming to σ eventually exits to s resp.r.Likewise, we say that σ has index i if all nodes of the deceleration lane with smaller index j < i are moving down the lane by σ, and that i is the first index which is directly exiting through the root. The first phase, called the waiting phase, corresponds to a stable strategy σ in which open cycles are busy waiting to be closed while the deceleration lane is assembling.Cycle gates that correspond to set bits are closed and accessed, while cycle gates of unset bits are open and skipped, i.e. b = b σ = a σ .The selector nodes k i move to the next higher cycle gate corresponding to a set bit, and both roots are connected to the least set bit νb.More formally, we say that σ is a b-phase 1 strategy iff all the following conditions hold: Proof.Let σ be a b-phase 1 strategy, Ξ := Ξ σ and ind (σ) < 2µb + 2. We first compute the valuations for all those nodes directly that do not involve any complicated strategy decision of player 1. Obviously, Ξ(x) = ∅.By Lemma 6.1(1) we know that for all set bits i (i.e.b i = 1) we have the following.

Ξ(e
Using these equations, we are able to compute many other valuations that do not involve any complicated strategy decision of player 1.Let U j = {g j , f j , e j , h j , k j }.The following holds (by CF p (A)

AN EXPONENTIAL LOWER BOUND FOR THE LATEST DETERMINISTIC STRATEGY ITERATION ALGORITHMS 19
we denote the function that returns A if p holds and ∅ otherwise): It is easy to see that we have the following orderings on the nodes specified above.
By Lemma 6.1(2), it follows from (a) that τ σ (e i ) = d i for all unset bits i (i.e.b i = 0), hence we are able to compute the valuations of the remaining nodes.
This completes the valuation of Ξ for all nodes.
It is easy to see that for every i with b i = 0 and every j with b j = 1 s.t.there is no i < i < j with b i = 1, the following holds: Also, for i > j with b i = 1 and b j = 1 we have By (a) and Lemma 6.3(2) we obtain that the following holds: We are now ready to prove that σ is of the desired form.
(1) By Lemma 6.2(1) and (a) we derive that closed cycles remain closed.By Lemma 6.6(1) we derive that closed cycles remain accessed.By (a) and Lemma 6.6(2) we derive that open cycles remain skipped.By phase 1 condition (5), phase 1 condition (6), (d), it follows that for every j with b j = 0, there is an improving node a * for d j .By Lemma 6.2(2), we conclude that open cycles remain open.
The first phase ends, when a simple cycle corresponding to an unset bit has no more edges leading to the deceleration lane that keeps it busy waiting, and closes.Since lower bits have less edges going to the lane, it is clear that this will be the least unset bit µb.
The second phase, called the set phase, corresponds to a strategy σ in which the least unset bit has just been set, i.e. to the global state b[µb → 1] = b σ .The selector nodes and roots are as in phase 1 and also the access states, i.e. b = a σ .More formally, we say that σ is a b-phase 2 strategy iff all the following conditions hold: (1) b[µb → 1] = b σ and b = a σ , i.e. set bits correspond to closed and accessed (for all set bits except for µb) cycle gates, while unset bits correspond to open and skipped cycle gates, (2) root(σ) = r, i.e. the strategy is rooted in r, (3) σ(s) = σ(r) = νb, i.e. both roots are connected to the former least set bit, (4) σ(k i ) = min({j > i | b j = 1} ∪ {n + 1}), i.e. the selector nodes move to the next set bit, (5) ind (σ) ≤ 2µb + 3, i.e. the deceleration lane has not passed the next bit, and (6) σ(d j ) = ind (σ) − 1 for all j > µb with b j = 0, i.e. every higher open cycle node is not connected to the best-valued node of the lane.
Proof.This can be shown essentially the same way as Lemma 6.8.The only difference now is that d µb has no more improving switches to the deceleration lane and hence, by Lemma 6.2(3), we learn that the µb-cycle has to close.
In phase 2, the deceleration lane is still assembling, and the improving switches again include edges of open simple cycles and edges of the deceleration lane.Additionally, it is improving for the cycle gate µb to be accessed and for the root s to update to cycle gate µb.By performing all these switches, we enter phase three.
The third phase, called the access phase, is defined by a renewed correspondence of the cycle gate structure again, i.e. b[µb → 1] = b σ = a σ .The s root is connected to µb while r is still connected to νb.This implies that s now has a much better valuation than r.More formally, we say that σ is a b-phase 3 strategy iff all the following conditions hold: (1) b[µb → 1] = b σ = a σ , i.e. set bits correspond to closed and accessed cycle gates, while unset bits correspond to open and skipped cycle gates, (2) root(σ) = r, i.e. the strategy is rooted in r, (3) σ(s) = µb and σ(r) = νb, i.e. one root is connected to the new set bit and the other one is still connected to the former least set bit, (4) σ(k i ) = min({j > i | b j = 1} ∪ {n + 1}), i.e. the selectors move to the former next set bit, (5) σ(d j ) = s for all j > µb with b j = 0, i.e. every higher open cycle node is not connected to the best-valued root node.
Proof.Again, this can be shown essentially as the previous Lemmas 6.8 and 6.9.The main difference is that now f i ≺ σ f µb for all i = µb which is why σ (s) = µb, and that by Lemma 6.6(1) we have that the µb-th gate is σ -accessed.
The cycle gate with the best valuation is now µb, hence, there are many improving switches, that eventually lead to cycle gate µb.First, there are all nodes of the deceleration lane that have improving switches to s.Second, r has an improving switch to µb.Third, lower closed cycles (all lower cycles should be closed!)have an improving switch to µb (opening them again).Fourth, all lower selector nodes have an improving switch to µb.By performing all these switches, we enter phase four.
The fourth and last phase, called the reset phase, corresponds to a strategy σ that performed the full increment, i.e. b σ = b ⊕ 1.However, the access states are not reset, i.e. a σ = b[µb → 1] and the deceleration lane is moving to root s.More formally, we say that σ is a b-phase 4 strategy iff all the following conditions hold: We first compute the valuations for all those nodes directly that do not involve any complicated strategy decision of player 1. Obviously, Ξ(x) = ∅.By Lemma 6.1(1) we know that for all set bits i (i.e.b i = 1) we have the following.
Using these equations, we are able to compute many other valuations that do not involve any complicated strategy decision of player 1.Let U j = {g j , f j , e j , h j , k j }.

Ξ(k
We have the following orderings on the nodes specified above. Note that the last inequality s ≺ σ h i≥µb holds for the following reason: If i corresponds to a set bit, then the path from s eventually reaches the node h i , but the highest priority on the way to h i is f i , which is odd.If i on the other hand corresponds to an unset bit, then path from s to the sink shares the common postfix with h i , which starts with the node σ(k i ).Comparing the two differing prefixes shows that the most significant difference is h i itself, which is even.
By Lemma 6.1(3), it follows from (a) that τ σ (e i ) = d i for all unset bits i (i.e.b i = 0), hence we are able to compute the valuations of the remaining nodes.

Ξ(e
It is easy to see that for every i with (b ⊕ 1) i = 0 and every j with (b ⊕ 1) j = 1 s.t.there is no i < i < j with (b ⊕ 1) i = 1, the following holds: Similarly, for i > j with (b ⊕ 1) i = 1 and (b ⊕ 1) j = 1 we have We are now ready to prove that σ is of the desired form.
(1) By Lemma 6.2(1) and (a) we derive that closed cycles with index i ≥ µb remain closed.By Lemma 6.2(4) and (a) we derive that closed cycles with index i < µb open.By Lemma 6.6(1) we derive that closed cycles remain accessed.By (a) and Lemma 6.6(2) we derive that open cycles remain skipped.By phase 3 condition ( 5) and (a), it follows that for every j with b j = 0, there is the improving node s for d j .By Lemma 6.2(2), we conclude that open cycles remain open.
By switching the lane back to the initial configuration and the access states to match the simple cycles states, we end up in phase 1 again that corresponds to the incremented global counter state.Lemma 6.12.Let σ be a b-phase 4 strategy and b ⊕ 1 = 1 n .Then σ is a b ⊕ 1-phase 1 strategy with ind (σ ) = 1.
We first compute the valuations for all those nodes directly that do not involve any complicated strategy decision of player 1. Obviously, Ξ(x) = ∅.By Lemma 6.1(1) we know that for all set bits i (i.e.b i = 1) we have the following.

Ξ(e
Using these equations, we are able to compute many other valuations that do not involve any complicated strategy decision of player 1.Let U j = {g j , f j , e j , h j , k j }.The following holds: Additionally for all i ≥ µb, we have: It is easy to see that we have the following orderings on the nodes specified above. By Lemma 6.1(2), it follows from (a) that τ σ (e i ) = d i for all unset bits i (i.e.b i = 0), hence we are able to compute the valuations of the remaining nodes.
Additionally for all i < µb, we have: This completes the valuation of Ξ for all nodes.
It is easy to see that for every i with b i = 0 and every j with b j = 1 s.t.there is no i < i < j with b i = 1, the following holds: Similarly, for i > j with b i = 1 and b j = 1 we have We are now ready to prove that σ is of the desired form.
(1) By Lemma 6.2(1) and (a) we derive that closed cycles remain closed.By Lemma 6.6(1) we derive that closed cycles remain accessed.By (a) and Lemma 6.6(2) we derive that open cycles remain or will be skipped.By Lemma 6. (5) By Lemma 6.4(1) it follows that ind (σ ) = 1.(6) By (a) it follows that σ (d i ) = r for every i with b i = 0. 6.6.Lower Bound Proof.Finally, we are ready to prove that our family of games really implements a binary counter.From Lemmas 6.8, 6.9, 6.10, 6.11 and 6.12, we immediately derive the following.Lemma 6.13.Let σ be a phase 1 strategy and b σ = 1 n .There is some k ≥ 4 s.t.σ = I loc k (σ) is a phase 1 strategy and b σ = b σ ⊕ 1.
Particularly, we conclude that strategy improvement with the locally optimizing policy requires exponentially many iterations on G n .Theorem 6.14.Let n > 0. The Strategy Improvement Algorithm with the I loc -policy requires at least 2 n improvement steps on G n starting with ι Gn .6.7.Remarks.One could conjecture that 1-sink games form a "degenerate" class of parity games as they are always won by player 1. Remember that the problem of solving parity games is to determine the complete winning sets for both players.Given a strategy σ of player 0, we know by Theorem 3.3 that both winning sets can be directly inferred if σ is the optimal strategy.But it is also possible to derive some information about player 0's winning set given a non-optimal strategy.More precisely, W 0 ⊇ {v | Ξ σ (v) = (w, , ) and w ∈ V ⊕ }.
In other words: Is there a family of games on which the strategy improvement algorithm requires exponentially many iterations to find a player 0 strategy that wins at least one node in the game?
The answer to this question is positive.Simply take our lower bound games G n and remove the edge from e n to h n .Remember that the first time player 1 wants to use this edge by best response is when the binary counter is about to flip bit n, i.e. after it processed 2 n−1 many counting steps.Eventually, the player 0 strategy is updated s.t.σ(d n ) = e n , forcing player 1 by best response to move to h n .Removing this edge leaves player 1 no choice but to stay in the cycle which is dominated by player 0.

IMPROVING THE LOWER BOUND CONSTRUCTION
We briefly address two improvements of our construction.First, we explain how to reduce the number of edges s.t. the overall size of the games is linear in n.Second, we describe how to obtain a lower bound construction with binary edge outdegree.7.1.Linear Number of Edges.Consider the lower bound construction again.It consists of a deceleration lane, cycle gates, two roots and connectives between these structures.All three kinds of structures only have linearly many edges when considered on their own.The quadratic number of edges is solely due to the d * -nodes of the simple cycles of the cycle gates that are connected to the deceleration lane and due to the k * -nodes of the cycle gates that are connected to all higher cycle gates.
We focus on the edges connecting the d * -nodes with the deceleration lane first.Their purpose is twofold: lower cycle gates have less edges to the deceleration lane (so they close first), and as long as an open cycle gate should be prevented from closing, there must be a directly accessible lane input node in every iteration with a better valuation than the currently chosen lane input node.
Instead of connecting d i to all a j with j < 2i + 1 nodes, it would suffice to connect d i to two intermediate nodes, say y i and z i , that are controlled by player 0 with negligible priorities.We connect z i to all a j with even j < 2i+1 and y i to all a j with odd j < 2i+1.By this construction, we shift the "busy updating"-part alternately to y i and z i , and d i remains updating as well by switching from y i to z i and vice versa in every iteration.
Next, we observe that the edges connecting y i (resp.z i ) to the lane are a proper subset of the edges connecting y i+1 (resp.z i+1 ) to the lane, and hence we adapt our construction in the following way.Instead of connecting y i+1 (and similarly z i+1 ) to all a j with even j < 2i + 3, we simply connect y i+1 to a 2i+1 and to y i .In order to ensure proper resetting of the two intermediate lanes constituted by y * and z * in concordance with the original deceleration, we need to connect every additional node to c. See Figure 5 for the construction (note that by introducing new nodes with "negligible priorities", we simply shift all other priorities in the game).
Second, we consider the edges connecting lower cycle gates with higher cycle gates.As the set of edges connecting k i+1 with higher g j is a proper subset of k i , we can apply a similar construction by attaching an additional lane to cycle gate connections that subsumes shared edges.7.2.Binary Outdegree.Every parity game can be linear-time reduced to an equivalent (in the sense that winning sets and strategies can be easily related to winning sets and strategies in the original game) parity game with an edge outdegree bounded by two.See Figure 6 for an example of such a transformation.
However, not every such transformation that can be applied to our construction (for clarity of presentation, we start with our original construction again) yields games on which strategy iteration still requires an exponential number of iterations.We discuss the necessary transformations for every player 0 controlled node in the following, although we omit the exact priorities of additional helper nodes.It suffices to assign arbitrary even priorities to the additional nodes that lie below the priorities of all other nodes of the original game (except for the 1-sink).
First, we consider the two root nodes s and r, that are connected to the 1-sink x and to f 1 ,. .., f n resp.g 1 ,. ..,g n .As r copies the decision (see the transition from the access to the reset phase) of s, it suffices to describe how the outdegree-two transformation is to be applied to s.We introduce n additional helper nodes s 1 ,. ..,s n , replace the outgoing edges of s by x and s n , connect s i+1 with f i+1 and s i , and finally s 1 simply with f 1 .It is still possible to show that s reaches the best valued f i after one iteration.Assume that s currently reaches some cycle gate i via the ladder that is given by the helper nodes.Let j be the next best-valued cycle gate that just has been set.If j > i, it follows that s currently reaches s j that moves to s j−1 , but updates within one iteration to f j .If j < i, it must be the case that j = 1 (i is the least bit which was set; j is the least bit which was unset).Moreover, s currently reaches s i that moves to f i .All lower s k+1 with k + 1 < i move to s k since lower unset cycle gates are more profitable than higher unset cycle gates (unset cycle gates eventually reach one of the roots via the unprofitable f * nodes).Hence, s i updates within one iteration to s i−1 .
Second, there are the output nodes of cycle gates k 1 ,. .., k n .We apply a very similar ladderstyle construction here.For every k i , we introduce n−i additional helper nodes k i,j with i < j ≤ n, replace the outgoing edges of k i by x and k i,i+1 , connect k i,j with g j and k i,j+1 (if j < n).The argument why this construction suffices runs similarly as for the root nodes.
Third, there are the nodes t 1 ,. ..,t 2n of the deceleration lane that are connected to three nodes.Again, we introduce an additional helper node t i for every t i , and replace the two edges to r and t i−1 resp.c by an edge to t i that is connected to r and t i−1 resp.c instead.It is not hard to see that this slightly modified deceleration lane still provides the same functionality.
Finally, there are the player 0 controlled nodes d 1 ,. ..,d n of the simple cycles of the cycle gates.Essentially, two transformations are possible here.Both replace d i by as many helper nodes d i,x as there are edges from d i to any other node x but e i .Then, every d i,x is connected to the target node x.
The first possible transformation connects every d i,x with e i and vice versa, yielding a multicycle with e i as the center of each cycle.The second possible transformation connects e i with the first d i,x 1 , d i,x 1 with d i,x 2 etc. and the last d i,x l again with e i , yielding one large cycle.Both replacements behave exactly as the original simple cycle.
The transformation described here results in a quadratic number of nodes since we started with a game with a quadratic number of edges.We note, however, that a similar transformation can be applied to the version of the game with linearly many edges, resulting in a game with binary outdegree of linear size.

LOWER BOUND FOR THE GLOBALLY OPTIMIZING POLICY
The lower bound construction for the globally optimizing policy again is a family of 1-sink parity games that implement a binary counter by a combination of a (modified) deceleration lane and a chain of (modified) cycle gates This section is organized as follows.First, we discuss the modifications of the deceleration lane and the cycle gates and why they are required to obtain a lower bound for the globally optimizing policy.Then, we present the full construction along with some remarks to the correctness.
The main difference between the locally optimizing policy and the globally optimizing policy is that the latter takes cross-effects of improving switches into account.It is aware of the impact of any combination of profitable edges, in contrast to the locally optimizing policy that only sees the local valuations, but not the effects.
One primary example that separates both policies are the simple cycles of the previous sections: the locally optimizing policy sees that closing a cycle is an improvement, but not that the actual profitability of closing a cycle is much higher than updating to another node of the deceleration lane.
The globally optimizing policy, on the other hand, is well aware of the profitability of closing the cycle in one step.In some sense, the policy has the ability of a one-step lookahead.However, our lower bound for the globally optimizing policy is not so different from the original construction -the trick is to hide very profitable choices by structures that cannot be solved by a single strategy iteration.In other words, we simply need to replace the gadgets that can be solved with a one-step lookahead by slightly more complicated variations that cannot be solved within one iteration and that maintain this property for as long as it is necessary.8.1.Modified Deceleration Lane.The modified deceleration lane looks almost the same as the original deceleration lane.It has again several, say m, input nodes a 1 , . . ., a m along with some special input node c.We have two output roots, r and s, this time with a slightly different connotation.We call r the default root and s the reset root.
More formally, a modified deceleration lane consists of m (in our case, m will be 6 • n − 2) internal nodes t 1 , . .., t m , m input nodes a 1 , . .., a m , one additional input node c, the default root output node r and the reset root output node s.
All priorities of the modified deceleration lane are based on some odd priority p.We assume that all root nodes have a priority greater than p + 2m + 1.The structural difference between the modified deceleration lane and the original one is that the lane base c only has one outgoing edge leading to the default root r.See Figure 7 for a deceleration lane with m = 5 and p = 27.The players, priorities and edges are described in Table 5.

Node Player
Priority Successors  The intuition behind the two roots is the same as before.The default root r serves as an entry point to the cycle gate structure and the reset root s is only used for a short time to reset the whole deceleration lane structure.
We describe the state of a modified deceleration lane again by a tuple specifying which root has been chosen and by how many t i nodes are already moving down to c. Formally, we say that σ is in deceleration state (x, j) (where x ∈ {s, r} and 0 < j ≤ m + 1 a natural number) iff (1) σ(t 1 ) = c if j > 1, (2) σ(t i ) = t i−1 for all 1 < i < j, and (3) σ(t i ) = x for all j ≤ i.
The modified deceleration lane treats the two roots differently.If the currently best-valued root is the reset root, it is the optimal choice for all t * -nodes to directly move to the reset root.In other words, no matter what state the deceleration lane is currently in, if the reset root provides the best valuation, it requires exactly one improvement step to reach the optimal setting.
If the currently best-valued root is the default root, however, it is profitable to reach the root via the lane base c.The globally optimizing policy behaves in this case just like the locally optimizing policy, because the deceleration lane has exactly one improving switch at a time which is also globally profitable.
The following lemma formalizes the intuitive description of the deceleration lane's behaviour: a change in the ordering of the root valuations leads to a reset of the deceleration lane, otherwise the lane continues to align its edges to eventually reach the best-valued root node via c.
It is notable that resetting the lane by an external event (i.e. by giving s a better valuation than r) is a bit more difficult than in the case of the locally optimizing policy.Let σ be a strategy and σ = I glo (σ).Assume that the current state of the deceleration lane is (r, i) and now we have that s has a better valuation than r, i.e. s σ r.Assume further -which for instance applies to our original lower bound construction -that the next strategy σ assigns a better valuation to r again, i.e. r σ s.Therefore, it would not be the globally optimal choice to reset the deceleration lane to s, but instead just to keep the original root r.
In other words, the globally optimizing policy refrains from resetting the lane if the resetting event persists for only one iteration.The solution to fool the policy, however, is not too difficult: we just alter our construction in such a way that the resetting root will have a better valuation than the default root for two iterations.
(2) x σ x and x σ x implies that σ is in state (x, 1).
The purpose of the modified deceleration lane is exactly the same as before: we absorb the update activity of cyclic structures that represent the counting bits of the lower bound construction.8.2.Stubborn Cycles.With the locally optimizing policy, we employed simple cycles and hid the fact that the improving edge leading into the simple cycle results in a much better valuation than updating to the next best-valued node of the deceleration lane.
However, simple cycles do not suffice to fool the globally optimizing policy.If it is possible to close the cycle within one iteration, the policy sees that closing the cycle is much more profitable than updating to the deceleration lane.
The solution to this problem is to replace the simple cycle structure by a cycle consisting of more than one player 0 node s.t. it is impossible to close the cycle within one iteration.More precisely, we use a structure consisting again of one player 1 node e and three player 0 nodes d 1 , d 2 and d 3 , called stubborn cycle.We connect all four nodes with each other in such a way that they form a cycle, and connect all player 0 nodes with the deceleration lane.See Figure 8 for an example of such a situation.
More precisely, we connect the player 0 nodes in a round robin manner to the deceleration lane, for instance d 1 to a 3 , a 6 , . .., d 2 to a 2 , a 5 , . .., and d 3 to a 1 , a 4 , . ... We assume that it is more profitable for player 1 to move into the cyclic structure as long as it is not closed.Now let σ be a strategy s.t.σ is in state (r, 6) and σ(d 1 ) = a 3 , σ(d 2 ) = d 3 and σ(d 3 ) = a 4 .There are exactly two improving switches here: d 2 to a 5 (which is the best-valued deceleration node) and d 1 to d 2 (because d 2 currently reaches a 4 via d 3 which has a better valuation than a 3 ).In fact, the combination of both switches is the optimal choice.A close observation reveals that the improved strategy has essentially the same structure as the original strategy σ: two nodes leave the stubborn cycle to the deceleration lane and one node moves into the stubborn cycle.By this construction, we can ensure that cycles are not closed within one iteration.In other words, the global policy makes no progress towards closing the cycle (it switches one edge towards the cycle, and one edge away from the cycle, leaving it in the exact same position).8.3.Modified Cycle Gate.We again use a slightly modified version of the cycle gates as a passthrough structure that is either very profitable or quite unprofitable.Essentially, we apply two modifications.First, we replace the simple cycle by a stubborn cycle, for the reasons outlined in the previous subsection.Second, we put an additional player 0 controlled internal node y i between the input node g i and the internal node f i .It will delay the update of g i to move to the stubborn cycle after closing the cycle by one iteration.By this, we ensure that the modified deceleration lane will have enough time to reset itself.
Formally, a modified cycle gate consists of three internal nodes e i , h i and y i , two input nodes f i and g i , and four output nodes d 1 i , d 2 i , d 3 i and k i .The output node d 1 i (resp.d 2 i and d 3 i ) will be connected to a set of other nodes D 1 i (resp.D 2 i and D 3 i ) in the game graph, and k i to some set K i .All priorities of the cycle gate are based on two odd priorities p i and p i .See Figure 9 for a cycle gate of index 1 with p 1 = 3 and p 1 = 65.The players, priorities and edges are described in Table 6.From an abstract point of view, we describe the state of a modified cycle gate again by a pair (β i (σ), α i (σ)) ∈ {0, 1, 2, 3} × {0, 1, 2}.The first component describes the state of the stubborn cycle, counting the number of edges pointing into the cycle, and the second component gives the state of the two access control nodes.Formally, we have the following.

Node Player Priority Successors
The behaviour is formalized in terms of modified cycle gate states as follows.Intuitively, it functions as the original cycle gates: if the cycle is σ-closed and remains closed, it is profitable to go through the cycle gate.If the cycle opens by some external event and remains open, it is more profitable to directly move to the output node instead.

Modified Construction.
In this subsection, we provide the complete construction of the lower bound family for the globally optimizing policy.It again consists of a 1-sink x, a modified deceleration lane of length 6n − 3 that is connected to the two roots s and r, and n modified cycle gates.The stubborn cycles of the cycle gates are connected to the r root, the lane base c and to the deceleration lane.The modified cycle gates are connected to each other in the same manner as in the original lower bound structure for the locally optimizing policy.The way the stubborn cycles are connected to the deceleration lane is more involved as in the previous lower bound construction.Remember that for all open stubborn cycles, we need to maintain the setting in which two edges point to the deceleration lane while the other points into the cycle.We achieve this task by assigning the three nodes of the respective stubborn cycle to the input nodes of the deceleration lane in a round-robin fashion.
We now give the formal construction.The games are denoted by The players, priorities and edges are described in As an initial strategy we select the following strategy ι Hn .Again, it corresponds to a global counter setting in which no bit has been set.
It is easy to see that the H n family again is a family of 1-sink games.(1) The game H n is completely won by player 1.
(2) x is the 1-sink of H n and the cycle component of Ξ ι Hn (w) equals x for all w.
Again, we note that it is possible to refine the family H n in such a way that it only comprises a linear number of edges and only outdegree two.8.5.Remarks.The way to prove the construction corrects runs almost exactly the same as for the locally optimizing policy.Every global counting step is separated into some counting iterations of the deceleration lane with busy updating of the open stubborn cycles of the cycle gates until the least significant open cycle closes.Then, resetting of the lane, reopening of lower cycles and alignment of connecting edges is carried out.
Theorem 8.4.Let n > 0. The Strategy Improvement Algorithm with the I glo -policy requires at least 2 n improvement steps on H n starting with ι Hn .
Our publicly available PGSOLVER Collection [FL09a] of parity game solvers contains implementations of strategy iteration, and particularly parameterizations with the locally and globally optimizing policy.Additionally, the platform features a number of game generators, including all the games and extensions that are presented here.Benchmarking both strategy iteration variants with our lower bound constructions results in exponential run-time behavior as can be seen in Figure 11.

MEAN PAYOFF, DISCOUNTED PAYOFF AND SIMPLE STOCHASTIC GAMES
We now show that the standard reductions [Pur95,ZP96] from parity games to mean payoff, discounted payoff as well as simple stochastic games can be used to derive worst-case families for all the other game classes.
A mean payoff game is a tuple G = (V, V 0 , V 1 , E, r) where V , V 0 , V 1 and E are as in the definition of parity games and r : ) is a mean payoff game and 0 < β < 1 is the so-called discount factor.Whenever we do not want to distinguish between a discounted and a mean payoff game, we simply write payoff game.
Strategies and plays are defined exactly the same as in the definition of parity games.Given a play π, the payoff of the play R G (π) is defined as follows.For a mean payoff game G Let G be a payoff game.For a given node v, a player 0 strategy σ and a player 1 strategy , let π v,σ, denote the unique play that starts in v and conforms to σ and .We say that a node v has a value iff sup σ inf R G (π v,σ, ) and inf sup σ R G (π v,σ, ) exist, and Whenever a node v has a value, we write ϑ G (v) := sup σ inf R G (π v,σ, ) to refer to it.If every node has a value, we say that a player 0 strategy σ is optimal iff inf R G (π v,σ, ) ≥ inf R G (π v,σ , ) for every node v and every player 0 strategy σ and similarly for player 1.

Theorem 9.1 ([EM79]
).Let G be a mean payoff game.Every node v has a value and there are optimal positional strategies σ and s.t.ϑ G (v) = R G (π v,σ, ) for every v.
Note that given two optimal positional strategies, it is fairly easy to compute the associated values.
Parity Games can be easily polynomial-time reduced to mean payoff games s.t.optimal strategies correspond to winning strategies and the values of the nodes directly induce corresponding winning sets in the original parity game.Given a parity game G operates on the same graph and defines the reward function r Ω as follows.
r ]).Let G be a parity game and let σ and be optimal positional strategies w.r.t.IndMPG(G).Then the following holds.
( σ ← I G (σ) 4: end while 5: return σ, σ Next, we will show that the strategy iteration for discounted payoff games behaves exactly the same as the strategy iteration for 1-sink-parity games.
Vöge proves in his thesis [Vög00] the following theorem that relates parity game strategy iteration to Puri's Algorithm for solving the induced discounted payoff game.
Theorem 9.5 ([Vög00]).Let G be a parity game, H = IndDPG(IndMPG(G)) be the induced discounted payoff game and σ be a player 0 strategy.For every two nodes v and u the following holds. Ξ In other words, every improving switch in the original parity game is also an improving switch in the induced discounted payoff game.The reason why this holds true is that by the reduction from parity games to mean payoff games, the priorities are mapped to such extremely large rewards that the largest reward that occurs on a path dominates all lower ones, the largest reward on a cycle dominates all other ones and that the cycle itself dominates all finite paths leading into it.
Theorem 9.5 is almost what we need to show that strategy iteration for discounted payoff games behaves exactly the same on IndDPG(IndMPG(G n )) as the discrete strategy iteration algorithm on G n .Essentially, we need to show the conversion which is equivalent to showing However, this statement is not true for every parity game.The reason why a run of the strategy improvement algorithm on general parity games may differ from a run on the induced discounted payoff game is that the parity game strategy iteration does not care about the priority of all nodes on its path to the dominating cycle node that are less relevant.In case of 1-sink-parity games, the only occurring dominating cycle node has the least priority in the game, and therefore all priorities occurring in paths influence the valuations.Also, the strategy iteration on arbitrary parity games does not consider the priorities of all the nodes on a cycle appearing in a node valuation.
First, we show that optimal player 1 counter strategies in the induced discounted payoff game also eventually reach the 1-sink.
Lemma 9.6.Let G be a 1-sink-parity game with v * being the 1-sink, H = IndDPG(IndMPG(G)) be the induced discounted payoff game, and σ be a player 0 strategy s.t.Ξ ι G ¢ Ξ σ .Let v 0 = v * be an arbitrary node.Then, π v 0 ,σ, σ is of the following form: Proof.Consider the games G := G| σ and H := H| σ and note that τ G σ = τ G σ as well as H σ = H σ .Note that G is won by player 1 following τ G σ since G is 1-sink parity game.By Theorems 9.2 and 9.3 it follows that H σ must be also a player 1 winning strategy for the whole game G .Therefore, it follows that every play π v 0 ,σ, σ eventually ends in cycle with a dominating cycle node w * of odd priority, hence Ω(w * ) ≥ Ω(v * ).
If Ω(w * ) > Ω(v * ), it follows that there is a w * -dominated cycle reachable in G starting from v 0 .But since Ξ σ (v 0 ) = (v * , , ), this cannot be the case.Hence Ω(w * ) = Ω(v * ), implying that w * = v * .Second, we show that the value ordering between two different paths leading to the 1-sink again depends solely on the most relevant node in the symmetric difference of the paths.
Corollary 9.9.Let G be a 1-sink-parity game, H = IndDPG(IndMPG(G)) be the induced discounted payoff game and σ be a player 0 strategy s.t.Ξ ι G ¢ Ξ σ .For every two nodes v and u the following holds.
Corollary 9.10.Puri's algorithm for solving payoff games requires exponentially many iterations in the worst case when parameterized with the locally or the globally optimal policy.
We note that it is possible to define strategy iteration for mean payoff games directly, i.e. without applying the reduction to discounted payoff games first.Unfortunately, with mean payoff games, it is not the case that if σ is not optimal then there necessarily exists at least one switch that strictly improves the reward.There are several way to remedy this situation; most of them are based on a lexicographic ordering again with the first component being the reward and the second component being a description of the nodes leading to the cycle, usually called potential.We note without proof that our results translate to this variant of strategy iteration as well.
Finally, we relate our results to simple stochastic games.Particularly, we consider simple stochastic games with arbitrary outdegree and arbitrary probabilities that halt almost surely.Zwick, Paterson and Condon show that there is direct correspondence between this version of simple stochastic games and the original one [ZP96,Con92].
A simple stochastic game is a tuple G = (V, V min , V max , V avg , 0, 1, E, p) s.t.V min , V max , V avg , {0} and {1} are a partition of V , (V, E) is a directed graph with exactly two sinks 0 and 1, and p : E ∩ (V avg × V ) → [0; 1] is the probability mapping s.t.u∈vE p(v, u) = 1 for all v ∈ V avg .
We say that a simple stochastic game halts with probability 1 iff every node v in G| σ,τ has a path with non-negligible probabilities to a sink for every pair of strategies σ and τ .Every simple stochastic game can be reduced to an equivalent simple stochastic game that halts with probability 1 in polynomial time [Con92].We assume from now on that every given simple stochastic game halts with priority 1.
Given a simple stochastic game and a play π, we say that player Max wins π iff it ends in the 1-sink and similarly that player Min wins π if it ends in the 0-sink.Let R G (v, σ, ) denote the probability that player Max wins starting from v conforming to the Max -strategy σ and the Min-strategy .
We say that a node v has a value iff sup σ inf R G (π v,σ, ) and inf sup σ R G (π v,σ, ) exist, and Whenever a node v has a value, we write ϑ G (v) := sup σ inf R G (π v,σ, ) to refer to it.If every node has a value, we say that a player 0 strategy σ is optimal iff inf R G (π v,σ, ) ≥ inf R G (π v,σ , ) for every node v and every player 0 strategy σ and similarly for player 1.
Theorem 9.11 ( [Con92]).Let G be a simple stochastic game.Every node v has a value and there are optimal positional strategies σ and s.t.ϑ G (v) = R G (π v,σ, ) for every v.
Again, simple stochastic games can be solved by strategy iteration.Given a player Max strategy σ, an (not necessarily unique) optimal counterstrategy σ -i.e.R G (v, σ, ) ≤ R G (v, σ, ) for all other player Min strategies and all nodes v -can be computed by solving an LP-problem as described in Algorithm 4.
The value assignment ϕ can be computed in polynomial time by applying Khachiyan's algorithm [Kha79] for instance.Given ϕ, an optimal counterstrategy σ can be efficiently deduced.The strategy iteration that solves the simple stochastic games runs exactly the same as for discounted payoff games. of priorities, direct-solving of simple cycles, see [FL09b] for instance -they are no solution to the general weakness of strategy iteration on these games, simply due to the fact that all known preprocessing techniques can be fooled quite easily without really touching the inner structure of the games.
Parity games are widely believed to be solvable in polynomial time, yet there is no algorithm known that is performing better than superpolynomially.Jurdziński and Vöge presented the strategy iteration technique for parity games over ten years ago, and this class of solving procedures is generally supposed to be the best candidate to give rise to an algorithm that solves parity games in polynomial time since then.Unfortunately, the locally and the globally optimizing technique are not capable of achieving this goal.
We think that the strategy iteration still is a promising candidate for a polynomial time algorithm, however it may be necessary to alter more of it than just the improvement policy.
and M ≺ N ) or (u = v and M = N and e < f and u ∈ V ) or (u = v and M = N and e > f and u ∈ V ⊕ )

Figure 4 :
Figure 4: Locally Optimizing Lower Bound Game G 3

6. 5 .
Lower Bound Description and Phases.Here, we describe how the binary counter performs the task of counting by strategy improvement.Our games implement a full binary counter in which every bit is represented by a simple cycle encapsulated in a cycle gate.An unset bit i corresponds to an open simple cycle in cycle gate i, a set bit i corresponds to a closed simple cycle in cycle gate i. Formally, we represent the bit state of the counter by elements from B n = {0, 1} n .For b = (b n , . . ., b 1 ) ∈ B n , let b i denote the i-th component in b for every i ≤ n, where b n denotes the most and b 1 denotes the least significant bit.By b ⊕ 1, we denote the increment of the number represented by b by 1.The least resp.greatest bit states are denoted by 0 n resp. 1 n .We refer to the least unset bit by µb := min({n + 1} ∪ {i ≤ n | b i = 0}), and similarly to the least set bit by νb := min({n + 1} ∪ {i ≤ n | b i = 1}).

Table 2 :
Description of the Deceleration Lane

Table 3 :
Description of the Cycle Gate Figure 3: A Cycle Gate (index 1 with p 1 = 3 and p 1 = 33) 14 O. FRIEDMANN

Table 5 :
Description of the Modified Deceleration Lane

Table 6 :
Description of the Modified Cycle Gate

Table 7 .
The game H 3 is depicted in Figure10.However, the edges connecting the cycle gates with the deceleration lane are not included in the figure.

Table 7 :
Lower Bound Construction for the Globally Optimizing Policy Fact 8.1.The game H n has 21 • n nodes, 3.5 • n 2 + 40.5 • n − 4 edges and 24 • n + 6 as highest priority.In particular, |H n Algorithm 3 Puri's Algorithm for Solving Discounted Payoff Games 3) σ is a G-winning strategy for player 0 on W 0 (4) is a G-winning strategy for player 1 on W 1 1: σ ← ι G 2: while σ is improvable do 3: