Improved Set-based Symbolic Algorithms for Parity Games

TL;DR

This paper introduces new set-based symbolic algorithms for solving parity games that significantly reduce symbolic operations and space requirements, improving scalability for analyzing reactive systems.

Contribution

The paper presents two novel set-based symbolic algorithms for parity games, achieving lower symbolic operations and linear space, including the first linear space algorithm with sub-exponential symbolic operations.

Findings

First algorithm: O(n^{c/2+1}) symbolic operations, linear space.

Second algorithm: O(n^{c/3+1}) symbolic operations, linear space.

First linear space algorithm with sub-exponential symbolic operations.

Abstract

Graph games with {\omega}-regular winning conditions provide a mathematical framework to analyze a wide range of problems in the analysis of reactive systems and programs (such as the synthesis of reactive systems, program repair, and the verification of branching time properties). Parity conditions are canonical forms to specify {\omega}-regular winning conditions. Graph games with parity conditions are equivalent to {\mu}-calculus model checking, and thus a very important algorithmic problem. Symbolic algorithms are of great significance because they provide scalable algorithms for the analysis of large finite-state systems, as well as algorithms for the analysis of infinite-state systems with finite quotient. A set-based symbolic algorithm uses the basic set operations and the one-step predecessor operators. We consider graph games with $n$ vertices and parity conditions with $c$ priorities. While many explicit algorithms exist for graph games with parity conditions, for set-based symbolic algorithms there are only two algorithms (notice that we use space to refer to the number of sets stored by a symbolic algorithm): (a) the basic algorithm that requires $O(n^c)$ symbolic operations and linear space; and (b) an improved algorithm that requires $O(n^{c/2+1})$ symbolic operations but also $O(n^{c/2+1})$ space (i.e., exponential space). In this work we present two set-based symbolic algorithms for parity games: (a) our first algorithm requires $O(n^{c/2+1})$ symbolic operations and only requires linear space; and (b) developing on our first algorithm, we present an algorithm that requires $O(n^{c/3+1})$ symbolic operations and only linear space. We also present the first linear space set-based symbolic algorithm for parity games that requires at most a sub-exponential number of symbolic operations.

Equations

$$\mathrm{best}(\rho ,v)=\{\begin{array}{ll}\min \{\rho (w)\mid (v,w)\in E\}& \text{if }v\in V_{\mathcal{E}},\\ \max \{\rho (w)\mid (v,w)\in E\}& \text{if }v\in V_{\mathcal{O}}.\end{array}$$

$$\mathrm{Lift}(\rho ,v)(u)=\{\begin{array}{ll}{\mathrm{inc}}_{\alpha (v)}(\mathrm{best}(\rho ,v))& \text{if }u=v,\\ \rho (u)& \text{otherwise}.\end{array}$$

$$S_r^0=\bigcup _{r_{c-1}<x\le n_{c-1}}{C}_x^{c-1}$$

$$S_r^i=\bigcap _{1\le k\le i}{C}_{r_{c-2k+1}}^{c-2k+1}\cap \bigcup _{r_{c-2i-1}<x\le n_{c-2i-1}}{C}_x^{c-2i-1}$$

$$S_r=S_{\top }\cup S_r^{=}\cup \bigcup _{i=0}^{c/2-1}{S}_r^i$$

$$|M_h^{\infty }|\le \left(\genfrac{}{}{0ex}{}{h+\lfloor c/2\rfloor }{h}\right)+1.$$

$$\left(\genfrac{}{}{0ex}{}{h+\lfloor c/2\rfloor }{h}\right)\le \frac{(h+\lfloor c/2\rfloor {)}^h}{h!}\le {\left(\frac{(h+\lfloor c/2\rfloor )e}{h}\right)}^h,$$

$${\left(\frac{(h+\lfloor c/2\rfloor )e}{h}\right)}^h\le {\left(\frac{2h\cdot e}{h}\right)}^h\le {\left(2e\right)}^h,$$

$${\left(\frac{(h+\lfloor c/2\rfloor )e}{h}\right)}^h\le {\left(\frac{2\lfloor c/2\rfloor \cdot e}{h}\right)}^h.$$

$$T(n)\le O(n^{\Gamma })+T(n-1)+T(n-\Gamma )$$

$$\gamma (c)=\gamma (c-1)+1-\beta (c-1),$$

$$\beta (c-1)\cdot \lceil c/2\rceil =\gamma (c-1).$$

$$O\left(c\cdot n_0\cdot \left(\genfrac{}{}{0ex}{}{\lceil n_0^{\beta (c-1)}\rceil +\lfloor c/2\rfloor }{\lceil n_0^{\beta (c-1)}\rceil }\right)\right)$$

$$\left(\genfrac{}{}{0ex}{}{\lceil n_0^{\beta (c-1)}\rceil +\lfloor c/2\rfloor }{\lceil n_0^{\beta (c-1)}\rceil }\right)$$

$$\le {\left(\frac{2e\cdot n_0^{\beta (c-1)}+e\cdot c}{c-1}\right)}^{\lfloor c/2\rfloor }\le {\left(\frac{4e\cdot n_0^{\beta (c-1)}}{c}\right)}^{\lfloor c/2\rfloor }$$

$${\kappa }_1\cdot n_0\cdot \frac{({\kappa }_2\cdot n_0{)}^{\gamma (c)}}{\sqrt[3]{c!}}$$

$$\le {\kappa }_1\cdot n_0\cdot {\left(\frac{{\kappa }_2\cdot e\cdot {\kappa }_3\cdot n_0}{c}\right)}^{\gamma (c)}$$

$$\lfloor \frac{n_0}{h+2}\rfloor +1\le \frac{n_0^{1-\beta (c-1)}}{2\sqrt[3]{c}}+1\le 2\cdot \frac{n_0^{1-\beta (c-1)}}{3\sqrt[3]{c}}.$$

$${\kappa }_1\cdot n_0\cdot \frac{({\kappa }_2\cdot n_0{)}^{\gamma (c-1)}}{\sqrt[3]{(c-1)!}}.$$

$$\begin{array}{rl}{\kappa }_1\cdot n_0\cdot \frac{({\kappa }_2\cdot n_0{)}^{\gamma (c-1)}}{\sqrt[3]{(c-1)!}}\cdot \frac{2\cdot n_0^{1-\beta (c-1)}}{3\sqrt[3]{c}}& \le {\kappa }_1\cdot n_0\cdot \frac{2\cdot ({\kappa }_2\cdot n_0{)}^{\gamma (c)}}{3\sqrt[3]{c!}}.\end{array}$$

$$\left(\genfrac{}{}{0ex}{}{\lceil 2\sqrt[3]{c}\cdot n_0^{\beta (c-1)}\rceil +\lfloor c/2\rfloor }{\lfloor c/2\rfloor }\right)$$

$$\le {\left(\frac{e\cdot (\lceil 2\sqrt[3]{c}\cdot n_0^{\beta (c-1)}\rceil +\lfloor c/2\rfloor )}{\lfloor c/2\rfloor }\right)}^{\lfloor c/2\rfloor },$$

$$\le {\left(\frac{(1+1/4)\cdot e\cdot \lceil 2\sqrt[3]{c}\cdot n_0^{\beta (c-1)}\rceil }{\lceil (c-1)/2\rceil }\right)}^{\lceil \frac{c-1}{2}\rceil }.$$

$${\kappa }_4\cdot c\cdot n_0\cdot {\left(\frac{7\lceil 2\sqrt[3]{c}{n}_0^{\beta (c-1)}\rceil }{c-1}\right)}^{\lceil \frac{c-1}{2}\rceil }$$

$$\lceil n_0^{\beta (c-1)}{\rceil }^{\lceil \frac{c-1}{2}\rceil }\cdot n_0^{1-\beta (c-1)}$$

$$c\cdot {\left(\frac{7\lceil 2\sqrt[3]{c}\rceil }{c-1}\right)}^{\lceil \frac{c-1}{2}\rceil }$$

$$\le c\cdot {\left(\frac{\sqrt{{\kappa }_6}}{\sqrt[3]{c-1}}\right)}^{c-1}\le c\cdot {\left(\frac{4}{\sqrt[3]{c-1}}\right)}^{c-1}.$$

$$c\cdot {\left(\frac{4\cdot \sqrt[3]{\hat{\kappa }}}{\sqrt[3]{\hat{\kappa }}\cdot \sqrt[3]{(c-1}}\right)}^{c-1}$$

$$\begin{array}{rl}{\kappa }_4\cdot c\cdot n_0\cdot {\left(\frac{7\lceil 2\sqrt[3]{c}{n}_0^{\beta (c-1)}\rceil }{\lceil \frac{c-1}{2}\rceil }\right)}^{\lceil \frac{c-1}{2}\rceil }\cdot \frac{2\cdot n_0^{1-\beta (c-1)}}{3\sqrt[3]{c}}& \le {\kappa }_1\cdot n_0\cdot \frac{({\kappa }_2\cdot n_0{)}^{\gamma (c)}}{3\sqrt[3]{c!}}\end{array}$$

Full text

1 Introduction

In this work we present improved set-based symbolic algorithms for solving graph games with parity winning conditions, which is equivalent to modal $\mu$-calculus model-checking.

Graph games.

Two-player graph games provide the mathematical framework to analyze several important problems in computer science, especially in formal methods for the analysis of reactive systems. Graph games are games that proceed for an infinite number of rounds, where the two players take turns to move a token along the edges of the graph to form an infinite sequence of vertices (which is called a play or a trace). The desired set of plays is described as an $\omega$-regular winning condition. A strategy for a player is a recipe that describes how the player chooses to move tokens to extend plays, and a winning strategy ensures the desired set of plays against all strategies of the opponent. Some classical examples of graph games in formal methods are as follows:

(a) If the vertices and edges of a graph represent the states and transitions of a reactive system, resp., then the synthesis problem (Church’s problem [13]) asks for the construction of a winning strategy in a graph game [8, 36, 35, 32, 34].

(b) The problems of (i) verification of a branching-time property of a reactive system [19], where one player models the existential quantifiers and the opponent models the universal quantifiers; as well as (ii) verification of open systems [2], where one player represents the controller and the opponent represents the environment; are naturally modeled as graph games, where the winning strategies represent the choices of the existential player and the controller, respectively.

Moreover, game-theoretic formulations have been used for refinement [24], compatibility checking [16] of reactive systems, program repair [27], and synthesis of programs [11]. Graph games with parity winning conditions are particularly important since all $\omega$-regular winning conditions (such as safety, reachability, liveness, fairness) as well as all Linear-time Temporal Logic (LTL) winning conditions can be translated to parity conditions [37, 38], and parity games are equivalent to modal $\mu$-calculus model checking [19]. In a parity winning condition, every vertex is assigned a non-negative integer priority from $\{0,1,\ldots,c-1\}$, and a play is winning if the highest priority visited infinitely often is even. Graph games with parity conditions can model all the applications mentioned above, and there is a rich literature on the algorithmic study of finite-state parity games [19, 6, 41, 28, 44, 30, 40].

Explicit vs. symbolic algorithms.

The algorithms for parity games can be classified broadly as explicit algorithms, where the algorithms operate on the explicit representation of the graph game, and implicit or symbolic algorithms, where the algorithms only use a set of predefined operations and do not explicitly access the graph game. Symbolic algorithms are of great significance for the following reasons: (a) first, symbolic algorithms are required for large finite-state systems that can be succinctly represented implicitly (e.g., programs with Boolean variables) and symbolic algorithms are scalable, whereas explicit algorithms do not scale; and (b) second, for infinite-state systems (e.g., real-time systems modeled as timed automata, or hybrid systems, or programs with integer domains) only symbolic algorithms are applicable, rather than explicit algorithms. Hence for the analysis of large systems or infinite-state systems symbolic algorithms are necessary.

Significance of set-based symbolic algorithms.

The most significant class of symbolic algorithms for parity games are based on set operations, where the allowed symbolic operations are: (a) basic set operations such as union, intersection, complement, and inclusion; and (b) one step predecessor (Pre) operations. Note that the basic set operations (that only involve state variables) are much cheaper as compared to the predecessor operations (that involve both variables of the current and of the next state). Thus in our analysis we will distinguish between the basic set operations and the predecessor operations. We refer to the number of sets stored by a set-based symbolic algorithm as its space. The significance of set-based symbolic algorithms is as follows:

(a) First, in several domains of the analysis of both infinite-state systems (e.g., games over timed automata or hybrid systems) as well as large finite-state systems (e.g., programs with many Boolean variables, or bounded integer variables), the desired model-checking question is specified as a $\mu$-calculus formula with the above set operations [17, 15]. Thus an algorithm with the above set operations provides a symbolic algorithm that is directly applicable to the formal analysis of such systems.

(b) Second, in other domains such as in program analysis, the one-step predecessor operators are routinely used (namely, with the weakest-precondition as a predicate transformer). A symbolic algorithm based only on the above operations thus can easily be developed on top of the existing implementations. Moreover, recent work [4] shows how efficient procedures (such as constraint-based approaches using SMTs) can be used for the computation of the above operations in infinite-state games. This highlights that symbolic one-step operations can be applied to a large class of problems.

(c) Finally, if a symbolic algorithm is described with the above very basic set of operations, then any practical improvement to these operations in a particular domain would translate to a symbolic algorithm that is faster in practice for the respective domain.

Thus the problem is practically relevant, and understanding the symbolic complexity of parity games is an interesting and important problem.

Previous results.

We summarize the main previous results for finite-state game graphs with parity conditions. Consider a parity game with $n$ vertices, $m$ edges, and $c$ priorities (which is equivalent to $\mu$-calculus model-checking of transitions systems with $n$ states, $m$ transitions, and a $\mu$-calculus formula of alternation depth $c$). In the interest of concise presentation, in the following discussion, we ignore denominators in $c$ in the running time bounds, see Appendix D and Theorems 8 and 9 for precise bounds.

Set-based symbolic algorithms. Recall that we use space to refer to the number of sets stored by a symbolic algorithm. The basic set-based symbolic algorithm (based on the direct evaluation of the nested fixed point of the $\mu$-calculus formula) for parity games requires $O(n^{c})$ symbolic operations and space linear in $c$ [18]. In a breakthrough result [6], a new set-based symbolic algorithm was presented that requires $O(n^{c/2+1})$ symbolic operations, but also requires $O(n^{c/2+1})$ many sets, i.e., exponential space as compared to the linear space of the basic algorithm. A simplification of the result of [6] was presented in [41].

Explicit algorithms. The classical algorithm for parity games requires $O(n^{c-1}m)$ time and can be implemented in quasi-linear space [45, 34], which was then improved to the small-progress measure algorithm that requires $O(n^{c/2}m)$ time and space to store $O(c\cdot n)$ integer counters [28]. The small-progress measure algorithm, which is an explicit algorithm, uses an involved domain of the product of integer priorities and lift operations (which is a lexicographic $\max$ and $\min$ in the involved domain). The algorithm shows that the fixed point of the lift operation computes the solution of the parity game. The lift operation can be encoded with algebraic binary decision diagrams [9] but this does not provide a set-based symbolic algorithm. Other notable explicit algorithms for parity games are as follows: (a) a strategy improvement algorithm [44], which in the worst-case is exponential [21]; (b) a dominion-based algorithm [30] that requires $n^{O(\sqrt{n})}$ time and a randomized $n^{O(\sqrt{n/\log{n}})}$ algorithm [5] (both algorithms are sub-exponential, but inherently explicit algorithms); and, combining the small-progress measure and the dominion-based algorithm, (c) an $O(n^{c/3}m)$ time algorithm [40] and its improvement for dense graphs with $c$ sub-polynomial in $n$ to an $O(n^{c/3}n^{4/3})$ time algorithm [12] (both bounds are simplified). A recent breakthrough result [10] shows that parity games can be solved in $O(n^{\log c})$ time, i.e., quasi-polynomial time. Follow-up work [29, 20] reduced the space requirements from quasi-polynomial to $O(n\log n\log c)$, i.e., to quasi-linear, space.

While the above algorithms are specified for finite-state graphs, the symbolic algorithms also apply to infinite-state graphs with a finite bi-simulation quotient (such as timed-games, or rectangular hybrid games), and then $n$ represents the size of the finite quotient.

Our contributions.

Our results for game graphs with $n$ vertices and parity objectives with $c$ priorities are as follows.

(1) First, we present a set-based symbolic algorithm that requires $O(n^{c/2+1})$ symbolic operations and linear space (i.e., a linear number of sets). Thus it matches the symbolic operations bound of [6, 41] and brings the space requirements down to a linear number of sets as in the classical algorithm (albeit linear in $n$ and not in $c$).

(2) Second, developing on our first algorithm, we present a set-based symbolic algorithm that requires $O(n^{c/3+1})$ symbolic operations (simplified bound) and linear space. Thus it improves the symbolic operations of [6, 41] while achieving an exponential improvement in the space requirement. We also present a modification of our algorithm that requires $n^{O(\sqrt{n})}$ symbolic operations and at most linear space. This is the first linear-space set-based symbolic algorithm that requires at most a sub-exponential number of symbolic operations.

In the results above the number of symbolic operations mentioned is the number of predecessor operations, and in all cases the number of required basic set operations (which are usually cheaper) is at most a factor of $O(n)$ more. Our main results and comparison with previous set-based symbolic algorithms are presented in the table below.

[TABLE]

Technical contribution.

We provide a symbolic version of the progress measure algorithm. The main challenge is to succinctly encode the numerical domain of the progress measure as sets. More precisely, the challenge is to represent $\Theta(n^{c/2})$ many numerical values with $O(n)$ many sets, such that they can still be efficiently processed by a set-based symbolic algorithm. For the sake of efficiency our algorithms consider sets $S_{r}$ storing all vertices with progress measure at least $r$. However, there are $\Theta(n^{c/2})$ many such sets $S_{r}$ and thus, to reduce the space requirements to a linear number of sets, we use a succinct representation that encodes all the sets $S_{r}$ with just $O(n)$ many sets, such that we can restore a set $S_{r}$ efficiently whenever it is processed by the algorithm.

2 Preliminaries and Previous Results

2.1 Parity Games

Game graphs.

We consider games on graphs played by two adversarial players, denoted by ${\mathcal{E}}$ (for even) and ${\mathcal{O}}$ (for odd). We use ${z}$ to denote one of the players of $\{{\mathcal{E}},{\mathcal{O}}\}$ and ${\overline{z}}$ to denote its opponent. We denote by $(V,E)$ a directed graph with $n=\lvert V\rvert$ vertices and $m=\lvert E\rvert$ edges, where $V$ is the vertex set and $E$ is the edge set. A game graph $\mathcal{G}=((V,E),(V_{\mathcal{E}},V_{\mathcal{O}}))$ is a directed graph $(V,E)$ with a partition of the vertices into player-${\mathcal{E}}$ vertices $V_{\mathcal{E}}$ and player-${\mathcal{O}}$ vertices $V_{\mathcal{O}}$. For a vertex $u\in V$, we write $\operatorname{\textit{Out}}(u)=\{v\in V\mid(u,v)\in E\}$ for the set of successor vertices of $u$. As a standard convention (for technical simplicity) we consider that every vertex has at least one outgoing edge, i.e., $\operatorname{\textit{Out}}(u)$ is non-empty for all vertices $u$.

Plays.

A game is initialized by placing a token on a vertex. Then the two players form an infinite path, called play, in the game graph by moving the token along the edges. Whenever the token is on a vertex of $V_{z}$, player ${z}$ moves the token along one of the outgoing edges of the vertex. Formally, a play is an infinite sequence $\langle v_{0},v_{1},v_{2},\ldots\rangle$ of vertices such that $(v_{j},v_{j+1})\in E$ for all $j\geq 0$.

Parity games.

A parity game $\mathcal{P}=(\mathcal{G},\alpha)$ with $c$ priorities consists of a game graph $G=((V,E),(V_{\mathcal{E}},V_{\mathcal{O}}))$ and a priority function $\alpha:V\rightarrow[c]$ that assigns an integer from the set $[c]=\{0,\ldots,c-1\}$ to each vertex (see Figure 1 for an example). Player ${\mathcal{E}}$ (resp. player ${\mathcal{O}}$) wins a play of the parity game if the highest priority occurring infinitely often in the play is even (resp. odd). We denote by $P_{i}$ the set of vertices with priority $i$, i.e., $P_{i}=\{v\in V\mid\alpha(v)=i\}$. Note that if $P_{i}$ is empty for $0<i<c-1$, then the priorities $>i$ can be decreased by 2 without changing the parity condition, and when $P_{c-1}$ is empty, we simply have a parity game with a priority less; thus we assume w.l.o.g. $P_{i}\neq\emptyset$ for $0<i<c$.

Strategies.

A strategy of a player ${z}\in\{{\mathcal{E}},{\mathcal{O}}\}$ is a function that, given a finite prefix of a play ending at $v\in V_{z}$, selects a vertex from $\operatorname{\textit{Out}}(v)$ to extend the finite prefix. Memoryless strategies depend only on the last vertex of the finite prefix. That is, a memoryless strategy of player ${z}$ is a function $\sigma:V_{z}\rightarrow V$ such that for all $v\in V_{z}$ we have $\sigma(v)\in\operatorname{\textit{Out}}(v)$. It is well-known that for parity games it is sufficient to consider memoryless strategies [19, 34]. Therefore we only consider memoryless strategies from now on. A start vertex $v$, a strategy $\sigma$ for ${\mathcal{E}}$, and a strategy $\pi$ for ${\mathcal{O}}$ describe a unique play $\omega(v,\sigma,\pi)=\langle v_{0},v_{1},v_{2},\ldots\rangle$, which is defined as follows: $v_{0}=v$ and for all $i\geq 0$, if $v_{i}\in V_{\mathcal{E}}$, then $\sigma(v_{i})=v_{i+1}$, and if $v_{i}\in V_{\mathcal{O}}$, then $\pi(v_{i})=v_{i+1}$.

Winning strategies and sets.

A strategy $\sigma$ is winning for player ${\mathcal{E}}$ at start vertex $v$ iff for all strategies $\pi$ of player ${\mathcal{O}}$ we have that the play $\omega(v,\sigma,\pi)$ satisfies the parity condition, and analogously for winning strategies for player ${\mathcal{O}}$. A vertex $v$ belongs to the winning set $W_{z}$ of player ${z}$ if player ${z}$ has a winning strategy from start vertex $v$. Every vertex is winning for exactly one of the two players. The algorithmic problem we study for parity games is to compute the winning sets of the two players. A non-empty set of vertices $D$ is a player-${z}$ dominion if player ${z}$ has a winning strategy from every vertex of $D$ that also ensures only vertices of $D$ are visited.

2.2 Set-based Symbolic Operations

Symbolic algorithms operate on sets of vertices, which are usually described by Binary Decision Diagrams (BDD) [31, 1]. For the symbolic algorithms for parity games we consider the most basic form of symbolic operations, namely, set-based symbolic operations. More precisely, we only allow the following operations:

Basic set operations. First, we allow basic set operations like $\cup$, $\cap$, $\setminus$, $\subseteq$, and $=$.

One-step operations. Second, we allow the following symbolic one-step operations:

(a) the one-step predecessor operator $\mathsf{Pre}(B)=\{v\in V\mid\exists u\in B:(v,u)\in E\};$ and (b) the one-step controllable predecessor operator $\mathsf{CPre}_{{z}}(B)=\left\{v\in V_{z}\mid\operatorname{\textit{Out}}(v)\cap B\neq\emptyset\right\}\cup\left\{v\in V_{\overline{z}}\mid\operatorname{\textit{Out}}(v)\subseteq B\right\};$ i.e., the $\mathsf{CPre}_{{z}}$ operator computes all vertices from which ${z}$ can ensure that in the next step the successor belongs to the given set $B$. Moreover, the $\mathsf{CPre}_{{z}}$ operator can be defined using the $\mathsf{Pre}$ operator and basic set operations as follows: $\mathsf{CPre}_{{z}}(B)=\mathsf{Pre}(B)\setminus(V_{\overline{z}}\cap\mathsf{Pre}(V\setminus B)).$

Algorithms that use only the above operations are called set-based symbolic algorithms. Additionally, successor operations can be allowed but are not needed for our algorithms. The above symbolic operations correspond to primitive operations in standard symbolic packages like CuDD [42].

Typically, the basic set operations are cheaper (as they encode relationships between state variables) as compared to the one-step symbolic operations (which encode the transitions and thus the relationship between the variables of the present and of the next state). Thus in our analysis we distinguish between these two types of operations.

For the space requirements of set-based symbolic algorithms, as per standard convention [6, 9], we consider that a set is stored in constant space (e.g., a set can be represented symbolically as one BDD [7]). We thus consider the space requirement of a symbolic algorithm to be the maximal number of sets that the algorithm has to store.

2.3 Progress Measure Algorithm

We first provide basic intuition for the progress measure [28] and then provide the formal definitions. Solving parity games can be reduced to computing the progress measure [28]. In Section 3 we present a set-based symbolic algorithm to compute the progress measure.

2.3.1 High-level intuition

Towards a high-level intuition behind the progress measure, consider an ${\mathcal{E}}$-dominion $D$, i.e., player ${\mathcal{E}}$ wins on all vertices of $D$ without leaving $D$. Fix a play started at a vertex $u\in D$ in which player ${\mathcal{E}}$ follows her winning strategy on $D$. In the play from some point on the highest priority visited by the play, say $\alpha^{*}$, has to be even. Let $v_{*}$ be the vertex after which the highest visited priority is $\alpha^{*}$ (recall that memoryless strategies are sufficient for parity games). Before $v_{*}$ is visited, the play might have visited vertices with odd priority higher than $\alpha^{*}$ but the number of these vertices has to be less than $n$. The progress measure is based on a so-called lexicographic ranking function that assigns a rank to each vertex $v$, where the rank is a “vector of counters” for the number of times player ${\mathcal{O}}$ can force a play to visit an odd priority vertex before a vertex with higher even priority is reached. If player ${\mathcal{O}}$ can ensure a counter value of at least $n$, then she can ensure that a cycle with highest priority odd is reached from $v$ and therefore player ${\mathcal{E}}$ cannot win from the vertex $v$. Conversely, if player ${\mathcal{O}}$ can reach a cycle with highest priority odd before reaching a higher even priority, then she can also force a play to visit an odd priority $n$ times (thus a counter value of $n$) before reaching a higher even priority. In other words, a vertex $u$ is in the ${\mathcal{E}}$-dominion $D$ if and only if player ${\mathcal{O}}$ cannot force any counter value to reach $n$ from $u$. When a vertex $u$ is classified as winning for player ${\mathcal{O}}$, it is marked with the rank $\top$ and whenever ${\mathcal{O}}$ has a strategy for some vertex $v$ to reach a $\top$-ranked vertex, it is also winning for player ${\mathcal{O}}$ and thus ranked $\top$. Computing the progress measure is done by updating the rank of a vertex according to the ranks of its successors and is equal to computing the least simultaneous fixed point for all vertices with respect to “ranking functions”.

Strategies from progress measure.

An additional property of the progress measure is that the ranks assigned to the vertices of the ${\mathcal{E}}$-dominion provide a certificate for a winning strategy of player ${\mathcal{E}}$ within the dominion, namely, player ${\mathcal{E}}$ can follow edges that lead to vertices with “lower or equal” rank with respect to a specific ordering of the ranks.

We next provide formal definitions of rank, the ranking function, the ordering on the ranks, the lift-operators, and finally the progress measure (see also [28]).

2.3.2 Formal Definitions

The progress measure domain $M^{\infty}_{G}$.

We consider parity games with $n$ vertices and priorities $[c]$. Let $n_{i}$ be the number of vertices with priority $i$ for odd $i$ (i.e., $n_{i}=|P_{i}|$), let $n_{i}=0$ for even $i$, and let $N_{i}=[n_{i}+1]$ for $0\leq i<c$. Let $M_{\mathcal{G}}=(N_{0}\times N_{1}\times\cdots\times N_{c-2}\times N_{c-1})$ be the product domain where every even index is 0 and every odd index $i$ is a number between [math] and $n_{i}$. The progress measure domain is $M^{\infty}_{\mathcal{G}}=M_{\mathcal{G}}\cup\{\top\}$, where $\top$ is a special element called the top element. Then we have |M^{\infty}_{\mathcal{G}}|=1+\prod_{i=1}^{\lfloor c/2\rfloor}(n_{2i-1}+1)=O\big{(}\big{(}\frac{n}{\lfloor c/2\rfloor}\big{)}^{\lfloor c/2\rfloor}\big{)} [28] (this bound uses that w.l.o.g. $|P_{i}|>0$ for each priority $i>0$).

Ranking functions.

A ranking function $\rho:V\rightarrow M^{\infty}_{\mathcal{G}}$ assigns to each vertex a rank $r$ that is either one of the $c$ dimensional vectors in $M_{\mathcal{G}}$ or the top element $\top$. Note that a rank has at most $\lfloor c/2\rfloor$ non-zero entries. Informally, we call the entries of a rank with an odd index $i$ a “counter” because as long as the top element is not reached, it counts (with “carry”, i.e., if $n_{i}$ is reached, the next highest counter is increased by one and the counter at index $i$ is reset to zero) the number of times a vertex of priority $i$ is reached before a vertex of higher priority is reached (from some specific start vertex). The co-domain of $\rho$ is $M^{\infty}_{\mathcal{G}}=M_{\mathcal{G}}\cup\{\top\}$ and we index the elements of the vectors from [math] to $c-1$.

Lexicographic comparison operator $<$.

We use the following ordering $<$ of the ranks assigned by $\rho$: the vectors are considered in the lexicographical order, where the left most entry is the least significant one and the right most entry is the most significant one, and $\top$ is the maximum element of the ordering. We write $\bar{0}$ to refer to the all zero vector (i.e., the minimal element of the ordering) and $\bar{N}$ to refer to the maximal vector $(n_{0},n_{1},\dots,n_{c-1})$ (i.e., the second largest element, after $\top$, in the ordering).

Lexicographic increment and decrement operations.

Given a rank $r$, i.e., either a vector or $\top$, we refer to the successor in the ordering $<$ by $\mathrm{inc}(r)$ (with $\mathrm{inc}(\top)=\top$), and to the predecessor in the ordering $<$ by $\mathrm{dec}(r)$ (with $\mathrm{dec}(\bar{0})=\bar{0}$). We also consider restrictions of $\mathrm{inc}$ and $\mathrm{dec}$ to fewer dimensions, which are described below. Given a vector $x=(x_{0},x_{1},x_{2},\dots,x_{c-1})$, we denote by $\left<x\right>_{\ell}$ (for $0\leq\ell<c$) the vector $(0,0,\dots,0,x_{\ell},\dots,x_{c-1})$, where we set all elements with index less than $\ell$ to [math]; in particular $x=\left<x\right>_{0}$. Intuitively, we use the notation $\left<x\right>_{\ell}$ to “reset the counters” for priorities lower than $\ell$ when a vertex of priority $\ell$ is reached (as long as we have not counted up to the top element). Moreover, we also generalize the ordering to a family of orderings $<_{\ell}$ where $x<_{\ell}y$ for two vectors $x$ and $y$ iff $\left<x\right>_{\ell}<\left<y\right>_{\ell}$; the top element $\top$ is the maximum element of each ordering. In particular, $x<_{0}y$ iff $x<y$ and in our setting also $x<_{1}y$ iff $x<y$. We further have restricted versions $\mathrm{inc}_{\ell}$ and $\mathrm{dec}_{\ell}$ of $\mathrm{inc}$ and $\mathrm{dec}$; note that $\mathrm{dec}_{\ell}$ is a partial function and that $\ell$ will be the priority of the vertex $v$ for which we want to update its rank and $x$ will be the rank of one of its neighbors in the game graph.

• •

$\mathrm{inc}_{\ell}(x)$: For $x=\top$ we have $\mathrm{inc}_{\ell}(\top)=\top$; Otherwise $\mathrm{inc}_{\ell}(x)=\left<x\right>_{\ell}$ if $\ell$ is even and $\mathrm{inc}_{\ell}(x)=\min\{y\in M^{\infty}_{\mathcal{G}}\mid y>_{\ell}x\}$ if $\ell$ is odd.

• •

$\mathrm{dec}_{\ell}(x):$ $\mathrm{dec}_{\ell}(x)=\bar{0}$ if $\left<x\right>_{\ell}=\bar{0}$; Otherwise if $\left<x\right>_{\ell}>\bar{0}$ then $\mathrm{dec}_{\ell}(x)=\min\{y\in M_{\mathcal{G}}\mid x=\mathrm{inc}_{\ell}(y)\}$.

For $\bar{0}<\left<x\right>_{\ell}<\top$ we have $\mathrm{inc}_{\ell}(\mathrm{dec}_{\ell}(x))=\mathrm{dec}_{\ell}(\mathrm{inc}_{\ell}(x))=\left<x\right>_{\ell}$ while for $\top$ we only have $\mathrm{inc}_{\ell}(\mathrm{dec}_{\ell}(\top))=\top$ and for $\left<x\right>_{\ell}=\bar{0}$ only $\mathrm{dec}_{\ell}(\mathrm{inc}_{\ell}(x))=\bar{0}$. By the restriction of $\mathrm{inc}$ by the priority $\ell$ of $v$, for both even and odd priorities the counters for lower (odd) priorities are reset to zero as long as the top element is not reached. For an odd $\ell$ additionally the counter for $\ell$ is increased or, if the counter for $\ell$ has already been at $n_{\ell}$, then one of the higher counters is increased while the counter for $\ell$ is reset to zero as well; if no higher counter can be increased any more, then the rank of $v$ is set to $\top$.

The $\mathrm{best}$ operation.

Recall the interpretation of the progress measure as a witness for a player-${\mathcal{E}}$ winning strategy on an ${\mathcal{E}}$-dominion, where player ${\mathcal{E}}$ wants to follow a path of non-increasing rank. The function $\mathrm{best}$ we define next reflects the ability of player ${\mathcal{E}}$ to choose the edge leading to the lowest rank when he owns the vertex, while for player-${\mathcal{O}}$ vertices all edges need to lead to non-increasing ranks if player ${\mathcal{E}}$ can win from this vertex. The function $\mathrm{best}$ for each vertex $v$ and ranking function $\rho$ is given by

[TABLE]

The $\operatorname{Lift}$ operation and the progress measure.

Finally, the lift operation implements the incrementing of the rank of a vertex $v$ according to its priority and the ranks of its neighbors:

[TABLE]

The $\operatorname{Lift}(.,v)$-operators are monotone and the progress measure for a parity game is defined as the least simultaneous fixed point of all $\operatorname{Lift}(.,v)$-operators. The progress measure can be computed by starting with the ranking function equal to the all-zero function and iteratively applying the $\operatorname{Lift}(.,v)$-operators in an arbitrary order [28]. Note that in this case the $\operatorname{Lift}(.,v)$-operator assigns only rank vectors $r$ with $r=\left<r\right>_{\alpha(v)}$ to $v$. See [28] for a worst-case example for any lifting algorithm. By [28], the winning set of player ${\mathcal{E}}$ can be obtained from the progress measure by selecting those vertices whose rank is a vector, i.e., smaller than $\top$.

Lemma 1**.**

[28]** For a given parity game and the progress measure $\rho$ with co-domain $M^{\infty}_{\mathcal{G}}$, the set of vertices with $\rho(v)<\top$ is exactly the winning set of player ${\mathcal{E}}$.

This implies that to solve parity games it is sufficient to provide an algorithm that computes the least simultaneous fixed point of all $\operatorname{Lift}(.,v)$-operators. The $\operatorname{Lift}$ operation can be computed explicitly in $O(m)$ time, which gives the SmallProgressMeasure algorithm of [28]. The SmallProgressMeasure algorithm is an explicit algorithm that requires O(m\cdot|M^{\infty}_{\mathcal{G}}|)=O\big{(}m\cdot\big{(}\frac{n}{\lfloor c/2\rfloor}\big{)}^{\lfloor c/2\rfloor}\big{)} time and $O(n\cdot c)$ space (assuming constant size integers).

Example 2**.**

In this example we apply the explicit progress measure algorithm to the parity game in Figure 2. We have $n_{1}=3$ and $n_{3}=1$ and thus we have to consider ranks in the co-domain $M^{\infty}_{G}=\{(0,0),(1,0),(2,0),(3,0),(0,1),$ $(1,1),(2,1),(3,1),\top\}$. We initialize $\rho(v)=(0,0)$ for all $v$ and then apply lifting operations as follows:

First, consider the vertices $a,h,c$. For $v\in\{a,h,c\}$ we have $\mathrm{best}(\rho,v)=(0,0)$ and $\alpha(v)=1$ and thus the lift operation $\operatorname{Lift}(\rho,v)$ sets $\rho(v)=(1,0)$. Now consider the vertex $e$ which also hast $\mathrm{best}(\rho,e)=(0,0)$ but $\alpha(e)=3$. Here $\operatorname{Lift}(\rho,a)$ sets $\rho(a)=(0,1)$. 2. 2.

Now consider vertices with even priority. The vertex $g$ has $\mathrm{best}(\rho,g)=(0,1)$ and as $\alpha(g)<3$ we lift $\rho(g)$ to $(0,1)$. The vertex $b$ has $\mathrm{best}(\rho,b)=(1,0)$ and as $\alpha(g)<1$ we lift $\rho(b)$ to $(1,0)$. The vertex $d$ has $\mathrm{best}(\rho,d)=(0,0)$ and $\rho(d)$ stays unchanged. Finally the vertex $f$ now has $\mathrm{best}(\rho,f)=(0,1)$ but $\rho(f)$ stays unchanged because $\alpha(f)>3$. 3. 3.

Now as $g$ was lifted we have $\mathrm{best}(\rho,h)=(1,0)$ and $\rho(h)$ is lifted to $(2,0)$. Similarly as $b$ was lifted we have $\mathrm{best}(\rho,a)=(1,0)$ and $\rho(a)$ is lifted to $(2,0)$, which in turn causes that $\mathrm{best}(\rho,b)=(2,0)$ and $\rho(b)$ being lifted to $(2,0)$. This behavior continues until both $\rho(a)$ and $\rho(b)$ are lifted to $\top$. 4. 4.

Now we already have a fixed-point with $\rho(f)=\rho(d)=(0,0)$, $\rho(c)=(1,0)$, $\rho(h)=(2,0)$, $\rho(e)=\rho(g)=(0,1)$, and $\rho(a)=\rho(b)=\top$.

That is, by Lemma 1, the winning set of player ${\mathcal{E}}$ is $\{c,d,e,f,g,h\}$. a $\lozenge$

3 Set-based Symbolic Progress Measure Algorithm for Parity Games

In this section we present a set-based symbolic algorithm for parity games, with $n$ vertices and $c$ priorities, by showing how to compute a progress measure (see Section 2.3) using only set-based symbolic operations (see Section 2.2). In Appendix A we provide additional intuition for our algorithm for the special case of $5$ priorities. All proofs are in Appendix B.

Key differences and challenges.

We mention the key differences of Algorithm 1 and the explicit progress-measure algorithm ([28], see Section 2.3).

(1) The main challenge for an efficient set-based symbolic algorithm similar to the SmallProgressMeasure algorithm is to represent $\Theta(n^{c/2})$ many numerical values succinctly with $O(n)$ many sets, such that they can still be efficiently processed by a symbolic algorithm.

(2) To exploit the power of symbolic operations, in each iteration of the algorithm we compute all vertices whose rank can be increased to a certain value $r$. This is in sharp contrast to the explicit progress-measure algorithm, where vertices are considered one by one and the rank is increased to the maximal possible value.

Key concepts.

Recall that the progress measure for parity games is defined as the least simultaneous fixed point of the $\operatorname{Lift}(\rho,v)$-operators on a ranking function $\rho:V\rightarrow M^{\infty}_{\mathcal{G}}$. There are two key aspects of our algorithm:

(1) Symbolic encoding of numerical domain. In our symbolic algorithm we cannot directly deal with the ranking function but have to use sets of vertices to encode it. We first formulate our algorithm with sets $S_{r}$ for $r\in M^{\infty}_{\mathcal{G}}$ that contain all vertices that have rank $r$ or higher; that is, given a function $\rho$, the corresponding sets are $S_{r}=\{v\mid\rho(v)\geq r\}$. On the other hand, given a family of sets $\{S_{r}\}_{r}$, the corresponding ranking function $\rho_{\{S_{r}\}_{r}}$ is given by $\rho_{\{S_{r}\}_{r}}(v)=\max\{r\in M^{\infty}_{\mathcal{G}}\mid v\in S_{r}\}$. This formulation encodes the numerical domain with sets but uses exponential in $c$ many sets.

(2) Space efficiency. We refine the algorithm to directly encode the ranks with one set for each possible index-value pair. This reduces the required number of sets to linear at the cost of increasing the number of set operations only by a factor of $n$; the number of one-step symbolic operations does not increase.

We first present the variant that uses an exponential number of sets and then show how to reduce the number of sets to linear.

The above ideas yield a set-based symbolic algorithm, but since we now deal with sets of vertices, as compared to individual vertices, the correctness needs to be established. The non-trivial aspect of the proof is to identify appropriate invariants on sets (which we call symbolic invariants, see Invariant 4) and use them to establish the correctness.

3.1 The Set-based Symbolic Progress Measure Algorithm

The codomain $M^{\infty}_{h}$.

We formulate our algorithm such that it cannot only compute the winning sets of the players but also ${\mathcal{E}}$-dominions of size at most $h+1$. (For ${\mathcal{O}}$-dominions add one to each priority and exchange the roles of the two players.) The only change needed for this is to use the codomain $M^{\infty}_{h}$, instead of $M^{\infty}_{\mathcal{G}}$, for the $\mathrm{inc}$ and $\mathrm{dec}$ operations. The codomain $M^{\infty}_{h}$ contains all ranks of $M^{\infty}_{\mathcal{G}}$ whose entries sum up to at most $h$ (see Appendix D.3).

The sets $S_{r}$ and the ranking

function $\rho_{\{S_{r}\}_{r}}$.

The algorithm implicitly maintains a rank for each vertex. A vertex is contained in a set $S_{r}$ only if its maintained rank is at least $r$. Each set $S_{r}$ is monotonically increasing throughout the algorithm. The rank of a vertex $v$ is the highest $r$ such that $v\in S_{r}$. In other words, the family of sets $\{S_{r}\}_{r}$ defines the ranking function $\rho_{\{S_{r}\}_{r}}(v)=\max\{r\in M^{\infty}_{h}\mid v\in S_{r}\}$. When the rank of a vertex is increased, this information has to be propagated to its predecessors. This is achieved efficiently by maintaining anti-monotonicity among the sets, i.e., we have $S_{r^{\prime}}\supseteq S_{r}$ for all $r$ and all $r^{\prime}<r$ before and after each iteration. Anti-monotonicity together with defining the sets $S_{r^{\prime}}$ to contain vertices with rank at least $r^{\prime}$ instead of exactly $r^{\prime}$ enables us to decide whether the rank of a vertex $v$ can be increased to $r$ by only considering one set $S_{r^{\prime}}$.

Structure of the algorithm.

The set $S_{\bar{0}}$ is initialized with the set of all vertices $V$, while all other sets $S_{r}$ for $r>\bar{0}$ are initially empty, i.e., the ranks of all vertices are initialized with the zero vector. The variable $r$ is initially set to the second lowest rank $\mathrm{inc}(\bar{0})$ that is one at index 1 and zero otherwise. In the while-loop the set $S_{r}$ is updated for the value of $r$ at the beginning of the iteration (see below). After the update of $S_{r}$, it is checked whether the set corresponding to the next lowest rank already contains the vertices newly added to $S_{r}$, i.e., whether the anti-monotonicity is preserved. If the anti-monotonicity is preserved despite the update of $S_{r}$, then for $r<\top$ the value of $r$ is increased to the next highest rank and for $r=\top$ the algorithm terminates. Otherwise the vertices newly added to $S_{r}$ are also added to all sets with $r^{\prime}<r$ that do not already contain them; the variable $r$ is then updated to the lowest $r^{\prime}$ for which a new vertex is added to $S_{r^{\prime}}$ in this iteration.

Update of set $S_{r}$.

To reach a simultaneous fixed point of the lift-operators, the rank of a vertex $v$ has to be increased to $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ whenever the value of $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ is strictly higher than $\rho_{\{S_{r}\}_{r}}(v)$ for the current ranking function $\rho_{\{S_{r}\}_{r}}$. Now consider a fixed iteration of the while-loop and let $r$ be as at the beginning of the while-loop. Let $\rho_{\{S_{r}\}_{r}}$ be denoted by $\rho$ for short. In this update of the set $S_{r}$ we want to add to $S_{r}$ all vertices $v$ with $\rho(v)<r$ and $\operatorname{Lift}(\rho,v)(v)\geq r$ under the condition that the priority of $v$ allows $v$ to be assigned the rank $r$, i.e., $r=\left<r\right>_{\alpha(v)}$. Note that by the anti-monotonicity property the set $S_{r}$ already contains all vertices with $\rho(v)\geq r$.

(1) We first consider the case $r<\top$. Let $\ell$ be maximal such that $r=\left<r\right>_{\ell}$, i.e., the first $\ell$ entries with indices [math] to $\ell-1$ of $r$ are [math] and the entry with index $\ell$ is larger than [math]. Note that $\ell$ is odd. We have that only the $\operatorname{Lift}(.,v)$-operators with $\alpha(v)\leq\ell$ can increase the rank of a vertex to $r$ as all the others would set the element with index $\ell$ to [math].

Recall that $\operatorname{Lift}(\rho,v)(v)=\mathrm{inc}_{\alpha(v)}(\mathrm{best}(\rho,v))$. The function $\mathrm{best}$ is implemented by the $\mathsf{CPre}_{{\mathcal{O}}}$ operator: For a player-${\mathcal{E}}$ vertex the value of $\mathrm{best}$ increases only if the ranks of all successor have increased, for a player-${\mathcal{O}}$ vertex it increases as soon as the maximum rank among the successor vertices has increased. The function $\mathrm{inc}_{\alpha(v)}(x)$ for $x<\top$ behaves differently for odd and even $\alpha(v)$ (see Section 2.3): If $\alpha(v)$ is odd, then $\mathrm{inc}_{\alpha(v)}(x)$ is the smallest rank $y$ in $M^{\infty}_{h}$ such that $y>_{\alpha(v)}x$, i.e., $y$ is larger than $x$ w.r.t. indices $\geq\alpha(v)$. If $\alpha(v)$ is even, then $\mathrm{inc}_{\alpha(v)}(x)$ is equal to $x$ with the indices lower than $\alpha(v)$ set to 0.

(i) First, consider a $\operatorname{Lift}(\rho,v)$ operation with odd $\alpha(v)\leq\ell$, i.e., let $\alpha(v)=2k-1$ for some $1\leq k\leq(\ell+1)/2$. Then $\operatorname{Lift}(\rho,v)(v)\geq r$ only if (a) $v\in V_{\mathcal{E}}$ and all successors $w$ have $\rho(w)\geq\mathrm{dec}_{2k-1}(r)$, or (b) $v\in V_{\mathcal{O}}$ and one successor $w$ has $\rho(w)\geq\mathrm{dec}_{2k-1}(r)$. That is, $\operatorname{Lift}(\rho,v)(v)\geq r$ only if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{\mathrm{dec}_{2k-1}(r)})$. Vice versa, we have that if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{\mathrm{dec}_{2k-1}(r)})$ then by $\rho=\rho_{\{S_{r}\}_{r}}$ also $\operatorname{Lift}(\rho,v)(v)\geq r$. This observation is implemented in 1 in line 1, where such vertices $v$ are added to $S_{r}$.

(ii) Now, consider a $\operatorname{Lift}(\rho,v)$ operation with even $\alpha(v)\leq\ell$, i.e., let $\alpha(v)=2k$ for some $1\leq k\leq\ell/2$. Then $\operatorname{Lift}(\rho,v)(v)\geq r$ only if (a) $v\in V_{\mathcal{E}}$ and all successors $w$ have $\rho(w)\geq r$, or (b) $v\in V_{\mathcal{O}}$ and one successor $w$ has $\rho(w)\geq r$. That is, $\operatorname{Lift}(\rho,v)(v)\geq r$ only if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{r})$. Vice versa, we have that if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{r})$ then $\operatorname{Lift}(\rho,v)(v)\geq r$. In 1 these vertices are added iteratively in line 1 until a fixed point is reached. The algorithm also adds vertices $v$ with odd priority to $S_{r}$, but due do the above argument we have $\operatorname{Lift}(\rho,v)(v)>r$ and thus they can be included in $S_{r}$.

(2) The case $r=\top$ works similarly except that (a) every vertex is a possible candidate for being assigned the rank $\top$, independent of its priority (line 1), and (b) whenever $x$ is equal to $\top$, $\mathrm{inc}_{\alpha(v)}(x)$ assigns the rank $\top$ independently of $\alpha(v)$ (line 1).

Sketch of bound on number of symbolic operations.

Observe that each rank $r$ is considered in at least one iteration of the while-loop but is only reconsidered in a later iteration if at least one vertex was added to the set $S_{r}$ since the last time $r$ was considered; in this case $O(c)$ one-step operations are performed. Thus the number of symbolic operations per set $S_{r}$ is of the same order as the number of times a vertex is added to the set. Hence the algorithm can be implemented with $O(c\cdot n\cdot|M^{\infty}_{h}|)$ symbolic operations. For the co-domain $M^{\infty}_{\mathcal{G}}$ the bound $O(c\cdot n\cdot|M^{\infty}_{\mathcal{G}}|)$ is analogous.

Example 3**.**

In this example we apply Algorithm 1 to the parity game in Figure 1. We have $n_{1}=3$ and $n_{3}=1$ and thus we have to consider ranks in the co-domain $M^{\infty}_{G}=\{(0,0),(1,0),(2,0),(3,0),(0,1),$ $(1,1),(2,1),(3,1),\top\}$ (we ignore entires of ranks that are always zero in this notation).

The algorithm initializes the set $S_{(0,0)}$ to $\{a,b,c,d,e,f,g,h\}$ and $r$ to $(1,0)$. All the other sets $S_{r}$ are initialized as the empty set. It then proceeds as follows:

In the first iteration of the while-loop it processes $r=(1,0)$. We have $\ell=1$ and thus the only possible value of $k$ in line 1 is $k=1$. That is, line 1 adds the vertices in $\mathsf{CPre}_{{\mathcal{O}}}(S_{0,0})\cap P_{1}=\{a,c,h\}$ to $S_{(1,0)}$ and then in line 1 also $b$ is added. We obtain $S_{(1,0)}=\{a,b,c,h\}$ and as $S_{(1,0)}\subseteq S_{(0,0)}$, the rank $r$ is increased to $(2,0)$. 2. 2.

In the second iteration it processes $r=(2,0)$ and the vertex $a$ is added to $S_{(2,0)}$ in line 1 and the vertex $b$ is added to $S_{(2,0)}$ in line 1, i.e., $S_{(2,0)}=\{a,b\}$, and $r$ is set to $(3,0)$. 3. 3.

When processing $r=(3,0)$ the set $S_{(3,0)}$ is updated to $\{a,b\}$ and $r$ is increased to $(0,1)$. 4. 4.

Now the algorithm processes the rank $(0,1)$ the first time. We have $\ell=3$ and thus the possible values for $k$ are $1$ and $2$. The vertex $a$ is added to $S_{(0,1)}$ because it is contained in $\mathsf{CPre}_{{\mathcal{O}}}(S_{3,0})\cap P_{1}$ and the vertex $e$ is added because it is contained in $\mathsf{CPre}_{{\mathcal{O}}}(S_{0,0})\cap P_{3}$ in line 1. Finally, also $b$ and $g$ are added in line 1. That is, we have $S_{(0,1)}=\{a,b,e,g\}$. Now as $S_{(3,0)}\not\subseteq S_{(0,1)}$, $S_{(2,0)}\not\subseteq S_{(0,1)}$ and $S_{(1,0)}\not\subseteq S_{(0,1)}$, we have to decrease $r$ to $(1,0)$, and also to modify the other sets with smaller rank as follows: $S_{(1,0)}=\{a,b,c,e,g,h\}$; and $S_{(2,0)}=S_{(3,0)}=\{a,b,e,g\}$. 5. 5.

The algorithm considers $r=(1,0)$ again, makes no changes to $S_{(1,0)}$ and sets $r$ to $(2,0)$. 6. 6.

Now considering $r=(2,0)$, the vertex $h$ is added to the set $S_{(2,0)}$ in line 1, i.e., $S_{(2,0)}=\{a,b,e,g,h\}$, and, as $h$ is already contained in $S_{(1,0)}$, $r$ is increased to $(3,0)$. 7. 7.

The set $S_{(3,0)}$ is not changed and $r$ is increased to $(0,1)$. 8. 8.

The set $S_{(0,1)}$ is not changed and $r$ is increased to $(1,1)$. 9. 9.

The vertex $a$ is added to $S_{(1,1)}$ in line 1 and the vertex $b$ is added to $S_{(1,1)}$ in line 1, i.e., $S_{(1,1)}=\{a,b\}$, and $r$ is increased to $(2,1)$. 10. 10.

The vertices $a,b$ are added to $S_{(2,1)}$, i.e., $S_{(2,1)}=\{a,b\}$, and $r$ is increased to $(3,1)$. 11. 11.

The vertices $a,b$ are added to $S_{(3,1)}$, i.e., $S_{(3,1)}=\{a,b\}$, and $r$ is increased to $\top$. 12. 12.

The vertex $a$ is added to $S_{\top}$ in line 1 and $b$ is added to $S_{\top}$ in line 1, i.e., $S_{\top}=\{a,b\}$. Now as $S_{(3,1)}\subseteq S_{\top}$, the algorithm terminates.

Finally we have that $S_{(0,0)}=\{a,b,c,d,e,f,g,h\}$, $S_{(1,0)}=\{a,b,c,e,g,h\}$, $S_{(2,0)}=\{a,b,e,g,h\}$, $S_{(3,0)}=S_{(0,1)}=\{a,b,e,g\}$, and $S_{(1,1)}=S_{(2,1)}=S_{(3,1)}=S_{\top}=\{a,b\}$, That is, the algorithm returns $\{c,d,e,f,g,h\}$ as the winning set of player ${\mathcal{E}}$. The final sets of the algorithm corresponds to the progress measure $\rho$ with $\rho(f)=\rho(d)=(0,0)$, $\rho(c)=(1,0)$, $\rho(h)=(2,0)$, $\rho(e)=\rho(g)=(0,1)$, and $\rho(a)=\rho(b)=\top$. a $\lozenge$

Outline correctness proof.

In the following proof we show that when Algorithm 1 terminates, the ranking function $\rho_{\{S_{r}\}_{r}}$ is equal to the progress measure for the given parity game and the co-domain $M^{\infty}_{h}$. The same proof applies to the co-domain $M^{\infty}_{\mathcal{G}}$. The algorithm returns the set of vertices that are assigned a rank $<\top$ when the algorithm terminates. By [40] (see Appendix D.3) this set is an ${\mathcal{E}}$-dominion that contains all ${\mathcal{E}}$-dominions of size at most $h+1$ when the co-domain $M^{\infty}_{h}$ is used, and by Lemma 1 this set is equal to the winning set of player ${\mathcal{E}}$ when the co-domain $M^{\infty}_{\mathcal{G}}$ is used. Thus it remains to show that $\rho_{\{S_{r}\}_{r}}$ equals the progress measure for the given co-domain when the algorithm terminates. We show that maintaining the following invariants over all iteration of the algorithm is sufficient for this and then prove that the invariants are maintained. All proofs are in Appendix B and are described for the co-domain $M^{\infty}_{h}$.

Invariant 4** (Symbolic invariants).**

In Algorithm 1 the following three invariants hold. Every rank is from the co-domain $M^{\infty}_{h}$ and the $\operatorname{Lift}(.,v)$-operators are defined w.r.t. the co-domain. Let $\tilde{\rho}$ be the progress measure of the given parity game and let $\rho_{\{S_{r}\}_{r}}(v)=\max\{r\in M^{\infty}_{h}\mid v\in S_{r}\}$ be the ranking function with respect to the sets $S_{r}$ that are maintained by the algorithm.

Before and after each iteration of the while-loop we have that if a vertex $v$ is in a set $S_{r_{1}}$ then it is also in $S_{r_{2}}$ for all $r_{2}<r_{1}$ (anti-monotonicity). 2. 2.

Throughout Algorithm 1 we have $\tilde{\rho}(v)\geq\rho_{\{S_{r}\}_{r}}(v)$ for all $v\in V$. 3. 3.

Before and after each iteration of the while-loop we have for the rank stored in $r$ and all vertices $v$ either $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ or $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$. (b) After the update of $S_{r}$ and before the update of $r$ we additionally have $v\in S_{r}$ for all vertices $v$ with $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r$ (closure property).

Informal description of invariants.

Invariant 4(1) ensures that the definition of the sets $S_{r}$ and the ranking function $\rho_{\{S_{r}\}_{r}}$ is sound; Invariant 4(2) guarantees that $\rho_{\{S_{r}\}_{r}}$ is a lower bound on $\tilde{\rho}$ throughout the algorithm; and Invariant 4(3) shows that when the algorithm terminates, a fixed point of the ranking function $\rho_{\{S_{r}\}_{r}}$ with respect to the $\operatorname{Lift}(.,v)$-operators is reached. Together these three properties guarantee that when the algorithm terminates the function $\rho_{\{S_{r}\}_{r}}$ corresponds to the progress measure, i.e., to the least simultaneous fixed point of the $\operatorname{Lift}(.,v)$-operators. We prove the invariants by induction over the iterations of the while-loop. In particular, Invariant 4(1) is ensured by adding vertices newly added to a set $S_{r}$ also to sets $S_{r^{\prime}}$ with $r^{\prime}<r$ that do not already contain them at the end of each iteration of the while-loop. For Invariant 4(2) we show that whenever $\rho_{\{S_{r}\}_{r}}(v)$ is increased, i.e., $v$ is added to the set $S_{r}$, then no fixed point of the lift-operator for $v$ was reached yet and thus also the progress measure for $v$ has to be at least as high as the new value of $\rho_{\{S_{r}\}_{r}}(v)$. The intuition for the proof of Invariant 4(3) is as follows: We first show that $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$ remains to hold for all vertices $v$ for which the value of $\rho_{\{S_{r}\}_{r}}(v)$ is less than the smallest value $r^{\prime}$ for which $S_{r^{\prime}}$ was updated in the considered iteration. In iterations in which the value of the variable $r$ is not increased, this is already sufficient to show part (a) of the invariant. If $r$ is increased, we additionally use part (b) to show part (a). For part (b) we prove by case analysis that, before the update of the variable $r$, a vertex with $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r$ is included in $S_{r}$. The correctness of the algorithm then follows from the invariants as outlined above.

3.2 Reducing Space to Linear.

Algorithm 1 requires $\lvert M^{\infty}_{\mathcal{G}}\rvert$ many sets $S_{r}$, which is drastically beyond the space requirement of the progress measure algorithm for explicitly represented graphs. Thus we aim to reduce the space requirement to $O(n)$ many sets in a way that still allows to restore the sets $S_{r}$ efficiently. For the sake of readability, we assume for this part that $c$ is even.

Main Idea.

The main idea to reduce the space requirement is as follows.

(1) Instead of storing sets $S_{r}$ corresponding to a specific rank, we encode the value of each coordinate of the rank $r$ separately. That is, we define the sets $C^{i}_{0},C^{i}_{1}\dots,C^{i}_{n_{i}}$ for each odd priority $i$. Intuitively, a vertex is in the set $C^{i}_{x}$ iff the $i$-th coordinate of the rank of $v$ is $x$. Given these $O(c+n)\in O(n)$ sets, we have encoded the exact rank vector $r$ of each vertex with $r<\top$. To also cover vertices with rank $\top$, we additionally store the set $S_{\top}$.

(2) Whenever the algorithm needs to process a set $S_{r}$, we reconstruct it from the stored sets, using a linear number of set operations. Algorithm 1 has to be adapted as follows. First, at the beginning of each iteration we have to compute the set $S_{r}$ and up to $c/2$ sets $S_{r^{\prime}}$ that correspond to some predecessor $r^{\prime}$ of $r$. Second, at the end of each iteration we have to update the sets $C^{i}_{x}$ to incorporate the updated set $S_{r}$.

Computing a set $S_{r}$ from the sets $C^{i}_{x}$.

Let $r_{i}$ denote the $i$-th entry of $r$. To obtain the set $S^{=}_{r}$ of vertices with rank exactly $r$ (for $r<\top$), one can simply compute the intersection $\bigcap_{1\leq k\leq c/2}C^{2k-1}_{r_{2k-1}}$ of the corresponding sets $C^{i}_{x}$. However, in the algorithm we need the sets $S_{r}$ containing all vertices $v$ with a rank at least $r$ and computing all sets $S^{=}_{r^{\prime}}$ with $r^{\prime}\geq r$ is not efficient. Towards a more efficient method to compute $S_{r}$, recall that a rank $r^{\prime}<\top$ is higher than $r$ if either (a) the right most odd element of $r^{\prime}$ is larger than the corresponding element in in $r$, i.e., $r^{\prime}_{c-1}>r_{c-1}$, or (b) if $r$ and $r^{\prime}$ coincide on the $i$ right most odd elements, i.e., $r^{\prime}_{c-2k+1}=r_{c-2k+1}$ for $1\leq k\leq i$, and $r^{\prime}_{c-2i-1}>r_{c-2i-1}$. In case (a) we can compute the corresponding vertices by

[TABLE]

while in case (b) we can compute the corresponding vertices by

[TABLE]

for $1\leq i\leq c/2-1$. That is, we can reconstruct the set $S_{r}$ by the following union of the above sets $S^{i}_{r}$, the set $S^{=}_{r}$ of vertices with rank $r$, and the set $S_{\top}$ of vertices with rank $\top$:

[TABLE]

Hence, a set $S_{r}$ can be computed with $O(c+n)\in O(n)$ many $\cup$ and $O(c)$ many $\cap$ operations; for the latter bound we use an additional set to store the set $\bigcap_{1\leq k\leq i}C^{c-2k+1}_{r_{c-2k+1}}$ for the current value of $i$, such that for each set $S^{i}_{r}$ we just need two $\cap$ operations. This implies the following lemma.

Lemma 5**.**

Given the sets $C^{i}_{x}$ as defined above, we can compute the set $S_{r}$ that contains all vertices with rank at least $r$ with $O(n)$ many symbolic set operations. No symbolic one-step operation is needed.

Updating a set $S_{r}$.

Now consider we have updated a set $S_{r}$ during the iteration of the while-loop, and now we want to store the updated set $S_{r}$ within the sets $C^{i}_{x}$. That is, we have already computed the fixed-point for $S_{r}$ and are now in line 1 of the Algorithm. To this end, let $S^{\text{old}}_{r}$ be the set as stored in $C^{i}_{x}$ and $S^{\text{new}}_{r}$ the updated set, which is a superset of the old one. First, one computes the difference $S^{\text{diff}}_{r}$ between the two sets $S^{\text{diff}}_{r}=S^{\text{new}}_{r}\setminus S^{\text{old}}_{r}$; intuitively, the set $S^{\text{diff}}_{r}$ contains the vertices for which the algorithm has increased the rank. Now for the vertices of $S^{\text{diff}}_{r}$ we have to (i) delete their old values by updating $C^{i}_{x}$ to $C^{i}_{x}\setminus S^{\text{diff}}_{r}$ for each $i\in\{1,3,\dots,c-1\}$ and each $x\in\{0,\dots,n_{i}\}$ and (ii) store the new values by updating $C^{i}_{x}$ to $C^{i}_{x}\cup S^{\text{diff}}_{r}$ for $i\in\{1,3,\dots,c-1\}$ and $x=r_{i}$. In total we have $O(c)$ many $\cup$ and $O(n)$ many $\setminus$ operations.

Notice that the update operation for a set $S_{r}$, as described above, also updates all sets $S_{r^{\prime}}$ for $r^{\prime}<r$. Thus, when using the more succinct representation via the sets $C^{i}_{x}$ and executing 1 literally, the computation of the maximal rank $r^{\prime}$ s.t. $S_{r^{\prime}}\supseteq S_{r}$ would fail because of the earlier update of $S_{r}$. Hence, we have to postpone the update of $S_{r}$ till the end of the iteration and adjust the computation of $r^{\prime}$ as follows. We do not update the set $S_{r}^{\prime}$, and first compute the final value for $r^{\prime}$ by decrementing $r^{\prime}$ until $S_{r^{\prime}}\supseteq S_{r}$ and then update $S_{r}$ to $S^{\text{new}}_{r}$ and thus implicitly also update the sets $S_{\tilde{r}}$ to $S_{\tilde{r}}\cup S_{r}$ for $r^{\prime}<\tilde{r}<r$. This gives the following lemma.

Lemma 6**.**

In each iteration of 1 only $O(n)$ symbolic set operations are needed to update the sets $C^{i}_{x}$, and no symbolic one-step operation is needed.

Number of Set Operations.

To sum up, when introducing the succinct representation of the sets $S_{r}$, we only need additional $\cup$, $\cap$, and $\setminus$ operations, while the number of $\mathsf{CPre}_{{z}}$ operations is unchanged. We show in Appendix B that whenever the algorithm computes or updates a set $S_{r}$, then we can charge a $\mathsf{CPre}_{{z}}$ operation for it, and each $\mathsf{CPre}_{{z}}$ operation is only charged for a constant number of set computations and updates. Hence, as both computing a set $S_{r}$ and updating the sets $C^{i}_{x}$ can be done with $O(n)$ set operations, the number of the additional set operations in 1 is in $O(n\cdot\#\mathsf{CPre})$, for $\#\mathsf{CPre}$ being the number of $\mathsf{CPre}_{{z}}$ operations in the algorithm.

Putting Things Together.

We presented a set-based symbolic implementation of the progress measure that uses $O(n)$ sets, $O(c\cdot n\cdot\lvert M^{\infty}_{h}\rvert)$ symbolic one-step operations and at most a factor of $n$ more symbolic set operations. We apply the following bound on the size of $M^{\infty}_{h}$:

[TABLE]

The following lemma summarizes the result for computing dominions.

Key Lemma 7**.**

For a parity game with $n$ vertices and $c$ priorities and an integer $h\in[1,n-1]$, Algorithm 1 computes a player-${\mathcal{E}}$ dominion that contains all ${\mathcal{E}}$-dominions with at most $h+1$ vertices and can be implemented with $O\left(c\cdot n\cdot\binom{h+\lfloor c/2\rfloor}{h}\right)$ symbolic one-step operations, $O\left(c\cdot n^{2}\cdot\binom{h+\lfloor c/2\rfloor}{h}\right)$ symbolic set operations, and $O(n)$ many sets.

To solve parity games directly with Algorithm 1, we use the co-domain $M^{\infty}_{\mathcal{G}}$ instead of $M^{\infty}_{h}$. Recall that we have \lvert M^{\infty}_{\mathcal{G}}\rvert\in O\big{(}\big{(}\frac{n}{\lfloor c/2\rfloor}\big{)}^{\lfloor c/2\rfloor}\big{)} [28].

Theorem 8**.**

Let \xi(n,c)=\big{(}\frac{n}{\lfloor c/2\rfloor}\big{)}^{\lfloor c/2\rfloor}. Algorithm 1 computes the winning sets of parity games and can be implemented with O\big{(}c\cdot n\cdot\xi(n,c)\big{)} symbolic one-step operations, O\big{(}c\cdot n^{2}\cdot\xi(n,c)\big{)} symbolic set operations, and $O(n)$ many sets.

See Appendix F for how to construct winning strategies within the same bounds.

4 Extensions and Conclusion

4.1 Big-Step Algorithm.

We presented a set-based symbolic algorithm for computing a progress measure that solves parity games. Since the progress measure algorithm can also compute dominions of bounded size, it can be combined with the big step approach of [40] to improve the number of symbolic steps as stated in the following theorem. All details are given in the appendix.

Theorem 9**.**

Let $\gamma(c)=c/3+1/2-4/(c^{2}-1)$ for odd $c$ and $\gamma(c)=c/3+1/2-1/(3c)-4/c^{2}$ for even $c$. There is a symbolic Big Step Algorithm that computes the winning sets for parity games and with the minimum of $O(n\cdot(\kappa\cdot n/c)^{\gamma(c)})$, for some constant $\kappa$, and $n^{O(\sqrt{n})}$ symbolic one-step operations and stores only $O(n)$ many sets.

4.2 Concluding Remarks.

In this work we presented improved set-based symbolic algorithms for parity games, and equivalently modal $\mu$-calculus model checking. Our main contribution improves the symbolic algorithmic complexity of one of the most fundamental problems in the analysis of program logics, with numerous applications in program analysis and reactive synthesis. There are several practical approaches to solve parity games, such as, [14, 22, 26, 25, 3] and [43]. A practical direction of future work would be to explore whether our algorithmic ideas can be complemented with engineering efforts to obtain scalable symbolic algorithms for reactive synthesis of systems. An interesting theoretical direction of future work is to obtain set-based symbolic algorithms for parity games with quasi-polynomial complexity. The breakthrough result of [10] (see also [23]) relies on alternating poly-logarithmic space Turing machines.. The follow-up papers of [29] and [20] that slightly improve the running time and reduce the space complexity from quasi-polynomial to quasi-linear rely on succinct notions of progress measures. All these algorithms are non-symbolic, and symbolic versions of these algorithms are an open question, in particular encoding the novel succinct progress measures in the symbolic setting when storing at most a linear number of sets.

Acknowledgements.

All authors are partially supported by the Vienna Science and Technology Fund (WWTF) through project ICT15-003. K. C. is partially supported by the Austrian Science Fund (FWF) NFN Grant No S11407-N23 (RiSE/SHiNE) and an ERC Start grant (279307: Graph Games). For W. D., M. H., and V. L. the research leading to these results has received funding from the European Research Council under the European Union’s Seventh Framework Programme (FP/2007-2013) / ERC Grant Agreement no. 340506. V.L. is partially supported by the ISF grant #1278/16.

Appendix A Illustration: Parity Games with $5$ Priorities

We informally introduce our symbolic algorithm to compute the progress measure, using parity games with $5$ priorities as an important special case. The pseudo-code is given in Algorithm 2.

In Example 10 we use the parity game in Figure 2 as an example to illustrate Algorithm 2.

Intuition for ranks $r$ and sets $S_{r}$.

We first provide some intuition for the ranks $r$ and the sets $S_{r}$ for parity games with $5$ priorities. The rank $r$ has an index for each of the priorities $\{0,1,2,3,4\}$ but may contain non-zero entries only for the odd priorities $\{1,3\}$. Thus, for this section, we denote a rank vector as a vector with two elements, where the first element corresponds to element $1$ of $r$ and the second element corresponds to element $3$ of $r$. The lowest rank is $(0,0)$, followed by $(1,0)$, the highest rank is $\top$, preceded by $(n_{1},n_{3})$. Throughout the algorithm, whenever a vertex is contained in the set $S_{r}$, then its rank in the progress measure is at least $r$. The sets $S_{r^{\prime}}$ are defined to contain vertices with rank at least $r^{\prime}$ instead of exactly $r^{\prime}$ such that for each vertex $v$ and rank $r$ we only have to consider one set $S_{r^{\prime}}$ in order to decide whether the rank of $v$ can be increased to $r$. The sets $S_{r}$ implicitly assign each vertex $v$ a rank, namely the maximum rank $r$ such that $v\in S_{r}$. Each vertex can only be assigned rank vectors for which the rank vector is zero at all indices corresponding to priorities lower than its own priority. For example, a vertex with priority $4$ can only be assigned rank $(0,0)$ or rank $\top$. Thus for such a vertex its rank can “jump” from $(0,0)$ to $\top$ (because of one of its successors being added to $S_{\top}$), and then this information has to be propagated to its predecessors. The algorithm achieves this efficiently by adding, e.g., vertices that are added to $S_{\top}$ to all sets representing lower ranks as well. We next describe the intuition for what it means when a vertex $v$ is assigned a specific rank $r$.

Intuitively, when a vertex $v$ is assigned a rank $(i,0)$ for $i\in N_{1}$, i.e., the set with highest rank it is contained in is $S_{(i,0)}$, then, in plays starting from $v$, player ${\mathcal{O}}$ can force a play from $v$ to visit $i$ vertices of priority $1$ before a vertex of priority $2$ or higher is reached; for $i>0$ this implies that the priority of $v$ is either [math] or $1$.

Let vertex $v$ be assigned rank $(i,j)$ for $i\in N_{1}$ and $j\in N_{3}$. The interpretation of the value of $i$ is the same as in the case $(i,0)$, where the value of $i$ is taken modulo $n_{1}+1$. Each contribution of 1 to the value of $j$ corresponds either (a) to the number of times a priority-$3$ vertex is visited before a priority-4 vertex is reached or (b) to priority-$1$ vertices being reached $n_{1}+1$ times before a vertex with priority at least $2$ is reached. Note that both cases can also happen for a vertex with priority 2 or 3; for $\alpha(v)=4$ the only set $S_{(i,j)}$ the vertex $v$ can belong to is $S_{(0,0)}$, as the rank of a priority-4 vertex can only be $(0,0)$ or $\top$.

Recall that $\top$ are the vertices where player ${\mathcal{E}}$ has no winning strategy. There are three ways a vertex $v$ can be ranked $\top$: (i) $v$ has priority-1 and the best successor is ranked $(n_{1},n_{3})$, (ii) $v$ has priority-3 and the best successor is ranked at least $(0,n_{3})$, and (iii) the best successor is ranked $\top$. The cases (i) and (ii) correspond to the cases where player ${\mathcal{E}}$ has to visit at least $n_{1}+1$ or $n_{3}+1$ many vertices of the respective odd priority before reaching a higher even priority. Note that this means that player ${\mathcal{O}}$ can force plays to reach a cycle where the highest priority is odd. In case (iii) player ${\mathcal{O}}$ can force plays to visit a vertex from which she can reach a cycle with highest odd priority.

Symbolic algorithm.

In our symbolic algorithm 2 we use the sets $S_{r}$ to represent the numerical values of the progress measure, and, to utilize the power of symbolic operations, we compute all vertices whose rank can be increased to a certain value $r$ in each iteration of the algorithm. The latter is in contrast to the explicit progress measure algorithm [28], where vertices are considered one by one and the rank is increased to the maximal possible value.

We next describe Algorithm 2 and then give some intuition for its correctness and the number of its symbolic operations. Recall that the sets $S_{r}$ define a ranking function $\rho_{\{S_{r}\}_{r}}(v)=\max\{r\in M^{\infty}_{\mathcal{G}}\mid v\in S_{r}\}$ that assigns a rank to each vertex and that by the definition of $\mathrm{inc}$ a vertex $v$ with priority $\alpha(v)$ is only assigned ranks $r$ with $r=\left<r\right>_{\alpha(v)}$.

Initialization.

To find the least simultaneous fixed point of the lift-operators, all ranks are initialized with the all zero vector, i.e., all vertices are added to $S_{(0,0)}$, while all other sets $S_{r}$ are empty. The variable $r$ is initialized to $(1,0)$.

The value of $r$.

In each iteration of the while loop the set $S_{r}$ for the rank that is stored in the variable $r$ at the beginning of the iteration is updated (more details below). By the definition of the sets $S_{r^{\prime}}$, we need to maintain $S_{r^{\prime}}\supseteq S_{r}$ for $r^{\prime}<r$, i.e., every vertex that is newly added to $S_{r}$ but not yet contained in $S_{r^{\prime}}$ is added to $S_{r^{\prime}}$ (line 2). For the vertices newly added to $S_{r}$ we say that their rank is increased. When the rank of a vertex is increased, this might influence the value of $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ for its predecessors $v$. Since we want to obtain a fixed point of $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ for all $v\in V$, we have to reconsider the predecessors of a vertex whenever the rank of the vertex is increased. This is achieved by updating the variable $r$ to the lowest $r^{\prime}$ for which a new vertex is added to $S_{r^{\prime}}$ in this iteration (lines 2–2). If $r=r^{\prime}$, then for $r<\top$ the value of $r$ is increased to the next highest rank in the ordering (line 2) and for $r=\top$ the algorithm terminates (line 2).

Update of set $S_{r}$.

To reach a simultaneous fixed point of the lift-operators, the rank of a vertex $v$ has to be increased to $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ whenever the value of $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ is strictly higher than $\rho_{\{S_{r}\}_{r}}(v)$ for the current ranking function $\rho_{\{S_{r}\}_{r}}$. Recall that this is the case only if the value of $\mathrm{best}(\rho,v)$ is increased, which implies that the rank assigned to at least one successor of $v$ was increased (or a rank $r$ is considered for the first time). For the update of the set $S_{r}$ in an iteration of the while-loop (where $r$ is the value of the variable at the beginning of the while-loop), the algorithm adds to $S_{r}$ all vertices that satisfy the following three conditions: (i) $\rho_{\{S_{r}\}_{r}}(v)<r$, (ii) $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$, and (iii) $r=\left<r\right>_{\alpha(v)}$. Note that the algorithm maintains the invariant that vertices with $\rho_{\{S_{r}\}_{r}}\geq r$ are already contained in $S_{r}$. We distinguish between $r=(i,j)$ with $i>0$, $r=(0,j)$, and $r=\top$.

(1) For $r=(i,j)$ with $i>0$ recall that only vertices $v$ with priority 0 or 1 can be assigned the rank $r$.

Case (a): Assume first that $\alpha(v)=1$, i.e., $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\min\{y\in M^{\infty}_{\mathcal{G}}\mid y>_{1}\mathrm{best}(\rho_{\{S_{r}\}_{r}},v)\}$. Then $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ if $\mathrm{best}(\rho_{\{S_{r}\}_{r}},v)\geq(i-1,j)$, i.e., if (i) $v\in V_{\mathcal{E}}$ and all successors $w$ of $v$ have $\rho_{\{S_{r}\}_{r}}(w)\geq(i-1,j)$ or (ii) $v\in V_{\mathcal{O}}$ and one successor $w$ of $v$ has $\rho_{\{S_{r}\}_{r}}(w)\geq(i-1,j)$. That is, $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ only if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{(i-1,j)})$. In this case the vertex $v$ is added to $S_{r}$ in line 2.

Case (b): Assume now that $\alpha(v)=0$, i.e., $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\left<\mathrm{best}(\rho_{\{S_{r}\}_{r}},v)\right>_{0}=\mathrm{best}(\rho_{\{S_{r}\}_{r}},v)$. Then $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ if $\mathrm{best}(\rho_{\{S_{r}\}_{r}},v)\geq(i,j)$, i.e., if (i) $v\in V_{\mathcal{E}}$ and all successors $w$ of $v$ have $\rho_{\{S_{r}\}_{r}}(w)\geq(i,j)$ or (ii) $v\in V_{\mathcal{O}}$ and one successor $w$ of $v$ has $\rho_{\{S_{r}\}_{r}}(w)\geq(i,j)$. That is, $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ only if $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{(i,j)})$. In this case the vertex $v$ is added to $S_{r}$ in some iteration of the repeat-until loop in line 2.

(2) The difference for $r=(0,j)$ is first that also vertices with priorities 2 or 3 are candidates for the assignment of rank $r$ and second that for a vertex $v$ with odd priority we now have the following possibilities: either (i) $\alpha(v)=1$ and we consider neighbors $w$ with $\rho_{\{S_{r}\}_{r}}(w)\geq(n_{1},j-1)$ or (ii) $\alpha(v)=3$ and we consider neighbors $w$ with $\rho_{\{S_{r}\}_{r}}(w)\geq(0,j-1)$.

(3) The case $r=\top$ corresponds to the case $r=(0,j)$ with $j=n_{3}+1$ with the difference that also vertices with priority 4 can be included in $S_{\top}$ in the case $\rho_{\{S_{r}\}_{r}}(w)=\top$.

Example 10**.**

In this example we apply Algorithm 2 to the parity game in Figure 2. We have $n_{1}=3$ and $n_{3}=1$ and thus we have to consider ranks in the co-domain $M^{\infty}_{G}=\{(0,0),(1,0),(2,0),(3,0),(0,1),$ $(1,1),(2,1),(3,1),\top\}$.

The algorithm initializes the set $S_{(0,0)}$ to $\{a,b,c,d,e,f,g,h\}$ and $r$ to $(1,0)$. All the other sets $S_{r}$ are initialized as the empty set. It then proceeds as follows:

In the first iteration of the while-loop it processes $r=(1,0)$. In line 2 the vertices $a,c$ and $h$ are added to $S_{(1,0)}$ and then in line 2 also $b$ is added. That is, we obtain $S_{(1,0)}=\{a,b,c,h\}$ and as $S_{(1,0)}\subseteq S_{(0,0)}$, the rank $r$ is increased to $(2,0)$. 2. 2.

In the second iteration it processes $r=(2,0)$ and the vertex $a$ is added to $S_{(2,0)}$ in line 2 and the vertex $b$ is added to $S_{(2,0)}$ in line 2, i.e., $S_{(2,0)}=\{a,b\}$, and $r$ is set to $(3,0)$. 3. 3.

When processing $r=(3,0)$ the set $S_{(3,0)}$ is updated to $\{a,b\}$ and $r$ is increased to $(0,1)$. 4. 4.

Now the algorithm processes the rank $(0,1)$ the first time. The vertex $a$ is added to $S_{(0,1)}$ because of the $\left(\mathsf{CPre}_{{\mathcal{O}}}(S_{n_{1},j-1})\cap P_{1}\right)$ part in line 2 and the vertex $e$ is added because of the $\left(\mathsf{CPre}_{{\mathcal{O}}}(S_{0,j-1})\cap P_{3}\right)$ part in line 2. Finally, also $b$ and $g$ are added in line 2. That is, we have $S_{(0,1)}=\{a,b,e,g\}$. Now as $S_{(3,0)}\not\subseteq S_{(0,1)}$, $S_{(2,0)}\not\subseteq S_{(0,1)}$ and $S_{(1,0)}\not\subseteq S_{(0,1)}$ we have to decrease $r$ to $(1,0)$, and also to modify the other sets with smaller rank as follows: $S_{(1,0)}=\{a,b,c,e,g,h\}$; and $S_{(2,0)}=S_{(3,0)}=\{a,b,e,g\}$. 5. 5.

The algorithm considers $r=(1,0)$ again, makes no changes to $S_{(1,0)}$, and sets $r$ to $(2,0)$. 6. 6.

Now considering $r=(2,0)$, the vertex $h$ is added to the set $S_{(2,0)}$ in line 2, i.e., $S_{(2,0)}=\{a,b,e,g,h\}$, and, as $h$ is already contained in $S_{(1,0)}$, $r$ is increased to $(3,0)$. 7. 7.

The set $S_{(3,0)}$ is not changed and $r$ is increased to $(0,1)$. 8. 8.

The set $S_{(0,1)}$ is not changed and $r$ is increased to $(1,1)$. 9. 9.

The vertex $a$ is added to $S_{(1,1)}$ in line 2 and the vertex $b$ is added to $S_{(1,1)}$ in line 2, i.e., $S_{(1,1)}=\{a,b\}$, and $r$ is increased to $(2,1)$. 10. 10.

The vertices $a,b$ are added to $S_{(2,1)}$, i.e., $S_{(2,1)}=\{a,b\}$, and $r$ is increased to $(3,1)$. 11. 11.

The vertices $a,b$ are added to $S_{(3,1)}$, i.e., $S_{(3,1)}=\{a,b\}$, and $r$ is increased to $\top$. 12. 12.

The vertex $a$ is added to $S_{\top}$ in line 2 and $b$ is added to $S_{\top}$ in line 2, i.e., $S_{\top}=\{a,b\}$.

Now as $S_{(3,1)}\subseteq S_{\top}$, the algorithm terminates.

Finally we have that $S_{(0,0)}=\{a,b,c,d,e,f,g,h\}$, $S_{(1,0)}=\{a,b,c,e,g,h\}$, $S_{(2,0)}=\{a,b,e,g,h\}$, $S_{(3,0)}=S_{(0,1)}=\{a,b,e,g\}$, and $S_{(1,1)}=S_{(2,1)}=S_{(3,1)}=S_{\top}=\{a,b\}$. That is, the algorithm returns $\{c,d,e,f,g,h\}$ as the winning set of player ${\mathcal{E}}$. The final sets of the algorithm corresponds to the progress measure $\rho$ with $\rho(f)=\rho(d)=(0,0)$, $\rho(c)=(1,0)$, $\rho(h)=(2,0)$, $\rho(e)=\rho(g)=(0,1)$, and $\rho(a)=\rho(b)=\top$. a $\lozenge$

Sketch of bound on number of symbolic operations.

Observe that each rank $r$ is considered in at least one iteration of the while-loop but is only reconsidered in a later iteration if at least one vertex was added to the set $S_{r}$ since the last time $r$ was considered. This implies by $\lvert S_{r}\rvert\leq n$ that Algorithm 2 can be implemented with $O(n\cdot|M^{\infty}_{\mathcal{G}}|)=O(n^{3})$ symbolic operations.

Sketch of correctness.

Let $\{S_{r}\}_{r}$ be the sets in the algorithm at termination. The algorithm returns the set of vertices that are not contained in $S_{\top}$, i.e., the vertices to which $\rho_{\{S_{r}\}_{r}}$ assigns a rank $<\top$. If $\rho_{\{S_{r}\}_{r}}$ is equal to the progress measure of the parity game, then by Lemma 1 the returned set $V\setminus S_{\top}$ is equal to the winning set of player ${\mathcal{E}}$. Let $\tilde{\rho}$ denote the progress measure. It remains to show that $\rho_{\{S_{r}\}_{r}}(v)=\tilde{\rho}(v)$ for all $v\in V$ when the algorithm terminates. To this end we show (1) that the algorithm only adds a vertex to a set $S_{r}$ when the progress measure $\tilde{\rho}$ is at least $r$, i.e., throughout the algorithm the ranking function $\rho_{\{S_{r}\}_{r}}$ is a lower bound on $\tilde{\rho}$ and (2) by the update of the variable $r$ we have before and after each iteration of the while-loop for all vertices $v$ that either $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$ or $\rho_{\{S_{r}\}_{r}}(v)\geq r$ and in the final iteration with $r=\top$ we have $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$ for all $v\in V$. This implies that when the algorithm terminates the ranking function $\rho_{\{S_{r}\}_{r}}$ is a simultaneous fixed point of the lift-operators. Together these two properties imply that the algorithm computes the progress measure of the parity game.

Appendix B Details for Section 3

Correctness.

The correctness of Algorithm 1, stated in the following lemma, follows from combining Lemma 12 with Lemmata 13–15, which we prove below.

Lemma 11** (Correctness).**

Algorithm 1 computes the progress measure for a given parity game (with $n$ vertices) and a given set of possible ranks $M^{\infty}_{h}$ (for some integer $h\in[1,n-1]$).

Lemma 12**.**

Assuming that Invariant 4 holds, the ranking function $\rho_{\{S_{r}\}_{r}}$ induced by the family of sets $\{S_{r}\}_{r}$ at termination of Algorithm 1 is equal to the progress measure for the given parity game and the co-domain $M^{\infty}_{h}$.

Proof.

Recall that the progress measure is the least simultaneous fixed point of all $\operatorname{Lift}(.,v)$-operators for the given parity game (where $\mathrm{inc}$, $\mathrm{dec}$, and the ordering of ranks are w.r.t. the given co-domain) and let the progress measure be denoted by $\tilde{\rho}$. Let $\{S_{r}\}_{r}$ be the sets in the algorithm at termination. For all $v\in V$ the ranking function $\rho_{\{S_{r}\}_{r}}(v)$ is defined as $\max\{r\in M^{\infty}_{h}\mid v\in S_{r}\}$. By Invariant 4(2) we have $\rho_{\{S_{r}\}_{r}}(v)\leq\tilde{\rho}(v)$ for all $v\in V$.

When the algorithm terminates, with $r=\top$, we have by Invariant 4(3) $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$ for each vertex $v$ and thus $\rho_{\{S_{r}\}_{r}}$ is a simultaneous fixed point of the $\operatorname{Lift}(.,v)$-operators. Now, as $\tilde{\rho}$ is the least simultaneous fixed point of all $\operatorname{Lift}(.,v)$-operators, we obtain $\rho_{\{S_{r}\}_{r}}(v)\geq\tilde{\rho}(v)$ for all $v\in V$. Hence we have $\rho_{\{S_{r}\}_{r}}(v)=\tilde{\rho}(v)$ for all $v\in V$. ∎

Lemma 13**.**

Before and after each iteration of the while-loop in Algorithm 1 we have $S_{r_{1}}\supseteq S_{r_{2}}$ for all $r_{1}\leq r_{2}$ with $r_{1},r_{2}\in M^{\infty}_{h}$, i.e., Invariant 4(1)* holds.*

Proof.

The proof is by induction over the iterations of the while-loop. The claim is satisfied when we first enter the while-loop and only $S_{\bar{0}}$ is non-empty. It remains to show that when the claim is valid at the beginning of a iteration then the claim also hold afterwards. By the induction hypothesis, the sets $S_{r^{\prime}}$ for $r^{\prime}<r$ are monotonically decreasing. Thus it is sufficient to find the lowest rank $r^{*}$ such that for all $r^{*}\leq r^{\prime}<r$ we have $S_{r}\not\subseteq S_{r^{\prime}}$ and add the vertices newly added to $S_{r}$ to the sets $S_{r^{\prime}}$ with $r^{*}\leq r^{\prime}<r$, which is done in lines 1–1 of the while-loop. ∎

Lemma 14**.**

Let $\tilde{\rho}$ be the progress measure of the given parity game and let $\rho_{\{S_{r}\}_{r}}(v)=\max\{r\in M^{\infty}_{h}\mid v\in S_{r}\}$ be the ranking function with respect to the family of sets $\{S_{r}\}_{r}$ that is maintained by the algorithm. Throughout Algorithm 1 we have $\tilde{\rho}(v)\geq\rho_{\{S_{r}\}_{r}}(v)$ for all $v\in V$, i.e., Invariant 4(2)* holds.*

Proof.

We show the lemma by induction over the iterations of the while-loop. Before the first iteration of the while-loop only $S_{\bar{0}}$ is non-empty, thus the claim holds by $\tilde{\rho}\geq\bar{0}$.

Assume we have $\rho_{\{S_{r}\}_{r}}(v)\leq\tilde{\rho}(v)$ for all $v\in V$ before an iteration of the while-loop. We show that $\rho_{\{S_{r}\}_{r}}(v)\leq\tilde{\rho}(v)$ also holds during and after the iteration of the while-loop. As the update of $S_{r^{\prime}}$ in line 1 does not change $\rho_{\{S_{r}\}_{r}}$, we only have to show that the invariant is maintained by the update of $S_{r}$ in lines 1–1. Further $\rho_{\{S_{r}\}_{r}}(v)$ only changes for vertices newly added to $S_{r}$, thus we only have to take these vertices into account.

Let $\ell$ be the maximal index such that $r=\left<r\right>_{\ell}$ or the highest odd priority if $r=\top$. Assume $r<\top$, the argument for $r=\top$ is analogous. The algorithm adds vertices to $S_{r}$ in (1) line 1 and (2) line 1. In case (1) we add the vertices $\bigcup_{1\leq k\leq(\ell+1)/2}(\mathsf{CPre}_{{\mathcal{O}}}(S_{{\mathrm{dec}_{2k-1}(r)}})\cap P_{2k-1})$ to $S_{r}$. Let $v\in\mathsf{CPre}_{{\mathcal{O}}}$ $(S_{{\mathrm{dec}_{2k-1}(r)}})\cap P_{2k-1}$ for some $1\leq k\leq(\ell+1)/2$.

• •

If $v\in V_{\mathcal{E}}\cap P_{2k-1}$, then all successors $w$ of $v$ are in $S_{{\mathrm{dec}_{2k-1}(r)}}$ and thus, by the induction hypothesis, have $\tilde{\rho}(w)\geq\mathrm{dec}_{2k-1}(r)$. Now as $v\in P_{2k-1}$, it has rank $\tilde{\rho}(v)$ at least $\mathrm{inc}_{2k-1}(\mathrm{dec}_{2k-1}(r))=r$.

• •

If $v\in V_{\mathcal{O}}\cap P_{2k-1}$, at least one successors $w$ of $v$ is in $S_{{\mathrm{dec}_{2k-1}(r)}}$ and thus, by the induction hypothesis, has $\tilde{\rho}(w)\geq\mathrm{dec}_{2k-1}(r)$. Now as $v\in P_{2k-1}$, it has rank $\tilde{\rho}(v)$ at least $\mathrm{inc}_{2k-1}(\mathrm{dec}_{2k-1}(r))=r$.

For case (2) consider a vertex $v\in\mathsf{CPre}_{{\mathcal{O}}}(S_{r})\setminus\bigcup_{\ell<k\leq d}P_{k}$ added in line 1.

• •

If $v\in V_{\mathcal{E}}$, all successors $w$ of $v$ are in $S_{r}$ and thus, by the induction hypothesis, have $\tilde{\rho}(w)\geq r$. Since the priority of $v$ is $\leq\ell$, we have $\tilde{\rho}(v)\geq\left<r\right>_{\ell}=r$.

• •

If $v\in V_{\mathcal{O}}$, at least one successors $w$ of $v$ is in $S_{r}$ and thus, by the induction hypothesis, has $\tilde{\rho}(w)\geq r$. Since the priority of $v$ is $\leq\ell$, we have $\tilde{\rho}(v)\geq\left<r\right>_{\ell}=r$.∎

Lemma 15**.**

Before and after each iteration of the while loop we have for the rank stored in $r$ and all vertices $v$ either $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)\geq r$ or $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=\rho_{\{S_{r}\}_{r}}(v)$. At line 1 of the algorithm we additionally have $v\in S_{r}$ for all vertices $v$ for which the value of $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)$ is equal to $r$. Thus Invariant 4(3)* holds.*

Proof.

We show the claim by induction over the iterations of the while-loop. Before we first enter the loop, we have $r=\mathrm{inc}(\bar{0})$ and $S_{\bar{0}}=V$ and thus the claim is satisfied. For the inductive step, let $r^{\text{old}}$ be the value of $r$ and $\rho^{\text{old}}$ the ranking function $\rho_{\{S_{r}\}_{r}}$ before a fixed iteration of the while-loop and assume we have for all $v\in V$ either $\operatorname{Lift}(\rho^{\text{old}},v)(v)\geq r^{\text{old}}$ or $\operatorname{Lift}(\rho^{\text{old}},v)(v)=\rho^{\text{old}}(v)$ before the iteration of the while-loop. Let $r^{\text{new}}$ be the value of $r$ and $\rho^{\text{new}}$ the ranking function $\rho_{\{S_{r}\}_{r}}$ after the iteration. We have three cases for the value of $r^{\text{new}}$: (1) $r^{\text{new}}=\mathrm{inc}(r^{\text{old}})$ (line 1), (2) $r^{\text{new}}=r^{\text{old}}=\top$ (line 1), or (3) $r^{\text{new}}<r^{\text{old}}$, i.e., the rank is decreased in lines 1–1 to maintain anti-monotonicity.

We show in Claim 16 that, in all three cases, if a set $S_{r^{\prime}}$, for some $r^{\prime}<r^{\text{old}}$, is not changed in the considered iteration of the while-loop then for all $v\in V$ with $\operatorname{Lift}(\rho^{\text{new}},v)(v)\leq r^{\prime}$ we have that $\operatorname{Lift}(\rho^{\text{new}},v)(v)=\rho^{\text{new}}(v)$.

Given Claim 16, we prove the first part of the invariant as follows. In the case (1) the lowest (and only) rank for which the set is updated is $r^{\text{old}}$, thus it remains to show $\operatorname{Lift}(\rho^{\text{new}},v)(v)=\rho^{\text{new}}(v)$ for vertices with $\operatorname{Lift}(\rho^{\text{new}},v)(v)=r^{\text{old}}$, which is done by showing the second part of the invariant, namely that $v\in S_{r^{\text{old}}}$ for all vertices $v$ with $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r^{\text{old}}$ after the update of the set $S_{r^{\text{old}}}$ in lines 1–1; for case (1) we have $\rho^{\text{new}}=\rho_{\{S_{r}\}_{r}}$ at this point in the algorithm.

In the cases (2) and (3) we have that the lowest rank for which the set is updated in the iteration is equal to $r^{\text{new}}$, thus Claim 16 implies that the invariant $\operatorname{Lift}(\rho^{\text{new}},v)(v)\geq r^{\text{new}}$ or $\operatorname{Lift}(\rho^{\text{new}},v)(v)=\rho^{\text{new}}(v)$ holds for all $v\in V$ after the while-loop.

Claim 16**.**

Let $r^{*}\leq r^{\text{old}}$ be a rank with the guarantee that no set corresponding to a lower rank than $r^{*}$ is changed in this iteration of the while-loop. Then we have for all $v\in V$ either $\operatorname{Lift}(\rho^{\text{new}},v)(v)\geq r^{*}$ or $\operatorname{Lift}(\rho^{\text{new}},v)(v)=\rho^{\text{new}}(v)$ after the iteration of the while-loop.

To prove the claim, note that since each set $S_{r}$ is monotonically non-decreasing over the algorithm, we have $\rho^{\text{new}}(v)\geq\rho^{\text{old}}(v)$ and $\operatorname{Lift}(\rho^{\text{new}},v)(v)\geq\rho^{\text{new}}(v)$. Assume by contradiction that there is a vertex $v$ with $\operatorname{Lift}(\rho^{\text{new}},v)(v)>\rho^{\text{new}}(v)$ and $\operatorname{Lift}(\rho^{\text{new}},v)(v)<r^{*}$. The latter implies $\mathrm{best}(\rho^{\text{new}},v)<r^{*}$. By the induction hypothesis for $r^{*}\leq r^{\text{old}}$ we have $\operatorname{Lift}(\rho^{\text{old}},v)(v)=\rho^{\text{old}}(v)$. By $\rho^{\text{new}}(v)\geq\rho^{\text{old}}(v)$ and the definition of the lift-operator this implies $\mathrm{best}(\rho^{\text{new}},v)>\mathrm{best}(\rho^{\text{old}},v)$, i.e., the rank assigned to at least one vertex $w$ with $(v,w)\in E$ is increased. By $\mathrm{best}(\rho^{\text{new}},v)<r^{*}$ this implies that a set $S_{r^{\prime}}$ with $r^{\prime}<r^{*}$ is changed in this iteration, a contradiction to the definition of $r^{*}$. This concludes the proof of the claim.

It remains to show that $v\in S_{r^{\text{old}}}$ for all vertices $v$ with $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r^{\text{old}}$ after the update of the set $S_{r^{\text{old}}}$ in lines 1–1. Towards a contradiction assume that there is a $v\not\in S_{r^{\text{old}}}$ such that $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r^{\text{old}}$. Assume $v\in V_{\mathcal{E}}$, the argument for $v\in V_{\mathcal{O}}$ is analogous. Let $\ell$ be maximal such that $r^{\text{old}}=\left<r^{\text{old}}\right>_{\ell}$ for $r^{\text{old}}<\top$ and let $\ell$ be the highest odd priority in the parity game for $r^{\text{old}}=\top$. Notice that $\alpha(v)$ can be at most $\ell$ for $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r^{\text{old}}$ to hold. We now distinguish two cases depending on whether $\alpha(v)$ is odd or even.

• •

If $\alpha(v)$ is odd, i.e., $\alpha(v)=2k-1$ for some $k\leq(\ell+1)/2$, then we have that all successors $w$ of $v$ have $\rho_{\{S_{r}\}_{r}}(w)\geq\mathrm{dec}_{2k-1}(r^{\text{old}})$ and thus, by Lemma 13, $w\in S_{\mathrm{dec}_{2k-1}(r^{\text{old}})}$. But then $v$ would have being included in $S_{r^{\text{old}}}$ in line 1, a contradiction.

• •

If $\alpha(v)$ is even, i.e., $\alpha(v)=2k$ for some $k\leq\ell/2$, then we have that all successors $w$ of $v$ have $\rho_{\{S_{r}\}_{r}}(w)\geq r^{\text{old}}$. Then by the definition of $\rho_{\{S_{r}\}_{r}}$ it must be that $w\in S_{r^{\prime}}$ for some $r^{\prime}\geq r^{\text{old}}$ and by Lemma 13 it must be that $w\in S_{r^{\text{old}}}$. But then $v$ would have being included in $S_{r^{\text{old}}}$ in line 1, a contradiction.

Thus, after the update of the set $S_{r^{\text{old}}}$ we have that $v\in S_{r^{\text{old}}}$ for all vertices $v$ with $\operatorname{Lift}(\rho_{\{S_{r}\}_{r}},v)(v)=r^{\text{old}}$. Together we the above observations this proves the lemma. ∎

Number of symbolic operations.

We address next the number of symbolic operations of Algorithm 1 when using the sets $S_{r}$ directly. We analyze the number of symbolic operations when using a linear number of sets below. The main idea is that a set $S_{r}$ is only reconsidered if at least one new vertex was added to $S_{r}$.

Lemma 17**.**

For parity games with $n$ vertices and $c$ priorities Algorithm 1 takes $O(c\cdot n\cdot|M^{\infty}_{h}|)$ many symbolic operations and uses $O(|M^{\infty}_{h}|)$ many sets, where $h$ is some integer in $[1,n-1]$.

Proof.

In the algorithm we use one set $S_{r}$ for each $r\in M^{\infty}_{h}$ and thus $|M^{\infty}_{h}|$ many sets. We first consider the number of symbolic operations needed to compute the sets $S_{r}$ in lines 1–1, and then consider the number of symbolic operations to compute the new value of $r$ in lines 1–1.

Whenever we consider a set $S_{r}$, we first initialize the set with $O(c)$ many symbolic operations (lines 1 & 1). After that we do a fixed-point computation that needs symbolic operations proportional to the number of added vertices. Now fix a set $S_{r}$ and consider all the fixed-point computations for $S_{r}$ over the whole algorithm. As only $O(n)$ many vertices can be added to $S_{r}$, all these fixed-points can be computed in $O(n+\#r)$ symbolic operations, where $\#r$ is the number of times the set $S_{r}$ is considered (the algorithm needs a constant number of symbolic operations to realize that a fixed-point was already reached). Each set $S_{r}$ is considered at least once and only reconsidered when some new vertices are added to the set, i.e., it is considered at most $n$ times. Thus for each set $S_{r}$ we have $O(c\cdot n)$ many operations, which gives a total number of operations of $O(c\cdot n\cdot|M^{\infty}_{h}|)$. 2. 2)

Now consider the computation of the new value of $r$ in lines 1–1. Lines 1–1 take a constant number of operations. It remains to count the iterations of the repeat-until loop in lines 1–1, which we bound by the number of iterations of the while-loop as follows. Whenever a set $S_{r^{\prime}}$ is considered as the left side argument in line 1, then the new value for $r$ is less or equal to $\mathrm{inc}(r^{\prime})$ and thus there will be another iteration of the while-loop considering $\mathrm{inc}(r^{\prime})$. As there are only $O(n\cdot|M^{\infty}_{h}|)$ many iterations of the while-loop over the whole algorithm, there are only $O(n\cdot|M^{\infty}_{h}|)$ many iterations of the repeat-until loop in total. In each iteration a constant number of operations is performed.

By (1) and (2) we have that Algorithm 1 takes $O(c\cdot n\cdot\left|M^{\infty}_{h}\right|)$ many symbolic operations. ∎

Number of set operations in linear space algorithm.

For the proof of Lemma 7 and thus of Theorem 8 it remains to show that whenever the algorithm computes or updates a set $S_{r}$ using the succinct representation with the sets $C^{i}_{x}$ introduced in Section 3.2, then we can charge a $\mathsf{CPre}_{{z}}$ operation for it, and each $\mathsf{CPre}_{{z}}$ operation is only charged for a constant number of set computations and updates. The argument is as follows. (a) Whenever the algorithm computes a set $S_{r}$ in line 1 or 1, at least one $\mathsf{CPre}_{{z}}$ computation with this set is done. (b) Now consider the computation of the new value of $r$. The subset tests in lines 1 and 1 are between a set that was already computed in line 1 or 1 and the set computed in line 1 or 1 and thus, if we store these sets, we do not require additional operations. Whenever a set $S_{r^{\prime}}$ is considered as the left side argument in line 1, then the new value of $r$ is less or equal to $\mathrm{inc}(r^{\prime})$ and thus there will be another iteration of the while-loop considering $\mathrm{inc}(r^{\prime})$. Hence, we can charge the additional operations needed for the comparison to the $\mathsf{CPre}_{{z}}$ operations of the next iteration that processes the rank $\mathrm{inc}(r^{\prime})$. (c) Finally, we only need to update the sets $C^{i}_{x}$ once per iteration and in each iteration we perform at least one $\mathsf{CPre}_{{z}}$ computation that we can charge for the update.

Appendix C Traps, Attractors, and Dominions

For the algorithms in Appendices D.1 and E we use the following well-known notions. An example is given below.

Traps.

A set $U\subseteq V$ is a ${z}$-trap if for all ${z}$-vertices $u$ in $U$ we have $\operatorname{\textit{Out}}(u)\subseteq U$ and for all ${\overline{z}}$-vertices $v$ in $U$ there exists a vertex $w\in\operatorname{\textit{Out}}(v)\cap U$. For each ${z}$-trap $U$ player ${\overline{z}}$ has a strategy from each vertex of $U$ to keep the play within $U$, namely choosing an edge $(v,w)$ with $w\in\operatorname{\textit{Out}}(v)\cap U$ whenever the current vertex $v$ is in $U\cap V_{\overline{z}}$ [45]. For a game graph $\mathcal{G}$ and a ${z}$-trap $U$ we denote by $\mathcal{G}[U]$ the game graph induced by the set of vertices $U$. Note that given that in $\mathcal{G}$ each vertex has at least one outgoing edge, the same property holds for $\mathcal{G}[U]$.

Attractors.

In a game graph $\mathcal{G}$, a ${z}$-attractor $A=\textit{Attr}_{{z}}(\mathcal{G},U)$ of a set $U\subseteq V$ is the set of vertices from which player ${z}$ has a strategy to reach $U$ against all strategies of player ${\overline{z}}$. We have that $U\subseteq A$. A ${z}$-attractor can be constructed inductively as follows: Let $Z_{0}=U$ and for all $i\geq 0$ let $Z_{i+1}=Z_{i}\cup\mathsf{CPre}_{{z}}(Z_{i})$. Then $A=\textit{Attr}_{{z}}(\mathcal{G},U)=\bigcup_{i\geq 0}Z_{i}$. In other words, $A$ is the least fixed point of $f(X)=U\cup\mathsf{CPre}_{{z}}(X)$, which provides a symbolic algorithm to compute attractors. Note that the number of $\mathsf{CPre}_{{z}}$ operations for computing the attractor is bounded by $\lvert A\setminus U\rvert+1$ and that from each vertex of $A$ player ${z}$ has a memoryless strategy that stays within $A$ to reach $U$ against any strategy of player ${\overline{z}}$ [45]. When every vertex has at least one outgoing edge, then the complement of a ${z}$-attractor is a ${z}$-trap [45].

Example 18**.**

In this example we describe a trap, an attractor, and a dominion of the parity game in Figure 2, an illustration is provided in Figure 3. For the vertex set $S=\{d,e,f,g\}$ we have the property that the player-${\mathcal{O}}$ vertices $\{e,f\}$ have edges only to vertices in $S$. Further, the player-${\mathcal{E}}$ vertices $\{d,g\}$ both have an edge to some other vertex in $S$. Thus the set $S$ is a trap for player ${\mathcal{O}}$. Further, when player ${\mathcal{E}}$ simply follows the edge to another vertex in $S$ whenever a play reaches $d$ or $g$, then at least every 4th step of the play the vertex $f$ with the highest priority $4$ is reached. Thus player ${\mathcal{E}}$ has a winning strategy from every vertex of $S$ that stays in $S$, hence $S$ is also an ${\mathcal{E}}$-dominion. Moreover, the player-${\mathcal{E}}$ vertices $c$ and $h$ have an edge to the set $S$, i.e., they are in the ${\mathcal{E}}$-attractor of $S$. As another example for a player-${\mathcal{E}}$ attractor, consider the vertex $f$. The vertex $d$ is in the ${\mathcal{E}}$-attractor of $f$ because it belongs to player ${\mathcal{E}}$ and has an edge to $f$. The vertex $e$ is in the ${\mathcal{E}}$-attractor because its only outgoing edge goes to $d$, thus player ${\mathcal{O}}$ cannot avoid reaching $f$ from $e$. Continuing this argument, it can easily be seen that the ${\mathcal{E}}$-attractor of $f$ is equal to $\{c,d,e,f,g,h\}$. Note that the set $V\setminus\{c,d,e,f,g,h\}=\{a,b\}$ is a ${\mathcal{E}}$-trap.a $\lozenge$

The basic algorithm for parity games uses the following well-known properties of traps and dominions. Furthermore, note that in a game graph where each vertex has at least one outgoing edge the complement of a ${z}$-attractor is a ${z}$-trap [45, Lemma 4] and that a player-${z}$ dominion is also a ${\overline{z}}$-trap and that the ${z}$-attractor of a player-${z}$ dominion is again a player-${z}$ dominion. Let for a specific game graph $\mathcal{G}$ or a specific parity game $\mathcal{P}$ denote the winning set of player ${z}$ by $W_{z}(\mathcal{G})$ and $W_{z}(\mathcal{P})$, respectively.

Lemma 19**.**

The following assertions hold for game graphs $\mathcal{G}$ with at least one outgoing edge per vertex and parity objectives. Let ${z}\in\{{\mathcal{E}},{\mathcal{O}}\}$ and let $U\subseteq V$.

[30, Lemma 4.4]** Let $U$ be a ${z}$-trap in $\mathcal{G}$. Then a ${\overline{z}}$-dominion in $\mathcal{G}[U]$ is a ${\overline{z}}$-dominion in $\mathcal{G}$. 2. 2.

[30, Lemma 4.1]** The set $W_{z}(\mathcal{G})$ is a ${z}$-dominion. 3. 3.

[30, Lemma 4.5]** Let $U$ be a subset of the winning set $W_{z}(\mathcal{G})$ of player ${z}$ and let $A$ be its ${z}$-attractor $\textit{Attr}_{{z}}(\mathcal{G},U)$. Then the winning set $W_{z}(\mathcal{G})$ of the player ${z}$ is the union of $A$ and the winning set $W_{z}(\mathcal{G}[V\setminus A])$, and the winning set $W_{\overline{z}}(\mathcal{G})$ of the opponent ${\overline{z}}$ is equal to $W_{\overline{z}}(\mathcal{G}[V\setminus A])$.

Proof.

Player ${z}$ cannot leave the ${z}$-trap $U$, thus player ${\overline{z}}$ can use the same winning strategy for the vertices of the ${\overline{z}}$-dominion in $\mathcal{G}$ as in $\mathcal{G}[U]$. 2. 2.

Recall that the winning sets of the two players partition the vertices [33]. Thus we have that as soon as the play leaves the winning set of player ${z}$, the opponent ${\overline{z}}$ can play his winning strategy starting from the vertex in his winning set that was reached. Hence the winning strategy of player ${z}$ for the vertices in $W_{z}(\mathcal{G})$ has to ensure that only vertices of $W_{z}(\mathcal{G})$ are visited and thus the set $W_{z}(\mathcal{G})$ is a ${z}$-dominion. 3. 3.

The set $V\setminus A$ is a ${z}$-trap [45, Lemma 4]. By 2 $W_{\overline{z}}(\mathcal{G}[V\setminus A])$ is a ${\overline{z}}$-dominion in $\mathcal{G}[V\setminus A]$ and by 1 also in $\mathcal{G}$. Thus we have $W_{\overline{z}}(\mathcal{G}[V\setminus A])\subseteq W_{\overline{z}}(\mathcal{G})$. Since $W_{z}(\mathcal{G})$ and $W_{\overline{z}}(\mathcal{G})$ form a partition of $V$, we complete the proof by showing $W_{z}(\mathcal{G}[V\setminus A])\subseteq W_{z}(\mathcal{G})$. For this we construct a winning strategy for player ${z}$ from the vertices of $W_{z}(\mathcal{G}[V\setminus A])$ in $\mathcal{G}$. As long as the play stays within $V\setminus A$, player ${z}$ follows her winning strategy in $\mathcal{G}[V\setminus A]$. If the play reaches $A\setminus U$, she follows her attractor strategy to $U$. When the play reaches $U$, she follows her winning strategy for $U$ in $\mathcal{G}$ (that exists by assumption). We have that player ${z}$ wins by the winning strategy in $\mathcal{G}[V\setminus A]$ if the play forever stays within $V\setminus A$ and by the winning strategy for $U$ in $\mathcal{G}$ if the play ever reaches a vertex of $A$. ∎

Appendix D Existing Algorithms for Parity Games

In this section we present, in addition to the progress measure algorithm presented in Section 2.3, the key existing algorithms for parity games along with the main ideas for correctness.

D.1 Classical Algorithm

In the following we describe a classical algorithm for parity games by [45, 34] and provide intuition for its correctness. Our symbolic big-step algorithm presented in Appendix E uses the same overall structure as the classical algorithm but determines dominions using our symbolic progress measure algorithm presented in Section 3.

Informal description of classical algorithm.

Let ${z}$ be ${\mathcal{E}}$ if $c$ is odd and ${\mathcal{O}}$ if $c$ is even. Let $\mathcal{G}$ be the game graph as maintained by the algorithm. The classical algorithm repeatedly identifies ${\overline{z}}$-dominions by recursive calls for a parity game $\mathcal{P}^{\prime}=(\mathcal{G}^{\prime},\alpha)$ with one priority less that is obtained by temporarily removing the ${z}$-attractor of $P_{c-1}$, i.e., the vertices with highest priority, from the game. In other words, the steps are as follows:

Obtain the game $\mathcal{P}^{\prime}$ by removing the ${z}$-attractor of $P_{c-1}$. 2. 2.

If the winning set $W^{\prime}_{\overline{z}}$ of player ${\overline{z}}$ in the parity game $\mathcal{P}^{\prime}$ is non-empty, then its ${\overline{z}}$-attractor $A$ is added to the winning set $W_{\overline{z}}$ of ${\overline{z}}$ and removed from the game graph $\mathcal{G}$. The algorithm recurses on the remaining game graph. 3. 3.

Otherwise all vertices in the parity game $\mathcal{P}^{\prime}$ are winning for player ${z}$. In this case the algorithm terminates and the remaining vertices $V\setminus W_{\overline{z}}$ are returned as the winning set of player ${z}$.

The pseudocode of the classical algorithm is given in Algorithm 3.

Key intuition for correctness.

The correctness argument is inductive over the number of priorities and has the following two key aspects.

The winning set of player ${\overline{z}}$ in $\mathcal{P}^{\prime}$ is a ${\overline{z}}$-dominion in $(\mathcal{G},\alpha)$ because the vertices in $\mathcal{P}^{\prime}$ form a ${z}$-trap. Thus the attractor of the winning set of player ${\overline{z}}$ in $\mathcal{P}^{\prime}$ can be removed as part of the winning set of player ${\overline{z}}$ and it suffices to solve the remaining game by Lemma 19(3). 2. 2.

If the algorithm terminates in some iteration where all vertices in $\mathcal{P}^{\prime}$ are winning for ${z}$, then a winning strategy for player ${z}$ on the remaining game can be constructed by combining her winning strategy in the subgame $\mathcal{P}^{\prime}$ (by the inductive hypothesis over the number of priorities as $\mathcal{P}^{\prime}$ has a strictly smaller number of priorities) with her attractor strategy to the vertices with highest priority, and the fact that the set of remaining vertices $V\setminus W_{\overline{z}}$ is a ${\overline{z}}$-trap.

The classical algorithm can be interpreted both as an explicit algorithm as well as a set-based symbolic algorithm, since it only uses attractor computations and set operations. The following theorem summarizes the results for the classical algorithm for parity games.

Theorem 20**.**

[45, 34]** Algorithm 3 computes the winning sets of parity games; as explicit algorithm it requires $O(n^{c-1}\cdot m)$ time and quasi-linear space; and as set-based symbolic algorithm it requires $O(n^{c})$ symbolic one step and set operations, and $O(c)$ many sets.

D.2 Sub-exponential Algorithm

The sub-exponential algorithm of [30] is based on the following modification of the classical algorithm. Before the recursive call, which finds a non-empty dominion, the algorithm enumeratively and explicitly searches for all dominions of size at most $\sqrt{n}$; if it succeeds to find a dominion, then its attractor is removed from the game; otherwise, the subsequent recursive call is guaranteed to find a dominion of size $>\sqrt{n}$. A clever analysis of the recurrence relation shows that the running time of the algorithm is at most $n^{O(\sqrt{n})}$, yielding the first deterministic sub-exponential time algorithm for parity games. However, the algorithm is inherently explicit and enumerative (it enumerates with a brute-force search all dominions of size at most $\sqrt{n}$). We refer the above algorithm as SubExp algorithm.

Theorem 21**.**

[30]** Algorithm SubExp computes the winning sets of parity games, and it is an explicit algorithm that requires $n^{O(\sqrt{n})}$ time and quasi-linear space.

D.3 Big-step Algorithm

The progress measure algorithm and the sub-exponential algorithm were combined in [40] to obtain the big-step algorithm. The main idea is to use the progress measure to identify (small) dominions of size $\leq h+1$, for some given integer $h\in[1,n-1]$. Given that an ${\mathcal{E}}$-dominion is of size $\leq h+1$, player ${\mathcal{E}}$ must have a strategy from each vertex of the ${\mathcal{E}}$-dominion to reach a vertex with an even priority by visiting at most $h$ vertices with odd priorities. Thus, one considers a product domain $M_{h}\subseteq M_{\mathcal{G}}$ containing only the vectors of $M_{\mathcal{G}}$ whose elements sum up to at most $h$. The co-domain $M^{\infty}_{h}$ of the ranking function $\rho$ is then given by $M^{\infty}_{h}=M_{h}\cup\{\top\}$ and the function $\mathrm{inc}(r)$ and $\mathrm{dec}(r)$ are then only defined on the restricted domain $M^{\infty}_{h}$ (the $\min$ in the definitions is over $M^{\infty}_{h}$ instead of $M^{\infty}_{\mathcal{G}}$). Again the corresponding progress measure for a parity game is defined as the least simultaneous fixed point of all $\operatorname{Lift}(.,v)$-operators. The identification of ${\mathcal{E}}$-dominions from the progress measure is achieved by selecting those vertices whose rank is a vector, i.e., smaller than $\top$.

Lemma 22**.**

[40]** For a given parity game with $n$ vertices and the progress measure $\rho$ with co-domain $M^{\infty}_{h}$ for some integer $h\in[1,n-1]$, the set of vertices $\{v\in V\mid\rho(v)<\top\}$ is an ${\mathcal{E}}$-dominion that contains all ${\mathcal{E}}$-dominions with at most $h+1$ vertices.

Remark 23**.**

Note that the progress measure algorithm determines ${\mathcal{E}}$-dominions. We can compute ${\mathcal{O}}$-dominions (including a winning strategy within the dominion) by adding one to each priority and changing the roles of the two players. If $c$ has been even before this modification, this does not increase the bound on the number of symbolic operations for the dominion search because the number of odd priorities, and therefore the possible number of non-empty indices of a rank vector, does not increase.

Combining the sub-exponential algorithm with the progress measure algorithm to identify small dominions gives the BigStep algorithm for parity games.

Theorem 24**.**

[39]** Let $\gamma(c)=c/3+1/2-4/(c^{2}-1)$ for odd $c$ and $\gamma(c)=c/3+1/2-1/(3c)-4/c^{2}$ for even $c$. Algorithm BigStep computes the winning sets of parity games and it is an explicit algorithm that requires O\big{(}m\cdot\big{(}\frac{\kappa\cdot n}{c}\big{)}^{\gamma(c)}\big{)} time for some constant $\kappa$ and $O(n\cdot c)$ space.

Recently, the running time bound for the BigStep algorithm was improved further to O\big{(}m\big{(}\frac{6e^{5/3}n}{c^{2}}\big{)}^{\gamma(c)}\big{)} [40].

Appendix E Symbolic Big-Step Algorithm

In Section 3 we presented a set-based symbolic algorithm to compute the progress measure that is also capable of determining dominions of bounded size. Since the classical algorithm can be implemented with set-based symbolic operations, we now show how to combine our algorithm and the classical set-based algorithm to obtain a set-based symbolic Big-Step algorithm for parity games (see Appendix D.3 for the explicit Big-Step algorithm [40]).

Iterative Winning Set Computation.

The basic structure of Algorithm 4 is the same as in the classical algorithm for parity games (see Appendix D.1). Let ${z}$ be ${\mathcal{E}}$ if $c$ is odd and ${\mathcal{O}}$ if $c$ is even and assume we have $c>2$ (the cases $c\leq 2$, i.e., Büchi games, are simpler). Let $\mathcal{G}$ be the game graph maintained by the algorithm. The winning set of ${\overline{z}}$ is initialized with the empty set and then the algorithm searches for ${\overline{z}}$-dominions in a repeat-until loop. When a ${\overline{z}}$-dominion is found in an iteration of the repeat-until loop, its ${\overline{z}}$-attractor is added to the winning set of ${\overline{z}}$ and removed from the game graph $\mathcal{G}$. If no ${\overline{z}}$-dominion is found, then the repeat-until loop terminates and the set of vertices in the remaining game graph $\mathcal{G}$ is returned as the winning set of player ${z}$.

Dominion Search.

The search for ${\overline{z}}$-dominions is conducted in two different ways: by Procedure $\operatorname{\textnormal{Dominion}}$ and by a recursive call to a derived parity game with game graph $\mathcal{G}^{\prime}$ and the priority function $\alpha$ restricted to the vertices of $\mathcal{G}^{\prime}$. The derived parity game is denoted by $(\mathcal{G}^{\prime},\alpha)$ and has $c-1$ priorities. The parameter $h$ is used to balance the number of symbolic operations of the two procedures.

First, all ${\overline{z}}$-dominions of size at most $h+1$ are found with Procedure $\operatorname{\textnormal{Dominion}}$ that uses Algorithm 1. Note that this algorithm determines ${\mathcal{E}}$-dominions. We can compute ${\mathcal{O}}$-dominions (including a winning strategy within the dominion) by adding one to each priority and changing the roles of the two players.

For the recursive call for the parity game $\mathcal{P}^{\prime}=(\mathcal{G}^{\prime},\alpha)$ we obtain the game graph $\mathcal{G}^{\prime}$ from $\mathcal{G}$ by removing the ${z}$-attractor of the vertices with the highest priority. Note that the vertices of $\mathcal{G}^{\prime}$ form a ${z}$-trap in $\mathcal{G}$. The winning set of player ${\overline{z}}$ in $\mathcal{P}^{\prime}$ is a ${\overline{z}}$-dominion in the original parity game.

Number of Iterations.

The following lemma shows that the number of iterations of the repeat-until loop is bounded by $O(n/h)$. This holds because in each but the last iteration the union of the dominion identified by $\operatorname{\textnormal{Dominion}}$ and the dominion identified by the recursive call is larger than $h+1$; otherwise, the union of the two dominions, which is itself a dominion, would already have been identified solely by Procedure $\operatorname{\textnormal{Dominion}}$ and the algorithm would have terminated.

Lemma 25** ([40]).**

Let $h$ be the parameter of Algorithm 4. In each but the last iteration of the repeat-until loop at least $h+2$ vertices are removed, and thus there are at most $\lfloor n/(h+2)\rfloor+1$ iterations.

Proof.

Consider a fixed iteration of the repeat-until loop. Let $W^{\prime\prime}_{\overline{z}}$ be the union of the ${\overline{z}}$-dominion identified by Procedure $\operatorname{\textnormal{Dominion}}$ and the ${\overline{z}}$-dominion identified by the recursive call. If $\lvert W^{\prime\prime}_{\overline{z}}\rvert\leq h+1$, then by Lemma 7 the ${\overline{z}}$-dominion $W^{\prime\prime}_{\overline{z}}$ is identified by Procedure $\operatorname{\textnormal{Dominion}}$ and therefore the recursive call returned the empty set and the algorithm terminates. Otherwise we have $\lvert W^{\prime\prime}_{\overline{z}}\rvert>h+1$, which can happen in at most $\lfloor n/(h+2)\rfloor$ iterations of the repeat-until loop since the vertices of $W^{\prime\prime}_{\overline{z}}$ are removed from the maintained game graph before the next iteration. ∎

Analysis of number of symbolic operations.

We first analyze the number of symbolic operations of Algorithm 4 for instances with an arbitrary numbers of priorities $c$ and then give better bounds for the case $c\leq\sqrt{n}$. For the former we follow the analysis of [30] for a similar explicit algorithm. There we choose the parameter $h$ to depend (only) on the number of vertices of the game graph for which Procedure $\operatorname{\textnormal{Dominion}}$ is called. In the analysis for $c\leq\sqrt{n}$ the parameter $h$ depends on the number of vertices in the input game graph and the number of priorities in the game graph for which the procedure is called.

Lemma 26**.**

Let $h=\lceil\sqrt{2n^{\prime}}\rceil-2$ where $n^{\prime}$ is the number of vertices in $\mathcal{G}$ when Procedure $\operatorname{\textnormal{Dominion}}$ is called in Algorithm 4. With this choice for $h$ and parity games with $n$ vertices, Algorithm 4 requires $n^{O(\sqrt{n})}$ symbolic one-step and set operations and $O(n)$ many sets.

Proof.

Let $T(n)$ denote the number of the symbolic one-step operations of Algorithm 4 when called for a game graph with $n$ vertices. We instantiate $h$ as $h=\lceil\sqrt{2n}\rceil-2$. First, for a game graph of size $n$, by Lemma 7, we can compute a dominion in $O\left(c\cdot n\cdot\binom{h+\lfloor c/2\rfloor}{h}\right)$. This can be bounded with $O(n^{h+2})$ as follows (using $c\leq n$). First we apply Stirling’s approximation $(h/e)^{h}\leq h!$ and we distinguish whether $h\geq\lfloor c/2\rfloor$ or $h\leq\lfloor c/2\rfloor$. We have

[TABLE]

and (a) if $h\geq\lfloor c/2\rfloor$, then

[TABLE]

(b) if $h\leq\lfloor c/2\rfloor$, then

[TABLE]

In both cases we obtain $O(n^{h+2})$.

Let $\Gamma=h+2=\lceil\sqrt{2n}\rceil$. To solve an instance of size $n$, the algorithm (1) calls the subroutine for computing a dominion, which is in $O(n^{\Gamma})$; (2) then makes a recursive call to Algorithm 4, with an instance of size at most size $n-1$ (it removes the largest parity and thus at least one vertex); and (3) finally processes the instance in which all winning vertices from the previous two steps have been removed, i.e., an instance of size at most $n-\Gamma$ (Lemma 25). Thus, we obtain the following recurrence relation for $T(n)$

[TABLE]

for $\Gamma=\lceil\sqrt{2n}\rceil$. This coincides with the recurrence relation for the explicit algorithm and thus we get $T(n)=n^{O(\sqrt{n})}$ [30, Theorem 8.1]. Finally, as in Algorithm 4 the number of symbolic set operations is at most a factor of $n$ higher than the number of symbolic one-step operations, we obtain the claim by $n\cdot T(n)=n^{O(\sqrt{n})}$.

Now let us consider the space requirements of Algorithm 4. Computing a dominion, by Lemma 7, can be done with $O(n)$ many sets. The recursion depth is bounded by $c$ and thus also by $n$, and for each instance on the stack we just need a constant number of sets to store the current subgraph and the winning sets of the two players. Finally, also attractor computations can be done with a constant number of sets. That is, Algorithm 4 uses $O(n)$ many sets, independent of the value of $h$. ∎

To provide an improved bound for $c\leq\sqrt{n}$ we follow the analysis of [39]; see [40] for a recent improvement of this analysis. We use the following definitions from [39]: let $\gamma(c)=c/3+1/2-4/(c^{2}-1)$ for odd $c$ and $\gamma(c)=c/3+1/2-1/(3c)-4/c^{2}$ for even $c$, and let $\beta(c)=\gamma(c)/(\lfloor c/2\rfloor+1)$. With these definitions we have $\beta(c)\in[1/2,7/10]\text{ for all }c\geq 3$, $\gamma(c)\in[c/3,c/3+1/2]$ and

[TABLE]

We first present a shorter proof for the simplified bound of $O(n^{1+\gamma(c)})$ symbolic one-step operations and then a more extensive analysis to show that, for some constant $\kappa$, $O(n\cdot(\kappa\cdot n/c)^{\gamma(c)})$ symbolic one-step operations are sufficient. We bound the number of symbolic set operations with an additional factor of $O(n)$. In both cases the parameter $h$ depends on number of vertices in the input game graph and the number of priorities $c$ in the parity game that is maintained by the algorithm.

Lemma 27** (Simplified Analysis of Number of Symbolic Operations).**

For parity games with $n$ vertices and $c$ priorities Algorithm 4 takes $O(n^{1+\gamma(c)})$ symbolic one-step operations and $O(n^{2+\gamma(c)})$ symbolic set operations for $2<c\leq\sqrt{n}$ and $O(n^{2})$ symbolic one-step and set operations for $c=2$. Moreover, it needs $O(n)$ many sets.

Proof.

By the proof of Lemma 26 the algorithm only stores $O(n)$ many sets, independent of the value of $h$, and thus it only remains to show the upper bound on the number of symbolic operations. We focus on the bound for the number of symbolic one-step operations, the number of symbolic set operations is higher only for the subroutine 1, where the difference is at most a factor of $O(n)$, by Lemma 7. For $c=2$ note that in each iteration of the repeat-until loop at least one vertex is removed from the game, thus there can be at most $O(n)$ iterations. In each iteration there are attractor computations, a recursive call for parity games with one priority, and set operations, which all can be done with $O(n)$ symbolic operations111Note that while the attractor computations in line 4 only need $O(n)$ symbolic operations over the whole algorithm, the attractor computations in line 4 might require $O(n)$ symbolic operations in each iteration., thus at most $O(n^{2})$ symbolic operations are needed for $c=2$.

By Lemma 25 the repeat-until loop can have at most $\left\lfloor\frac{n}{(h+2)}\right\rfloor+1$ iterations. We show the claimed number of symbolic one-step operations for $c\geq 3$ by induction over $c$. For the base case of $c=3$ let $h=n$. In this case there is only one iteration of the repeat-until loop. The call to the progress measure procedure and the recursive call for parity games with one priority less, i.e., Büchi games, both take $O(n^{2})$ symbolic one-step operations. Thus the total number of symbolic one-step operations for $c=3$ is bounded by $O(n^{1+\gamma(3)})=O(n^{2})$. For $c=3$ the number of sets $S_{r}$ is only $O(n)$, therefore we do not have to use the sets $C^{i}_{x}$ to achieve linear space and thus the number of symbolic set operations is also $O(n^{2})$.

For the induction step we differentiate between the number of vertices $n_{0}$ in the first (i.e., non-recursive) call to Algorithm 4 and the number of vertices $n^{\prime}$ in the parity game that is maintained by the algorithm. We set the parameter $h$ according to $n_{0}$ (and to at most $n^{\prime}$) to maintain the property $c\leq\sqrt{n_{0}}$ in all recursive calls.

Let h=\min\big{(}\lceil n_{0}^{\beta(c-1)}\rceil,n^{\prime}\big{)} for $c>3$. By Lemma 25 the number of iterations in Algorithm 4 is bounded by $O(n_{0}^{1-\beta(c-1)})$. By Lemma 7 each call to 1 needs only

[TABLE]

many symbolic one-step operations. The binomial coefficient can be bounded using $\beta(c-1)\geq 1/2$, Stirling’s approximation of $(c/e)^{c}\leq c!$, and $3<c\leq\sqrt{n_{0}}$.

[TABLE]

thus, the number of symbolic one-step operations in a call to 1 is bounded by $O(n_{0}\cdot n_{0}^{\beta(c-1)\lfloor c/2\rfloor})$. Hence, we can bound the total number of symbolic one-step operations for all calls to 1 with $O(n_{0}\cdot n_{0}^{\beta(c-1)\lfloor c/2\rfloor}\cdot n_{0}^{1-\beta(c-1)})$. Using (2), we have $\beta(c-1)\lfloor c/2\rfloor\leq\beta(c-1)\lceil c/2\rceil=\gamma(c-1)$ and can bound the total number of symbolic one-step operations of the calls to the progress measure procedure with $O(n_{0}\cdot n_{0}^{\gamma(c-1)+1-\beta(c-1)})$, which by (1) is equal to $O(n_{0}^{1+\gamma(c)})$. By the induction assumption we further have that the total number of symbolic one-step operations for all recursive calls is $O(n_{0}^{1-\beta(c-1)+1+\gamma(c-1)})=O(n_{0}^{1+\gamma(c)})$, which concludes the proof. ∎

Lemma 28** (Number of Symbolic Operations).**

For parity games with $n$ vertices and $2<c\leq\sqrt{n}$ priorities Algorithm 4 takes, for some constant $\kappa$, O\big{(}n\cdot(\frac{\kappa\cdot n}{c})^{\gamma(c)}\big{)} symbolic one-step operations and O\big{(}n^{2}\cdot(\frac{\kappa\cdot n}{c})^{\gamma(c)}\big{)} symbolic set operations. Moreover, it needs $O(n)$ many sets.

Proof.

By the proof of Lemma 26 the algorithm only stores $O(n)$ many sets independent of the value of $h$, and thus it only remains to show the upper bound on the number of symbolic operations. We show the bound for the number of symbolic one-step operations, the number of symbolic set operations is higher only for the subroutine 1, where the difference is at most a factor of $O(n)$ by Lemma 7.

We differentiate between the number of vertices $n_{0}$ in the first (i.e. non-recursive) call to Algorithm 4 and the number of vertices $n^{\prime}$ in the parity game that is maintained by the algorithm. We will set the parameter $h$ according to $n_{0}$ (and to at most $n^{\prime}$) to maintain the property $c\leq\sqrt{n_{0}}$ in all recursive calls.

Similar to [39], we use $h=\min\left(\lceil 2\sqrt[3]{c}\cdot n_{0}^{\beta(c-1)}\rceil,n^{\prime}\right)$ to balance the number of symbolic operations to compute dominions with the number of symbolic operations in the recursive calls. We will frequently apply Stirling’s approximation by which we have

• (S1)

\big{(}\frac{c}{e}\big{)}^{c}\leq c!, and

• (S2)

c!\in O\big{(}\big{(}\frac{c}{\hat{\kappa}}\big{)}^{c}\big{)} for all $\hat{\kappa}<e$.

We first show that proving the following claim is sufficient.

Claim 29**.**

The number of symbolic one-step operations is bounded by $\kappa_{1}\cdot n_{0}\cdot\frac{(\kappa_{2}\cdot n_{0})^{\gamma(c)}}{\sqrt[3]{c!}}$ for some constants $\kappa_{1}$ and $\kappa_{2}$.

The claim implies the lemma since we have for $c\geq 3$

[TABLE]

for some constant $\kappa_{3}>1$. The first inequality is by (S1) and the second by the definition of $\gamma(c)$. Thus it remains to prove the above claim.

We prove the claim by induction over $c$, where the base case is provided by Lemma 27 for, e.g., $c=3$. Assume the claim holds for parity games with $c-1$ priorities; we will show that the claim then also holds for parity games with $c$ priorities. For $c>2$ the number of symbolic operations per iteration is dominated by (a) the recursive call for parity games with one priority less and (b) the call to Procedure $\operatorname{\textnormal{Dominion}}$. To bound the total number of symbolic operations for (a) and (b), we use that by Lemma 25 the number of iterations in Algorithm 4 is bounded by

[TABLE]

(a) We first bound the total number of symbolic one-step operations for the recursive call. By the induction hypothesis the number of symbolic one-step operations in a single recursive call is bounded by

[TABLE]

By the definition of $\gamma(c)$ (see also the proof of Lemma 27) we can bound the total number of symbolic one-step operations for all recursive calls with

[TABLE]

(b) Thus it remains to bound the total number of symbolic one-step operations in the calls to Procedure $\operatorname{\textnormal{Dominion}}$. By Lemma 7 the number of symbolic one-step operations in a call to Procedure $\operatorname{\textnormal{Dominion}}$ is bounded by $O\left(c\cdot n_{0}\cdot\binom{h+\lfloor c/2\rfloor}{\lfloor c/2\rfloor}\right)$. The binomial coefficient can be bounded by using $\beta(c-1)\geq 1/2$, Stirling’s approximation (S1), and $3<c\leq\sqrt{n_{0}}$. We have

[TABLE]

With this bound on the binomial coefficient we have that the number of symbolic one-step operations in one call to Procedure $\operatorname{\textnormal{Dominion}}$ is bounded by

[TABLE]

for some constant $\kappa_{4}$. To obtain a bound on the total number of symbolic one-step operations for all calls to Procedure $\operatorname{\textnormal{Dominion}}$, we multiply that with the number of iterations $2\cdot n_{0}^{1-\beta(c-1)}/(3\sqrt[3]{c})$ and split the further analysis into two parts.

(1) First, we consider the factor $\lceil n_{0}^{\beta(c-1)}\rceil^{\lceil\frac{c-1}{2}\rceil}\cdot n_{0}^{1-\beta(c-1)}$ depending on $n_{0}$. We upper bound the factor by using $c\leq\sqrt{n_{0}}$ and $\beta(c-1)\geq 1/2$, and then apply (1).

[TABLE]

(2) Second, we consider the factor $c\cdot\left(7{\lceil 2\sqrt[3]{c}\rceil}/{(c-1)}\right)^{\lceil\frac{c-1}{2}\rceil}$ depending on $c$ and show that, when assuming222Notice that for $c\leq 63$ the factor is bounded by a constant anyway. $c\geq 64$, we have

[TABLE]

with $\kappa_{5}=63/4$, and $\kappa_{6}=\kappa_{5}\cdot\sqrt[3]{64/63}\approx 15.83$. Notice that in the above equation we exploited the assumption $c\geq 64$ several times. First, to bound $7\lceil 2\sqrt[3]{c}\rceil$ by $\kappa_{5}\sqrt[3]{c}$, second, to obtain $\left(\frac{\kappa_{5}\sqrt[3]{c}}{c-1}\right)\leq 1$, and, finally, to bound $\kappa_{5}\sqrt[3]{c}$ by $\kappa_{6}\sqrt[3]{c-1}$.

Now let $\kappa_{7}$ be such that $\kappa_{7}/(c-1)!\geq(\hat{\kappa}/(c-1))^{c-1}$ for some $\hat{\kappa}$ slightly smaller than $e$, such that we can apply (S2). Notice that we also can bound $4^{3}/\hat{\kappa}$ by $24$ for $\hat{\kappa}$ close to $e$. We have

[TABLE]

for appropriately chosen constants $\kappa_{8}$ and $\kappa_{9}$. Putting parts (1),  (2) and the not yet considered factor of $\kappa_{4}\cdot 2/(3\sqrt[3]{c})$ together, we have that the total number of symbolic one-step operations for all calls to Procedure $\operatorname{\textnormal{Dominion}}$ is bounded by

[TABLE]

for $\kappa_{1}\geq 2\sqrt{e}\cdot\kappa_{4}\cdot\kappa_{8}$ and $\kappa_{2}\geq\kappa_{9}$. Together with Equation (3) this concludes the proof. ∎

Correctness.

The correctness of Algorithm 4 is as follows: (i) the algorithm correctly identifies dominions for player ${\overline{z}}$ (Lemma 7), and then removes them (Lemma 19(3)), and it suffices to solve the remaining game graph; and (ii) when no vertices are removed, then no dominion is found, and the computation is exactly as the classical algorithm, and from the correctness of the classical algorithm it follows that the remaining vertices are winning for player ${z}$. We present a correctness proof below to make the paper self-contained.

Lemma 30** (Correctness).**

The algorithm correctly computes the winning sets of player ${\mathcal{E}}$ and player ${\mathcal{O}}$ for parity games with $c\geq 1$ priorities.

Proof.

The proof is by induction over $c$. For $c=1$ all vertices are winning for player ${\mathcal{E}}$ and the algorithm correctly returns $W_{\mathcal{E}}=V$ and $W_{\mathcal{O}}=\emptyset$. Assume the algorithm correctly computes the winning sets for parity games with $c-1$ priorities. We show that this implies the correctness for $c$ priorities. Let ${z}$ be ${\mathcal{E}}$ if $c$ is odd and ${\mathcal{O}}$ otherwise. We first show (1) that each vertex of $W_{\overline{z}}$ is indeed winning for player ${\overline{z}}$ and then (2) that each vertex of $W_{z}$ is winning for player ${z}$; this is sufficient to prove the lemma by $W_{\overline{z}}\cup W_{z}=V$.

For (1) recall that the algorithm repeatedly computes ${\overline{z}}$-dominions $D$ and their ${\overline{z}}$-attractor $A$, adds $A$ to the winning set of player ${\overline{z}}$ and recurses on the parity game with $A$ removed. By Lemma 19(3) we have that this approach is correct if the sets $D$ are indeed ${\overline{z}}$-dominions. By the soundness of 1 by Lemma 7 we have that $D$ is a ${\overline{z}}$-dominion when computed with 1; it remains to show the soundness of determining a dominion $W_{\overline{z}}^{\prime}$ of player ${\overline{z}}$ by the recursive call to 4 on the parity game $(\mathcal{G}^{\prime},\alpha)$ with one priority less (line 4). This follows by Lemma 19(1) from $\mathcal{G}^{\prime}$ not containing a vertex with priority $c-1$ and the complement of a ${\mathcal{E}}$-attractor being a ${\mathcal{E}}$-trap [45, Lemma 4].

To show completeness, i.e., $W_{\overline{z}}(P)\subseteq W_{\overline{z}}$, we describe a winning strategy for player ${z}$ on the vertices of $W_{z}$. Since the set $W_{z}$ is the set of remaining vertices after the removal of ${\overline{z}}$-attractors, the set $W_{z}$ is a ${\overline{z}}$-trap. Let $\mathcal{G}^{*}$ be the game graph as in the last iteration of the algorithm, i.e., $\mathcal{G}^{*}=\mathcal{G}[W_{z}]$. Furthermore, let $Z$ be the set of vertices in $\mathcal{G}^{*}$ with priority $c-1$, and let $\mathcal{G}^{\prime}=\mathcal{G}^{*}\setminus\textit{Attr}_{{z}}(\mathcal{G}^{*},Z)$. Since the algorithm has terminated, we have that player ${z}$ wins on all vertices of $\mathcal{G}^{\prime}$ in the parity game $(\mathcal{G}^{\prime},\alpha)$. The winning strategy for player ${z}$ for the vertices of $W_{z}$ is as follows: for vertices of $Z$ the player choses an edge to some vertex in $W_{z}$; for vertices of $\textit{Attr}_{{z}}(\mathcal{G}^{*},Z)\setminus Z$ the player follows her attractor strategy to $Z$; and for the vertices of $\mathcal{G}^{\prime}$ the player plays according to her winning strategy in $(\mathcal{G}^{\prime},\alpha)$. Then in a play starting from $W_{z}$ either $Z$ is visited infinitely often or the play remains within $\mathcal{G}^{\prime}$ from some point on; in both cases player ${z}$ wins with the given strategy. ∎

Appendix F Strategy Construction

Here we discuss how our algorithms can be extended to also compute winning strategies within the same bounds for the number of symbolic operations and sets required.

Obtaining Strategies from the Symbolic Progress Measure.

Let us first consider Algorithm 1. Given the set representation of the progress measure returned by Algorithm 1 the winning strategy for player ${\mathcal{E}}$ can be computed with $O(n)$ symbolic one-step operations and $O(c\cdot n^{2})$ symbolic set operations.

To this end, notice that the values of the progress measure immediately give a winning strategy of player ${\mathcal{E}}$. That is, for a vertex $v$ in the winning set of ${\mathcal{E}}$ a winning strategy of ${\mathcal{E}}$ picks an arbitrary successor $w$ of $v$, with $\rho(w)\leq_{\alpha(v)}\rho(v)$ if $v$ is of even priority or with $\rho(w)<_{\alpha(v)}\rho(v)$ if $v$ is of odd priority.

In the symbolic setting we can compute the strategy as follows. We maintain a set $S$ of the vertices in $V_{\mathcal{E}}\setminus V_{\top}$ that already have a strategy, and first initialize $S$ as the empty set. We then iterate over all vertices $v\in V\setminus V_{\top}$, i.e., over all vertices that are winning for player ${\mathcal{E}}$, and do the following.

• •

First, compute the exact rank $\rho(v)$ of the vertex $v$ by checking for which of the sets $C^{i}_{x}$ the intersection with $\{v\}$ is not empty with $O(n)$ set operations.333Alternatively we could use binary search on the sets $S_{r}$ at the cost of increasing the set operations for this step by a factor of $O(c\cdot\log n)$.

• •

Second, for each $0\leq\ell<c$ compute the set $S_{\mathrm{inc}_{\ell}(\rho(v))}$ with $O(n)$ many symbolic set operations per set.

• •

Then compute $\mathsf{CPre}_{{\mathcal{E}}}(\{v\})$ and consider the sets $\mathsf{CPre}_{{\mathcal{E}}}(\{v\})\cap S_{\mathrm{inc}_{\ell}(\rho(v))}\cap V_{\mathcal{E}}\cap P_{\ell}$, for $0\leq\ell<c$. From each vertex contained in one of the sets a winning strategy for player ${\mathcal{E}}$ can move to $v$ and thus, for each of these vertices not already in yhe set $S$, we fix $v$ as the strategy of player ${\mathcal{E}}$ and add it to $S$.

In each iteration of the above algorithm we use only one $\mathsf{CPre}_{{z}}$ operation and $O(c\cdot n)$ symbolic set operations and as we have $O(n)$ iterations, the claim follows.

Computing Strategies with the Big-Step Algorithm.

Now consider the symbolic big step algorithm 4 that computes the winning sets for a parity game. One can also compute the actual strategies for both players by using 4 and within the bounds of Theorem 9. This is by the following observations.

• •

Whenever a vertex is added to a winning set because of 1 (line 4) then we can obtain a winning strategy for that vertex within the same algorithmic bounds (as outlined above).

• •

For $c=1$ player ${\mathcal{E}}$ can just pick any successor. It is then easy to construct a strategy with $O(|V|)$ many symbolic operations.

• •

For a vertex that is added to a winning set because of a recursive call to 4 (line 4), we can use the strategy that was computed in the recursive call.

• •

When a vertex is added to a winning set because of the computation of the ${z}$-attractor $A$ in lines 4 and 4 we can compute the winning strategy with $O(\lvert A\rvert)$ symbolic operations as follows. In the computation of the attractor we keep track of the vertices $A_{i-1}$ added in the previous iteration of the attractor computation and whenever a vertices of $V_{\overline{z}}$ is added to the attractor we identify a successor for each of them. To this end, for each vertex in $v\in A_{i-1}$ we compute $\mathsf{Pre}(\{v\})\cap A_{i}\cap V_{\overline{z}}$ and fix $v$ as players ${\overline{z}}$ choice for all these vertices. As each vertex of $A$ is in exactly one set $A_{i}$, we only need $O(\lvert A\rvert)$ many operations, and as the attractor computation itself needs $O(\lvert A\rvert)$ many $\mathsf{CPre}_{{z}}$ operations this does not increase the bound for the number of symbolic operations.