An equational approach to theorem proving in first-order predicate calculus (original) (raw)
Related papers
2016
We present a method to simplify expressions in the context of a formal, axiomatically defined, theory. In this paper, equality axioms are typically used but the method is more generally applicable. The key idea of the method is to represent large, even infinite, sets of expressions by means of a special data structure that allows us to apply axioms to the sets as a whole, not to single individual expressions. We then propose a bottom-up algorithm to finitely compute theories with a finite number of equivalence classes of equal terms. In that case, expressions can be simplified (i.e., minimized) in linear time by “folding” them on the computed representation of the theory. We demonstrate the method for boolean expressions with a small number of variables. Finally, we propose a “goal oriented” algorithm that computes only small parts of the underlying theory, in order to simplify a given particular expression. We show that the algorithm is able to simplify boolean expressions with man...
Experience with Predicate Abstraction
1999
This reports some experiences with a recently-implemented prototype system for verification using predicate abstraction, based on the method of Graf and Saïdi [9]. Systems are described using a language of iterated guarded commands, called Murø -- (since it is a simplified version of our Murø protocol description language). The system makes use of two libraries: SVC [1] (an efficient decision procedure for quantifier- free first-order logic) and the CMU BDD library. The use of these libraries increases the scope of problems that can be handled by predicate abstraction through increased efficiency, especially in SVC, which is typically called thousands of times. The verification system also provides limited support for quantifiers in formulas. The system has been applied successfully to two nontrivial examples: the Flash multiprocessor cache coherence protocol, and a concurrent garbage collection algorithm. Verification of the garbage collector algorithm required proving properties simple of graphs, which was also done using predicate abstraction.
Generating theorem proving procedures from axioms of Truncated Predicate Calculus
Cornell University - arXiv, 2019
We present a novel approach to the problem of automated theorem proving. Polynomial cost procedures that recognise sentences belonging to a theory are generated on a basis of a set of axioms of the so-called Truncated Predicate Calculus being a subset of standard predicate calculus. Several exemplary problems are included to show the performance of the proposed approach.
A superposition oriented theorem prover
Theoretical Computer Science, 1985
This paper describes a theorem proving procedure which combines the approach of Resolution with that of Rewriting. The basic-theoretical result is the completeness of a strong restriction of paramodulation for locking resolution procedures. Its oriented character suggests to consider the restricted paramodulation as a form of superposition (the Rewriting operation). This is achieved by means of a new formalism of clauses, named equational clauses, in which each literal is converted into an equation. Thereby, superposition on equational clauses is shown to embody not only paramodulation but also binary resolution; so clausal superposition will build up our major rule of inference. In addition, term simplification is incorporated in our procedure as well as subsumption. Experimental results and potential applications for our theorem prover are lastly reported.
Automatic theorem proving based on resolution
Annual Review in Automatic Programming, 1973
J. A. Robinson's resolution principle has given rise to much research work and has contributed to the establishment of automatic theorem proving as a field of its own in artificial intelligence. The present paper is addressed to two kinds of readers: by its elementary introduction, it should enable a non-specialist in resolution theorem proving to grasp the essence of the method and read virtually any paper on the subject, whereas the researcher in artificial intelligence will find in specialized sections a collection of results on resolution-based procedures connected to the relevant papers in the literature.
A resolution rule for well-formed formulae
Theoretical Computer Science, 1991
Bhatta, K.S.H.S.R. and H. Karnick, A resohttion rule for well-formed formulae, Theoretical Computer Science 81 (1991) 223-235. A resolution proof procedure that operates on well-formed formulae with all quantifiers in place is presented. Extension of the unification algorithm 'o Q-unijcation (i.e. with quantifiers in place) is also discussed. The procedure involves a single irference rule called WFF-resolution which is proved to be sound and complete.
A simplified problem reduction format
Artificial Intelligence, 1982
Some new approaches to mechanical theorem proving in the first-order predicate calculus are presented. These are based on a natural deduction system which can be used to show that a set of clauses is inconsistent. This natural deduction system distinguishes positive from negative literals and treats clauses having O, 1, and 2 or more positive literals in three separate ways. Several such systems are presented. The systems are complete and relatively simple and allow a goal to be decomposed into subgoals, and solutions to the subgoals can then be searched for in the same way. Also, the systems permit a natural use of semantic information to delete unachievable subgoals. The goal-subgoal structure of these systems should allow much of the current artificial intelligence methodology to be applied to mechanical theorem proving.
An Efficient and Flexible Approach to Resolution Proof Reduction
Lecture Notes in Computer Science, 2011
A resoution proof is a certificate of the unsatisfiability of a Boolean formula. Resolution proofs, as generated by modern SAT solvers, find application in many verification techniques. For efficiency smaller proofs are preferable over larger ones. This paper presents a new approach to proof reduction, situated among the purely post-processing methods. The main idea is to reduce the proof size by eliminating redundancies of occurrences of pivots along the proof paths. This is achieved by matching and rewriting local contexts into simpler ones. In our approach, rewriting can be easily customized in the way local contexts are matched, in the amount of transformations to be performed, or in the different application of the rewriting rules. We provide an extensive experimental evaluation of our technique on a set of benchmarks, which shows considerable reduction in the proofs size.
SLWV — A theorem prover for logic programming
Lecture Notes in Computer Science, 1993
The purpose of this work is to define a theorem prover that retains the procedural aspects of logic programing. The proof system we propose (SLWV 1 resolution) is defined for a set of clauses in the implicational form (keeping to the form of logic programs), not requiring contrapositives, and has an execution method that respects the execution order of literals in a clause, preserving the procedural flavor of logic programming. SLWV resolution can be seen as a combination of SL-resolution [Chan73] and case-analysis, that admits a form of linear derivation. We prove its soundness and completeness, give it an operational semantics by defining a standard derivation, and produce an implementation. Our work can be seen as an extension to logic programs that goes beyond normal programs, as defined in [Lloy87], and thus beyond(positive) definite clause programming, by allowing also definite negative heads. Thus we admit program clauses with both positive and (classically) negated atoms conjoined in the body, and at most one literal as its head (clauses with disjunctions of literals in the head are transformed into a single clause of that form). As this approach does not require alternative clause contrapositives, it provides for better control over the search space. We provide a method of execution keeping to the implicational clausal form of program statements typical of Prolog (without the use of clause contrapositives), adding an increased expressiveness, but at a tolerable computational cost for regular Prolog programs. The implementation relies on the source program being preprocessed into directly executable Prolog. Since preprocessing only involves the addition of three additional variables to each predicate definition while keeping the overall program structure untouched, a directly recognizable execution pattern that mimics Prolog is obtained: this can be useful in debugging.