32 research outputs found
Sparse Positional Strategies for Safety Games
We consider the problem of obtaining sparse positional strategies for safety
games. Such games are a commonly used model in many formal methods, as they
make the interaction of a system with its environment explicit. Often, a
winning strategy for one of the players is used as a certificate or as an
artefact for further processing in the application. Small such certificates,
i.e., strategies that can be written down very compactly, are typically
preferred. For safety games, we only need to consider positional strategies.
These map game positions of a player onto a move that is to be taken by the
player whenever the play enters that position. For representing positional
strategies compactly, a common goal is to minimize the number of positions for
which a winning player's move needs to be defined such that the game is still
won by the same player, without visiting a position with an undefined next
move. We call winning strategies in which the next move is defined for few of
the player's positions sparse.
Unfortunately, even roughly approximating the density of the sparsest
strategy for a safety game has been shown to be NP-hard. Thus, to obtain sparse
strategies in practice, one either has to apply some heuristics, or use some
exhaustive search technique, like ILP (integer linear programming) solving. In
this paper, we perform a comparative study of currently available methods to
obtain sparse winning strategies for the safety player in safety games. We
consider techniques from common knowledge, such as using ILP or SAT
(satisfiability) solving, and a novel technique based on iterative linear
programming. The results of this paper tell us if current techniques are
already scalable enough for practical use.Comment: In Proceedings SYNT 2012, arXiv:1207.055
Discounted-Sum Automata with Multiple Discount Factors
Discounting the influence of future events is a key paradigm in economics and
it is widely used in computer-science models, such as games, Markov decision
processes (MDPs), reinforcement learning, and automata. While a single game or
MDP may allow for several different discount factors, discounted-sum automata
(NDAs) were only studied with respect to a single discount factor. For every
integer , as opposed to every , the class of NDAs with discount factor
(-NDAs) has good computational properties: it is closed
under determinization and under the algebraic operations min, max, addition,
and subtraction, and there are algorithms for its basic decision problems, such
as automata equivalence and containment.
We define and analyze discounted-sum automata in which each transition can
have a different integral discount factor (integral NMDAs). We show that
integral NMDAs with an arbitrary choice of discount factors are not closed
under determinization and under algebraic operations and that their containment
problem is undecidable. We then define and analyze a restricted class of
integral NMDAs, which we call tidy NMDAs, in which the choice of discount
factors depends on the prefix of the word read so far. Some of their special
cases are NMDAs that correlate discount factors to actions (alphabet letters)
or to the elapsed time. We show that for every function that defines
the choice of discount factors, the class of -NMDAs enjoys all of the
above good properties of integral NDAs, as well as the same complexity of the
required decision problems. Tidy NMDAs are also as expressive as deterministic
integral NMDAs with an arbitrary choice of discount factors.
All of our results hold for both automata on finite words and automata on
infinite words.Comment: arXiv admin note: text overlap with arXiv:2301.0408
Graph Logics with Rational Relations
Abstract. We investigate some basic questions about the interaction of regular and rational relations on words. The primary motivation comes from the study of logics for querying graph topology, which have recently found numerous applications. Such logics use conditions on paths expressed by regular languages and relations, but they often need to be extended by rational relations such as subword or subsequence. Evaluating formulae in such extended graph logics boils down to checking nonemptiness of the intersection of rational relations with regular or recognizable relations (or, more generally, to the generalized intersection problem, asking whether some projections of a regular relation have a nonempty intersection with a given rational relation). We prove that for several basic and commonly used rational relations, the intersection problem with regular relations is either undecidable (e.g., for subword or suffix, and some generalizations), or decidable with non-primitive-recursive complexity (e.g., for subsequence and its generalizations). These results are used to rule out many classes of graph logics that freely combine regular and rational relations, as well as to provide the simplest problem related to verifying lossy channel systems that has non-primitive-recursive complexity. We then prove a dichotomy result for logics combining regular conditions on individual paths and rational relations on paths, by showing that the syntactic form of formulae classifies them into either efficiently checkable or undecidable cases. We also give examples of rational relations for which such logics are decidable even without syntactic restrictions
Explicit or Symbolic Translation of Linear Temporal Logic to Automata
Formal verification techniques are growing increasingly vital for the development of safety-critical software and hardware in practice. Techniques such as requirements-based design and model checking for system verification have been successfully used to verify systems for air traffic control, airplane separation assurance, autopilots, CPU logic designs, life-support, medical equipment, and other functions that ensure human safety.
Formal behavioral specifications written early in the system-design process and communicated across all design phases increase the efficiency, consistency, and quality of the system under development. We argue that to prevent introducing design or verification errors, it is crucial to test specifications for satisfiability. We advocate for the adaptation of a new sanity check via satisfiability checking for property assurance. Our focus here is on specifications expressed in Linear Temporal Logic (LTL). We demonstrate that LTL satisfiability checking reduces to model checking and satisfiability checking for the specification, its complement, and a conjunction of all properties should be performed as a first step to LTL model checking.
We report on an experimental investigation of LTL satisfiability checking. We introduce a large set of rigorous benchmarks to enable objective evaluation of LTL-to-automaton algorithms in terms of scalability, performance, correctness, and size of the automata produced. For explicit model checking, we use the Spin model checker; we tested all LTL-to-explicit automaton translation tools that were publicly available when we conducted our study. For symbolic model checking, we use CadenceSMV, NuSMV, and SAL-SMC for both LTL-to-symbolic automaton translation and to perform the satisfiability check. Our experiments result in two major findings. First, scalability, correctness, and other debilitating performance issues afflict most LTL translation tools. Second, for LTL satisfiability checking, the symbolic approach is clearly superior to the explicit approach.
Ironically, the explicit approach to LTL-to-automata had been heavily studied while only one algorithm existed for LTL-to-symbolic automata. Since 1994, there had been essentially no new progress in encoding symbolic automata for BDD-based analysis. Therefore, we introduce a set of 30 symbolic automata encodings. The set consists of novel combinations of existing constructs, such as different LTL formula normal forms, with a novel transition-labeled symbolic automaton form, a new way to encode transitions, and new BDD variable orders based on algorithms for tree decomposition of graphs. An extensive set of experiments demonstrates that these encodings translate to significant, sometimes exponential, improvement over the current standard encoding for symbolic LTL satisfiability checking.
Building upon these ideas, we return to the explicit automata domain and focus on the most common type of specifications used in industrial practice: safety properties. We show that we can exploit the inherent determinism of safety properties to create a set of 26 explicit automata encodings comprised of novel aspects including: state numbers versus state labels versus a state look-up table, finite versus infinite acceptance conditions, forward-looking versus backward-looking transition encodings, assignment-based versus BDD-based alphabet representation, state and transition minimization, edge abbreviation, trap-state elimination, and determinization either on-the-fly or up-front using the subset construction. We conduct an extensive experimental evaluation and identify an encoding that offers the best performance in explicit LTL model checking time and is constantly faster than the previous best explicit automaton encoding algorithm
Graph Patterns: Structure, Query Answering and Applications in Schema Mappings and Formal Language Theory
Graph data appears in a variety of application domains, and many uses of it, such as querying,
matching, and transforming data, naturally result in incompletely specified graph data, i.e.,
graph patterns. Queries need to be posed against such data, but techniques for querying patterns
are generally lacking, and even simple properties of graph patterns, such as the languages
needed to specify them, are not well understood.
In this dissertation we present several contributions in the study of graph patterns. We
analyze how to query them and how to use them as queries. We also analyze some of their
applications in two different contexts: schema mapping specification and data exchange for
graph databases, and formal language theory. We first identify key features of patterns, such as
node and label variables and edges specified by regular expressions, and define a classification
of patterns based on them. Next we study how to answer standard graph queries over graph patterns,
and give precise characterizations of both data and combined complexity for each class
of patterns. If complexity is high, we do further analysis of features that lead to intractability, as
well as lower-complexity restrictions that guarantee tractability. We then turn to the the study
of schema mappings for graph databases. As for relational and XML databases, our mapping
languages are based on patterns. They subsume all previously considered mapping languages
for graph databases, and are capable of expressing many data exchange scenarios in the graph
database context. We study the problems of materializing solutions and query answering for
data exchange under these mappings, analyze their complexity, and identify relevant classes of
mappings and queries for which these problems can be solved efficiently. We also introduce a
new model of automata that is based on graph patterns, and define two modes of acceptance
for them. We show that this model has applications not only in graph databases but in several
other contexts. We study the basic properties of such automata, and the key computational
tasks associated with them
Survey on Directed Model Checking
International audienceThis article surveys and gives historical accounts to the algorithmic essentials of directed model checking, a promising bug-hunting technique to mitigate the state explosion problem. In the enumeration process, successor selection is prioritized. We discuss existing guidance and methods to automatically generate them by exploiting system abstractions. We extend the algorithms to feature partial-order reduction and show how liveness problems can be adapted by lifting the search Space. For deterministic, finite domains we instantiate the algorithms to directed symbolic, external and distributed search. For real-time domains we discuss the adaption of the algorithms to timed automata and for probabilistic domains we show the application to counterexample generation. Last but not least, we explain how directed model checking helps to accelerate finding solutions to scheduling problems
Automata-theoretic and bounded model checking for linear temporal logic
In this work we study methods for model checking the temporal logic LTL. The focus is on the automata-theoretic approach to model checking and bounded model checking.
We begin by examining automata-theoretic methods to model check LTL safety properties. The model checking problem can be reduced to checking whether the language of a finite state automaton on finite words is empty. We describe an efficient algorithm for generating small finite state automata for so called non-pathological safety properties. The presented implementation is the first tool able to decide whether a formula is non-pathological. The experimental results show that treating safety properties can benefit model checking at very little cost. In addition, we find supporting evidence for the view that minimising the automaton representing the property does not always lead to a small product state space. A deterministic property automaton can result in a smaller product state space even though it might have a larger number states.
Next we investigate modular analysis. Modular analysis is a state space reduction method for modular Petri nets. The method can be used to construct a reduced state space called the synchronisation graph. We devise an on-the-fly automata-theoretic method for model checking the behaviour of a modular Petri net from the synchronisation graph. The solution is based on reducing the model checking problem to an instance of verification with testers. We analyse the tester verification problem and present an efficient on-the-fly algorithm, the first complete solution to tester verification problem, based on generalised nested depth-first search.
We have also studied propositional encodings for bounded model checking LTL. A new simple linear sized encoding is developed and experimentally evaluated. The implementation in the NuSMV2 model checker is competitive with previously presented encodings. We show how to generalise the LTL encoding to a more succint logic: LTL with past operators. The generalised encoding compares favourably with previous encodings for LTL with past operators. Links between bounded model checking and the automata-theoretic approach are also explored.reviewe