Theorem Prover For First-order Logic Research Articles

A Novel Combinational ATP Based on Contradiction Separation for First-Order Logic

At present, most of the first-order logic theorem provers use a binary-resolution method, which can effectively solve the general first-order logic problems to a certain extent. However, the cooperative processing ability of this method for multiple clauses is insufficient, and it is easy to cause rapid expansion of clause set in the deductive process. In this paper, we propose a novel first-order logic theorem prover based on the standard contradiction separation (S-CS) rule. This prover can realize the dynamic cooperative deduction of multiple clauses in each deduction process, as well as it can effectively learn and control the deduction process. This paper incorporates the S-CS rule with the well-known prover Prover9, to build a combined system, which effectively integrates the advantages of the two methods, not only improves the binary-resolution prover’s ability, but also solves more than 100 problems that cannot be solved by other provers.

CSE_E 1.0: An Integrated Automated Theorem Prover for First-Order Logic

First-order logic is an important part of mathematical logic, and automated theorem proving is an interdisciplinary field of mathematics and computer science. The paper presents an automated theorem prover for first-order logic, called C S E _ E 1.0, which is a combination of two provers contradiction separation extension (CSE) and E, where CSE is based on the recently-introduced multi-clause standard contradiction separation (S-CS) calculus for first-order logic and E is the well-known equational theorem prover for first-order logic based on superposition and rewriting. The motivation of the combined prover C S E _ E 1.0 is to (1) evaluate the capability, applicability and generality of C S E _ E , and (2) take advantage of novel multi-clause S-CS dynamic deduction of CSE and mature equality handling of E to solve more and harder problems. In contrast to other improvements of E, C S E _ E 1.0 optimizes E mainly from the inference mechanism aspect. The focus of the present work is given to the description of C S E _ E including its S-CS rule, heuristic strategies, and the S-CS dynamic deduction algorithm for implementation. In terms of combination, in order not to lose the capability of E and use C S E _ E to solve some hard problems which are unsolved by E, C S E _ E 1.0 schedules the running of the two provers in time. It runs plain E first, and if E does not find a proof, it runs plain CSE, then if it does not find a proof, some clauses inferred in the CSE run as lemmas are added to the original clause set and the combined clause set handed back to E for further proof search. C S E _ E 1.0 is evaluated through benchmarks, e.g., CASC-26 (2017) and CASC-J9 (2018) competition problems (FOFdivision). Experimental results show that C S E _ E 1.0 indeed enhances the performance of E to a certain extent.

HALO

Even well-typed programs can go wrong in modern functional languages, by encountering a pattern-match failure, or simply returning the wrong answer. An increasingly-popular response is to allow programmers to write contracts that express semantic properties, such as crash-freedom or some useful post-condition. We study the static verification of such contracts. Our main contribution is a novel translation to first-order logic of both Haskell programs, and contracts written in Haskell, all justified by denotational semantics. This translation enables us to prove that functions satisfy their contracts using an off-the-shelf first-order logic theorem prover.

First-Order Logic Reasoning Support for the Semantic Web

This paper investigates reasoning support for the semantic Web based on the first-order logic. The key reasoning tasks of the semantic Web can be reduced to deciding the satisfiability of formulas. The first-order logic theorem prover is efficient and complete for unsatisfiability, while finite model searcher finds models for satisfiable formula. This paper proposes to use a theorem prover and a finite model searcher concurrently in the semantic Web reasoning. The experiments show that the method can make up the deficiencies of the description logic reasoner and complement the theorem prover for satisfiable formulas.

Automated Security Verification for Crypto Protocol Implementations: Verifying the Jessie Project

An important missing link in the construction of secure systems is finding a practical way to establish a correspondence between a software specification and its implementation. We address this problem for the case of crypto-based Java implementations (such as crypto protocols) with an approach using automated theorem provers for first-order logic, by linking the implementation to a specification model. In this paper, we present details on an application of this approach to the open-source Java implementation Jessie of the SSL protocol. We also shortly comment on how these results can be transferred to the standard Java Secure Sockets Extension (JSSE) library that was recently open-sourced by Sun.

The axiomatic translation principle for modal logic

In this paper we present a translation principle, called the axiomatic translation , for reducing propositional modal logics with background theories, including triangular properties such as transitivity, Euclideanness and functionality, to decidable fragments of first-order logic. The goal of the axiomatic translation principle is to find simplified theories, which capture the inference problems in the original theory, but in a way that can be readily automated and is easier to deal with by existing (first-order) theorem provers than the standard translation. The principle of the axiomatic translation is conceptually very simple and can be almost completely automated. Soundness is automatic under reasonable assumptions, general decidability results can be stated and termination of ordered resolution is easily achieved. The non-trivial part of the approach is proving completeness. We prove results of completeness, decidability, model generation, the small model property and the interpolation property for a number of common and less common modal logics. We also present results of experiments with a number of first-order logic theorem provers which are very encouraging.

Applying automated deduction to natural language understanding

Very few natural language understanding applications employ methods from automated deduction. This is mainly because (i) a high level of interdisciplinary knowledge is required, (ii) there is a huge gap between formal semantic theory and practical implementation, and (iii) statistical rather than symbolic approaches dominate the current trends in natural language processing. Moreover, abduction rather than deduction is generally viewed as a promising way to apply reasoning in natural language understanding. We describe three applications where we show how first-order theorem proving and finite model construction can efficiently be employed in language understanding. The first is a text understanding system building semantic representations of texts, developed in the late 1990s. Theorem provers are here used to signal inconsistent interpretations and to check whether new contributions to the discourse are informative or not. This application shows that it is feasible to use general-purpose theorem provers for first-order logic, and that it pays off to use a battery of different inference engines as in practice they complement each other in terms of performance. The second application is a spoken-dialogue interface to a mobile robot and an automated home. We use the first-order theorem prover spass for checking inconsistencies and newness of information, but the inference tasks are complemented with the finite model builder mace used in parallel to the prover. The model builder is used to check for satisfiability of the input; in addition, the produced finite and minimal models are used to determine the actions that the robot or automated house has to execute. When the semantic representation of the dialogue as well as the number of objects in the context are kept fairly small, response times are acceptable to human users. The third demonstration of successful use of first-order inference engines comes from the task of recognising entailment between two (short) texts. We run a robust parser producing semantic representations for both texts, and use the theorem prover vampire to check whether one text entails the other. For many examples it is hard to compute the appropriate background knowledge in order to produce a proof, and the model builders mace and paradox are used to estimate the likelihood of an entailment.

Living Book ? Deduction, Slicing, and Interaction

Living Book is a system for the management of personalized and scenario-specific teaching material. The main goal of the system is to support active, explorative, and self-determined learning in lectures, tutorials, and self-study. Living Book includes a course on "logic for computer scientists," with uniform access to various tools such as theorem provers and an interactive tableau editor. It is routinely used in teaching undergraduate courses at our university. This paper describes Living Book, together with its use of theorem-proving technology as a core component in the knowledge management system (KMS) and the use of this new concept in academic teaching. The KMS provides a scenario management component in which teachers may describe those parts of given documents that are relevant in order to achieve a certain learning goal. The task of the KMS is to assemble new documents from a database of elementary units called "slices" (definitions, theorems, and so on) in a scenario-based way (such as, "I want to prepare for an exam and need to learn about resolution"). The computation of such assemblies is carried out by a model-generating theorem prover for first-order logic with a default negation principle. Its input consists of metadata that describes the dependencies between different slices and logic-programming style rules that describe the scenario-specific composition of slices. Additionally, users may assess what units they know or don't know. This information is stored in a user model, which is taken into account to compute a model that specifies the assembly of a personalized document. This paper introduces the e-learning context we are faced with, motivates our choice of logic, and sketches the newly developed calculus used in the KMS. Furthermore, the application and evaluation of Living Book are presented.

The design and implementation of VAMPIRE

In this article we describe VAMPIRE: a high-performance theorem prover for first-order logic. As our description is mostly targeted to the developers of such systems and specialists in automated re...

Theorem proving for untyped constructive -calculus: implementation and application

This paper presents a theorem prover for a highly intensional logic, namely a constructive version of property theory [25] (this language essentially provides a combination of constructive first-order logic and the λ-calculus). The paper presents the basic theorem prover, which is a higher-order extension of Manthey and Bry's model generation theorem prover for first-order logic [14]; considers issues relating to the compile-time optimisations that are often used with first-order theorem provers; and shows how the resulting system can be used in a natural language understanding system.

Parallelization of a Hyper-Linking–Based Theorem Prover

We describe the parallelization of a first-order logic theorem prover that is based on the hyper-linking proof procedure (HLPP). Four parallel schemes – process level, clause level, literal level, and flow level – are developed for two types of sequential implementation of HLPP: list based and network based. The motivation for developing each parallel scheme is presented, and the architecture and implementation details of each scheme are described. Issues about parallel processing, such as serialization and synchronization, load balancing, and access conflicts, are examined. Speedups over sequential implementations are attained, and timing results for benchmark problems are provided.

Goals and Benchmarks for Automated Map Reasoning

Tarski–Givant’s map calculus is briefly reviewed, and a plan of research is outlined aimed at investigating applications of this ground equational formalism in the theorem-proving field. The main goal is to create synergy between first-order predicate calculus and the map calculus. Techniques for translating isolated sentences, as well as entire theories, from first-order logic into map calculus are designed, or in some cases simply brought nearer through the exercise of specifying properties of a few familiar structures (natural numbers, nested lists, finite sets, lattices). It is also highlighted to what extent a state-of-the-art theorem-prover for first-order logic, namely Otter, can be exploited not only to emulate, but also to reason about, map calculus. Issues regarding “safe" forms of map reasoning are singled out, in sight of possible generalizations to the database area.

Rule-based induction

Induction is indispensable for reasoning about parameterized logical models, as they arise in the context of hardware and software verification. Sophisticated heuristics for mechanizing induction proofs exist and have been successfully implemented in theorem provers for first-order logic. This article is a presentation of a complementary induction method that makes extensive use of the expressiveness of higher-order logic and higher-order unification facilities ofLAMBDA. Rather than hard-coded routines, rules are used that incarnate induction schemes in a concise way. By means of instantiatable meta-variables, these rules are more general and preserve the flexibility to gradually specify an induction scheme throughout a proof process, as more and more information is available, rather than fully determining the induction scheme right at the beginning. Safe inference mechanisms and general-purpose proof automation utilities in the proof checkerLAMBDA are well-suited for an interactive induction assistant that integrates automatic induction heuristics and at they same time accepts human guidance.

SETHEO: A high-performance theorem prover

A sound and complete theorem prover for first-order logic is presented, which is based on the connection method. The inference machine is implemented using PROLOG technology, an approach taken also with other systems, most prominently with Stickel's PTTP. But SETHEO differs from those in essential characteristics, among which are the following ones. It incorporates a powerful preprocessing module for a reduction of the input formula. The main proof procedure is realized as a variant of Warren's abstract machine. For search pruning we perform subsumption and regular proofs. Factorization, lemma generation, and the application of proof schemata are offered as options. The entire system is implemented in C and is running on several machines. The most remarkable feature of SETHEO is its performance of up to 70 Klips on a SUN SPARC station 1 with 12 Mips. The paper comprises the theoretical background, the system architecture as well as details of the implementation.

The OTTER environment for resolution-based proof of hardware correctness

Efficient proof techniques are vital for the success of formal verification of hardware. First-Order Logic theorem provers satisfy this requirement. This paper deals with experiences in applying such a tool, OTTER, to boolean expression and combinational logic. Preliminary results are reported and future developments are described.