6,300 research outputs found
Invariant Synthesis for Incomplete Verification Engines
We propose a framework for synthesizing inductive invariants for incomplete
verification engines, which soundly reduce logical problems in undecidable
theories to decidable theories. Our framework is based on the counter-example
guided inductive synthesis principle (CEGIS) and allows verification engines to
communicate non-provability information to guide invariant synthesis. We show
precisely how the verification engine can compute such non-provability
information and how to build effective learning algorithms when invariants are
expressed as Boolean combinations of a fixed set of predicates. Moreover, we
evaluate our framework in two verification settings, one in which verification
engines need to handle quantified formulas and one in which verification
engines have to reason about heap properties expressed in an expressive but
undecidable separation logic. Our experiments show that our invariant synthesis
framework based on non-provability information can both effectively synthesize
inductive invariants and adequately strengthen contracts across a large suite
of programs
Predicate Abstraction with Indexed Predicates
Predicate abstraction provides a powerful tool for verifying properties of
infinite-state systems using a combination of a decision procedure for a subset
of first-order logic and symbolic methods originally developed for finite-state
model checking. We consider models containing first-order state variables,
where the system state includes mutable functions and predicates. Such a model
can describe systems containing arbitrarily large memories, buffers, and arrays
of identical processes. We describe a form of predicate abstraction that
constructs a formula over a set of universally quantified variables to describe
invariant properties of the first-order state variables. We provide a formal
justification of the soundness of our approach and describe how it has been
used to verify several hardware and software designs, including a
directory-based cache coherence protocol.Comment: 27 pages, 4 figures, 1 table, short version appeared in International
Conference on Verification, Model Checking and Abstract Interpretation
(VMCAI'04), LNCS 2937, pages = 267--28
A Polynomial Translation of Logic Programs with Nested Expressions into Disjunctive Logic Programs: Preliminary Report
Nested logic programs have recently been introduced in order to allow for
arbitrarily nested formulas in the heads and the bodies of logic program rules
under the answer sets semantics. Nested expressions can be formed using
conjunction, disjunction, as well as the negation as failure operator in an
unrestricted fashion. This provides a very flexible and compact framework for
knowledge representation and reasoning. Previous results show that nested logic
programs can be transformed into standard (unnested) disjunctive logic programs
in an elementary way, applying the negation as failure operator to body
literals only. This is of great practical relevance since it allows us to
evaluate nested logic programs by means of off-the-shelf disjunctive logic
programming systems, like DLV. However, it turns out that this straightforward
transformation results in an exponential blow-up in the worst-case, despite the
fact that complexity results indicate that there is a polynomial translation
among both formalisms. In this paper, we take up this challenge and provide a
polynomial translation of logic programs with nested expressions into
disjunctive logic programs. Moreover, we show that this translation is modular
and (strongly) faithful. We have implemented both the straightforward as well
as our advanced transformation; the resulting compiler serves as a front-end to
DLV and is publicly available on the Web.Comment: 10 pages; published in Proceedings of the 9th International Workshop
on Non-Monotonic Reasonin
Recommended from our members
A prototype implementation of the AUnit test automation framework for alloy
Alloy is a declarative language based on relational first-order logic. Unlike commonly used procedural languages, the testing criteria of declarative languages like Alloy has remained largely ad hoc. Recent work on the AUnit test automation framework introduced a foundation for testing Alloy models. This report presents our effort on developing a prototype implementation of AUnit based on the standard Alloy distribution. Our implementation of AUnit has all core functionalities for writing unit tests, running all tests, showing the test execution results including the number of tests ran, the number of tests failed, coverage obtained (which is highlighted using coloring), all test requirements, and all uncovered requirements. We compute coverage for signatures, fields, predicates and specifically for primitive Booleans and quantified formulas. Our implementation can allow users to check the quality of their models in the spirit of traditional unit testing.Electrical and Computer Engineerin
On the Succinctness of Query Rewriting over OWL 2 QL Ontologies with Shallow Chases
We investigate the size of first-order rewritings of conjunctive queries over
OWL 2 QL ontologies of depth 1 and 2 by means of hypergraph programs computing
Boolean functions. Both positive and negative results are obtained. Conjunctive
queries over ontologies of depth 1 have polynomial-size nonrecursive datalog
rewritings; tree-shaped queries have polynomial positive existential
rewritings; however, in the worst case, positive existential rewritings can
only be of superpolynomial size. Positive existential and nonrecursive datalog
rewritings of queries over ontologies of depth 2 suffer an exponential blowup
in the worst case, while first-order rewritings are superpolynomial unless
. We also analyse rewritings of
tree-shaped queries over arbitrary ontologies and observe that the query
entailment problem for such queries is fixed-parameter tractable
On QBF Proofs and Preprocessing
QBFs (quantified boolean formulas), which are a superset of propositional
formulas, provide a canonical representation for PSPACE problems. To overcome
the inherent complexity of QBF, significant effort has been invested in
developing QBF solvers as well as the underlying proof systems. At the same
time, formula preprocessing is crucial for the application of QBF solvers. This
paper focuses on a missing link in currently-available technology: How to
obtain a certificate (e.g. proof) for a formula that had been preprocessed
before it was given to a solver? The paper targets a suite of commonly-used
preprocessing techniques and shows how to reconstruct certificates for them. On
the negative side, the paper discusses certain limitations of the
currently-used proof systems in the light of preprocessing. The presented
techniques were implemented and evaluated in the state-of-the-art QBF
preprocessor bloqqer.Comment: LPAR 201
The Vampire and the FOOL
This paper presents new features recently implemented in the theorem prover
Vampire, namely support for first-order logic with a first class boolean sort
(FOOL) and polymorphic arrays. In addition to having a first class boolean
sort, FOOL also contains if-then-else and let-in expressions. We argue that
presented extensions facilitate reasoning-based program analysis, both by
increasing the expressivity of first-order reasoners and by gains in
efficiency
- …