Results 1  10
of
11
Integrating decision procedures into heuristic theorem provers: A case study of linear arithmetic
 Machine Intelligence
, 1988
"... We discuss the problem of incorporating into a heuristic theorem prover a decision procedure for a fragment of the logic. An obvious goal when incorporating such a procedure is to reduce the search space explored by the heuristic component of the system, as would be achieved by eliminating from the ..."
Abstract

Cited by 107 (9 self)
 Add to MetaCart
We discuss the problem of incorporating into a heuristic theorem prover a decision procedure for a fragment of the logic. An obvious goal when incorporating such a procedure is to reduce the search space explored by the heuristic component of the system, as would be achieved by eliminating from the system’s data base some explicitly stated axioms. For example, if a decision procedure for linear inequalities is added, one would hope to eliminate the explicit consideration of the transitivity axioms. However, the decision procedure must then be used in all the ways the eliminated axioms might have been. The difficulty of achieving this degree of integration is more dependent upon the complexity of the heuristic component than upon that of the decision procedure. The view of the decision procedure as a "black box " is frequently destroyed by the need pass large amounts of search strategic information back and forth between the two components. Finally, the efficiency of the decision procedure may be virtually irrelevant; the efficiency of the final system may depend most heavily on how easy it is to communicate between the two components. This paper is a case study of how we integrated a linear arithmetic procedure into a heuristic theorem prover. By linear arithmetic here we mean the decidable subset of number theory dealing with universally quantified formulas composed of the logical connectives, the identity relation, the Peano "less than " relation, the Peano addition and subtraction functions, Peano constants,
Termination of Nested and Mutually Recursive Algorithms
, 1996
"... This paper deals with automated termination analysis for functional programs. Previously developed methods for automated termination proofs of functional programs often fail for algorithms with nested recursion and they cannot handle algorithms with mutual recursion. We show that termination proofs ..."
Abstract

Cited by 39 (9 self)
 Add to MetaCart
This paper deals with automated termination analysis for functional programs. Previously developed methods for automated termination proofs of functional programs often fail for algorithms with nested recursion and they cannot handle algorithms with mutual recursion. We show that termination proofs for nested and mutually recursive algorithms can be performed without having to prove the correctness of the algorithms simultaneously. Using this result, nested and mutually recursive algorithms do no longer constitute a special problem and the existing methods for automated termination analysis can be extended to nested and mutual recursion in a straightforward way. We give some examples of algorithms whose termination can now be proved automatically (including wellknown challenge problems such as McCarthy's f_91 function).
A Theorem Prover for a Computational Logic
, 1990
"... We briefly review a mechanical theoremprover for a logic of recursive functions over finitely generated objects including the integers, ordered pairs, and symbols. The prover, known both as NQTHM and as the BoyerMoore prover, contains a mechanized principle of induction and implementations of line ..."
Abstract

Cited by 24 (0 self)
 Add to MetaCart
We briefly review a mechanical theoremprover for a logic of recursive functions over finitely generated objects including the integers, ordered pairs, and symbols. The prover, known both as NQTHM and as the BoyerMoore prover, contains a mechanized principle of induction and implementations of linear resolution, rewriting, and arithmetic decision procedures. We describe some applications of the prover, including a proof of the correct implementation of a higher level language on a microprocessor defined at the gate level. We also describe the ongoing project of recoding the entire prover as an applicative function within its own logic.
Proof checking the RSA public key encryption algorithm
 American Mathematical Monthly
, 1984
"... The authors describe the use of a mechanical theoremprover to check the published proof of the invertibility of the public key encryption algorithm of Rivest, Shamir and Adleman: (M mod n) mod N=M, provided n is the product of two distinct primes p and q, M
Abstract

Cited by 22 (9 self)
 Add to MetaCart
The authors describe the use of a mechanical theoremprover to check the published proof of the invertibility of the public key encryption algorithm of Rivest, Shamir and Adleman: (M mod n) mod N=M, provided n is the product of two distinct primes p and q, M<n, and e and d are multiplicative inverses in the ring of integers modulo (p1)*(q1). Among the lemmas proved mechanically and used in the main proof are many familiar theorems of number theory, including Fermat’s theorem: M mod p=1, when p M. The axioms underlying the proofs are those of Peano arithmetic and ordered pairs. The development of mathematics toward greater precision has led, as is well known, to the formalization of large tracts of it, so that one can prove any theorem using nothing but a few mechanical rules. Godel [11] But formalized mathematics cannot in practice be written down in full, and therefore we must have confidence in what might be called the common sense of the mathematician... We shall therefore very quickly abandon formalized mathematics... Bourbaki [1] 1.
Proving Termination of Normalization Functions for Conditional Expressions
 JOURNAL OF AUTOMATED REASONING
, 1986
"... ..."
Program verification
 Journal of Automated Reasoning
, 1985
"... Computer programs may be regarded as formal mathematical objects whose properties are subject to mathematical proof. Program verification is the use of formal, mathematical techniques to debug software and software specifications. 1. Code Verification How are the properties of computer programs prov ..."
Abstract

Cited by 14 (4 self)
 Add to MetaCart
Computer programs may be regarded as formal mathematical objects whose properties are subject to mathematical proof. Program verification is the use of formal, mathematical techniques to debug software and software specifications. 1. Code Verification How are the properties of computer programs proved? We discuss three approaches in this article: inductive invariants, functional semantics, and explicit semantics. Because the first approach has received by far the most attention, it has produced the most impressive results to date. However, the field is now moving away from the inductive invariant approach. 1.1. Inductive Assertions The socalled FloydHoare inductive assertion method of program verification [25, 33] has its roots in the classic Goldstine and von Neumann reports [53] and handles the usual kind of programming language, of which FORTRAN is perhaps the best example. In this style of verification, the specifier "annotates " certain points in the program with mathematical assertions that are supposed to describe relations that hold between the program variables and the initial input values each time "control " reaches the annotated point. Among these assertions are some that characterize acceptable input and the desired output. By exploring all possible paths from one assertion to the next and analyzing the effects of intervening program statements it is possible to reduce the correctness of the program to the problem of proving certain derived formulas called verification conditions. Below we illustrate the idea with a simple program for computing the factorial of its integer input N flowchart assertion start with input(N) input N A: = 1 N = 0 yes stop with? answer A
Textbook Examples of Recursion
 In Artificial Intelligence and Theory of Computation
, 1991
"... Abstract. We discuss properties of recursive schemas related to McCarthy’s “91 function” and to Takeuchi’s triple recursion. Several theorems are proposed as interesting candidates for machine verification, and some intriguing open questions are raised. ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
Abstract. We discuss properties of recursive schemas related to McCarthy’s “91 function” and to Takeuchi’s triple recursion. Several theorems are proposed as interesting candidates for machine verification, and some intriguing open questions are raised.
Inductive invariants for nested recursion
 Theorem Proving in Higher Order Logics (TPHOLS'03), volume 2758 of LNCS
, 2003
"... Abstract. We show that certain inputoutput relations, termed inductive invariants are of central importance for termination proofs of algorithms defined by nested recursion. Inductive invariants can be used to enhance recursive function definition packages in higherorder logic mechanizations. We d ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Abstract. We show that certain inputoutput relations, termed inductive invariants are of central importance for termination proofs of algorithms defined by nested recursion. Inductive invariants can be used to enhance recursive function definition packages in higherorder logic mechanizations. We demonstrate the usefulness of inductive invariants on a large example of the BDD algorithm Apply. Finally, we introduce a related concept of inductive fixpoints with the property that for every functional in higherorder logic there exists a largest partial function that is such a fixpoint. 1
Checking Termination of Queries to Logic Programs
, 1996
"... Termination of programs is known to be undecidable. However in the case of logic programs, where the only possible cause for nontermination is infinite recursion, termination can actually be proved automatically for a large class of programs. This paper describes an algorithm for automatically chec ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
Termination of programs is known to be undecidable. However in the case of logic programs, where the only possible cause for nontermination is infinite recursion, termination can actually be proved automatically for a large class of programs. This paper describes an algorithm for automatically checking termination of queries to logic programs. Given a program and query the algorithm either answers that the query terminates or that there may be nontermination due to infinite recursion. The algorithm can use any norm of a wide family of norms for proving termination. It has been implemented in SICStus Prolog. The implementation can handle automatically most of the examples we encountered in the literature on termination of logic programs, and about half the programs in a collection of benchmarks, which were originally used for purposes other than termination (for 11 of the 24 programs termination can be decided automatically and for 3 more it can be decided after suitable transformatio...
Knuth's Generalization of Takeuchi's Tarai Function: Preliminary Report
, 2000
"... Donald E. Knuth of Stanford University raises, in [2] and [3, chapter 22], intriguing open questions about his generalization of the tarai function and proposes an interesting candidate for machine verification. We answer some of the open questions and explore the use of ACL2 to meet Knuth's challen ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Donald E. Knuth of Stanford University raises, in [2] and [3, chapter 22], intriguing open questions about his generalization of the tarai function and proposes an interesting candidate for machine verification. We answer some of the open questions and explore the use of ACL2 to meet Knuth's challenge. 1 Takeuchi's Tarai Function Ikuo Takeuchi devised the following recursive function for benchmarking LISP systems. The recursion can take a long time to terminate without generating large intermediate numerical values. Knuth comments [3, chapter 22]: "Takeuchi called his function tarai, from the word `taraimawashi,' which connotes passing an unpleasant object from one person to another." For integer inputs, x; y; z, t(x; y; z) def ( if x y then y (1) else t(t(x \Gamma 1; y; z); t(y \Gamma 1; z; x); t(z \Gamma 1; x; y)): John McCarthy proved that this recursion terminates and that t can be computed without any recursion, t(x; y; z) = if x y then y (2) else if y z then z else x: 1 J Moore [5] discovered a simpler measure than the one used by McCarthy and used the early BoyerMoore theorem prover, THM, to verify termination and that t satisfies the simpler nonrecursive equation. 2 Knuth's Generalization Knuth generalizes the tarai function to higher dimensions: For integer inputs, x 1 ; x 2 ; : : : ; xm , t(x 1 ; x 2 ; : : : ; xm ) def ( if x 1 x 2 then x 2 else t( t(x 1 \Gamma 1; x 2 ; : : : ; xm ); t(x 2 \Gamma 1; x 3 ; : : : ; xm ; x 1 ); . . .