151,279 research outputs found
Correct Reasoning about Logic Programs
In this PhD project, we present an approach to the problem of determinacy inference in logic programs with cut, which treats cut uniformly and contextually. The overall aim is to develop a theoretical analysis, abstract it to a suitable domain and prove both the concrete analysis and the abstraction correct in a formal theorem prover (Coq). A crucial advantage of this approach, besides the guarantee of correctness, is the possibility of automatically extracting an implementation of the analysis
Nominal Logic Programming
Nominal logic is an extension of first-order logic which provides a simple
foundation for formalizing and reasoning about abstract syntax modulo
consistent renaming of bound names (that is, alpha-equivalence). This article
investigates logic programming based on nominal logic. We describe some typical
nominal logic programs, and develop the model-theoretic, proof-theoretic, and
operational semantics of such programs. Besides being of interest for ensuring
the correct behavior of implementations, these results provide a rigorous
foundation for techniques for analysis and reasoning about nominal logic
programs, as we illustrate via examples.Comment: 46 pages; 19 page appendix; 13 figures. Revised journal submission as
of July 23, 200
Multi-agent Confidential Abductive Reasoning
In the context of multi-agent hypothetical reasoning, agents typically have partial knowledge about their environments, and the union of such knowledge is still incomplete to represent the whole world. Thus, given a global query they collaborate with each other to make correct inferences and hypothesis, whilst maintaining global constraints. Most collaborative reasoning systems operate on the assumption that agents can share or communicate any information they have. However, in application domains like multi-agent systems for healthcare or distributed software agents for security policies in coalition networks, confidentiality of knowledge is an additional
primary concern. These agents are required to collaborately compute consistent answers for a query whilst preserving their own private information. This paper addresses this issue showing how this dichotomy between "open communication" in collaborative reasoning and protection of confidentiality can be accommodated. We present a general-purpose distributed abductive logic programming system for multi-agent hypothetical reasoning with confidentiality. Specifically, the system computes consistent conditional answers for a query over a set of distributed normal logic programs with possibly unbound domains and arithmetic constraints, preserving the private information within the logic programs. A case study on security policy analysis in distributed coalition networks is described, as an example of many applications of this system
Proofs as stateful programs: A first-order logic with abstract Hoare triples, and an interpretation into an imperative language
We introduce an extension of first-order logic that comes equipped with
additional predicates for reasoning about an abstract state. Sequents in the
logic comprise a main formula together with pre- and postconditions in the
style of Hoare logic, and the axioms and rules of the logic ensure that the
assertions about the state compose in the correct way. The main result of the
paper is a realizability interpretation of our logic that extracts programs
into a mixed functional/imperative language. All programs expressible in this
language act on the state in a sequential manner, and we make this intuition
precise by interpreting them in a semantic metatheory using the state monad.
Our basic framework is very general, and our intention is that it can be
instantiated and extended in a variety of different ways. We outline in detail
one such extension: A monadic version of Heyting arithmetic with a wellfounded
while rule, and conclude by outlining several other directions for future work.Comment: 29 page
An Implementation of Separation Logic in Coq
For certain applications, the correctness of software involved is crucial, particularly if
human life is in danger. In order to achieve correctness, common practice is to gather
evidence for program correctness by testing the system. Even though testing may find
certain errors in the code, it cannot guarantee that the program is error-free. The program
of formal verification is the act of proving or disproving the correctness of the system with
respect to a formal specification. A logic for program verification is the so-called Hoare
Logic. Hoare Logic can deal with programs that do not utilize pointers, i.e., it allows
reasoning about programs that do not use shared mutable data structures. Separation Logic
extends Hoare logic that allows pointers, including pointer arithmetic, in the programming
language. It has four-pointer manipulating commands which perform the heap operations
such as lookup, allocation, deallocation, and mutation. We introduce an implementation of
separation logic in the interactive proof system Coq. Besides verifying that separation logic
is correct, we will provide several examples of programs and their correctness proof
Fred:An Approach to Generating Real, Correct, Reusable Programs from Proofs
In this paper we describe our system for automatically extracting "correct" programs from proofs using a development of the Curry-Howard process. Although program extraction has been developed by many authors (see, for example, [HN88], [Con97] and [HKPM97]), our system has a number of novel features designed to make it very easy to use and as close as possible to ordinary mathematical terminology and practice. These features include 1. the use of Henkin's technique [Hen50] to reduce higher-order logic to many-sorted (first-order) logic; 2. the free use of new rules for induction subject to certain conditions; 3. the extensive use of previously programmed (total, recursive) functions; 4. the use of templates to make the reasoning much closer to normal mathematical proofs and 5. a conceptual distinction between the computational type theory (for representing programs) and the logical type theory (for reasoning about programs). As an example of our system we give a constructive proof of the well known theorem that every graph of even parity, which is non-trivial in the sense that it does not consist of isolated vertices, has a cycle. Given such a graph as input, the extracted program produces a cycle as promised
- …