2,161 research outputs found
Finite Model Finding for Parameterized Verification
In this paper we investigate to which extent a very simple and natural
"reachability as deducibility" approach, originated in the research in formal
methods in security, is applicable to the automated verification of large
classes of infinite state and parameterized systems. The approach is based on
modeling the reachability between (parameterized) states as deducibility
between suitable encodings of states by formulas of first-order predicate
logic. The verification of a safety property is reduced to a pure logical
problem of finding a countermodel for a first-order formula. The later task is
delegated then to the generic automated finite model building procedures. In
this paper we first establish the relative completeness of the finite
countermodel finding method (FCM) for a class of parameterized linear arrays of
finite automata. The method is shown to be at least as powerful as known
methods based on monotonic abstraction and symbolic backward reachability.
Further, we extend the relative completeness of the approach and show that it
can solve all safety verification problems which can be solved by the
traditional regular model checking.Comment: 17 pages, slightly different version of the paper is submitted to
TACAS 201
Well Structured Transition Systems with History
We propose a formal model of concurrent systems in which the history of a
computation is explicitly represented as a collection of events that provide a
view of a sequence of configurations. In our model events generated by
transitions become part of the system configurations leading to operational
semantics with historical data. This model allows us to formalize what is
usually done in symbolic verification algorithms. Indeed, search algorithms
often use meta-information, e.g., names of fired transitions, selected
processes, etc., to reconstruct (error) traces from symbolic state exploration.
The other interesting point of the proposed model is related to a possible new
application of the theory of well-structured transition systems (wsts). In our
setting wsts theory can be applied to formally extend the class of properties
that can be verified using coverability to take into consideration (ordered and
unordered) historical data. This can be done by using different types of
representation of collections of events and by combining them with wsts by
using closure properties of well-quasi orderings.Comment: In Proceedings GandALF 2015, arXiv:1509.0685
On Verifying Complex Properties using Symbolic Shape Analysis
One of the main challenges in the verification of software systems is the
analysis of unbounded data structures with dynamic memory allocation, such as
linked data structures and arrays. We describe Bohne, a new analysis for
verifying data structures. Bohne verifies data structure operations and shows
that 1) the operations preserve data structure invariants and 2) the operations
satisfy their specifications expressed in terms of changes to the set of
objects stored in the data structure. During the analysis, Bohne infers loop
invariants in the form of disjunctions of universally quantified Boolean
combinations of formulas. To synthesize loop invariants of this form, Bohne
uses a combination of decision procedures for Monadic Second-Order Logic over
trees, SMT-LIB decision procedures (currently CVC Lite), and an automated
reasoner within the Isabelle interactive theorem prover. This architecture
shows that synthesized loop invariants can serve as a useful communication
mechanism between different decision procedures. Using Bohne, we have verified
operations on data structures such as linked lists with iterators and back
pointers, trees with and without parent pointers, two-level skip lists, array
data structures, and sorted lists. We have deployed Bohne in the Hob and Jahob
data structure analysis systems, enabling us to combine Bohne with analyses of
data structure clients and apply it in the context of larger programs. This
report describes the Bohne algorithm as well as techniques that Bohne uses to
reduce the ammount of annotations and the running time of the analysis
Parameterized bounded-depth Frege is not optimal
A general framework for parameterized proof complexity was introduced by Dantchev, Martin, and Szeider [9]. There the authors concentrate on tree-like Parameterized Resolution-a parameterized version of classical Resolution-and their gap complexity theorem implies lower bounds for that system. The main result of the present paper significantly improves upon this by showing optimal lower bounds for a parameterized version of bounded-depth Frege. More precisely, we prove that the pigeonhole principle requires proofs of size n in parameterized bounded-depth Frege, and, as a special case, in dag-like Parameterized Resolution. This answers an open question posed in [9]. In the opposite direction, we interpret a well-known technique for FPT algorithms as a DPLL procedure for Parameterized Resolution. Its generalization leads to a proof search algorithm for Parameterized Resolution that in particular shows that tree-like Parameterized Resolution allows short refutations of all parameterized contradictions given as bounded-width CNF's
Model-Checking Problems as a Basis for Parameterized Intractability
Most parameterized complexity classes are defined in terms of a parameterized
version of the Boolean satisfiability problem (the so-called weighted
satisfiability problem). For example, Downey and Fellow's W-hierarchy is of
this form. But there are also classes, for example, the A-hierarchy, that are
more naturally characterised in terms of model-checking problems for certain
fragments of first-order logic.
Downey, Fellows, and Regan were the first to establish a connection between
the two formalisms by giving a characterisation of the W-hierarchy in terms of
first-order model-checking problems. We improve their result and then prove a
similar correspondence between weighted satisfiability and model-checking
problems for the A-hierarchy and the W^*-hierarchy. Thus we obtain very uniform
characterisations of many of the most important parameterized complexity
classes in both formalisms.
Our results can be used to give new, simple proofs of some of the core
results of structural parameterized complexity theory.Comment: Changes in since v2: Metadata update
Hierarchies of Inefficient Kernelizability
The framework of Bodlaender et al. (ICALP 2008) and Fortnow and Santhanam
(STOC 2008) allows us to exclude the existence of polynomial kernels for a
range of problems under reasonable complexity-theoretical assumptions. However,
there are also some issues that are not addressed by this framework, including
the existence of Turing kernels such as the "kernelization" of Leaf Out
Branching(k) into a disjunction over n instances of size poly(k). Observing
that Turing kernels are preserved by polynomial parametric transformations, we
define a kernelization hardness hierarchy, akin to the M- and W-hierarchy of
ordinary parameterized complexity, by the PPT-closure of problems that seem
likely to be fundamentally hard for efficient Turing kernelization. We find
that several previously considered problems are complete for our fundamental
hardness class, including Min Ones d-SAT(k), Binary NDTM Halting(k), Connected
Vertex Cover(k), and Clique(k log n), the clique problem parameterized by k log
n
- …