Smaller Progress Measures and Separating Automata for Parity Games

Calude et al. have recently shown that parity games can be solved in quasi-polynomial time, a landmark result that has led to a number of approaches with quasi-polynomial complexity. Jurdinski and Lasic have further improved the precise complexity of parity games, especially when the number of priorities is low (logarithmic in the number of positions). Both of these algorithms belong to a class of game solving techniques now often called separating automata: deterministic automata that can be used as witness automata to decide the winner in parity games up to a given number of states and colours. We suggest a number of adjustments to the approach of Calude et al. that lead to smaller statespaces. These include and improve over those earlier introduced by Fearnley et al. We identify two of them that, together, lead to a statespace of exactly the same size Jurdzinski and Lasic's concise progress measures, which currently hold the crown as smallest statespace. The remaining improvements, hence, lead to a further reduction in the size of the statespace, making our approach the most succinct progress measures available for parity games.


Introduction
Parity games are two-player perfect information turn-based zero-sum games of infinite duration played on finite directed graphs. Each vertex, that is labelled with an integer colour, is assigned to one of the two players, even and odd, here referred to as he and she, respectively. A play consists in an infinite sequence of player's moves around the graph, and the winner is determined by the parity of the largest colour encountered along the play. Hence, player even (he) wins if it is an even colour, and player odd (she) wins otherwise.
Parity games have been extensively studied for their practical applications, to determine their complexity status, and to find efficient solutions.
From a practical point of view, many problems in formal verification and synthesis can be reformulated in terms of solving parity games. Computing winning strategies for these games is linear-time equivalent to solving the modal µ-calculus model checking problem [12,13]. They can be applied to solve the complementation problem for alternating automata [18] or the emptiness of the corresponding nondeterministic tree automata [22]. These automata, in turn, can be used to solve the satisfiability and model checking problems for several expressive logics [9,27,26,5,6], such as µ-calculus [35,32] and ATL* [1,31].
On the complexity theoretic side, determining the winner of a parity game is a problem that lies in NP ∩ co-NP [12], being memoryless determined [28,11,25], but it has been even proved to belong to UP ∩ co-UP [19], and later to be solvable in quasi-polynomial time [8]. However, determining their exact complexity is still an open problem.
The existing algorithms for solving parity game can be divided into two classes. The first one collects approaches that solve the game by creating a winning strategy for one of the two players on the entire game. This can be done either employing a value iteration over progress measures [20] or iteratively improving the current strategy [34,14,17]. To the second class, instead, belong approaches that decompose the solution of a game into the analysis of its subgames in a divide-et-empera concept. To do so, these approaches partition the game into a set of positions that satisfy the required properties. The name of the sets depend on the properties: attraction set [36,30], region [4,3,2], tangle [33], and justification [23].
Many algorithms from both the classes have been refined to achieve a quasipolynomial upper bound since the contribution of Calude et al. [8]. This seminal paper works as a value iteration algorithm with compact measures for which a poly-logarithmic size witness is sufficient, rather than storing the entire history of the play. The same approach has been refined improving the complexity result [16,21], while the same complexity has been achieved by a number of different approaches such as the register-index algorithm [24] and the bounded version of the recursive algorithm [29]. Interestingly, all the known quasi-polynomial algorithms have been proved to be derived by the separation approach that also provide a lower bound for these techniques [10].

Contribution
We adjust the definitions of witnesses, the data structure first used by Calude et al. [8] and the way they are updated in a number of ways.
The most clear-cut improvement is the increased succinctness of the resulting structures: integrating them with the improvements suggested in Fearnley et al. [15], we achieve a number of improvements with different power to improve the succinctness of the data structure. The most powerful of these improvements is the restriction of the occurrences of odd colours within the witnesses to at most one. Together with the small improvement from [15] that, when the maximal colour is odd, we can just reset the witness to its initial value instead of recording this value, we obtain a statespace of quite different strucuture to, but the same size as, the currently smallest statespace from Jurdzinski and Lasic [21].
On top of this improvement, we offer small additional improvements, incl. the improvement from [15] that the odd colours can be skipped for the least significant position of a witness, and the new improvements that make a more careful use bounds on the length of 'even chains' (usually the number of positions with even colour) and the exclusion of the least colour when this colour is odd. Depending on the bound for the length of an even chain, this translates to a further improvement between a factor from just under two to just under four.
The second improvement is a re-definition of the semantics of witnesses, moving from the classic witnesses to colour witnesses, where all positions with the came colour in a witness refer to one chain, instead of referring to many. This accelerated convergence, though the acceleration is muted where it is used for value iteration.

Outline
We discuss a variation of the algorithm of Calude et al. [8], partly in the original version and partly in the variation suggested by Fearnley et al. [15], to extend this approach to value iteration.
After the general preliminaries, we therefore recap this approach in Section 3, using a mild variation of the witness from [8] for a basic update rule up that updates a witness b when reading a state with colour v to a witness b = up (b, v), and an antagonistic update rule au that updates a witness b when reading a state with colour v to the witness We then amend those rules in two steps. The first step (Section 4) reduces the statespace, but otherwise retains the classic lines of [15]. It is a simple extension that carries the easiest to spot (and sell) improvement of this work: the reductions from the statespace of the witnesses used, leading to more concise witnesses.
The backbone of the statespace reduction is to simply restricts the number of times an odd colour occurs in a witness to at most once. Where the maximal colour is even, this change alone leads to a perfect match in size with the statespace of [21], which is currently the smallest. This perfect match is a bit surprising, as the structure of the statespace is very different.
The remaining changes extend this to the case where the maximal colour is odd and collects some further minor reductions that roughly lead to a spatespace reduction that is usually in a range between 2 and 4, where the advantage is strongest when the number of states with an even number of colours is a power of 2.
Subsequently, we re-interpret the semantics of a witness in Section 5. This change in semantics does not change the statespace, but it allows for updating the witnesses faster. Faster updating is mainly improving the basic update rule, but to some extend also the antagonistic update rule, leading to faster convergence in both cases.
We then turn to an estimation of the new statespace in Section 6. For this, we proceed in a number of steps. We first look at the two classic statespaces, considering the previously most concise one those of Calude et al.'s original QP algorithm [8].
We then turn to using those improvements to [8] that lead to a statespace of size equal to that of [21]. This is done in order to be able to show that the two statespaces are of precisely the same size, but also to have a clear understanding which improvements remain beyond this, and to focus on how they influence the statespace.
We then exemplify how the three statespaces compare in size in Section 6.5.

Preliminaries
Parity games are turn-based zero-sum games played between two players-even and odd, referred to as he and she, respectively-over finite graphs. A parity game P is a tuple is a finite directed graph, where the set V of vertices is partitioned into a set V e of vertices controlled by player even and a set V o of vertices controlled by player odd, and where E ⊆ V × V is the set of edges; -C ⊆ N = {1, 2, 3, . . .} is a finite consecutive set of colours, such that C = {1, 2, . . . , max{C} or C = {2, 3, . . . , max{C} holds; and φ : V → C is the colouring functions that maps each vertex to a colour.
We define C − = C max{C} if the highest colour max{C} is odd, and C − = C if the highest colour max{C} is even, and require that every vertex has at least one outgoing edge.
Intuitively, a parity game P is played between the two players by moving a token along the edges of the directed graph (V, E). A play of such a game starts at some initial vertex v 0 ∈ V where the token is placed at the beginning. The player controlling this vertex then chooses a successor vertex v 1 such that (v 0 , v 1 ) ∈ E, and the token is moved to this successor vertex. In the next turn the player controlling the vertex v 1 make his choice by picking a successor vertex v 2 where to move the token, such that (v 1 , v 2 ) ∈ E, and so on. In this manner both players move the token over the arena and thus form an infinite play of the game.
Formally, a play of a game P is an infinite sequence of vertices We denote as Plays P (v) the set of plays of the game P that origins in a vertex v ∈ V and as Plays P the set of all plays of the game. We omit the subscript when the arena is clear from the context. The colour mapping φ : V → C can be extended from vertices to plays by defining the mapping φ : A play v 0 , v 1 , . . . is won by player even if lim sup i→∞ φ(v i ) is even, and by player odd otherwise.
A prefix of a play (or play prefix) is a non-empty initial sequence v 0 , v 1 , . . . , v m of a play v 0 , v 1 , . . . .
A strategy for player even is a function σ : V * V e → V such that v, σ(ρ, v) ∈ E for all ρ ∈ V * and v ∈ V e . If a strategy σ only depends on the last state, then is called memoryless (σ(ρ, v) = σ(ρ , v) for all ρ, ρ ∈ V * and v ∈ V e ). A play v 0 , v 1 , . . . is consistent with σ if, for every initial sequence ρ n = v 0 , v 1 , . . . , v n of the play that ends in a state of player even (v n ∈ V e ), σ(ρ n ) = v n+1 holds. Player even wins the game starting at v 0 if he has a strategy σ such that either all plays v 0 , v 1 , . . . consistent with σ satisfy lim sup i→∞ φ(v i ) (i.e. the highest colour that occurs infinitely often in the play) is even or all plays v 0 , v 1 , . . . consistent with σ contain a loop v i , v i+1 , . . . , v i+k , that satisfies v i = v i+k and that max{φ(v i ), . . . , φ(v i+j ) is even. In both cases σ might be memoryless. We use different criteria in the technical part, choosing the one that is most convenient.
A separating automaton [7] for parity games with a set of colours C and a bounded number of states, or a bounded number of states with even colour, is a deterministic reachability automaton A = (Q, C, q 0 , δ, won), where -Q is the set of states, with q 0 , won ∈ Q, q 0 is the initial state and won is the target state (and sink), and δ : Q × C → Q is the transition function (with δ(won, v) = won for all v ∈ C), such that, for all parity games with colours C and that have no more states (of even colour) than the given bound, there are if q ∈ V is a winning state, then there is a positional strategy σ for player even such that the run of A on all plays consistent σ are accepted by A, i.e. reach the target state won; and if q ∈ V is a winning state, then there is a positional strategy σ for player odd such that the run of A on all plays in Plays(q) consistent σ are accepted by A, i.e. does not reach the target state won.

Classic Witnesses
We adjust the approach from [8] and [15], and this section is predominantly taking the representation from [15]. It does, however, change some details in the definitions of i-witnesses that end in an odd priority and the definition of the value of a witness slightly to suite the rest of the paper better. Where the proofs are affected, they are adjusted and given, but the proofs are mostly unaffected by these minor details.

Classic Forward Witness
We start with describing the old witness without making its semantics formal (as we do not need it in this paper), and will turn to the new concise witness (Section 4) and the colour witness (Section 5) afterwards.
i-Witnesses Let ρ = v 1 , v 2 , . . . , v m be a prefix of a play of the parity game. An even i-witness is a sequence of (not necessarily consecutive) positions of ρ p 1 , p 2 , p 3 , . . . , p 2 i , of length exactly 2 i , and an odd i-witness is a sequence of (not necessarily consecutive) positions of ρ p 0 , p 1 , p 2 , . . . , p 2 i of length exactly 2 i + 1, that satisfy the following properties: -Position: each p j specifies a position in the play ρ, so each p j is an integer that satisfies 1 ≤ p j ≤ m. -Order: the positions are ordered. So we have p j < p j+1 for all j < 2 i .
-Evenness: all positions but the final one are even. Formally, for all j < 2 i the colour φ(v pj ) of the vertex in position p j is even. For position p 2 i , its colour φ(v p 2 i ) is even for an even i-witness, and odd for an odd i-witness. Note that this entails that an i-witness contains an even chain of length 2 i . -Inner domination: the colour of every vertex between p j and p j+1 is dominated by the colour of p j or the colour of p j+1 . Formally, for all j < 2 i , the colour of every vertex in the subsequence v pj , v (pj )+1 , . . . , v p (j+1) is less than or equal to max φ(v pj ), φ(v pj+1 ) . -Outer domination: the colour of p 2 i is greater than or equal to the colour of every vertex that appears after p 2 i in ρ. Formally, for all k in the range Witnesses We define C = C − ∪ { } as the set of colours plus with the symbol. A witness is a sequence such that each element b i ∈ C , and that satisfies the following properties: -Witnessing: there exists a family of i-witnesses, one for each element b i with b i = .
We refer to such an i-witness in the run ρ. We will refer to this witness as for even witnesses and p i,0 , p i,1 , . . . , p i,2 i for odd witnesses. -Dominating colour: For each b i = , we have that b i = φ(v p i,2 i ). That is, b i is the outer domination colour of the i-witness. -Ordered sequences: The i-witness associated with b i starts after a j-witness associated with b j whenever i < j. Formally, for all i and j with i < j, if b i = and b j = , then p j,2 j < p i,1 when the i-witness is even, and p j,2 j < p i,0 otherwise.
For a little bit of extra conciseness, we also require that b 0 is either even or . Note that the witness does not store the i-witnesses associated with each position b i . However, the sequence is a witness only if the corresponding i-witnesses exist. Moreover, the colours in a witness are monotonically increasing for growing indices (and thus increase from right to left), since each colour b j (weakly) dominates all colours that appear afterwards in ρ as a consequence of the dominating colour property and the ordered sequences property.
Forward and backward witnesses. The forward witnesses described so far were introduced in [8], while we now describe the backward witnesses and an ordering over them that have been introduced in [15]. For each play prefix ρ = v 1 , v 2 , . . . , v m , we define a reverse play ← − ρ = v m , v m−1 , . . . , v 1 ; a backward witness is a witness for ← − ρ , or for a prefix of it.
Order on witnesses. The order we have mentioned earlier orders the set C such that even numbers are better than odd numbers, higher even numbers are better than smaller even numbers, smaller odd numbers are better than higher odd numbers, and every number is better than . Formally, a b if b = ; or a is even and b is either odd or a ≥ b; or a ≤ b and they are both odd.
Using , we define an order over witnesses that compares two witnesses lexicographically, where the most significant element is b k and the least significant element is b 0 . Each element is compared using the order . The biggest witness has a special value won; i.e., won b holds for all witnesses b.
The value of a witness. For each witness b = b k , b k−1 , . . . , b 0 , we define the following functions: -Even positions: Remark. The value function from [15] is different in that is uses i∈even(b) 2 i . We will discuss the impact that this difference has on the statespace at the end of Section 6.
We can show that the value of b corresponds to the length of an even chain in ρ that is witnessed by b. Lemma 1. [15] If b is a (forward or backward) witness of ρ, then there is an even chain of length value(b) in ρ.
If we count the number of vertices with even colours in the game as e = |{v ∈ V : φ(v) is even }|, then we can observe that in case we have an even chain longer than e then ρ contains a cycle, as there is a vertex with even colour visited twice in this even chain. Moreover, the cycle is winning player even, since the largest priority of its vertices must be even. As a consequence, if player even can force a play that has a witness whose value is strictly greater than e, he wins the game. Lemma 2. [15] If, from an initial state v 0 , player even can force the game to run through a sequence ρ, such that ρ has a (forward or backward) witness b such that value(b) is greater than the number of vertices with even colour, then player even wins the parity game starting at v 0 .
For this reason, we only need witnesses with value ≤ e. If an update would produce a witness of value > e, then the resulting witness must contain a winning cycle.
Thus, the set of classic witnesses is

Updating Witnesses
Forward witnesses can be constructed incrementally by processing the play one vertex at a time. The following lemmas assume that we have a play ρ = v 0 , v 1 , . . . , v m , and a new vertex v m+1 that we are going to append to ρ in order to create ρ . The value d = φ(v m+1 ) denotes the colour of the new vertex v m+1 . We will suppose that b = b k , b k−1 , . . . , b 1 , b 0 is a witness for ρ, and we will construct a witness c = c k , c k−1 , . . . , c 1 , c 0 for ρ .
We present three lemmas that allow us to perform this task.
[15] Suppose that d is even, there exists an index j such that: If we set c i = b i for all i > j, c j = d, and c i = for all i < j, then c is a witness for ρ .
Note that we returned to the original definition from Calude et al. [8] by restricting the 'overflow rule' from Lemma 3 to even numbers, whereas the witnesses from [15] also allowed this operation to be performed in the case where d is odd. The reason for this is that it reduces the statespace: while this reduction is insignificant in most cases, it is quite substantial if e = 2 p − 1 for some power p ∈ N, as it leads to an increase in the length of the witness. As this statespace reduction is a core target of this paper, we opted to be precise here.
Note that the following lemmas (and their proofs) are essentially independent of this.

Lemma 4.
[15] Suppose that d ∈ C − and there exists an index j such that: Then setting c i = b i for all i > j, setting c j = d if j = 0 (and c j = if j = 0), and setting c i = for all i < j yields a witness for ρ .
There is a tiny difference in the proof of this lemma in that we require the length of the j-witness to be 2 j + 1 when c j is set to d. But either b j was odd before, in which case replacing the last index of the j-witness by m + 1 still produces a witness of length 2 j + 1, or it was even, and in that case we can instead append m + 1 to the old j-witness.
When we want to update a witness with the raw udate rule upon scanning another state v m+1 with colour d = φ(v m+1 ), we select the according lemma if d ∈ C − . Otherwise, i.e. when d = max{C} and odd, we re-set the witness to , . . . , (which is a witness for every play prefix).
For a given witness b and a vertex v m+1 , we denote with -Raw update: ru (b, d) the raw update of the witness to c, as obtained by the update rules described above.
Basic and Antagonistic Update Game With these update rules, we define a forward and a backward basic update game played between the two players he and she. In this game, they produce a play of the game as usual: if the pebble is on a his position, then he selects a successor, and if the pebble is on a her position, then she selects a successor. Player even can stop any time he likes and evaluate the game using b 0 = , . . . , as a starting point and the update rule For a forward game, he would process the partial play ρ + = v 0 , v 1 , v 2 , . . . , v n from left to right, and for the backward game he would process the partial play ρ − = v n , v n−1 , . . . , v 0 . In both cases, he has won if, and only if, b n+1 = won. Theorem 1. [15] If, and only if, player even has a strategy to win the classic forward resp. backward basic resp. antagonistic update game, then he has a strategy to win the parity game.
This can be formulated in a way that, for a given set C of colours and e states with even colour, the deterministic reachability automaton with states W, initial state , , . . . , , update rules up (or au ), and reachability goal to reach won is a separating automaton.
Corollary 1. For a parity game with e states and k = log 2 (e) and W the space for witnesses of value ≤ e, length k + 1 and colours C, both U = (W; C; , . . . , ; up ; won) and A = (W; C; , . . . , ; au ; won) are separating automata.
The advantages of the antagonistic update rule is that it is monotone: b c → au (b, d) au (c, d). This allows for using au in a value iteration algorithm [15].

Concise Witness
As in this article we suggest a change in the semantics of the witness, which reduces the statespace of witnesses to C ⊂ W, in the following section we will improve the update rule.
The main theoretical advancement is the smaller statespace, as it directly translates into improved bounds, slightly outperforming the currently leading QP algorithm in this regard.
Note that the definition of ↓ 1 entails Building on the definition of ↓ 1 , we continue with the following definitions.
is simply a restriction of from W to C), and -Antagonistic update: Proof. We look at the effect the different update rules have on b and c. Lemma 3 would (for the same j) change the tail (starting with the j-witness) of c and b in the same way to d, , . . . , , and they either both do or do not satisfy the prerequisites for its application. Thus, the ↓ 1 operator would remove exactly those positions > j from ru (c, d) that it removed from c.
When Lemma 4 applies, then it does so for the same index j, and it simply overwrites the tail starting there with d, , . . . , (or with if j = 0). As all higher positions are unchanged and greater or equal to When the conditions of Lemma 5 apply either for both, b and c, or for neither of them, then we note that Lemma 5 does not change the witness.
Finally, if d = max{C} and odd, then Theorem 2. If, and only if, player even has a strategy to win the concise forward resp. backward basic antagonistic update game, then he has a strategy to win the parity game.
Proof. This follows from Theorem 1: because the same runs are winning when using up and up due to Corollary 2, the same player wins the classic and the concise basic update game.
Theorem 3. If, and only if, player even has a strategy to win the concise forward resp. backward antagonistic update game, then he has a strategy to win the parity game.
Proof. For the 'if' case, we observe that Corollary 2 implies with the monotonicity of au that, when even wins the classic antagonistic update game, he also wins the concise antagonistic update game (with the same strategy). Together with Theorem 1, this provides the 'if' case.
For the 'only if' case, we observe that the monotonicity of au entails that, when odd wins the basic concise update game, then she wins the antagonistic update game (with the same strategy). Together with Theorem 2, this provides the 'only if' case.
Corollary 3. For a parity game with e states of even colour and k = log 2 (e) and W the space for witnesses of value ≤ e, length k + 1 and colours C, both U = (C; C; , . . . , ; up; won) and A = (C; C; , . . . , ; au; won) are separating automata.
To give an intuition to their states, for U being in a state b = won means that b is a witness for the play prefix, while won means that the play prefix contains an even chain of length > e, and thus an even cycle.
For A being in a state b means that there is a state c b with this property.
As a final remark, in the rare cases where even colours are scarce, their appearance in C can also be restricted: if only e # states have an even colour e, then the number of occurrences of e in a concise witness can be capped to e # , too, as more occurrences of e without an intermediate occurrence of a higher colour would imply that an accepting cycle is in the word.
However, for this to reduce the statespace, e # ≤ log 2 (e) is required, and the closer it comes to log 2 (e) , the lesser is the saving. In particular, for e # = log 2 (e) , we would just safe a single state.

Colour Witnesses
In this section, we use the same data structure as before-the concise witnesses from the previous section-but adjusting its semantics.
We introduce two changes to the semantics of witnesses that accelerate the speed in which updates can be made. We discuss them for concise witnesses C.
Before formalising how we make our witnesses more flexible and how we use this to re-define the raw update function (and, through this, the update function and the antagonistic update), we describe on a number of examples how we change the semantics of witnesses.

Motivating examples
Merging witnesses: If we consider the classic witness b = 4, , 4, , it referred to two i-witnesses that each end on a state with colour 4, one of length 8 and one of length 2.
We will instead view this as a single colour witness for colour 4, which then refers to a single even chain of length at least 10.
As a consequence, when passing by a state with colour 6, we can now update the witness to 6, , 6, 6, as this would require a single even chain of at least length 11 that ends in a 6.
Shifting witnesses: If we consider the witness b = 4, 2, , , it referred to two iwitnesses, where the first has length 8 and ends on colour 4, while the second has length 4 and ends on colour 2.
We will allow to make the latter sequence shorter, so long as the former sequence is extended accordingly. For example, when the sequence that ends in 4 has length 10, then it would suffice if the sequence that ends in 2 has length 2.
Likewise, for b = 6, , 4, 2, 2, it would be allowed that the length of the even chain that ends in 6 is 18, the subsequent sequence that ends in 4 is 3, and the length of the sequence that ends in 2 is 2. If the length of the sequences ending in 6, 4, and 2 are 6 , 4 , and 2 , respectively, the constraints would be 6 ≥ 16, 6 + 4 ≥ 20, and When passing by a state with colour 8, we can now update the witness to 8, 8, , , , as this would require a single sequence of at least length 24 that ends in an 8.
Blocked shifting: This shifting cannot be done through an odd colour: for b = 4, 3, 2, 2, the requirement for the rightmost sequence would be to be of length at least three and to end in a 2. It is, however, possible to shift some of the required length of the sequence that ends in 3 to the sequence that ends in 4: if the length of the sequences ending in 4 and 3 are 4 and 3 , respectively, the constraints would be 4 ≥ 8 and 4 + 3 ≥ 13.
(Recall the odd witnesses need to be one position longer to contain an even chain of the same length.) Thus, reading a 6 would lead to the witness 6, 6, , 6.

Colour Witness
The biggest change is that an i-colour witness (i-cowit) refers to the colour i, rather than to the position b i in the witness. Consequently, we do not have a fixed length of an i-colour witness, and refer to the length of the witness for each colour i that appears in a witness as i .
As before, we focus in our description on forward witnesses, with backward witnesses being defined accordingly.
i-Colour witness (i-cowit) with value i Let ρ = v 1 , v 2 , . . . , v m be a prefix of a play of the parity game. An even i-cowit is a sequence of (not necessarily consecutive) positions of ρ p 1 , p 2 , p 3 , . . . , p i of length exactly i , and an odd i-cowit is a sequence of (not necessarily consecutive) positions of ρ p 0 , p 1 , p 2 , . . . , p i of length exactly i + 1, that satisfy the following properties: -Position: each p j specifies a position in the play prefix ρ, so each p j is an positive integer that satisfies 1 ≤ p j ≤ m. -Order: the positions are ordered. So we have p j < p j+1 for all j < i . -Evenness: all positions but the final one are even. Formally, for all j < i the colour φ(v pj ) of the vertex in position p j is even. For position p i , its colour φ(v p i ) = i. Then, the colour of that position is even for even i-cowit, and odd for odd i-cowit. Note that this entails that an i-cowit has i initial even positions that define an even chain of length i .
-Inner domination: the colour of every vertex between p j and p j+1 is dominated by the colour of p j or the colour of p j+1 . Formally, for all j < i , the colour of every vertex in the subsequence v pj , v pj +1 , . . . , v pj+1 is less than or equal to Moreover, i is greater than or equal to the colour of every vertex that appears after position p i in ρ. Formally, for all k in the range Colour witnesses Like a concise witness, a colour witness is a sequence of length 2 k + 1, such that each element b i ∈ C , and that satisfies the following properties.
-Properties of the sequence: defining i-positions as the positions in b that have value i, positions(i, b) = {j ≤ k | b j = i} for every i ∈ C − , the sequence has to satisfy the following constraints: • order: for i > j, we have that b i ≥ b j or ∈ {b i , b j } holds; and • conciseness: for all odd i ∈ C − , positions(i, b) ≤ 1 and b 0 = i hold. -Witnessing: • ordered witnesses: for i > j with positions(i, b) = ∅ and positions(j, b) = ∅, the j-witness starts after the i-witness ends. That is p i, i < p j,1 if j is even and p i, i < p j,0 if j is odd.
It should be noted that neither the i-cowit-s associated with each colour, nor the value of the i are stored in a colour witness. However, in order for a sequence to be a colour witness for an initial sequence of a run, the corresponding i-cowit-s must exist.

Updating Colour Witnesses
We now show how forward colour witnesses can be constructed incrementally by processing the play one vertex at a time. Throughout this subsection, we will suppose that we have a play ρ = v 0 , v 1 , . . . , v m , and a new vertex v m+1 that we would like to append to ρ to create ρ . We will use d = φ(v m+1 ) to denote the colour of this new vertex. We will suppose that b = b k , b k−1 , . . . , b 1 , b 0 is a colour witness for ρ, and has i-cowit-s with individual lengths i . We will construct a witness c = c k , c k−1 , . . . , c 1 , c 0 for ρ and discuss how its inferred i-cowit-s look like.
We present four lemmas that allow us to perform this task.
Lemma 7. Suppose that d ∈ C − is odd and, for all j ≤ k, either b j = or b j > d. If we set c i = b i for all i ≤ k, then c is a colour witness for ρ .
Proof. Since d < b j for all j, the outer domination of every e-colour witness implied by b is not changed. Moreover, no other property of any e-colour witness is changed by the inclusion of v m+1 in the initial sequence, so by setting c = b we obtain a colour witness for ρ .
Note that the proof of Lemma 7 does not use that d is odd and holds similarly when d is even; however, in that case Lemma 10 provides a better update for the colour witness. Proof. For all e > d, the e-colour witness (if any) implied by b can be kept: the outer domination of every such e-colour witness implied by b is not changed. Moreover, no other property of any such e-colour witness is changed by the inclusion of v m+1 in the initial sequence.
For the b j -colour witness, we either update the last vertex to m + 1 (if b j is odd) or append m + 1 to the it (if b j is even). In both cases, the inner domination rules are valid (due to the inner and outer domination rules for the b j -colour witness) and the outer domination rule holds trivially. Moreover, the side constraints for the length carry over from those for b (when b j is odd), for d , by adding one to the length constraint while also appending one state (when b j is even).
So, c is a colour witness for ρ .
Lemma 9. Suppose that d is even, there exists a maximal index j such that b j < d, and b j is odd. Then setting: yields a colour witness for ρ .
Proof. We simply append all i-cowit-s that exist for b in the interval i ∈ {b j , . . . , d}.
We append them in the given order (from the largest i to the the lowest, b j ), and then replace the last index (which is from the b j -covit) by m + 1.
The inner domination rules are valid (due to the inner and outer domination rules for the i-cowit-s involved, and by b j < d. The outer domination rule trivially holds. The only new rule to be considered is the rule on the joint length of the i-cowit-s in ubp(d, c), but this is the same length (as only the last element is changed) and the same constraint as for the sum of the length of the i-cowit-s in ubp(b j , b).
Lemma 10. Suppose that d is even and there is no index j such that b j < d and b j is odd. Let j be the maximal index (which might be 0) such that: either b j = , or b j > d and b j is odd; and for all i < j, b i is even.
If we set: (and thus even), c j = d, and for all i < j, b j = , then c is a colour witness for ρ .
Proof. We simply append all i-cowit-s that exist for b in the interval i ∈ {2, . . . , d}. We append them in the given order (from the largest i to the the lowest), and then append m + 1.
The inner domination rules are valid (due to the inner and outer domination rules for the i-cowit-s involved. The outer domination rule trivially holds. The only new rule to be considered is the rule on the joint length of the i-cowit-s in ubp(d, c), but this is one more than the length (as only the last element is appended) and the same constraint as for the sum of the length of the i-cowit-s in ubp (2, b).
Again, if d = max{C} and odd, then the raw update of the colour witness is , . . . , , which is a colour witness for every play prefix.
When we want to update a witness upon scanning another state v m+1 with colour d = φ(v m+1 ), we can apply the update rule from one of the Lemmas 7 through 10.
For a given witness b and a vertex v m+1 , we denote with -Raw update: ru + (b, d) the raw update of the witness to c, as obtained by the update rules described above.
where e is the number of vertices with even colour), or up + (b, v m+1 ) = won otherwise. In particular, up + (won, d) = won for all d ∈ C. -Antagonistic update: We first observe that up + is indeed 'faster' than up in that it always leads to a better (w.r.t. ) state: This is easy to check by the raw update rules, and it entails: Theorem 4. The following three claims are equivalent for both, forward and backward witnesses: 1. player even has a strategy to win the parity game, 2. player even has a strategy to win the fast basic update game (using up + ), and 3. player even has a strategy to win the fast antagonistic update game (using au + ).
Proof. (1) implies (3): By Theorem 3, that player even wins the parity game entails that he wins the concise antagonistic update game. As au + provides (not necessarily strictly) better updates (w.r.t. ) than au, and by the antagonistic update being monotone by definition, this entails (3).
(2) implies (1): when up + produces a win if, and only if, ru + produces a colour witness with value > e, which according to Lemmas 7 through 10 entails that it has an even chain whose length is strictly greater than e. The play ρ must, at that point, contain a cycle, since there must be a vertex with even colour that has been visited twice. Moreover, the largest priority on this cycle must be even, so this is a winning cycle for player even.
Corollary 5. For a parity game with e states of even colour, colours C, k = log 2 (e) and C the space for concise witnesses of value ≤ e, length k + 1 and colours C, both U = (C; C; , . . . , ; up + ; won) and A = (C; C; , . . . , ; au + ; won) are separating automata.
To give an intuition to their states, for U being in a state b = won means that b is a colour witness for the play prefix, while won means that the play prefix contains an even chain of length > e, and thus an even cycle.
For A being in a state b means that there is a state c b with this property.

Faster Conversion
While the method will speed up A = (C; C; , . . . , ; au + ; won) a little, the difference is easier to see when using U = (C; C; , . . . , ; up + ; won). The classic QP algorithms [8,21,15] have very simple pathological examples. For example, [21] would traverse the complete statespace for a state colour 2 and a selfloop (or for a state with colour 1 and a selfloop, depending on whose player's side the algorithm takes). Similarly, [8] would traverse very large parts of its statespace when fed with only even colours.
Using our update rules for colour witnesses, a loop with even colours will always lead to acceptance within e + 1 steps.
It is possible to make this a bit more robust against the occurrence of odd priorities that are then immediately followed by higher even priorities by returning to W as a statespace 3 .

Statespace
In this section, we compare the size of the statespace with both the statespace from the construction of Jurdzinski and Lasic [21]-which comes with the best current boundsand the original stataspace from Calude et al. [8].
We then discuss the effect of the four improvements over the original approach from Calude et al. [8]: 1. the restriction of the number of occurrences of odd colours in a witness to once, 2. not using any colour that is higher than any even colour; 3. not allowing for odd colours in the rightmost position (i.e. b 0 ); 4. the removal of the colour 1; and 5. moving from length to value restriction.
The first of these improvements is, individually, the most powerful one. Three of the other improvements, (2) -(4), have already been discussed in this form in [15].
We will show in Subsection 6.3 that applying only improvements (1) and (2) leads to a statespace of exactly the same size as that of Jurdzinski and Lasic [21].
Consequently, the further improvements, (3) -(5), lead to a strictly smaller statespace. The improvement from (3) alone almost halves the statespace, while (4) alone has only a small effect. The effect of rule (5) varies greatly: it is strongest when the bound on the length of an even chain is a power of 2 (2 p for some p ∈ N), where it leads to halving the statespace, and vanishes if it is one less (2 p − 1 for some p ∈ N).
After briefly visiting the statespace from [15], we then turn to an experimental comparison of the three statespaces of interest, confirming the quantification of the advantage we have obtained over [21].
In this section, we use count size alg for counting the number of state minus one, estimating the number of states except for the winning state ('won'), which all progress measures under consideration have. The superscript size can be , saying that only the length of the data structure (or: the log 2 (e + 1) for the maximal length e of an even chain) is taken into account; v if the value of witness is taken into account (or: the maximal length e of an even chain) is taken into account, and , v if both are used. The subscript is either JL when counting the concise progress measures from [21], O when considering the original approach from [8], 1, 2 when adding improvements (1) and (2), or blank when considering either improvements (1) through (4) or all improvements. In a closing comparison with the statespace of [15], we use the subscript JKSSW .

Concise Progress Measures [21]
While we will not describe the algorithm, but the data structure, which holds a winning state besides the states we describe. For each even priority, there is a (possibly empty) word over two symbols, say + and −, such that the words concatenated have length at most = log 2 (e + 1) , where e is the number of states with an even priority. That is, is the length of the witness and colour witness from the previous section ( = k + 1).
For [21] (i.e. alg = JL), with c priorities {1, . . . , c} and n states with even priority (not counting the winning state) we have the following counts: -Induction basis, length: we start with the case in which we bound the sum of the lengths of + and − by 0 or 1. These are the binary words of length at most l.
-For all other cases, we define inductively: where the first summand refers to the case where the leading sequence (which refers to colour 2c) is empty. In this case, the length of the remaining sequences is still bound by l, but the number of even colours has dropped by one. The two summands count JL (2c, l − 1) represent the cases, where the sequence assigned to the highest even priority starts with a + and −, respectively. Cutting off this leading sign leaves count JL (2c, l − 1) different states.
To estimate the number of concise progress measures, count JL (c, l)+1, we put aside the winning state and the function that maps all even priorities to the empty sequence.
For the remaining states, we first fix a positive length i ≤ l of the concatenated words, and then the j ≤ c/2 of the even priorities that have a non-empty word assigned to them.
There are i − 1 j − 1 assignments of positive lengths to j positions that add up to i.
For each distribution of lengths, there are 2 i different assignments to words. Finally there are c/2 j possibilities to assign j of the c/2 different even priorities.
This provides an overall statespace of

Calude et al. [8]
We now continue with the statespace of the original quasi-polynomial approach of Calude et al. [8], hence, alg = O. The statespace used in [8] is slightly larger than W, as it only uses the length of the witness as restriction and does not exclude odd values for the rightmost position ('b 0 ') in a witness.
For the precise count of this statepace without the winning state 'won', we have the following counts: -Induction basis, length: sequences of length 1 (only containing b 0 ) whose colour values are bounded by c, can take c + 1 values in {1, . . . , c} plus . We therefore have: count O (c, 1) = c + 1 .
-For longer tails of sequences, we define inductively: The size of |W + | of the statespace can be given as: The '2' refers to the winning state and the 'empty' sequence that consists only of symbols (which is more convenient for us to treat separately), and the sum refers to the states represented by non-empty sequences of length l = log 2 (e + 1) , where e is the number of states with an even priority. Note that the estimation given in [8] is slightly coarser, and their game definition is slightly different from the normal definition of parity games, but the bound can be taken from [15]. For different combinations for all number of priorities put together, providing the following size:

Improvements
We now discuss the differences obtained when moving from W + to C by looking at the effect of the three optimisations we have introduced. These are: 1. the restriction of the number of occurrences of odd colours in a witness to once, 2. not using any colour that is higher than any even colour; 3. not allowing for odd colours in the rightmost position ('b 0 '); 4. the removal of the colour 1; and 5. moving from length to value restriction.
(1) and (2) Restricted Occurrence of Odd Colours. Restricting the occurrence of odd colours to once, together with the optimization of not using any colour that is higher than any even colour, leads to a situation where the highest colour allowed in any position is even. To see this, we observe that the banning of a potential odd colour higher then any even colour guarantees this initially, where the highest colour allowed is the highest even colour. When an odd colour o is used in the witness ('b l = o'), then the highest colour allowed to its right is o − 1, whereas when an even colour e is used in the witness ('b l = e'), then the highest colour allowed to its right is e.
We therefore only have to define our improved counting function for even colours: -Induction basis, length: apart from using only even bounds, the base case remains the same: count 1,2 (2c, 1) = 2c + 1 .
-For longer tails of sequences, we define inductively: The summands refers to the possible values taken by the leftmost postion ('b l ') of the tail (b l , b l−1 , . . . , b 0 ). The first summand refers to the leading position being 1 ('b l = 1'). If this is the case, then all entries to its right must be strictly smaller than 1 (which is not possible) or -consequently, they must all be , which just leaves one such tail. The other summands refer to the leading position taking the value 2i or 2i + 1 when i < c ('b l = 2i' or 'b l = 2i + 1'), in either case, the maximal value of the colours occurring in the remaining tale is 2i. The final two summands (for i = c) refer to the leading position taking the value 2c or ('b l = 2c' or 'b l = '). In both cases, the maximal value of the colours occurring in the remaining tale is 2c.
While the representation is different, it is easy to see that count 1,2 (2c, l) = count JL (2c, l) holds.
To see this, we first observe that count JL (2, l + 1) = 1 + 2count JL (2, l) holds, and then by induction over c that: Given that we also have count 1,2 (2c, 1) = count JL (2c, 1), we get the claim, because count JL (2c, l) cannot be derived in the same way as count 1,2 (2c, l). -For longer tails of sequences, we define inductively: When evaluating the term count , the reduction from 2c + 1 to c + 1 is halving the value (rounded up) at the leaf of each call tree, which provides more than the removing of '= 1' in each node of the call tree. Together, they broadly halve the value.
(5) Taking the value into account. We start with using both the length and the value, and then remove the length in next step to get a more concise representation, but we note that, for a given length l, the value v allowed always satisfies v < 2 l .
First, we get another induction base, one by value: -Induction basis, value: Regardless of the remaining length, if the value of the tail is bounded by (and thus needs to be) 0, then it can only consist of signs. -Induction basis, length: count ,v (2c, 1, 1) = c + 1 .
-For longer tails of sequences and positive values, we distinguish a number of cases.
The first case is that v < 2 l . Then we have This is simply because filling the position l + 1 with any number, even or odd, would exceed the value budget. This leaves the case v ≥ 2 l , that is: This is because, when filling position l with an even number, it takes 2 l from the budget of the value, leaving an remaining budget of v − 2 l . When filling this position with an odd number, while the value would be increased by 2 l , this is within the value budget. Moreover, if this position is still relevant to the value, then the positions to its right no longer add to the value of the sequence, as the leftmost odd position would be the last to be considered. We therefore set the value for the remaining tail to the right to be the maximal value that can be obtained by this tail, which is 2 l − 1; this is a rendering of saying that for the tail the values are not constrained.
The effect of adding the value can vary greatly. It is larger when the number of positions with even colour is a power of 2, say 2 l , and it has no effect at all if it is 2 2 − 1.
Taking the value into account therefore broadly halves the statespace when e is a power of 2, and has no effect when e is a predecessor of a power of 2, and falls from 2 l−1 to 2 l − 1 for all l > 1.
Looking at the definition of count ,v , it is easy to see that an explicit reference to the length can be replaced by a reference to the next relevant length, log 2 v . This provides: count v (2c, 0) = 1 , count v (2c, 1) = c + 1 , and

Comparison with the statespace of [15]
While improvement (1) is the most powerful of the optimizations, the improvements (2) -(4) were present in [15], where the algorithm makes use of a value function, namely value (b) = i∈even(b) 2 i . It is therefore interesting to provide a count function for [15].
We use the subscript JKSSW , and only use the count that uses both length and value.
We get the following state counts: To explain the difference to count ,v , one major difference is that the highest colour allowed in a position can be odd. The other is that positions with odd colour do not contribute to the weight, which allows for adding positions with odd colour the remaining budget is lower than 2 l . Thus, the call tree for the calculation of count ,v JKSSW has c/2 successors where v < 2 l while the call tree for count ,v has just one. For v ≥ 2 l , the call tree has the same number of successors (for even c) or just one additional successor (for odd c), but the parameter falls slower.

Statespace comparison
In this subsection we provide a graphical representation of the statespace size for the three algorithms: Calude et al. [8], Jurdzinski and Lasic [21], and the improvement described in this article. The size of the statespace on which an algorithm works does not represent how good the algorithm performs in practice. Indeed, in the context of parity games, there are quasi-polynomial time algorithms that behaves like brute-force approaches. Therefore, they always require quasi-polynomial many steps to compute the solution, while most of the exponential time algorithms, instead, almost visit a polynomial fraction of their statespace. The first improvement we described does not affect the performance of the algorithm, since both the original and the improved algorithm requires the same number of steps to solve a game, but the latter works on a reduced statespace. To measure how big is the cut we consider in Figure 1 games with a fixed number of colours and in Figure 2 games with a linear number of colours in the size of the game. The games of Figure 1 range from 2 3 to 2 15 positions n. Therefore, the length of the measure, that is logarithmic in n, constantly increases, while the colours are fixed to value 10. As a consequence, the ratio of colours with respect to n range from 80% to 0.02%. As expected, the cut with the original algorithm significantly increases for games that are not dense of colours as the lines tend to diverge on a logarithmic scale. The ratio between Jurdzinski and Lasic approach (JL) and the new improvement, instead, converge to a cut of 73% of the statespace. The games of Figure 2, instead range from 2 8 to 2 9 positions n, so that the length of the measure is fixed, while the number colours constantly grows from 26 to 50. As a consequence, we have that the ratio of colours with respect to n is fixed to 10%. In this case, the scale are linear and, even if the improved statespace is always smaller than the other two, the cut tends to shrink.

Discussion
We have introduced three technical improvements over the progress measures used in the original quasipolynomial approach by Calude et al. [8] and its improvements by Fearnley et al. [15]. The first two reduce the statespace.
The more powerful of the two is a simple limitation of the occurrences of odd colours in a witness to one. Where the highest colour is even, this alone reduces the size of the statespace of Calude et al.'s approach to the currently smallest one of Jurdzinski and Lasic [21]. Where the highest colour is odd, we obtain the same by borrowing the simple observation that this highest colour does not need to be used from [15].