Fault-Tolerant Distributed Theorem Proving (original) (raw)

Fast Tactic-Based Theorem Proving

Lecture Notes in Computer Science, 2000

Theorem provers for higher-order logics often use tactics to implement automated proof search. Tactics use a general-purpose metalanguage to implement both general-purpose reasoning and computationally intensive domain-specific proof procedures. The generality of tactic provers has a performance penalty; the speed of proof search lags far behind special-purpose provers. We present a new modular proving architecture that significantly increases the speed of the core logic engine. Our speedup is due to efficient data structures and modularity, which allows parts of the prover to be customized on a domain-specific basis. Our architecture is used in the MetaPRL logical framework, with speedups of more than two orders of magnitude over traditional tactic-based proof search.

Progress in the Development of Automated Theorem Proving for Higher-Order Logic

Lecture Notes in Computer Science, 2009

The Thousands of Problems for Theorem Provers (TPTP) problem library is the basis of a well established infrastructure supporting research, development, and deployment of first-order Automated Theorem Proving (ATP) systems. Recently, the TPTP has been extended to include problems in higher-order logic, with corresponding infrastructure and resources. This paper describes the practical progress that has been made towards the goal of TPTP support for higher-order ATP systems.

PM: A Proof Manager For HOL And Other Provers

1991., International Workshop on the HOL Theorem Proving System and Its Applications, 1991

Different theorem-proving systems have different things to recommend them: automatic proiiers such as the Boyer-Moore prover or a number of resolution systems minimize human intervention in proving simple first-order assertions, but systems such as HOL or. Nuprl that are based on a more powerful logic better support reasoning about higher abstractions. In typical verification systems, a verifier is limited to the choice of a single theorem-prover. The proof manager PM is intended to allow a verifier t o choose among several theorem-proving systems during the course of a single proof. We report on its current status as a HOL interface, and our initial design of a translation scheme that, when possible, transforms HOL input into firstorder assertions suited to the Boyer-Moore prover or automatic first-order provers. 286 0-8186-2460-4D2 $03.00 Q 1992 IEEE

A Verified Theorem Prover Backend Supported by a Monotonic Library

Building a verified proof assistant entails implementing and mechanizing the concept of a library, as well as adding support for standard manipulations on it. In this work we develop such mechanism for the Nuprl proof assistant, and integrate it into the formalization of Nuprl's meta-theory in Coq. We formally verify that standard operations on the library preserve its validity. This is a key property for any interactive theorem prover, since it ensures consistency. Some unique features of Nuprl, such as the presence of undefined abstractions, make the proof of this property nontrivial. Thus, e.g., to achieve monotonicity the semantics of sequents had to be refined. On a broader view, this work provides a backend for a verified version of Nuprl. We use it, in turn, to develop a tool that converts proofs exported from the Nuprl proof assistant into proofs in the Coq formalization of Nuprl's meta-theory, so as to be verified.

SNAP: A Validator/Annotator for Proofs of Distributed Programs

Distributed programs are notorious for subtle errors, requiring proofs to establish their correctness. Correctness proofs carried out on paper tend to be error-prone. This paper presents system Snap Simple Notion of Annotating Proofs being developed to validate correctness proofs in Linear Time Temporal Logic LTL. Snap supports forward p r oofs and can be used either interactively or in batch mode. The system validates proofs entered by users | in a representation close to handwritten proofs | by providing justi cations for every proof step. Justi cations are in essence theorems or meta rules in the system's rule-base; together with the proof, they constitute a proof annotation. Theorems proved elsewhere may be loaded into the system's rule-base without having to redo proofs, a mechanism to raise the abstraction level of proofs. Snap supports proofs of theorems and certain meta rules, all of which m a y be dynamically added to its rule-base. Since the design goal of Snap is to validate and annotate correctness proofs of programs, we h a ve sacri ced generality for e ciency and ease of use. For example, the system does not support higher-order logics.

Ω-MKRP: A proof development environment

Lecture Notes in Computer Science, 1994

This report presents the main ideas underlying the {mkrp-system, an environment for the development of mathematical proofs. The motivation for the development of this system comes from our extensive experience with traditional rst-order theorem provers and aims to overcome some of their shortcomings. After comparing the bene ts and drawbacks of existing systems, we propose a system architecture that combines the positive features of di erent types of theorem-proving systems, most notably the advantages of human-oriented systems based on methods (our version of tactics) and the deductive strength of traditional automated theorem provers. In {mkrp a user rst states a problem to be solved in a typed and sorted higherorder language (called POST) and then applies natural deduction inference rules in order to prove it. He can also insert a mathematical fact from an integrated database into the current partial proof, he can apply a domain-speci c problem-solving method, or he can call an integrated automated theorem prover to solve a subproblem. The user can also pass the control to a planning component that supports and partially automates his long-range planning of a proof. Toward the important goal of user-friendliness, machine-generated proofs are transformed in several steps into much shorter, better-structured proofs that are nally translated into natural language.

ACT-P: A configurable theorem-prover

Data & Knowledge Engineering, 1994

There has been a considerable amount of research into the provision of explicit representation of control regimes for resolution-based theorem provers. However, most of the existing systems are either not adequate in that they do not allow the user to express any arbitrary control regime, or are too inefficient to be of practical use. In this paper a theorem prover, ACT-P, which is adequate but retains satisfactory efficiency is presented. It does so by providing a number of user-changeable heuristics which are called at specific points during the search for a proof. The set of user-changeable heuristics was determined on the basis of a classification of the heuristics used by existing resolution-based theorem provers.

A Proof System for Communicating Sequential Processes

ACM Transactions on Programming Languages and Systems, 1980

An axiomatic proof system is presented for proving partial correctness and absence of deadlock (and failure) of communicating sequential processes. The key (meta) rule introduces cooperation between proofs, a new concept needed to deal with proofs about synchronization by message passing. CSP's new convention for distributed termination of loops is dealt with. Applications of the method involve correctness proofs for two algorithms, one for distributed partitioning of sets, the other for distributed computation of the greatest common divisor of n numbers.

Implementing extensible theorem provers

1999

The growing application of theorem proving techniques has increased the need for customized theorem provers. Powerful provers contain numerous interacting subsystems, each o f w h i c h requires substantial time and expertise to build constructing new provers from scratch i s v i rtually prohibitive. Plug-and-play p r o ver frameworks promise an alternative in which developers can construct provers by selecting logics, reasoning techniques, and interfaces. Realizing such frameworks cleanly requires specialized software architectures and particular language abstractions, even for frameworks supporting only simple interactions between logics. This paper explores architectural and linguistic issues in plug-and-play theorem prover development. It re ects our experience creating and using such a framewo r k t o d e v elop several versions of a research prototype theorem prover.