22 research outputs found
A framework for proof certificates in finite state exploration
Model checkers use automated state exploration in order to prove various
properties such as reachability, non-reachability, and bisimulation over state
transition systems. While model checkers have proved valuable for locating
errors in computer models and specifications, they can also be used to prove
properties that might be consumed by other computational logic systems, such as
theorem provers. In such a situation, a prover must be able to trust that the
model checker is correct. Instead of attempting to prove the correctness of a
model checker, we ask that it outputs its "proof evidence" as a formally
defined document--a proof certificate--and that this document is checked by a
trusted proof checker. We describe a framework for defining and checking proof
certificates for a range of model checking problems. The core of this framework
is a (focused) proof system that is augmented with premises that involve "clerk
and expert" predicates. This framework is designed so that soundness can be
guaranteed independently of any concerns for the correctness of the clerk and
expert specifications. To illustrate the flexibility of this framework, we
define and formally check proof certificates for reachability and
non-reachability in graphs, as well as bisimulation and non-bisimulation for
labeled transition systems. Finally, we describe briefly a reference checker
that we have implemented for this framework.Comment: In Proceedings PxTP 2015, arXiv:1507.0837
Relating Nominal and Higher-order Abstract Syntax Specifications
Nominal abstract syntax and higher-order abstract syntax provide a means for
describing binding structure which is higher-level than traditional techniques.
These approaches have spawned two different communities which have developed
along similar lines but with subtle differences that make them difficult to
relate. The nominal abstract syntax community has devices like names,
freshness, name-abstractions with variable capture, and the new-quantifier,
whereas the higher-order abstract syntax community has devices like
lambda-binders, lambda-conversion, raising, and the nabla-quantifier. This
paper aims to unify these communities and provide a concrete correspondence
between their different devices. In particular, we develop a
semantics-preserving translation from alpha-Prolog, a nominal abstract syntax
based logic programming language, to G-, a higher-order abstract syntax based
logic programming language. We also discuss higher-order judgments, a common
and powerful tool for specifications with higher-order abstract syntax, and we
show how these can be incorporated into G-. This establishes G- as a language
with the power of higher-order abstract syntax, the fine-grained variable
control of nominal specifications, and the desirable properties of higher-order
judgments.Comment: To appear in PPDP 201
Constructive Provability Logic
We present constructive provability logic, an intuitionstic modal logic that
validates the L\"ob rule of G\"odel and L\"ob's provability logic by permitting
logical reflection over provability. Two distinct variants of this logic, CPL
and CPL*, are presented in natural deduction and sequent calculus forms which
are then shown to be equivalent. In addition, we discuss the use of
constructive provability logic to justify stratified negation in logic
programming within an intuitionstic and structural proof theory.Comment: Extended version of IMLA 2011 submission of the same titl
On the Expressivity of Minimal Generic Quantification
AbstractWe come back to the initial design of the ∇ quantifier by Miller and Tiu, which we call minimal generic quantification. In the absence of fixed points, it is equivalent to seemingly stronger designs. However, several expected theorems about (co)inductive specifications can not be derived in that setting. We present a refinement of minimal generic quantification that brings the expected expressivity while keeping the minimal semantic, which we claim is useful to get natural adequate specifications. We build on the idea that generic quantification is not a logical connective but one that is defined, like negation in classical logics. This allows us to use the standard (co)induction rule, but obtain much more expressivity than before. We show classes of theorems that can now be derived in the logic, and present a few practical examples
Property-Based Testing via Proof Reconstruction Work-in-progress
International audienceProperty-based testing is a technique for validating code against an executable specification by automatically generating test-data. From its original use in programming languages, this technique has now spread to most major proof assistants to complement theorem proving with a preliminary phase of conjecture testing. We present a proof theoretical reconstruction of this style of testing for relational specifications (such as those used in the semantics of programming languages) and employ the Foundational Proof Certificate framework to aid in describing test generators. We do this by presenting certain kinds of " proof outlines " that can be used to describe the shape and size of the generators for the conditional part of a proposed property. Then the testing phase is reduced to standard logic programming search. After illustrating our techniques on simple, first-order (algebraic) data structures, we lift it to data structures containing bindings using λ-tree syntax. The λProlog programming language is capable of performing both the generation and checking of tests. We validate this approach by tackling benchmarks in the metatheory of programming languages coming from related tools such as PLT-Redex
Formalizing Operational Semantic Specifications in Logic
AbstractWe review links between three logic formalisms and three approaches to specifying operational semantics. In particular, we show that specifications written with (small-step and big-step) SOS, abstract machines, and multiset rewriting, are closely related to Horn clauses, binary clauses, and (a subset of) linear logic, respectively. We shall illustrate how binary clauses form a bridge between the other two logical formalisms. For example, using a continuation-passing style transformation, Horn clauses can be transformed into binary clauses. Furthermore, binary clauses can be seen as a degenerative form of multiset rewriting: placing binary clauses within linear logic allows for rich forms of multiset rewriting which, in turn, provides a modular, big-step SOS specifications of imperative and concurrency primitives. Establishing these links between logic and operational semantics has many advantages for operational semantics: tools from automated deduction can be used to animate semantic specifications; solutions to the treatment of binding structures in logic can be used to provide solutions to binding in the syntax of programs; and the declarative nature of logical specifications provides broad avenues for reasoning about semantic specifications