0.1 Introduction
In this work, we present new contributions related to algorithms for parity games in the setbased symbolic model of computation.
Parity games. Games on graphs are central in many applications in computer science, especially, in the formal analysis of reactive systems. The vertices of the graph represent states of the system, the edges represent transitions of the system, the infinite paths of the graph represent traces of the system and the players represent the interacting agents. The reactive synthesis problem (Church’s problem [18]) is equivalent to constructing a winning strategy in a graph game [9, 46, 45]. Besides reactive synthesis, the game graph problem has been used in many other applications, such as (1) verification of branchingtime properties [28], (2) verification of open systems [1], (3) simulation and refinement between reactive systems [43, 31, 2]; (4) compatibility checking [25], (5) program repair [33], (6) synthesis of programs [13]; to name a few. Game graphs with parity winning conditions are particularly important since all regular winning conditions (such as safety, reachability, liveness, fairness) as well as all Lineartime Temporal Logic (LTL) winning conditions can be translated into parity conditions [47, 48]. In a parity game, every vertex of the game graph is assigned a nonnegative integer priority from , and a play is winning if the highest priority visited infinitely often is even. Game graphs with parity conditions can model all the applications mentioned above, and are also equivalent to the modal calculus [39] modelchecking problem [28]. Thus the parity games problem is a core algorithmic problem in formal methods, and has received wide attention over the decades [28, 5, 51, 34, 58, 36, 50, 12, 35].
Models of computation: Explicit and symbolic algorithms. For the algorithmic analysis of parity games, two models of computation are relevant. First, the standard model of explicit algorithms, where the algorithms operate on the explicit representation of the game graph. Second, the model of implicit or symbolic algorithms, where the algorithms do not explicitly access the game graph but operate with a set of predefined operations. For parity games, the most relevant class of symbolic algorithms are called setbased symbolic algorithms, where the allowed symbolic operations are: (a) basic set operations such as union, intersection, complement, and inclusion; and (b) one step predecessor (Pre) operations (see [22, 26, 32]).
Significance of setbased symbolic algorithms. We describe the two most significant aspects of setbased symbolic algorithms.

Consider large scale finitestate systems, e.g., hardware circuits, or programs with many Boolean variables or boundeddomain integer variables. While the underlying game graph is described implicitly (such as program code), the explicit game graph representation is huge (e.g., exponential in the number of variables). The implicit representation and symbolic algorithms often do not incur the exponential blowup, that is inevitable for algorithms that require the explicit representation of the game graph. Datastructures such as Binary Decision Diagrams (BDDs) [7] (with wellestablished tools e.g. CuDD [52]) support symbolic algorithms that are used in verification tools such as NuSMV [19].

In several domains of formal analysis of infinitestate systems, such as games of hybrid automata or timed automata, the underlying state space is infinite, but there is a finite quotient. Symbolic algorithms provide a practical and scalable approach for the analysis of such systems: For many applications the winning set is characterized by calculus formulas with onestep predecessor operations which immediately give the desired setbased symbolic algorithms [26, 24]. Thus, the setbased symbolic model of computation is an equally important theoretical model of computation to be studied as the explicit model.
Symbolic resources. In the explicit model of computation, the two important resources are time and space. Similarly, in the symbolic model of computation, the two important resources are the number of symbolic operations and the symbolic space.

Symbolic operations: Since a symbolic algorithm uses a set of predefined operations, instead of time complexity, the first efficiency measure for a symbolic algorithm is the number of symbolic operations required. Note that basic set operations (that only involve variables of the current state) are less resource intensive 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 number of basic set operations and the number of predecessor operations.

Symbolic space: We refer to the number of sets stored by a setbased symbolic algorithm as the symbolic space for the following reason: A set in the symbolic model is considered to be unit space, for example, a set that contains all vertices, or a set that contain all vertices where the first variable is true, represent each vertices, but can be represented as BDD of constant size. While the size of a set and its symbolic representation is notoriously hard to characterize (e.g., for BDDs it can depend on the variable reordering), in the theoretical model of computation every set is considered of unit symbolic space, and the symbolic space requirement is thus the maximum number of sets required by a symbolic algorithm.
The goal is to find algorithms that minimize the symbolic space (ideally polylogarithmic) and the symbolic operations.
Previous results. We summarize the main previous results for parity games on graphs with vertices, edges, and priorities. To be concise in the following discussion, we ignore denominators in in the bounds.

Explicit algorithms. The classical algorithm for parity games requires time and linear space [59, 42], which was then improved by the small progress measure algorithm that requires time and space [34]. Many improvements have been achieved since then, such as the bigstep algorithm [50], the subexponential time algorithm [36], an improved algorithm for dense graphs [17], and the strategyimprovement algorithm [58], but the most important breakthrough was achieved last year where a quasipolynomial time algorithm was obtained [12]. While the original algorithm of [12] required quasipolynomial time and space, a succinct small progress measure based algorithm [35] and valueiteration based approach [29] achieve the quasipolynomial time bound with quasilinear space. However, all of the above algorithms are inherently explicit algorithms.

Setbased symbolic algorithms. The basic setbased symbolic algorithm (based on the direct evaluation of the nested fixed point of the calculus formula) requires symbolic operations and space [27]. In a breakthrough result [5] presented a setbased symbolic algorithm that requires symbolic operations and symbolic space (for a simplified exposition see [51]). In recent work [14], a new setbased symbolic algorithm was presented that requires symbolic operations and symbolic space, where the symbolic space requirement is even with a constant number of priorities.
Open questions. Despite the wealth of results for parity games, many fundamental algorithmic questions are still open. Besides the major and longstanding open question of the existence of a polynomialtime algorithm for parity games, two important open questions in relation to setbased symbolic algorithms are as follows:

Question 1. Does there exist a setbased symbolic algorithm that requires only quasipolynomially many symbolic operations?

Question 2. Given the symbolic space requirement of the basic algorithm, whereas all other algorithms require at least space (even for a constant number of priorities) an important question is: Does there exist a setbased symbolic algorithm that requires symbolic space (note that hides polylogarithmic factors), but beats the number of symbolic operations of the basic algorithm? This question is especially relevant since in many applications the number of priorities is small, e.g., in determinization of automata, the number of priorities is logarithmic in the size of the automata [47].
reference  symbolic operations  symbolic space 

[27, 59]  
[5, 51]  
[14]  
Thm. 2, 3 
Our contributions. In this work, we not only answer the above open questions (Question 1 and Question 2) in the affirmative but also show that both can be achieved by the same algorithm:

First, we present a blackbox setbased symbolic algorithm based on explicit progress measure algorithm for parity games that use symbolic space and symbolic operations. There are two important consequences of our algorithm: (a) First, given the ordered progress measure algorithm (which is an explicit algorithm), as a consequence of our blackbox algorithm, we obtain a setbased symbolic algorithm for parity games that requires quasipolynomially many symbolic operations and symbolic space. (b) Second, any future improvement in progress measure based explicit algorithm (such as polynomialtime progress measure algorithm) would immediately imply the same improvement for setbased symbolic algorithms. Thus we answer Question 1 in affirmative and also show that improvements in explicit progress measure algorithms carry over to symbolic algorithms.

Second, we present a setbased symbolic algorithm that requires quasipolynomially many symbolic operations and symbolic space. Thus we not only answer Question 2 in affirmative, we also match the number of symbolic operations with the current bestknown bounds for explicit algorithms. Moreover, for the important case of , our algorithm requires polynomially many symbolic operations and polylogarithmic symbolic space.
We compare our main results with previous setbased symbolic algorithms in Table 1.
Symbolic Implementations. Recently, symbolic algorithms for parity games received attention from a practical perspective: First, three explicit algorithms (Zielonka’s recursive algorithm, Priority Promotion [4] and FixpointIteration [6]) were converted to symbolic implementations [49]. The symbolic solvers had a huge performance gain compared to the corresponding explicit solvers on a number of practical instances. Second, four symbolic algorithms to solve parity games were compared to their explicit versions (Zielonka’s recursive algorithm, small progress measure and an automatabased algorithm [40, 54]) [55]. For the symbolic versions of the small progress measure, two implementations were considered: (i) Symbolic Small Progress Measure using Algebraic Decision Diagrams [11] and (ii) the SetBased Symbolic Small Progress Measure [14]. The symbolic algorithms were shown to perform better in several structured instances.
Other related works. Besides the discussed theoretical results on parity games, there are several practical approaches for parity games, such as, (a) accelerated progress measure [23], (b) quasidominion [4], (c) identifying winning cores [57], (d) BDDbased approaches [37, 38], and (e) an extensive comparison of various solvers [56]. A straightforward symbolic implementation (not setbased) of small progress measure was done in [11] using Algebraic Decision Diagrams (ADDs) and BDDs. Unfortunately, the running time is not comparable with our results as using ADDs breaks the boundaries of the SetBased Symbolic Model: ADDs can be seen as BDDs which allow the use of a finite domain at the leaves [3]. Recently, a novel approach for solving parity games in quasipolynomial time which uses the registerindex was introduced [41]. Moreover, [41] presents a calculus formula describing the winning regions of the parity game with alternation depth based on the registerindex. The existence of such a calculus formula does not immediately imply a quasipolynomial setbased symbolic algorithm due to constructing the formula using the registerindex.
Our work considers the theoretical model of symbolic computation and presents a blackbox algorithm as well as a quasipolynomial algorithm, matching the bestknown bounds of explicit algorithms. Thus our work makes a significant contribution towards the theoretical understanding of symbolic computation for parity games.
0.2 Preliminaries
We follow a similar notation as [14].
0.2.1 Basic Definitions
Game Graphs. A game graph is a graph where the vertices are partitioned into player vertices and player vertices , i.e., . Let describe the set of successor vertices of . The set describes the set of predecessors of the vertex . More formally and . We assume without loss of generality that every vertex has an outgoing edge. We denote the number of vertices with and the number of edges with .
Plays. Let be a game graph. Initially, a token is placed on a vertex . When for , player moves the token along one of the edges to a vertex in . Formally, a play is an infinite sequence where for every the following condition holds: .
Parity Game. A parity game with priorities is a game graph with a function that assigns each vertex a priority, i.e., where and and . The set is the set of all priorities. Let be a play of . Player wins if the highest priority occurring infinitely often is even. Player , on the other hand, wins
if the highest priority occurring infinitely often is odd. Let
for denote the vertices in with priority . Formally, we define .Strategies. A strategy for player is a function that extends a finite prefix of a play which ends at vertex by appending a vertex . A memoryless strategy is a strategy that depends only on the last vertex of a play. This corresponds to a function such that for all . The results from [28, 42] show that it is sufficient to consider memoryless strategies for parity games. We shall therefore from now on only consider memoryless strategies. A starting vertex , a player strategy , and a player strategy describe a unique play in a game graph. It is defined as follows: and for all , if then and if then .
Winning Strategies and Winning Sets. A strategy is winning at a start vertex for player iff for all strategies of player , player wins the play . If there exists a winning strategy at a start vertex for player , is part of the winning set of player , . Every vertex is winning for exactly one of the players [28, 44]. In this work, we study the problem of computing the winning sets for the two players.
0.2.2 Symbolic Model of Computation
In the setbased symbolic model, the game graph is not accessed explicitly but with setbased symbolic operations. The resources in the symbolic model of computation are characterized by the number of setbased symbolic operations and the setbased space.
SetBased Symbolic Operations. A setbased symbolic algorithm is allowed to use the same mathematical, logical and memory access operations as a regular RAM algorithm, except for the access to the input graph. Given an input game graph and a set of vertices , the game graph can be accessed only by the following two types of operations:

The basic set operation: and .

The onestep operation to obtain the predecessors of the vertices of in . In particular, we define the predecessor operation
Let , then if and if . The controllable predecessor operation for is defined as
The set can be expressed using only and basic set operations. Note that basic set operations (that only involve variables of the current state) are much cheaper compared to the onestep operations (that involve both variables of the current and of the next state). Thus, in our analysis, we will distinguish between the number of basic set operations and the number of onestep operations. Notice that one can define a onestep successor operation (denoted ) as well [15], but for the algorithms presented in this work the given predecessor operation suffices.
Setbased Symbolic Space. The basic unit of space for a setbased symbolic algorithm for game graphs are sets [5, 14]. For example, a set can be represented symbolically as one BDD [7, 8, 10, 21, 53, 22, 20, 30, 16] and each such set is considered as unit space. Consider for example a game graph whose statespace consists of valuations of Boolean variables. The set of all vertices is simply represented as a true BDD. Similarly, the set of all vertices where the th bit is false is represented by a BDD which depending on the value of the th bit chooses true or false. Again, this set can be represented as a constant size BDD. Thus, even large sets can sometimes be represented as constantsize BDDs. In general, the size of the smallest BDD representing a set is notoriously hard to determine and depends on the variable reordering [22]. To obtain a clean theoretical model for the algorithmic analysis, each set is represented as a unit data structure and requires unit space. Thus, for the space requirements of a symbolic algorithm, we count the maximal number of sets the algorithm stores simultaneously and denote it as the symbolic space.
0.2.3 The Progress Measure Algorithm
Highlevel intuition. Let be a parity game and let be a finite total order with a maximal element and a minimal element . A ranking function is a function which maps every vertex in to a value in . The value of a vertex with respect to the ranking function is called rank of . The rank of a vertex determines how “close” the vertex is to being in , the winning set of a fixed player . Initially, the rank of every vertex is the minimal value of . The progress measure algorithm iteratively increases the rank of a vertex with an operator called with respect to the successors of and another function called . The algorithm terminates when the rank of no vertex can be increased any further, i.e., the least fixed point of is reached. We call the least simultaneous fixed point of all operators progress measure. When the rank of a vertex is the maximal element of the total order it is declared winning for player . The rest of the vertices are declared winning for the adversarial player .
Ranking Function. Let be a total order with a minimal element and maximal element . A ranking function is a function .
The function. The function represents the ability of player , given the token is at vertex , to choose the vertex in with the maximal ranking function. Analogously, it constitutes the ability of player , given the token is at vertex , to choose the vertex in with the minimal ranking function. Formally, the function is defined for a vertex and a ranking function as follows:
The function. The function defines how the rank of a vertex is increased according to the rank of a successor vertex, and the priority of . The function needs to be monotonic in the first argument. Notice that we do not need information about the graph to compute the function. In all known progress measures, the function is computable in constant time.
The operation. The operation potentially increases the rank of a vertex according to its priority and the rank of all its successors in the graph.^{1}^{1}1Notice that in the original definition [34] the function is applied to all successors and the best of them is chosen subsequently. As the is monotone in the first argument the two definitions are equivalent.
A ranking function is a progress measure if it is the least simultaneous fixed point of all operators.
The Progress Measure Algorithm. The progress measure algorithm initializes the ranking function with the minimum element of . Then, the operator is computed in an arbitrary order regarding the vertices. The winning set of player z can be obtained from a progress measure by selecting those vertices whose rank is . Notice that we need to define the total order and a function to initialize the algorithm.
For example, the following instantiations of the progress measure algorithm determine the winning set of a parity game: (i) Small Progress Measure [34], (ii) Succinct Progress Measure [35] and the (iii) The Ordered Approach [29]. The running time is dominated by the size of . For a discussion on the stateoftheart size of we refer the reader to Remark 2.
0.3 SetBased Symbolic Black Box Progress Measure Algorithm
In this section, we briefly present a basic version of a setbased symbolic progress measure algorithm. The key idea is to compute the Liftoperation with a setbased symbolic algorithm. Then, we improve the basic version to obtain our black box setbased symbolic progress measure algorithm. Finally, we prove its correctness and analyze the symbolic resources.
A basic Black Box Algorithm. Throughout the algorithm, we maintain the family of sets of vertices, which contains a set for every element in , i.e., . Intuitively, a vertex has rank . Initially, we put each vertex into the set with the minimal value of , i.e., . In each iteration, we consider all nonempty sets : The algorithm checks if the ranking function of the predecessors of the vertices in must be increased, i.e. where , and if so, performs the operator for the predecessors. We repeat this step until the algorithm arrives at a fixed point.
Performing a Lift operation. To compute the operation in the setbased symbolic setting we need to compute two functions for the predecessors of : (1) the function and (2) the function. By definition, the function does not access the game graph or vertices thereof. Thus we can compute the function without the use of symbolic operations. To compute the function we need access to the game graph. In turns out it is simpler to compute the vertices with rather than the vertices with . Thus, we lift all vertices with to the rank . To this end, we first compute the set of vertices with rank . Then, we compute and, hence, the set comprises the vertices with . Finally, to compute , for each , we consider the vertices of with priority , i.e., the set , and add them to the set . Notice that we lift each vertex to where as we consider all nonempty sets . No vertex will be lifted to a set higher than where due to the monotonicity of the lift function in the first argument. If after an iteration of the algorithm a vertex appears in several sets of we only keep it in the set corresponding to the largest rank and remove it from all the other sets.
0.3.1 Improving the Basic Algorithm
In this section, we improve the basic Algorithm by (a) reducing the symbolic space from to and (b) by reducing the number of symbolic operations required to compute the fixed point.
Key Idea. The naive algorithm considers each nonempty set in iteration again no matter if has been changed in iteration or not. Notice that we only need to consider the predecessors of the set again when the set in iteration contains additional vertices compared to the set in iteration . To overcome this weakness, we propose Algorithm 1. In this algorithm, we introduce a data structure called . In the data structure we keep track of the sets instead of the sets . The set contains all vertices with a rank greater or equal than . Furthermore, we separately keep track of the elements where the set changed since the last time was selected to be processed. These elements of are called active. Moreover, if we have two sets with there is no need to process the set because holds due to the monotonicity of the function. To summarize, we precisely store a set if there is no with and . Notice, that this instantly gives us a bound on the symbolic space of .
Algorithm Description. In Algorithm 1 we use the data structure to manage the active and in each iteration of the outer whileloop we process the corresponding set of such an . We first compute , then, for each we compute and update the set by adding . The inner whileloop ensures that is also added to all the sets with and the properties of the data structure are maintained, i.e., (a) all active elements are in the active list, and (b) exactly those with , for are stored in .
Active Elements. Intuitively, an element is active if , for all where and has been changed since the last time was selected at Line 1 of Algorithm 1. We define active elements more formally later.
Data Structure 1.
Our algorithm relies on a data structure , which supports the following operations:

returns an element marked as active and makes it inactive. If all elements are inactive, returns false.

returns the set .

returns the smallest with .

returns the largest where .

marks as inactive.

marks as active.

updates the set to , i.e., returns . Moreover, all sets with and beforehand are updated to as well.
We initialize with and .
We can define active elements formally now as the definition depends on .
Definition 1.
Let be the set stored in for after the initialization of , and let be the set stored in for after the th iteration of the whileloop at Line 1. An element is active after the th iteration of the whileloop if (i) for all where we have and (ii) there is a such that and for all the set is not selected in Line 1 in the th iteration. Additionally, we consider as active before the first iteration. An element is inactive if it is not active.
Notice that, in Algorithm 1 an is active iff is marked as active in . The algorithm ensures this in a very direct way. At the beginning only is active, which is also marked as active in in the initial phase of the algorithm. Whenever some vertices are added to a set , it is tested whether is larger than its successor and if so is activated (Lines 11). On the other hand, if something is added to the successor of in the data structure then the algorithm tests whether the two sets are equal and if so is rendered inactive (Lines 11).
Implementation of the data structure . The data structure uses an AVLtree and a doubly linked list called “active list” that keeps track of the active elements. The nodes of the tree contain a pointer to the corresponding set and to the corresponding element in the active list.

Initialization of the data structure : Create the AVL tree with the elements and . The former points to the set of all vertices and the latter to the empty set. Create the doubly linked list called “active list” as an empty list.

: Return the first element from the active list and remove it from the active list. If the list is empty, return false.

: Searches the AVL tree for or for the next greater element (w.r.t. ). Then we return the set by using the pointer we stored at the node.

: First performs and then computes the inorder successor in the AVLtree. This corresponds to the next greater node w.r.t. .

: First performs and then computes the inorder predecessor in the AVLtree. This corresponds to the next smaller node w.r.t. .

: This operation needs the element to be stored in the AVL tree. Search the AVL tree for . Remove the corresponding element from the active list and the AVL Tree.

: This operation needs the element to be stored in the AVL tree. Add to the active list and add pointers to the AVLtree. The element in the active list contains a pointer to the tree element and vice versa.

: Perform : If is contained in the AVL tree then update to . Otherwise, insert as a new element and let the element point to .
We initialize the data structure with and . Thus, whenever we query for a value we find it or there exists an which is in .
Analysis of the data structure . The data structure can be implemented with an AVLtree and a doubly linked list called “active list” that keeps track of the active elements such that all of the operations can be performed in : when the algorithm computes we store and a pointer to the set as a node in the AVL tree. By construction, the algorithm only stores pointers to different sets and when we additionally preserve antimonotonicity among the sets we only store sets. Therefore, the AVL tree has only nodes with pointers to the corresponding sets and searching for a set with the operation only adds a factor of to the nonsymbolic operations when we store as key with a pointer to in the AVLtree. Moreover, we maintain pointers between the elements of the active list and the corresponding vertices in the AVL tree.
Remark 1.
The described algorithm is based on a data structure which keeps track of the sets that will be processed at some point later in time. Note that this data structure does not access the game graph but only stores pointers to sets that the Algorithm 1 maintains. The size of the AVL tree implementing is proportional to the symbolic space of the algorithm.
Correctness
In order to prove the correctness of Algorithm 1 we tacitly assume that the algorithm terminates. An upper bound on the running time is then shown in Proposition 2.
Proposition 1 (Correctness.).
Let be a parity game. Given a finite total order with minimum element , a maximum element and a monotonic function Algorithm 1 computes the least simultaneous fixed point of all operators.
To prove the correctness of Algorithm 1, we prove that when Algorithm 1 terminates, the function is equal to the least simultaneous fixed point of all operators. We show that when the properties described in Invariant 1 hold, the function is equal to the least fixed point at the termination of the algorithm. Then, we prove that we maintain the properties of Invariant 1.
Invariant 1.
Let be the least simultaneous fixed point of and be the ranking function w.r.t. the sets that are maintained by the algorithm.
In the following paragraph, we describe the intuition of Invariant 1. Then, we show that the properties of Invariant 1 are sufficient to obtain the correctness of Algorithm 1. Finally, we prove that each property holds during the whileloop at Line 1.
Intuitive Description. The intuitive description is as follows:

Ensures that the sets contain the correct elements. Having the sets allows computing as discussed at the beginning of the section.

Guarantees that is a lower bound on throughout the algorithm.

When an is not active, the rank of no vertex can be increased by applying to the vertices which have .
When the algorithm terminates, all are inactive and is a fixed point of all by condition (3b). The next lemma proves that Algorithm 1 computes the least simultaneous fixed point of all operators for a parity game.
Lemma 1 (The Invariant is sufficient).
Let the function be monotonic in the first argument and be a total order. The ranking function at termination of Algorithm 1 is equal to the least simultaneous fixed point of all operators for the given parity game .
Proof.
Consider the ranking function computed by Algorithm 1. By Invariant 1(2) we have for all . We next show that is a fixed point of for all . When the algorithm terminates, no is active. Consider an arbitrary and let . Now, as the set is not active, by Invariant 1(3b), we have . Thus is a fixed point of for all vertices in . Therefore, as is a simultaneous fixed point of all operators and is the least such fixed point, we obtain for all . Hence we have for all . ∎
The following lemmas prove each part of the invariant separately. The first part of the invariant describes the antimonotonicity property which is needed to compute the function with the operator.
Lemma 2.
Proof.
We prove the claim by induction over the iterations of the whileloop. Initially, the claim is satisfied as the only nonempty set is . It remains to show that when the claim is valid at the beginning of an iteration, then the claim also holds in the next iteration. By induction hypothesis, the claim holds for the sets at the beginning of the whileloop. In the trivial case, the algorithm terminates and the claim holds by the induction hypothesis. Otherwise, the sets are only modified at Line 1 and stored at Line 1. First, the vertices are added into the set . Let . Notice that after activating all with refer to the same set as and thus we add implicitly to all . In the next iteration the whileloop then adds also to the set . As this done iteratively until a set with is reached (Lines 11), the algorithm ensures that is contained in all set with . By induction hypothesis we know that the invariant holds for all ( is unchanged), and as the algorithm added to all set with the claim holds for all . ∎
The second part of the invariant shows that the fixed point Algorithm 1 computes is always smaller or equal to the least fixed point. In particular, the fixed point computed by the algorithm is defined as and we denote the least fixed point with . The proof is by induction: In the beginning, every vertex is initialized with the minimum element which obviously suffices for the claim. When we apply the function to vertices, we observe that by the induction hypothesis the current value of a vertex is below or equal to the fixed point. Additionally, we obtain a rank which is also smaller or equal to the lifted value of for every vertex as is a monotonic function.
Proof.
Before the whileloop at Line 1 the claim is obviously satisfied as for all . We prove the claim by induction over the iterations of the whileloop: Assume we have for all before an iteration of the whileloop. The function is only changed at Line 1 and stored at Line 1 where the set is added to . For we have that is a priority vertex and either is a player vertex with a successor in or a player vertex with all successors in . Thus, for . At Line 1 we compute the operation for ranking with priority which results in the ranking for the first iteration of the whileloop. By the monotonicity of the operation and the induction hypothesis we have that for and thus adding to maintains the invariant (if beforehand it is not changed and otherwise it is lifted to ). In the later iterations of the whileloop is added to sets with smaller , which does not affect , as these vertices already appear in sets with larger rank. ∎
The following lemma proves the third part of Invariant 1: Either there is an active , i.e., the set needs to be processed, or is a fixed point. We prove the property again by induction: Initially, the set is active and every other set is empty which trivially fulfills the property. Then, in every iteration when we change a set with value we either activate it, or there is a set with a value where subsumes . In the former case, the condition is instantly fulfilled. In the latter case, there is no vertex where which renders irrelevant by definition of .
Lemma 4.
Invariant 1(3) holds: For all :

is active or,

, then
Proof.
We prove this invariant by induction over the iterations of the whileloop: Before the whileloop at Line 1 the claim is obviously satisfied as we activate which contains all vertices; for all other the set is empty and thus condition (2) is trivially satisfied.
Assume the condition holds at the beginning of the loop. We can, therefore, assume by the induction hypothesis that the condition holds for all the sets. If there is no active , the algorithm terminates and the condition holds by the induction hypothesis. The condition for a set can be violated only if either the set is changed or the set is deactivated. That is either at Line 1, Line 1 or Line 1 of the algorithm.
Let us first consider the changes made in the whileloop. If a set is changed in Line 1, then the algorithm either activates (Line 1) and thus satisfies (1) or which implies that and thus (2) is fulfilled trivially. At Line 1 there is no vertex with (as there is no vertex with ) and thus (2) is satisfied (and it is safe to remove/deactivate the set in Line 1).
Now consider the case where we remove the set and make inactive at Line 1. If the set is unchanged during the iteration of the outer whileloop then satisfies condition (2) after the iteration. This is because for all with and we have that if is not already contained in the algorithm adds it to the set in Line 1 in the first iteration of the whileloop when processing . This is equivalent to applying . If the set is changed during the iteration then this happens in the inner whileloop. As argued above, then either is activated and thus satisfies (1) or holds. Thus, there is no vertex with , i.e., (2) is satisfied. ∎
Symbolic Resources
In the following, we discuss the amount of symbolic resources Algorithm 1 needs. We determine the number of symbolic onestep operations, the number of basic set operations and the symbolic space consumption.
Proposition 2.
The number of symbolic onestep operations in Algorithm 1 is in .
Proof.
Each iteration of the whileloop at Line 1 processes an active . That means, that the set was changed in a prior iteration. We use a symbolic onestep operation at Line 1 for each active . It, therefore, suffices to count the number of possibly active sets throughout the execution of the algorithm. Initially only is active. After extracting an active set out of the data structure , it is deactivated at Line 1. We only activate a set when a new vertex is added to it at Line 1. Because there can only be vertices with ranking for all the size of each set is smaller or equal to . In the worst case, we eventually put every vertex into every set where . Thus we activate sets which is equal to the number of symbolic onestep operations. ∎
A similar argument works for analysing the number of basic set operations.
Proposition 3.
The number of basic set operations in Algorithm 1 is in .
Proof of Proposition 3..
As proven in Proposition 2, there are iterations of the outer whileloop and thus iterations of the forloop. Thus the inner whileloop is started times. The test whether the whileloop is started only requires two basic set operations and the overall costs are bound by . We bound the overall costs for the iterations of the inner whileloop by an amortized analysis. First, notice that each iteration just requires 8 basic set operations (including testing the while condition afterward). In each iteration for a value we charge the for the involved basic set operations. Notice, that in each such an iteration new vertices are added to the set and thus is processed at most times. Thus each is charged for at most basic set operations Therefore, the number of basic set operations is . ∎
Due to Proposition 1, Proposition 2, Proposition 3 and the fact that we use sets in the data structure , we obtain Theorem 1.
Theorem 1.
Given a parity game, a finite total order and a monotonic function we can compute the least fixed point of all operators with symbolic onestep operations, basic set operations, and symbolic space.
0.4 Implementing the Ordered Progress Measure
In this section, we plug the ordered approach to progress measure (OPM) described by Fearnley et al. [29] into Algorithm 1. To do this, we recall the witnesses they use in their algorithm and encode it with a speciallytailored technique to obtain an algorithm with a sublinear amount of symbolic space. Finally, we argue that the function and the total order described in [29] can be used to fully implement Algorithm 1.
The Ordered Progress Measure. To implement the ordered progress measure algorithm we need to argue that the operation is monotonic in the first argument and the order is a total finite order in order to fulfill the conditions of Algorithm 1. Let be a parity game and be the set of priorities in . The set in the ordered progress measure consists of tuples of priorities of length , where . Each element in the tuple is an element of , i.e., it is either a priority or "". The set has a total order such that is the smallest element, odd priorities are order descending and are considered smaller than even priorities which are ordered ascending. The order is then obtained by extending the order lexicographically to the tuples .
For the details of the function we refer the reader to the work of Fearnley et al. [29]. An implementation of the lift operation can be found at the GitHub repository of the Oink system [56].
By the results in [29] the order and meet the requirements of our algorithms.
Lemma 5.
Theorem 2.
Algorithm 1 implemented with the OPM computes the winning set of a parity game with symbolic onestep operations, basic set operations, and symbolic space.
Remark 2.
(Bounds for ). We now discuss the bounds on . The breakthrough result of [12] shows that is quasipolynomial () in general and polynomial when . Using the refined analysis of [29], we obtain the following bound on : in general, , where and ; and if , then is polynomial due to [12, Theorem 2.8] and [29, Corollary 8.8]. Note that gives a naive upper bound on in general. Plugging the bounds in Theorem 2 we obtain a setbased symbolic algorithm that requires quasipolynomially many symbolic onestep and basic set operations and symbolic space. The algorithm requires only polynomially many symbolic onestep and basic set operations when .
0.5 Reducing the Number of Sets for the OPM
In this section, we tailor a data structure for the OPM in order to only use sets. While each progress measure can be encoded by many sets, the challenge is to provide a representation that also allows to efficiently compute the sets . Such a representation has been provided for the small progress measure [14] and in the following we adapt their techniques for the OPM.
Key Idea. The key idea of the symbolic space reduction is that we encode the value of each coordinate of the rank separately. A set no longer just stores the vertices with specific rank but instead stores all vertices where, say, the first coordinate is equal to a specific value in . This encoding enables us to use only a polylogarithmic amount of symbolic space under the assumption that the number of priorities in the game graph is polylogarithmic in the number of vertices.
Symbolic Space Reduction. Let the rank of be . Vertex is in the set iff the th coordinate of the rank of is and a vertex is in the set iff the rank of is . Thus sets suffice to encode all . We demonstrate this encoding of the sets in Example 1.
Example 1.
Let be a parity game containing the vertices . Assume the following ranking function: Using the definition of our encoding, we have that: .
Computing the set from . We obtain the set for rank with an intersection of the sets . To acquire the set we first consider sets where the first elements are the equal to but the th element is .
(1) 
To construct the set we apply the following union operations:
(2) 
That is, we can compute the set with set operations and four additional sets. Notice that there is no need to store all sets as we can immediately add them to the final set when we have computed them. The number of operations is immediately bounded by