308 research outputs found
The Fixpoint-Iteration Algorithm for Parity Games
It is known that the model checking problem for the modal mu-calculus reduces
to the problem of solving a parity game and vice-versa. The latter is realised
by the Walukiewicz formulas which are satisfied by a node in a parity game iff
player 0 wins the game from this node. Thus, they define her winning region,
and any model checking algorithm for the modal mu-calculus, suitably
specialised to the Walukiewicz formulas, yields an algorithm for solving parity
games. In this paper we study the effect of employing the most straight-forward
mu-calculus model checking algorithm: fixpoint iteration. This is also one of
the few algorithms, if not the only one, that were not originally devised for
parity game solving already. While an empirical study quickly shows that this
does not yield an algorithm that works well in practice, it is interesting from
a theoretical point for two reasons: first, it is exponential on virtually all
families of games that were designed as lower bounds for very particular
algorithms suggesting that fixpoint iteration is connected to all those.
Second, fixpoint iteration does not compute positional winning strategies. Note
that the Walukiewicz formulas only define winning regions; some additional work
is needed in order to make this algorithm compute winning strategies. We show
that these are particular exponential-space strategies which we call
eventually-positional, and we show how positional ones can be extracted from
them.Comment: In Proceedings GandALF 2014, arXiv:1408.556
Simple Fixpoint Iteration To Solve Parity Games
A naive way to solve the model-checking problem of the mu-calculus uses
fixpoint iteration. Traditionally however mu-calculus model-checking is solved
by a reduction in linear time to a parity game, which is then solved using one
of the many algorithms for parity games. We now consider a method of solving
parity games by means of a naive fixpoint iteration. Several fixpoint
algorithms for parity games have been proposed in the literature. In this work,
we introduce an algorithm that relies on the notion of a distraction. The idea
is that this offers a novel perspective for understanding parity games. We then
show that this algorithm is in fact identical to two earlier published fixpoint
algorithms for parity games and thus that these earlier algorithms are the
same. Furthermore, we modify our algorithm to only partially recompute deeper
fixpoints after updating a higher set and show that this modification enables a
simple method to obtain winning strategies. We show that the resulting
algorithm is simple to implement and offers good performance on practical
parity games. We empirically demonstrate this using games derived from
model-checking, equivalence checking and reactive synthesis and show that our
fixpoint algorithm is the fastest solution for model-checking games.Comment: In Proceedings GandALF 2019, arXiv:1909.0597
A Comparison of BDD-Based Parity Game Solvers
Parity games are two player games with omega-winning conditions, played on
finite graphs. Such games play an important role in verification,
satisfiability and synthesis. It is therefore important to identify algorithms
that can efficiently deal with large games that arise from such applications.
In this paper, we describe our experiments with BDD-based implementations of
four parity game solving algorithms, viz. Zielonka's recursive algorithm, the
more recent Priority Promotion algorithm, the Fixpoint-Iteration algorithm and
the automata based APT algorithm. We compare their performance on several types
of random games and on a number of cases taken from the Keiren benchmark set.Comment: In Proceedings GandALF 2018, arXiv:1809.0241
Permutation Games for the Weakly Aconjunctive -Calculus
We introduce a natural notion of limit-deterministic parity automata and
present a method that uses such automata to construct satisfiability games for
the weakly aconjunctive fragment of the -calculus. To this end we devise a
method that determinizes limit-deterministic parity automata of size with
priorities through limit-deterministic B\"uchi automata to deterministic
parity automata of size and with
priorities. The construction relies on limit-determinism to avoid the full
complexity of the Safra/Piterman-construction by using partial permutations of
states in place of Safra-Trees. By showing that limit-deterministic parity
automata can be used to recognize unsuccessful branches in pre-tableaux for the
weakly aconjunctive -calculus, we obtain satisfiability games of size
with priorities for weakly aconjunctive
input formulas of size and alternation-depth . A prototypical
implementation that employs a tableau-based global caching algorithm to solve
these games on-the-fly shows promising initial results
Fixpoint Games on Continuous Lattices
Many analysis and verifications tasks, such as static program analyses and
model-checking for temporal logics reduce to the solution of systems of
equations over suitable lattices. Inspired by recent work on lattice-theoretic
progress measures, we develop a game-theoretical approach to the solution of
systems of monotone equations over lattices, where for each single equation
either the least or greatest solution is taken. A simple parity game, referred
to as fixpoint game, is defined that provides a correct and complete
characterisation of the solution of equation systems over continuous lattices,
a quite general class of lattices widely used in semantics. For powerset
lattices the fixpoint game is intimately connected with classical parity games
for -calculus model-checking, whose solution can exploit as a key tool
Jurdzi\'nski's small progress measures. We show how the notion of progress
measure can be naturally generalised to fixpoint games over continuous lattices
and we prove the existence of small progress measures. Our results lead to a
constructive formulation of progress measures as (least) fixpoints. We refine
this characterisation by introducing the notion of selection that allows one to
constrain the plays in the parity game, enabling an effective (and possibly
efficient) solution of the game, and thus of the associated verification
problem. We also propose a logic for specifying the moves of the existential
player that can be used to systematically derive simplified equations for
efficiently computing progress measures. We discuss potential applications to
the model-checking of latticed -calculi and to the solution of fixpoint
equations systems over the reals
Model-Checking the Higher-Dimensional Modal mu-Calculus
The higher-dimensional modal mu-calculus is an extension of the mu-calculus
in which formulas are interpreted in tuples of states of a labeled transition
system. Every property that can be expressed in this logic can be checked in
polynomial time, and conversely every polynomial-time decidable problem that
has a bisimulation-invariant encoding into labeled transition systems can also
be defined in the higher-dimensional modal mu-calculus. We exemplify the latter
connection by giving several examples of decision problems which reduce to
model checking of the higher-dimensional modal mu-calculus for some fixed
formulas. This way generic model checking algorithms for the logic can then be
used via partial evaluation in order to obtain algorithms for theses problems
which may benefit from improvements that are well-established in the field of
program verification, namely on-the-fly and symbolic techniques. The aim of
this work is to extend such techniques to other fields as well, here
exemplarily done for process equivalences, automata theory, parsing, string
problems, and games.Comment: In Proceedings FICS 2012, arXiv:1202.317
Strategy Derivation for Small Progress Measures
Small Progress Measures is one of the most efficient parity game solving
algorithms. The original algorithm provides the full solution (winning regions
and strategies) in
time, and requires a re-run of the algorithm on one of the winning regions. We
provide a novel operational interpretation of progress measures, and modify the
algorithm so that it derives the winning strategies for both players in one
pass. This reduces the upper bound on strategy derivation for SPM to .Comment: polished the tex
Improving Strategies via SMT Solving
We consider the problem of computing numerical invariants of programs by
abstract interpretation. Our method eschews two traditional sources of
imprecision: (i) the use of widening operators for enforcing convergence within
a finite number of iterations (ii) the use of merge operations (often, convex
hulls) at the merge points of the control flow graph. It instead computes the
least inductive invariant expressible in the domain at a restricted set of
program points, and analyzes the rest of the code en bloc. We emphasize that we
compute this inductive invariant precisely. For that we extend the strategy
improvement algorithm of [Gawlitza and Seidl, 2007]. If we applied their method
directly, we would have to solve an exponentially sized system of abstract
semantic equations, resulting in memory exhaustion. Instead, we keep the system
implicit and discover strategy improvements using SAT modulo real linear
arithmetic (SMT). For evaluating strategies we use linear programming. Our
algorithm has low polynomial space complexity and performs for contrived
examples in the worst case exponentially many strategy improvement steps; this
is unsurprising, since we show that the associated abstract reachability
problem is Pi-p-2-complete
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
- …