Derek C. Oppen

Simplification by Cooperating Decision Procedures

A method for combining decision procedures for several theories into a single decision procedure for their combination is described, and a simplifier based on this method is discussed. The simplifier finds a normal form for any expression formed from individual variables, the usual Boolean connectives, the equality predicate =, the conditional function if-then-else, the integers, the arithmetic functions and predicates +, -, and ≤, the Lisp functions and predicates car, cdr, cons, and atom, the functions store and select for storing into and selecting from arrays, and uninterpreted function symbols. If the expression is a theorem it is simplified to the constant true, so the simplifier can be used as a decision procedure for the quantifier-free theory containing these functions and predicates. The simplifier is currently used in the Stanford Pascal Verifier.

A 222pn upper bound on the complexity of Presburger Arithmetic

The decision problem for the theory of integers under addition, or “Presburger Arithmetic,” is proved to be elementary recursive in the sense of Kalmar. More precisely, it is proved that a quantifier elimination decision procedure for this theory due to Cooper determines, for any n, the truth of any sentence of length n within deterministic time 222pn for some constant p > 1. This upper bound is approximately one exponential higher than the best known lower bound on nondeterministic time. Since it seems to cost one exponential to simulate a nondeterministic algorithm with a deterministic one, it may not be possible to significantly improve either bound.

Reasoning About Recursively Defined Data Structures

A decision algorithm is given for the quantifier-free theory of recursively defined data structures which, for a conjunction of length n, decides its satisfiability in time linear in n. The first-order theory of recursively defined data structures, in particular the first-order theory of LISP list structure (the theory of CONS, CAR and CDR), is shown to be decidable but not elementary recursive.

Complexity, convexity and combinations of theories☆

Abstract We restrict our attention to decidable quantifier-free theories, such as the quantifier-free theory of integers under addition, the quantifier-free theory of arrays under storing and selecting, or the quantifier-free theory of list structure under cons, car and cdr. We consider combinations of such theories: theories whose sets of symbols are the union of the sets of the symbols of the individual theories and whose set of axioms is the union of the sets of axioms of the individual theories. We give a general technique for determining the complexity of decidable combinations of theories, and show, for example, that the satisfiability problem for the quantifier-free theory of integers, arrays, list structure and uninterpreted function symbols under +, ≤, store, select, cons, car and cdr is NP-complete. We next consider the complexity of the satisfiability problem for formulas already in disjunctive normal form: why some combinations of theories admit deterministic polynomial time decision procedures while for others the problem is NP-hard. Our analysis hinges on the question of whether the theories being combined are convex; that is, whether any conjunction of literals in the theory can entail a proper disjunction of equalities between variables. This leads to a discussion of the role that case analysis plays in deciding combinations of theories.

A simplifier based on efficient decision algorithms

We describe a simplifier for use in program manipulation and verification. The simplifier finds a normal form for any expression over the language consisting of individual variables, the usual boolean connectives, the conditional function cond (denoting if-then-else), the integers (numerals), the arithmetic functions and predicates +, - and ≤, the LISP constants, functions and predicates nil, car, cdr, cons and atom, the functions store and select for storing into and selecting from arrays, and uninterpreted function symbols. Individual variables range over the union of the rationals, the set of arrays, the LISP s-expressions and the booleans true and false. The constant, function and predicate symbols take their natural interpretations.The simplifier is complete; that is, it simplifies every valid formula to true. Thus it is also a decision procedure for the quantifier-free theory of rationals, arrays and s-expressions under the above functions and predicates.The organization of the simplifier is based on a method for combining decision algorithms for several theories into a single decision algorithm for a larger theory containing the original theories. More precisely, given a set S of functions and predicates over a fixed domain, a satisfiability program for S is a program which determines the satisfiability of conjunctions of literals (signed atomic formulas) whose predicates and function signs are in S. We give a general procedure for combining satisfiability programs for sets S and T into a single satisfiability program for S ∪ T, given certain conditions on S and T. We show how a satisfiability program for a set S can be used to write a complete simplifier for expressions containing functions and predicates of S as well as uninterpreted function symbols.The simplifier described in this paper is currently used in the Stanford Pascal Verifier.

Unrestricted procedure calls in Hoare's logic

This paper presents a new version of Hoares logic including generalized procedure call and assignment rules which correctly handle aliased variables. Formal justifications are given for the new rules.

The Logic of Aliasing

SummaryWe present a new version of Hoares logic that correctly handles programs with aliased variables. The central proof rules of the logic (procedure call and assignment) are proved sound and complete.

Reasoning about recursively defined data structures

A decision algorithm is given for the quantifier-free theory of recursively defined data structures which, for a conjunction of length n, decides its satisfiability in time linear in n. The first-order theory of recursively defined data structures, in particular the first-order theory of LISP list structure (the theory of CONS, CAR, CDR), is shown to be decidable but not elementary recursive.