Congruence Closure Research Articles

A General Setting for Flexibly Combining and Augmenting Decision Procedures

The efficient combining and augmenting of decision procedures are often very important for a successful use of theorem provers. There are several schemes for combining and augmenting decision procedures; some of them support handling uninterpreted functions, use of available lemmas, and the like. In this paper we introduce a general setting for describing different schemes for both combining and augmenting decision procedures. This setting is based on the macro inference rules used in different approaches. Some of these rules are abstraction, entailment, congruence closure, and lemma invoking. The general setting gives a simple description and the key ideas of one scheme and makes different schemes comparable. Also, it makes easier combining ideas from different schemes. In this paper we describe several schemes via introduced macro inference rules and report on our prototype implementation.

Congruence classes with logic variables

We are improving equality reasoning in automatic theorem-provers, and congruence classes provide an ecient storage mechanism for terms, as well as the congruence closure decision procedure. We describe the technical steps involved in integrating logic variables with congruence classes, and present an algorithm that can be proved to nd all matches between classes (modulo certain equalities). An application of this algorithm makes possible a percolation algorithm for undirected rewriting in minimal space; this is described and an implementation in hol98 is examined in some detail. 1

Quantifiers and Congruence Closure

We prove some results about the limitations of the expressive power of quantifiers on finite structures. We define the concept of a bounded quantifier and prove that every relativizing quantifier which is bounded is already first-order definable (Theorem 3.8). We weaken the concept of congruence closed (see [6]) to weakly congruence closed by restricting to congruence relations where all classes have the same size. Adapting the concept of a thin quantifier (Caicedo [1]) to the framework of finite structures, we define the concept of a meager quantifier. We show that no proper extension of first-order logic by means of meager quantifiers is weakly congruence closed (Theorem 4.9). We prove the failure of the full congruence closure property for logics which extend first-order logic by means of meager quantifiers, arbitrary monadic quantifiers, and the Hartig quantifier (Theorem 6.1).

A theory of using history for equational systems with applications

Implementation of programming language interpreters, proving theorem of the form A=B, implementation of abstract data types, and program optimization are all problems that can be reduced to the problem of finding a normal form for an expression with respect to a finite set of equations. In 1980, Chew proposed an elegant congruence closure based simplifier (CCNS) for computing with regular systems, which stores the history of it computations in a compact data structure. In 1990, Verma and Ramakrishnan showed that it can also be used for noetherian systems with no overlaps. In this paper, we develop a general theory of using CCNS for computing normal forms and present several applications. Our results are more powerful and widely applicable than earlier work. We present an independent set of postulates and prove that CCNS can be used for any system that satisfies them. (This proof is based on the notion of strong closure ). We then show that CCNS can be used for consistent convergent systems and for various kinds of priority rewrite systems. This is the first time that the applicability of CCNS has been shown for priority systems. Finally, we present a new and simpler translation scheme for converting convergent systems into effectively nonoverlapping convergent priority systems. Such a translation scheme has been proposed earlier, but we show that it is incorrect. Because CCNS requires some strong properties of the given system, our demonstration of its wide applicability is both difficult and surprising. The tension between demands imposed by CCNS and our efforts to satisfy them gives our work much general significance. Our results are partly achieved through the idea of effectively simulating “bad” systems by almost-equivalent “good” ones, partly through our theory that substantially weakens the demands, and partly through the design of a powerful and unifying reduction proof method.

REGULAR TREE LANGUAGES AND REWRITE SYSTEMS

We present a collection of results on regular tree languages and rewrite systems. Moreover we prove the undecidability of the preservation of regularity by rewrite systems. More precisely we prove that it is undecidable whether or not for a set E of equations the set E(R) congruence closure of set R is a regular tree language whenever R is a regular tree language. It is equally undecidable whether or not for a confluent and terminating rewrite system S the set S(R) of ground S-normal forms of set R is a regular tree language whenever R is a regular tree language. Finally we study fragments of the theory of ground term algebras modulo congruence generated by a set of equations which can be compiled in a terminating, confluent rewrite system which preserves regularity.

Finite representation of infinite query answers

We define here a formal notion of finite representation of infinite query answers in logic programs. We apply this notion to Datalog nS programs may be infinite and consequently queries may have infinite answers. We present a method to finitely represent infinite least Herbrand models of Datalog nS program (and its underlying computational engine) can be forgotten. Given a query to be evaluated, it is easy to obtain from the relational specification finitely many answer substitutions that represent infinitely many answer substitutions to the query. The method involved is a combination of a simple, unificationless, computational mechanism (graph traversal, congruence closure, or term rewriting) and standard relational query evaluation methods. Second, a relational specification is effectively computable and its computation is no harder, in the sense of the complexity class, than answering yes-no queries. Our method is applicable to every range-restricted Datalog nS program. We also show that for some very simple non-Datalog nS logic programs, finite representations of query answers do not exist.

Another variation on the common subexpression problem

In their work from 1980 (to which our title makes reference) Downey et al. (1980) study various cases of the problem of constructing the ‘congruence closure’ of a relation R on a graph (which is the unique extension R' of R on the vertex set V such that R' is an equivalence relation and closed under congruences; the problem is viewed by Kozen (1977) as the word problem for finite algebras and by Nelson and Oppen (1980) as the decision problem for the quantifier-free theory of equality with uninterpreted function symbols). In this work they prove the upper bound O( n log n) for the general case ( n=| V|) and linear upper bounds for various special cases. We give an almost linear algorithm for yet another special case: the case of congruences of finite index (without any acyclicity restrictions), in the notation of Kozen (1977). It is there that the relationship to the finite tree automata of Thatcher and Wright (1968) was pointed out the first time. In fact, the problem reduces to the equivalence problem for finite tree automata. We are able to extend the algorithm by Hopcroft and Karp (1971) for the equivalence problem for deterministic finite automata (dfa's). The approach, the use of certain methods for monadic structures also for nonmonadic ones, is of further-reaching interest. Finally, by showing that Kozen's lower bound for the general problem, logspace-complete for P(not parallelizable), is also valid for the equivalence problem for tree automata, a nice gap between the theories on monadic and nonmonadic structures is established, because Kannelakis and Revesz (1988) show in a recent paper that the equivalence problem for dfa's lies in NC 2.

Automatic recognition of tractability in inference relations

A procedure is given for recognizing sets of inference rules that generate polynomial time decidable inference relations. The procedure can automatically recognize the tractability of the inference rules underlying congruence closure. The recognition of tractability for that particular rule set constitutes mechanical verification of a theorem originally proved independently by Kozen and Shostak. The procedure is algorithmic, rather than heuristic, and the class of automatically recognizable tractable rule sets can be precisely characterized. A series of examples of rule sets whose tractability is nontrivial, yet machine recognizable, is also given. The technical framework developed here is viewed as a first step toward a general theory of tractable inference relations.

A Fast Algorithm for Generating Reduced Ground Rewriting Systems from a Set of Ground Equations

In this paper we give a fast method for generating reduced sets of rewrite rules equivalent to a given set of ground equations. Since reduced sets of ground rewrite rules are in fact canonical, this is an efficient Knuth-Bendix procedure for the ground case. The dominant cost of the algorithm is for congruence closure, so the method runs in O(n log n) time and quadratic space, or in O(n (log n)2) time and linear space, where n is the number of occurrences of symbols in the original set of ground equations E. We also show how our method provides a precise characterization of the (finite) collection of all reduced sets of rewrite rules equivalent to a given ground set of equations E, and prove that our algorithm is complete in the sense that it can enumerate every member of this collection. Finally, we show that a modified version of this procedure can produce a reduced ground rewriting system contained in the lexicographic path ordering generated by a given total precedence ordering on the symbols of E , still in a worst-case time of O(n log n).

An algorithm for finding canonical sets of ground rewrite rules in polynomial time

In this paper, it is shown that there is an algorithm that, given by finite set E of ground equations, produces a reduced canonical rewriting system R equivalent to E in polynomial time. This algorithm based on congruence closure performs simplification steps guided by a total simplification ordering on ground terms, and it runs in time O(n 3 ) .

Theorem proving using equational matings and rigid E -unification

In this paper, it is shown that the method of matings due to Andrews and Bibel can be extended to (first-order) languages with equality. A decidable version of E -unification called rigid E-unification is introduced, and it is shown that the method of equational matings remains complete when used in conjunction with rigid E -unification. Checking that a family of mated sets is an equational mating is equivalent to the following restricted kind of E -unification. Problem Given E → ={E i | 1≤i≤n} a family of n finite sets of equations and S={〈u i ,v i 〉 |1≤i≤n} a set of n pairs of terms, is there a substitution θ such that, treating each set θ(E i ) as a set of ground equations (i.e., holding the variables in θ(E i ) “rigid”), θ(u i ), and θ(v i ) are provably equal from θ(E i ) for i=1,...,n? Equivalently, is there a substitution θ such that θ(u i ) and θ(v i ) can be shown congruent from θ(E i ) by the congruence closure method for i=1,...,n? A substitution θ solving the above problem is called a rigid E → -unifier of S , and a pair 〈E → ,S〉 such that S has some rigid E → -unifier is called an equational premating. It is shown that deciding whether a pair 〈 E → ,S〉is an equational premating is an NP-complete problem.

Definability properties and the congruence closure

We introduce a natural class of quantifiersTh containing all monadic type quantifiers, all quantifiers for linear orders, quantifiers for isomorphism, Ramsey type quantifiers, and plenty more, showing that no sublogic ofLωω(Th) or countably compact regular sublogic ofL∞ω(Th), properly extendingLωω, satisfies the uniform reduction property for quotients. As a consequence, none of these logics satisfies eitherΔ-interpolation or Beth's definability theorem when closed under relativizations. We also show the failure of both properties for any sublogic ofL∞ω(Th) in which Chang's quantifier or some cardinality quantifierQα, with α≧1, is definable.

TERM: A parallel executable graph reduction machine for equational language

We have designed and implemented a machine, called TERM, in order to execute an equational language in parallel. The equational language is a non-procedural language based on the equational logic, and is a typical computational model of logical, algebraic, and functional programming languages. Two types of hardware systems have been proposed to execute equational languages very fast. One is of a string reduction type and the other is of a graph reduction type. The string reduction type is easier to implement and the graph reduction type is faster to execute. TERM uses the latter approach. We have developed a procedure CCM (Congruence Closure Method) for the execution of the equational language. CCM transforms a program of the equational language into a graph structure. Then it seeks the applicable equations and rewrites this graph in parallel. TERM is a realization of CCM by using cross-bar switch networks to represent graph structures. TERM can perform some part of parallelism conceived in CCM. In this paper, we show advantages and disadvantages of TERM as well as CCM.

On the relationship of congruence closureand unification

Congruence closure is a fundamental operation for symbolic computation. Unification closureis defined as its directional dual, i.e., on the same inputs but top-down as opposed to bottom-up. Unifying terms is another fundamental operation for symbolic computation and is commonly computed using unification closure. We clarify the directional duality by reducing unification closure to a special form of congruence closure. This reduction reveals a correspondence between repeated variables in terms to be unified and equalities of monadic ground terms. We then show that: (1) single equality congruence closure on a directed acyclic graph, and (2) acyclic congruence closure of a fixed number of equalities, are in the parallel complexity class NC. The directional dual unification closures in these two cases are known to be log-space complete for PTIME. As a consequence of our reductions we show that if the number of repeated variables in the input terms is fixed, then term unification can be performed in NC; this extends the known parallelizable cases of term unification. Using parallel complexity we also clarify the relationship of unification closure and the testing of deterministic finite automata for equivalence.

Extending SLD resolution to equational horn clauses using E-unification

We study the role of unification modulo a set of equations, or E-unification, in the context of refutation methods for sets of Horn clauses with equality. Two extensions of SLD resolution based on E-unification are presented, and rigorous completeness results are shown, including an analysis of the ground case for insight into the computational implications. The concept of a congruence closure generalized to sets of ground Horn clauses is central to these completeness results. The first method is general, in that it applies to arbitrary sets of equational Horn clauses, but is not practical, as it assumes a procedure which gives an explicit sequence of substitutions for each E-unifier. A second method uses a procedure enumerating a complete set of E-unifiers, and appears to be well suited to a class of “well-behaved” equational logic programs which allows a clean and natural integration of the functional and logic-programming paradigms. Using this second method, we have formalized the refutation method used in Eqlog for this class of programs, and a theorem establishes rigorously the completeness of this method. We compare these methods in detail with related work, and show that other methods either explicitly include E-unification or simulate it in some manner.

Fast algorithms for testing unsatisfiability of ground horn clauses with equations

This paper presents two fast algorithms for testing the unsatisfiability of a set of ground Horn clauses with or without equational atomic formulae. If the length of the set H of Horn clauses (viewed as the string obtained by concatenating the clauses in H) is n, it is possible to design an algorithm running in time O(n log(n)). These algorithms are obtained by generalising the concept of congruence closure to ground Horn clauses. The basic idea behind these algorithms is that the congruence closure induced by a set of ground Horn clauses can be obtained by interleaving steps in which an equational congruence closure is computed, and steps in which an implicational type of closure is computed.

A semantic editor

We describe an interactive tool for program development and transformation, a semantic editor. The domain of the semantic editor is Backus's FP programming language. The editor facilitates manipulation of FP program schemas by the meaning-preserving transformations of FP's algebra of programs. The semantic editor aids program development, program optimization and equivalence proofs. It also serves as a tool for investigating the algebra of programs itself. The semantic editor does not depend on the existence of normal forms for FP programs. Instead, a history of all program transformations is retained in the system in the form of a congruence relation. The user is free to step through the congruence classes to see different but equivalent versions of his programs. A program equivalence is applied to a program schema by unifying one side of the equivalence with a sub-program, then labeling it congruent to the other side if the unification is successful. A congruence closure algorithm is applied to find any new congruence relations in expressions containing these program schemas. The program schemas are represented internally by a directed, acyclic graph ( dag ) with identical sub-programs occupying the same sub-graph. The semantic editor uses the Patterson and Wegman unification algorithm and the Nelson and Oppen congruence closure algorithm. Both employ the dag representation. The system is implemented in Scheme, a dialect of Lisp.

Fast Decision Procedures Based on Congruence Closure

The notion of the congruence closure of a relation on a graph is defined and several algorithms for computing it are surveyed. A simple proof is given that the congruence closure algorithm provides a decision procedure for the quantifier-free theory of equality. A decision procedure is then given for the quantifier-free theory of LISP list structure based on the congruence closure algorithm. Both decision procedures determine the satisfiability of a conjunction of literals of length n in average time O ( n log n ) using the fastest known congruence closure algorithm. It is also shown that if the axiomatization of the theory of list structure is changed slightly, the problem of determining the satisfiability of a conjunction of literals becomes NP-complete. The decision procedures have been implemented in the authors' simplifier for the Stanford Pascal Verifier.