384,641 research outputs found
Covering and separation for logical fragments with modular predicates
For every class of word languages, one may associate a decision
problem called -separation. Given two regular languages, it asks
whether there exists a third language in containing the first
language, while being disjoint from the second one. Usually, finding an
algorithm deciding -separation yields a deep insight on
.
We consider classes defined by fragments of first-order logic. Given such a
fragment, one may often build a larger class by adding more predicates to its
signature. In the paper, we investigate the operation of enriching signatures
with modular predicates. Our main theorem is a generic transfer result for this
construction. Informally, we show that when a logical fragment is equipped with
a signature containing the successor predicate, separation for the stronger
logic enriched with modular predicates reduces to separation for the original
logic. This result actually applies to a more general decision problem, called
the covering problem
Automating Deductive Verification for Weak-Memory Programs
Writing correct programs for weak memory models such as the C11 memory model
is challenging because of the weak consistency guarantees these models provide.
The first program logics for the verification of such programs have recently
been proposed, but their usage has been limited thus far to manual proofs.
Automating proofs in these logics via first-order solvers is non-trivial, due
to reasoning features such as higher-order assertions, modalities and rich
permission resources. In this paper, we provide the first implementation of a
weak memory program logic using existing deductive verification tools. We
tackle three recent program logics: Relaxed Separation Logic and two forms of
Fenced Separation Logic, and show how these can be encoded using the Viper
verification infrastructure. In doing so, we illustrate several novel encoding
techniques which could be employed for other logics. Our work is implemented,
and has been evaluated on examples from existing papers as well as the Facebook
open-source Folly library.Comment: Extended version of TACAS 2018 publicatio
Program Verification with Separation Logic
International audienceSeparation Logic is a framework for the development of modular program analyses for sequential, inter-procedural and concurrent programs. The first part of the paper introduces Separation Logic first from a historical, then from a program verification perspective. Because program verification eventually boils down to deciding logical queries such as the validity of verification conditions, the second part is dedicated to a survey of decision procedures for Separation Logic, that stem from either SMT, proof theory or automata theory. Incidentally we address issues related to decidability and computational complexity of such problems, in order to expose certain sources of intractability
Separating regular languages with two quantifier alternations
We investigate a famous decision problem in automata theory: separation.
Given a class of language C, the separation problem for C takes as input two
regular languages and asks whether there exists a third one which belongs to C,
includes the first one and is disjoint from the second. Typically, obtaining an
algorithm for separation yields a deep understanding of the investigated class
C. This explains why a lot of effort has been devoted to finding algorithms for
the most prominent classes.
Here, we are interested in classes within concatenation hierarchies. Such
hierarchies are built using a generic construction process: one starts from an
initial class called the basis and builds new levels by applying generic
operations. The most famous one, the dot-depth hierarchy of Brzozowski and
Cohen, classifies the languages definable in first-order logic. Moreover, it
was shown by Thomas that it corresponds to the quantifier alternation hierarchy
of first-order logic: each level in the dot-depth corresponds to the languages
that can be defined with a prescribed number of quantifier blocks. Finding
separation algorithms for all levels in this hierarchy is among the most famous
open problems in automata theory.
Our main theorem is generic: we show that separation is decidable for the
level 3/2 of any concatenation hierarchy whose basis is finite. Furthermore, in
the special case of the dot-depth, we push this result to the level 5/2. In
logical terms, this solves separation for : first-order sentences
having at most three quantifier blocks starting with an existential one
The Effects of Adding Reachability Predicates in Propositional Separation Logic
International audienceThe list segment predicate ls used in separation logic for verifying programs with pointers is well-suited to express properties on singly-linked lists. We study the effects of adding ls to the full proposi-tional separation logic with the separating conjunction and implication, which is motivated by the recent design of new fragments in which all these ingredients are used indifferently and verification tools start to handle the magic wand connective. This is a very natural extension that has not been studied so far. We show that the restriction without the separating implication can be solved in polynomial space by using an appropriate abstraction for memory states whereas the full extension is shown undecidable by reduction from first-order separation logic. Many variants of the logic and fragments are also investigated from the computational point of view when ls is added, providing numerous results about adding reachability predicates to propositional separation logic
Completeness for a First-order Abstract Separation Logic
Existing work on theorem proving for the assertion language of separation
logic (SL) either focuses on abstract semantics which are not readily available
in most applications of program verification, or on concrete models for which
completeness is not possible. An important element in concrete SL is the
points-to predicate which denotes a singleton heap. SL with the points-to
predicate has been shown to be non-recursively enumerable. In this paper, we
develop a first-order SL, called FOASL, with an abstracted version of the
points-to predicate. We prove that FOASL is sound and complete with respect to
an abstract semantics, of which the standard SL semantics is an instance. We
also show that some reasoning principles involving the points-to predicate can
be approximated as FOASL theories, thus allowing our logic to be used for
reasoning about concrete program verification problems. We give some example
theories that are sound with respect to different variants of separation logics
from the literature, including those that are incompatible with Reynolds's
semantics. In the experiment we demonstrate our FOASL based theorem prover
which is able to handle a large fragment of separation logic with heap
semantics as well as non-standard semantics.Comment: This is an extended version of the APLAS 2016 paper with the same
titl
Applicative matching logic
This paper proposes a logic for programming languages, which is both simple and expressive, to serve as a foundation for language semantics frameworks. Matching mu-logic has been recently proposed as a unifying foundation for programming languages, specification and verification. It has been shown to capture several logics important for programming languages, including first-order logic with least fixpoints, separation logic, temporal logics, modal mu-logic, and importantly, reachability logic, a language-independent logic for program verification that subsumes Hoare
logic. This paper identifies a fragment of matching mu-logic called applicative matching logic (AML), which is much simpler and thus more appealing from a foundational perspective, yet as expressive as matching mu-logic. Several additional logical frameworks fundamental for programming languages are shown to be faithfully captured by AML,
including many- and order-sorted algebras, lambda-calculus, (dependent) type systems, evaluation contexts, and rewriting. Finally, it is shown how all these make AML an appropriate underlying logic foundation for complex language semantics frameworks, such as K.Ope
The Complexity of Prenex Separation Logic with One Selector
We first show that infinite satisfiability can be reduced to finite
satisfiability for all prenex formulas of Separation Logic with
selector fields (\seplogk{k}). Second, we show that this entails the
decidability of the finite and infinite satisfiability problem for the class of
prenex formulas of \seplogk{1}, by reduction to the first-order theory of one
unary function symbol and unary predicate symbols. We also prove that the
complexity is not elementary, by reduction from the first-order theory of one
unary function symbol. Finally, we prove that the Bernays-Sch\"onfinkel-Ramsey
fragment of prenex \seplogk{1} formulae with quantifier prefix in the
language is \pspace-complete. The definition of a complete
(hierarchical) classification of the complexity of prenex \seplogk{1},
according to the quantifier alternation depth is left as an open problem
- …