Divide and conquer with dominion preprocessing by progress measure lifting

The algorithms in Sections 3.3.2 and 3.3.3 apply very distinct techniques to efficiently solve parity games with a large and small, respectively, number of priorities relative to the number of vertices. In this section we show that the two techniques can be successfully combined to improve the worst-case running time from O(dm· (n/(d/2))^d/2) = O(n^d/2+O(1)) of the latter algorithm to O(n^d/3+O(1)), which is the best currently known for parity games with d = O(√

n). The improvement requires a vital modification of the progress measure lifting algorithm from Section 3.3.3.

In Section 3.3.3 we have introduced sets M_Dof (d/2)-tuples of non-negative integers (x_d−1, . . . , x3, x1), where for each odd q the component xqis bounded by the number n^D_q of vertices of priority q in a set D⊆ V . We argued that this set was sufficiently large to express the values of the pointwise-lexicographic least game parity progress measure, and the algorithm progress-measure-lifting(G) computed the least progress measure by iterative application of the lift(·, v) operators.

In this section, for all integers b > 0, we consider an alternative set Nb

of (d/2)-tuples of non-negative integers (xd−1, . . . , x3, x1) that satisfy the condition 

odd qxq ≤ b. Note that for every b > 0, the set Nb ∪ {  } is totally ordered by the lexicographic order on (d/2)-tuples of numbers, and the lift(·, v) operators can be appropriately modified to select only values in the set Nb∪ {  }.

We argue that using sets Nb, for appropriately chosen numbers b, instead of using the set MV, turns the algorithm progress-measure-lifting(G) into an efficient procedure for computing 0-dominions of moderate size, or estab-lishing that no small 0-dominions exist. It is routine and straightforward to adapt the algorithm progress-measure-lifting(G) to compute 1-dominions of moderate size, or establishing lack thereof, too.

These combined procedures for computing 0-dominions and 1-dominions of moderate size are then used in a modification of the dovetailing algorithm parity-win-dominion(G) from Section 3.3.2, instead of using the brute-force search procedure dominion(G, ). We will refer to this modification of pro-cedure parity-win-dominion(G) as propro-cedure parity-win-dominion^†(G), the details of which are presented in Figure 3.5. Note that the procedure parity-win^‡(G), that is used in procedure parity-win-dominion^†(G), is a copy of the procedure parity-win(G) from Section 3.3.1 in which both recursive calls parity-win(G^) and parity-win(G^) have been replaced by calls parity-win-dominion^†(G^) and parity-win-dominion^†(G^), respectively.

Algorithms for Solving Parity Games 93

algorithm parity-win-dominion^†(G)

(D₀, D₁)← progress-measure-lifting^†(G, b) D^∗← reach₀(D₀)∪ reach₁(D₁)

G^∗← G \ D^∗ if|D^∗| < b/2

then (W₀^∗, W₁^∗)← parity-win^‡(G^∗)

else (W₀^∗, W₁^∗)← parity-win-dominion^†(G^∗) endif

(W₀, W₁)← (reach₀(D₀)∪ W₀^∗, reach₁(D₁)∪ W₁^∗) return (W₀, W₁)

Figure 3.5 A divide-and-conquer algorithm for parity games with dominion preprocessing using modified progress measure lifting

For every integer b > 0, we define ξ(b) to be the game parity progress measure computed by the procedure progress-measure-lifting(G) that uses the set N_b∪ {  } instead of M^V ∪ {  }. We also write ζ(b) for the analogous game parity progress measure for player 1 defined mutatis mutandis. In what follows, we write progress-measure-lifting^†(G, b) for the procedure that combines the above-described modified versions of the progress measure lifting procedures for computing 0-dominions and 1-dominions, respectively, and that returns the pair of sets (dom(ξ_(b)), dom(ζ_(b))).

An important property of procedure dominion(G, ) used in Section 3.3.2 was that if it failed to produce a dominion of size at most  then there was no dominion of size at most  in game G, and hence it followed that the argument G^ of the call parity-win-dominion(G^) in procedure parity-win^†(G) had at most n−  vertices. Unsurprisingly, a similar property holds for the procedure progress-measure-lifting^†(G, b): if dom(ξ(b)) =∅ then every 0-dominion in game G is of size strictly larger than b. However, in order to achieve the improved O(n^d/3+O(1)) upper bound for the running time of the algorithm parity-win-dominion^†(G), we need a stronger property that allows us to carry out analysis similar to that used in Exercise 3.11. We formulate this stronger property in the following exercise.

Exercise 3.22 Let b > 0 be even, and assume that|dom(ξ(b))| < b/2. Argue that then dom(ξ_(b)) = dom(ξ_(b/2)), and that reach0(dom(ξ_(b))) = dom(ξ_(b)).

Prove that there is no 0-dominion of size at most b/2 in the game G\ reach0(dom(ξ_(b))), using the property that the set of 0-dominions is closed under union.

94 Marcin Jurdzi´nski

In order to achieve the worst-case running time bound O(n^d/3+O(1)) for the modified divide-and-conquer algorithm parity-win-dominion^†(G), we have to make an appropriate choice of the parameter b for the calls to the preprocessing procedure progress-measure-lifting^†(G, b). It turns out that a good choice for the analysis of the modified algorithm is b = 2n^2/3, where n is the number of vertices of the parity game in the top-level call of the algorithm parity-win-dominion^†(G).

Note that in order to facilitate the running-time analysis of the algorithm, the choice of the parameter b is fixed globally for all recursive calls. This is unlike procedure parity-win-dominion(G), in which the parameter  has been always the function of the number of vertices in the actual argument G of each recursive call. It is worth noting that the analysis of the running time of the algorithm parity-win-dominion(G) carried out in Section 3.3.2 could have also been done with the parameter  fixed at the top level throughout all recursive calls.

In the following exercise we analyse the worst-case running time of the preprocessing procedure progress-measure-lifting^†(G, b).

Exercise 3.23 Argue that |Nb| =_b+(d/2)

d/2

=d/2 i=1

b+i

i . Prove that for all sufficiently large integers n, if b = 2n^2/3 then we have ^b+1₁ ·^b+2₂ ·^b+3₃ ·^b+4₄ ≤ (n^2/3)⁴, and ^b+i_i ≤ n^2/3for all i≥ 3, and hence that |Nb| ≤ n^d/3 for all d≥ 8.

Conclude that if b(n) = 2n^2/3 then the worst-case running time of the procedure progress-measure-lifting^†(G, b(n)) is O(n^d/3+O(1)).

We are now ready to complete the analysis of the worst-case running time of the divide-and-conquer algorithm parity-win-dominion^†(G). Observe that if the else-case in the algorithm parity-win-dominion^†(G) obtains then the argument of the only recursive call parity-win-dominion^†(G^∗) is clearly a game with no more than n− n^2/3 vertices. On the other hand, if the then-case obtains instead, then within the call parity-win^‡(G^∗) two recursive calls parity-win-dominion^†(G^) and parity-win-dominion^†(G^) are made, the argument G^ of the former has at most d− 1 priorities if G had d, and the number of vertices of the argument G^ of the latter is, by Exercise 3.22, at most n−n^2/3. In either case, for every n^2/3 decrease in size of game G^∗or of G^, at most one recursive call is made to a game with at most d−1 priorities.

Finally, each recursive call of procedure parity-win-dominion^†(G) leads to one call of procedure progress-measure-lifting^†(G, b) which, by Exercise 3.23, runs in time O(n^d/3+O(1)).

Exercise 3.24 Argue that the worst-case running time of the procedure

Algorithms for Solving Parity Games 95 parity-win-dominion^†(G) can be characterised by the recurrence:

T (n, d) ≤ T (n, d − 1) + T (n − n^2/3, d) + O(n^d/3+O(1)), T (n, 1) = O(n),

and hence also by the recurrence:

T (n, d) ≤ n^1/3· T (n, d − 1) + O(n^d/3+O(1)), T (n, 1) = O(n).

Prove that T (n, d) = O(n^d/3+O(1)).

Theorem 3.10 (Schewe [2007]) The winning sets and positional win-ning strategies of both players in parity games can be computed in time O(n^d/3+O(1)).