1,851 research outputs found
Zielonka's Recursive Algorithm: dull, weak and solitaire games and tighter bounds
Dull, weak and nested solitaire games are important classes of parity games,
capturing, among others, alternation-free mu-calculus and ECTL* model checking
problems. These classes can be solved in polynomial time using dedicated
algorithms. We investigate the complexity of Zielonka's Recursive algorithm for
solving these special games, showing that the algorithm runs in O(d (n + m)) on
weak games, and, somewhat surprisingly, that it requires exponential time to
solve dull games and (nested) solitaire games. For the latter classes, we
provide a family of games G, allowing us to establish a lower bound of 2^(n/3).
We show that an optimisation of Zielonka's algorithm permits solving games from
all three classes in polynomial time. Moreover, we show that there is a family
of (non-special) games M that permits us to establish a lower bound of 2^(n/3),
improving on the previous lower bound for the algorithm.Comment: In Proceedings GandALF 2013, arXiv:1307.416
Robust Exponential Worst Cases for Divide-et-Impera Algorithms for Parity Games
The McNaughton-Zielonka divide et impera algorithm is the simplest and most
flexible approach available in the literature for determining the winner in a
parity game. Despite its theoretical worst-case complexity and the negative
reputation as a poorly effective algorithm in practice, it has been shown to
rank among the best techniques for the solution of such games. Also, it proved
to be resistant to a lower bound attack, even more than the strategy
improvements approaches, and only recently a family of games on which the
algorithm requires exponential time has been provided by Friedmann. An easy
analysis of this family shows that a simple memoization technique can help the
algorithm solve the family in polynomial time. The same result can also be
achieved by exploiting an approach based on the dominion-decomposition
techniques proposed in the literature. These observations raise the question
whether a suitable combination of dynamic programming and game-decomposition
techniques can improve on the exponential worst case of the original algorithm.
In this paper we answer this question negatively, by providing a robustly
exponential worst case, showing that no intertwining of the above mentioned
techniques can help mitigating the exponential nature of the divide et impera
approaches.Comment: In Proceedings GandALF 2017, arXiv:1709.0176
Energy Parity Games
Energy parity games are infinite two-player turn-based games played on
weighted graphs. The objective of the game combines a (qualitative) parity
condition with the (quantitative) requirement that the sum of the weights
(i.e., the level of energy in the game) must remain positive. Beside their own
interest in the design and synthesis of resource-constrained omega-regular
specifications, energy parity games provide one of the simplest model of games
with combined qualitative and quantitative objective. Our main results are as
follows: (a) exponential memory is necessary and sufficient for winning
strategies in energy parity games; (b) the problem of deciding the winner in
energy parity games can be solved in NP \cap coNP; and (c) we give an algorithm
to solve energy parity by reduction to energy games. We also show that the
problem of deciding the winner in energy parity games is polynomially
equivalent to the problem of deciding the winner in mean-payoff parity games,
while optimal strategies may require infinite memory in mean-payoff parity
games. As a consequence we obtain a conceptually simple algorithm to solve
mean-payoff parity games
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
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
Hyperplane Separation Technique for Multidimensional Mean-Payoff Games
We consider both finite-state game graphs and recursive game graphs (or
pushdown game graphs), that can model the control flow of sequential programs
with recursion, with multi-dimensional mean-payoff objectives. In pushdown
games two types of strategies are relevant: global strategies, that depend on
the entire global history; and modular strategies, that have only local memory
and thus do not depend on the context of invocation. We present solutions to
several fundamental algorithmic questions and our main contributions are as
follows: (1) We show that finite-state multi-dimensional mean-payoff games can
be solved in polynomial time if the number of dimensions and the maximal
absolute value of the weight is fixed; whereas if the number of dimensions is
arbitrary, then problem is already known to be coNP-complete. (2) We show that
pushdown graphs with multi-dimensional mean-payoff objectives can be solved in
polynomial time. (3) For pushdown games under global strategies both single and
multi-dimensional mean-payoff objectives problems are known to be undecidable,
and we show that under modular strategies the multi-dimensional problem is also
undecidable (whereas under modular strategies the single dimensional problem is
NP-complete). We show that if the number of modules, the number of exits, and
the maximal absolute value of the weight is fixed, then pushdown games under
modular strategies with single dimensional mean-payoff objectives can be solved
in polynomial time, and if either of the number of exits or the number of
modules is not bounded, then the problem is NP-hard. (4) Finally we show that a
fixed parameter tractable algorithm for finite-state multi-dimensional
mean-payoff games or pushdown games under modular strategies with
single-dimensional mean-payoff objectives would imply the solution of the
long-standing open problem of fixed parameter tractability of parity games.Comment: arXiv admin note: text overlap with arXiv:1201.282
Solving Parity Games in Scala
Parity games are two-player games, played on directed graphs, whose nodes are labeled with priorities. Along a play, the maximal priority occurring infinitely often determines the winner. In the last two decades, a variety of algorithms and successive optimizations have been proposed. The majority of them have been implemented in PGSolver, written in OCaml, which has been elected by the community as the de facto platform to solve efficiently parity games as well as evaluate their performance in several specific cases.
PGSolver includes the Zielonka Recursive Algorithm that has been shown to perform better than the others in randomly generated games. However, even for arenas with a few thousand of nodes (especially over dense graphs), it requires minutes to solve the corresponding game.
In this paper, we deeply revisit the implementation of the recursive algorithm introducing several improvements and making use of Scala Programming Language. These choices have been proved to be very successful, gaining up to two orders of magnitude in running time
The Rabin index of parity games
We study the descriptive complexity of parity games by taking into account
the coloring of their game graphs whilst ignoring their ownership structure.
Colored game graphs are identified if they determine the same winning regions
and strategies, for all ownership structures of nodes. The Rabin index of a
parity game is the minimum of the maximal color taken over all equivalent
coloring functions. We show that deciding whether the Rabin index is at least k
is in PTIME for k=1 but NP-hard for all fixed k > 1. We present an EXPTIME
algorithm that computes the Rabin index by simplifying its input coloring
function. When replacing simple cycle with cycle detection in that algorithm,
its output over-approximates the Rabin index in polynomial time. Experimental
results show that this approximation yields good values in practice.Comment: In Proceedings GandALF 2013, arXiv:1307.416
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
- …