1,433 research outputs found
A Multi-Core Solver for Parity Games
We describe a parallel algorithm for solving parity games,\ud
with applications in, e.g., modal mu-calculus model\ud
checking with arbitrary alternations, and (branching) bisimulation\ud
checking. The algorithm is based on Jurdzinski's Small Progress\ud
Measures. Actually, this is a class of algorithms, depending on\ud
a selection heuristics.\ud
\ud
Our algorithm operates lock-free, and mostly wait-free (except for\ud
infrequent termination detection), and thus allows maximum\ud
parallelism. Additionally, we conserve memory by avoiding storage\ud
of predecessor edges for the parity graph through strictly\ud
forward-looking heuristics.\ud
\ud
We evaluate our multi-core implementation's behaviour on parity games\ud
obtained from mu-calculus model checking problems for a set of\ud
communication protocols, randomly generated problem instances, and\ud
parametric problem instances from the literature.\ud
\u
Parity games : descriptive complexity and algorithms for new solvers
Parity games are 2-person, 0-sum, graph-based, and determined games
that form an important foundational concept in formal methods (see e.g.,
[Zie98]), and their exact computational complexity has been an open problem
for over twenty years now.
In this thesis, we study algorithms that solve parity games in that they
determine which nodes are won by which player, and where such decisions
are supported with winning strategies. We modify and so improve a known
algorithm but also propose new algorithmic approaches to solving parity
games and to understanding their descriptive complexity.
For all of our contributions, we write our own custom frameworks, in the
Scala programming language, to perform tailored experiments and empirical
studies to demonstrate and support our theoretical findings.
First, we improve on one of the solver algorithms, based on small progress
measures [Jur00], by use of concurrency. We show that, for many parity
games, it is possible to deliver extra performance using this technique in a
multi-core environment.
Second, we design algorithms to reduce the computational complexity
of parity games, and create implementations to observe and evaluate the
behaviours of these reductions in our experimental settings. The measure
Rabin index, arising from the design of the said algorithm, is shown to be a
new descriptive complexity for parity games.
Finally, we define a new family of attractors and derive new parity game solvers from them. Although these new solvers are āpartialā, in that they
do not solve all parity games completely, our experiments show that they do
solve a set of benchmark games (i.e., games with known structures) designed
to stress test solvers from PGSolver toolkit [FL10] completely, and some of
these partial solvers deliver favourable performance against a known high
performance solver in many circumstances
Generating and Solving Symbolic Parity Games
We present a new tool for verification of modal mu-calculus formulae for
process specifications, based on symbolic parity games. It enhances an existing
method, that first encodes the problem to a Parameterised Boolean Equation
System (PBES) and then instantiates the PBES to a parity game. We improved the
translation from specification to PBES to preserve the structure of the
specification in the PBES, we extended LTSmin to instantiate PBESs to symbolic
parity games, and implemented the recursive parity game solving algorithm by
Zielonka for symbolic parity games. We use Multi-valued Decision Diagrams
(MDDs) to represent sets and relations, thus enabling the tools to deal with
very large systems. The transition relation is partitioned based on the
structure of the specification, which allows for efficient manipulation of the
MDDs. We performed two case studies on modular specifications, that demonstrate
that the new method has better time and memory performance than existing PBES
based tools and can be faster (but slightly less memory efficient) than the
symbolic model checker NuSMV.Comment: In Proceedings GRAPHITE 2014, arXiv:1407.767
Benchmarks for Parity Games (extended version)
We propose a benchmark suite for parity games that includes all benchmarks
that have been used in the literature, and make it available online. We give an
overview of the parity games, including a description of how they have been
generated. We also describe structural properties of parity games, and using
these properties we show that our benchmarks are representative. With this work
we provide a starting point for further experimentation with parity games.Comment: The corresponding tool and benchmarks are available from
https://github.com/jkeiren/paritygame-generator. This is an extended version
of the paper that has been accepted for FSEN 201
Oink: an Implementation and Evaluation of Modern Parity Game Solvers
Parity games have important practical applications in formal verification and
synthesis, especially to solve the model-checking problem of the modal
mu-calculus. They are also interesting from the theory perspective, as they are
widely believed to admit a polynomial solution, but so far no such algorithm is
known. In recent years, a number of new algorithms and improvements to existing
algorithms have been proposed. We implement a new and easy to extend tool Oink,
which is a high-performance implementation of modern parity game algorithms. We
further present a comprehensive empirical evaluation of modern parity game
algorithms and solvers, both on real world benchmarks and randomly generated
games. Our experiments show that our new tool Oink outperforms the current
state-of-the-art.Comment: Accepted at TACAS 201
Efficient Instantiation of Parameterised Boolean Equation Systems to Parity Games
Parameterised Boolean Equation Systems (PBESs) are sequences of Boolean fixed point equations with data variables, used for, e.g., verification of modal Ī¼-calculus formulae for process algebraic specifications with data. Solving a PBES is usually done by instantiation to a Parity Game and then solving the game. Practical game solvers exist, but the instantiation step is the bottleneck. We enhance the instantiation in two steps. First, we transform the PBES to a Parameterised Parity Game (PPG), a PBES with each equation either conjunctive or disjunctive. Then we use LTSmin, that offers transition caching, efficient storage of states and both distributed and symbolic state space generation, for generating the game graph. To that end we define a language module for LTSmin, consisting of an encoding of variables with parameters into state vectors, a grouped transition relation and a dependency matrix to indicate the dependencies between parts of the state vector and transition groups. Benchmarks on some large case studies, show that the method speeds up the instantiation significantly and decreases memory usage drastically
Synthesising Strategy Improvement and Recursive Algorithms for Solving 2.5 Player Parity Games
2.5 player parity games combine the challenges posed by 2.5 player
reachability games and the qualitative analysis of parity games. These two
types of problems are best approached with different types of algorithms:
strategy improvement algorithms for 2.5 player reachability games and recursive
algorithms for the qualitative analysis of parity games. We present a method
that - in contrast to existing techniques - tackles both aspects with the best
suited approach and works exclusively on the 2.5 player game itself. The
resulting technique is powerful enough to handle games with several million
states
Symbolic Parity Game Solvers that Yield Winning Strategies
Parity games play an important role for LTL synthesis as evidenced by recent
breakthroughs on LTL synthesis, which rely in part on parity game solving. Yet
state space explosion remains a major issue if we want to scale to larger
systems or specifications. In order to combat this problem, we need to
investigate symbolic methods such as BDDs, which have been successful in the
past to tackle exponentially large systems. It is therefore essential to have
symbolic parity game solving algorithms, operating using BDDs, that are fast
and that can produce the winning strategies used to synthesize the controller
in LTL synthesis.
Current symbolic parity game solving algorithms do not yield winning
strategies. We now propose two symbolic algorithms that yield winning
strategies, based on two recently proposed fixpoint algorithms. We implement
the algorithms and empirically evaluate them using benchmarks obtained from
SYNTCOMP 2020. Our conclusion is that the algorithms are competitive with or
faster than an earlier symbolic implementation of Zielonka's recursive
algorithm, while also providing the winning strategies.Comment: In Proceedings GandALF 2020, arXiv:2009.0936
Improving parity games in practice
Parity games are infinite-round two-player games played on directed graphs whose nodes are labeled with priorities. The winner of a play is determined by the smallest priority (even or odd) that is encountered infinitely often along the play. In the last two decades, several algorithms for solving parity games have been proposed and implemented in PGSolver, a platform written in OCaml. PGSolver includes the Zielonkaās recursive algorithm (RE, for short) which is known to be the best performing one over random games. Notably, several attempts have been carried out with the aim of improving the performance of RE in PGSolver, but with small advances in practice. In this work, we deeply revisit the implementation of RE by dealing with the use of specific data structures and programming languages such as Scala, Java, C++, and Go. Our empirical evaluation shows that these choices are successful, gaining up to three orders of magnitude in running time over the classic version of the algorithm implemented in PGSolver
- ā¦