608 research outputs found
Verifying Monadic Second-Order Properties of Graph Programs
The core challenge in a Hoare- or Dijkstra-style proof system for graph
programs is in defining a weakest liberal precondition construction with
respect to a rule and a postcondition. Previous work addressing this has
focused on assertion languages for first-order properties, which are unable to
express important global properties of graphs such as acyclicity,
connectedness, or existence of paths. In this paper, we extend the nested graph
conditions of Habel, Pennemann, and Rensink to make them equivalently
expressive to monadic second-order logic on graphs. We present a weakest
liberal precondition construction for these assertions, and demonstrate its use
in verifying non-local correctness specifications of graph programs in the
sense of Habel et al.Comment: Extended version of a paper to appear at ICGT 201
A Logic of Reachable Patterns in Linked Data-Structures
We define a new decidable logic for expressing and checking invariants of
programs that manipulate dynamically-allocated objects via pointers and
destructive pointer updates. The main feature of this logic is the ability to
limit the neighborhood of a node that is reachable via a regular expression
from a designated node. The logic is closed under boolean operations
(entailment, negation) and has a finite model property. The key technical
result is the proof of decidability. We show how to express precondition,
postconditions, and loop invariants for some interesting programs. It is also
possible to express properties such as disjointness of data-structures, and
low-level heap mutations. Moreover, our logic can express properties of
arbitrary data-structures and of an arbitrary number of pointer fields. The
latter provides a way to naturally specify postconditions that relate the
fields on entry to a procedure to the fields on exit. Therefore, it is possible
to use the logic to automatically prove partial correctness of programs
performing low-level heap mutations
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
Transformations of Logic Programs on Infinite Lists
We consider an extension of logic programs, called \omega-programs, that can
be used to define predicates over infinite lists. \omega-programs allow us to
specify properties of the infinite behavior of reactive systems and, in
general, properties of infinite sequences of events. The semantics of
\omega-programs is an extension of the perfect model semantics. We present
variants of the familiar unfold/fold rules which can be used for transforming
\omega-programs. We show that these new rules are correct, that is, their
application preserves the perfect model semantics. Then we outline a general
methodology based on program transformation for verifying properties of
\omega-programs. We demonstrate the power of our transformation-based
verification methodology by proving some properties of Buechi automata and
\omega-regular languages.Comment: 37 pages, including the appendix with proofs. This is an extended
version of a paper published in Theory and Practice of Logic Programming, see
belo
Towards a navigational logic for graphical structures
One of the main advantages of the Logic of Nested Conditions, defined by Habel and Pennemann, for reasoning about graphs, is its generality: this logic can be used in the framework of many classes of graphs and graphical structures. It is enough that the category of these structures satisfies certain basic conditions.
In a previous paper [14], we extended this logic to be able to deal with graph properties including paths, but this extension was only defined for the category of untyped directed graphs. In addition it seemed difficult to talk about paths abstractly, that is, independently of the given category of graphical structures. In this paper we approach this problem. In particular, given an arbitrary category of graphical structures, we assume that for every object of this category there is an associated edge relation that can be used to define a path relation. Moreover, we consider that edges have some kind of labels and paths can be specified by associating them to a set of label sequences. Then, after the presentation of that general framework, we show how it can be applied to several classes of graphs. Moreover, we present a set of sound inference rules for reasoning in the logic.Peer ReviewedPostprint (author's final draft
- …