Quasipolynomial Set-Based Symbolic Algorithms for Parity Games

09/11/2019 ∙ by Krishnendu Chatterjee, et al. ∙ Institute of Science and Technology Austria TU Wien Universität Wien 0

Solving parity games, which are equivalent to modal μ-calculus model checking, is a central algorithmic problem in formal methods. Besides the standard computation model with the explicit representation of games, another important theoretical model of computation is that of set-based symbolic algorithms. Set-based symbolic algorithms use basic set operations and one-step predecessor operations on the implicit description of games, rather than the explicit representation. The significance of symbolic algorithms is that they provide scalable algorithms for large finite-state systems, as well as for infinite-state systems with finite quotient. Consider parity games on graphs with n vertices and parity conditions with d priorities. While there is a rich literature of explicit algorithms for parity games, the main results for set-based symbolic algorithms are as follows: (a) an algorithm that requires O(n^d) symbolic operations and O(d) symbolic space; and (b) an improved algorithm that requires O(n^d/3+1) symbolic operations and O(n) symbolic space. Our contributions are as follows: (1) We present a black-box set-based symbolic algorithm based on the explicit progress measure algorithm. Two important consequences of our algorithm are as follows: (a) a set-based symbolic algorithm for parity games that requires quasi-polynomially many symbolic operations and O(n) symbolic space; and (b) any future improvement in progress measure based explicit algorithms imply an efficiency improvement in our set-based symbolic algorithm for parity games. (2) We present a set-based symbolic algorithm that requires quasi-polynomially many symbolic operations and O(d ·log n) symbolic space. Moreover, for the important special case of d ≤log n, our algorithm requires only polynomially many symbolic operations and poly-logarithmic symbolic space.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

0.1 Introduction

In this work, we present new contributions related to algorithms for parity games in the set-based 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 branching-time 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 Linear-time 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 non-negative 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] model-checking 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 set-based 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 set-based symbolic algorithms. We describe the two most significant aspects of set-based symbolic algorithms.

  1. Consider large scale finite-state systems, e.g., hardware circuits, or programs with many Boolean variables or bounded-domain 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 blow-up, that is inevitable for algorithms that require the explicit representation of the game graph. Data-structures such as Binary Decision Diagrams (BDDs) [7] (with well-established tools e.g. CuDD [52]) support symbolic algorithms that are used in verification tools such as NuSMV [19].

  2. In several domains of formal analysis of infinite-state 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 one-step predecessor operations which immediately give the desired set-based symbolic algorithms [26, 24]. Thus, the set-based 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 set-based 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 poly-logarithmic) 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 big-step algorithm [50], the sub-exponential time algorithm [36], an improved algorithm for dense graphs [17], and the strategy-improvement algorithm [58], but the most important breakthrough was achieved last year where a quasi-polynomial time algorithm was obtained [12]. While the original algorithm of [12] required quasi-polynomial time and space, a succinct small progress measure based algorithm [35] and value-iteration based approach [29] achieve the quasi-polynomial time bound with quasi-linear space. However, all of the above algorithms are inherently explicit algorithms.

  • Set-based symbolic algorithms. The basic set-based 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 set-based symbolic algorithm that requires symbolic operations and symbolic space (for a simplified exposition see [51]). In recent work [14], a new set-based 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 long-standing open question of the existence of a polynomial-time algorithm for parity games, two important open questions in relation to set-based symbolic algorithms are as follows:

  • Question 1. Does there exist a set-based symbolic algorithm that requires only quasi-polynomially 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 set-based symbolic algorithm that requires symbolic space (note that hides poly-logarithmic 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
Table 1: Set-Based Symbolic Algorithms for Parity Games.

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 black-box set-based 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 black-box algorithm, we obtain a set-based symbolic algorithm for parity games that requires quasi-polynomially many symbolic operations and symbolic space. (b) Second, any future improvement in progress measure based explicit algorithm (such as polynomial-time progress measure algorithm) would immediately imply the same improvement for set-based 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 set-based symbolic algorithm that requires quasi-polynomially 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 best-known bounds for explicit algorithms. Moreover, for the important case of , our algorithm requires polynomially many symbolic operations and poly-logarithmic symbolic space.

We compare our main results with previous set-based 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 Fixpoint-Iteration [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 automata-based 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 Set-Based 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) quasi-dominion [4], (c) identifying winning cores [57], (d) BDD-based approaches [37, 38], and (e) an extensive comparison of various solvers [56]. A straightforward symbolic implementation (not set-based) 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 Set-Based 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 quasi-polynomial time which uses the register-index was introduced [41]. Moreover, [41] presents a -calculus formula describing the winning regions of the parity game with alternation depth based on the register-index. The existence of such a -calculus formula does not immediately imply a quasi-polynomial set-based symbolic algorithm due to constructing the formula using the register-index.

Our work considers the theoretical model of symbolic computation and presents a black-box algorithm as well as a quasi-polynomial algorithm, matching the best-known 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 set-based symbolic model, the game graph is not accessed explicitly but with set-based symbolic operations. The resources in the symbolic model of computation are characterized by the number of set-based symbolic operations and the set-based space.

Set-Based Symbolic Operations. A set-based 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:

  1. The basic set operation: and .

  2. The one-step 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 one-step 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 one-step operations. Notice that one can define a one-step successor operation (denoted ) as well [15], but for the algorithms presented in this work the given predecessor operation suffices.

Set-based Symbolic Space. The basic unit of space for a set-based 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 state-space 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 constant-size 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

High-level 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.111Notice 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 state-of-the-art size of we refer the reader to Remark 2.

0.3 Set-Based Symbolic Black Box Progress Measure Algorithm

In this section, we briefly present a basic version of a set-based symbolic progress measure algorithm. The key idea is to compute the Lift-operation with a set-based symbolic algorithm. Then, we improve the basic version to obtain our black box set-based 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 non-empty 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 set-based 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 non-empty 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 non-empty 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 while-loop we process the corresponding set of such an . We first compute , then, for each we compute and update the set by adding . The inner while-loop 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 .

input : Parity Game
1 Initialize data structure ;
2 D.activate;
3 while  do
4       ;
5       ;
6       for  do
7             ;
8             ;
9             while  do
10                   ;
11                   ;
12                   if  or  then
                         // is a super set of and thus we save it
13                         ; ;
14                        
15                  ;
16                   if  then
                         // We only keep sets which are different
17                         ;
18                        
19                  ;
20                   ;
21                  
22            
23      
return
Algorithm 1 Black Box Set-Based Symbolic Progress Measure

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 while-loop at Line 1. An element is active after the -th iteration of the while-loop 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 1-1). 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 1-1).

Implementation of the data structure . The data structure uses an AVL-tree 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 AVL-tree. This corresponds to the next greater node w.r.t. .

  • : First performs and then computes the inorder predecessor in the AVL-tree. 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 AVL-tree. 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 AVL-tree 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 anti-monotonicity 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 non-symbolic operations when we store as key with a pointer to in the AVL-tree. 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.

  1. Before each iteration of the while-loop at Line 1 we have for all (anti-monotonicity).

  2. Throughout Algorithm 1 we have for all .

  3. For all : (a) is active or (b) for all , then .

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 while-loop at Line 1.

Intuitive Description. The intuitive description is as follows:

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

  2. Guarantees that is a lower bound on throughout the algorithm.

  3. 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 anti-monotonicity property which is needed to compute the function with the operator.

Lemma 2.

Invariant 1(1) holds: Let and . Before each iteration of the while-loop at Line 1 we have that if a vertex is in a set then it is also in (anti-monotonicity).

Proof.

We prove the claim by induction over the iterations of the while-loop. Initially, the claim is satisfied as the only non-empty 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 while-loop. 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 while-loop then adds also to the set . As this done iteratively until a set with is reached (Lines 1-1), 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.

Lemma 3.

Invariant 1(2) holds: Throughout Algorithm 1 we have for all .

Proof.

Before the while-loop at Line 1 the claim is obviously satisfied as for all . We prove the claim by induction over the iterations of the while-loop: Assume we have for all before an iteration of the while-loop. 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 while-loop. 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 while-loop 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 :

  1. is active or,

  2. , then

Proof.

We prove this invariant by induction over the iterations of the while-loop: Before the while-loop 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 while-loop. 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 while-loop 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 while-loop when processing . This is equivalent to applying . If the set is changed during the iteration then this happens in the inner while-loop. 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 one-step operations, the number of basic set operations and the symbolic space consumption.

Proposition 2.

The number of symbolic one-step operations in Algorithm 1 is in .

Proof.

Each iteration of the while-loop at Line 1 processes an active . That means, that the set was changed in a prior iteration. We use a symbolic one-step 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 one-step 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 while-loop and thus iterations of the for-loop. Thus the inner while-loop is started times. The test whether the while-loop 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 while-loop 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 one-step 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 specially-tailored 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.

The following holds: (1) The function is monotonic in the first parameter [29, p.6]. (2) The order is a total finite order [29, p.3]. (3) Let be the least simultaneous fixed point of all operators. Then iff player has a strategy to win the parity game when starting from  [29, Lemma 7.3, Lemma 7.4].

Theorem 1 together with Lemma 5 imply the following theorem.

Theorem 2.

Algorithm 1 implemented with the OPM computes the winning set of a parity game with symbolic one-step 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 quasi-polynomial () 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 set-based symbolic algorithm that requires quasi-polynomially many symbolic one-step and basic set operations and symbolic space. The algorithm requires only polynomially many symbolic one-step 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