533 research outputs found
Implementing Theorem Provers in Logic Programming
Logic programming languages have many characteristics that indicate that they should serve as good implementation languages for theorem provers. For example, they are based on search and unification which are also fundamental to theorem proving. We show how an extended logic programming language can be used to implement theorem provers and other aspects of proof systems for a variety of logics. In this language first-order terms are replaced with simply-typed λ-terms, and thus unification becomes higher-order unification. Also, implication and universal quantification are allowed in goals. We illustrate that inference rules can be very naturally specified, and that the primitive search operations of this language correspond to those needed for searching for proofs. We argue on several levels that this extended logic programming language provides a very suitable environment for implementing tactic style theorem provers. Such theorem provers provide extensive capabilities for integrating techniques for automated theorem proving into an interactive proof environment. We are also concerned with representing proofs as objects. We illustrate how such objects can be constructed and manipulated in the logic programming setting. Finally, we propose extensions to tactic style theorem provers in working toward the goal of developing an interactive theorem proving environment that provides a user with many tools and techniques for building and manipulating proofs, and that integrates sophisticated capabilities for automated proof discovery. Many of the theorem provers we present have been implemented in the higher-order logic programming language λProlog
Initial Semantics for higher-order typed syntax in Coq
Initial Semantics aims at characterizing the syntax associated to a signature
as the initial object of some category. We present an initial semantics result
for typed higher-order syntax together with its formalization in the Coq proof
assistant. The main theorem was first proved on paper in the second author's
PhD thesis in 2010, and verified formally shortly afterwards. To a simply-typed
binding signature S over a fixed set T of object types we associate a category
called the category of representations of S. We show that this category has an
initial object Sigma(S). From its construction it will be clear that the object
Sigma(S) merits the name abstract syntax associated to S. Our theorem is
implemented and proved correct in the proof assistant Coq through heavy use of
dependent types. The approach through monads gives rise to an implementation of
syntax where both terms and variables are intrinsically typed, i.e. where the
object types are reflected in the meta-level types. This article is to be seen
as a research article rather than about the formalization of a classical
mathematical result. The nature of our theorem - involving lengthy, technical
proofs and complicated algebraic structures - makes it particularly interesting
for formal verification. Our goal is to promote the use of computer theorem
provers as research tools, and, accordingly, a new way of publishing
mathematical results: a parallel description of a theorem and its formalization
should allow the verification of correct transcription of definitions and
statements into the proof assistant, and straightforward but technical proofs
should be well-hidden in a digital library. We argue that Coq's rich type
theory, combined with its various features such as implicit arguments, allows a
particularly readable formalization and is hence well-suited for communicating
mathematics.Comment: Article as published in JFR (cf. Journal ref). Features some more
example
Extracting proofs from documents
Often, theorem checkers like PVS are used to check an existing proof, which is part of some document. Since there is a large difference between the notations used in the documents and the notations used in the theorem checkers, it is usually a laborious task to convert an existing proof into a format which can be checked by a machine. In the system that we propose, the author is assisted in the process of converting an existing proof into the PVS language and having it checked by PVS. 1 Introduction The now-classic ALGOL 60 report [5] recognized three different levels of language: a reference language, a publication language and several hardware representations, whereby the publication language was intended to admit variations on the reference language and was to be used for stating and communicating processes. The importance of publication language ---often referred to nowadays as "pseudo-code"--- is difficult to exaggerate since a publication language is the most effective way..
Type-Based Termination, Inflationary Fixed-Points, and Mixed Inductive-Coinductive Types
Type systems certify program properties in a compositional way. From a bigger
program one can abstract out a part and certify the properties of the resulting
abstract program by just using the type of the part that was abstracted away.
Termination and productivity are non-trivial yet desired program properties,
and several type systems have been put forward that guarantee termination,
compositionally. These type systems are intimately connected to the definition
of least and greatest fixed-points by ordinal iteration. While most type
systems use conventional iteration, we consider inflationary iteration in this
article. We demonstrate how this leads to a more principled type system, with
recursion based on well-founded induction. The type system has a prototypical
implementation, MiniAgda, and we show in particular how it certifies
productivity of corecursive and mixed recursive-corecursive functions.Comment: In Proceedings FICS 2012, arXiv:1202.317
SPIKE, an automatic theorem prover -- revisited
International audienceSPIKE, an induction-based theorem prover built to reason on conditional theories with equality, is one of the few formal tools able to perform automatically mutual and lazy induction. Designed at the beginning of 1990s, it has been successfully used in many non-trivial applications and served as a prototype for different proof experiments and extensions. The first paper introducing SPIKE is [14], published shortly after the tool was created. The goal of this paper is to highlight and bring together in one spot the major changes supported by SPIKE since then
- …