A parallel approach for theorem proving in prepositional logic

INFORMATION

SCIENCES

61

41, 61-76 (1987)

A Parallel Approach for Theorem Proving in Propositional Logic WEN-TSUEN

CHEN

LUNG-LUNG

LIU

Institute of Computer and Decision Sciences, National Hsinchu, Taiwan (30043), Republic of China

Communicated

Tsing Hua University,

by C. V. Rarnamoorthy

ABSTRACT In this paper, the divide-and-conquer strategy and a pipelining discipline are applied to theorem proving in propositional logic. The strategy is itself logically complete and sound. Based on this strategy a parallel proof procedure can be constructed. With a pipelined execution model, we show that the processing time using our parallel approach to solve such an NP-complete problem is of 0( ma), where m is the number of clauses and n is the number of distinct Boolean variables in the given formula. The approach is simpler than those using explicit inference rules, since the deductions are performed implicitly by only simple checking and deleting operations on each clause.

1.

INTRODUCTION

The theorem-proving problem in propositional logic was originally defined as follows: Given a set of Boolean formulas F1, F2,. . . , Fn and G, determine whether the formula F1 A F2 A . . . A I;;, --) G is valid or not [l, 21. If the formula is valid, then it is always true and it can be stated as a theorem. Equivalently, a proof of the theorem can be obtained by proving that the negated formula -( F1 A F2 A . . . A F, + G) is unsatisfiable (i.e., always false). Such a proof method has been frequently used in the past because there may be chances that contradiction can be easily detected in an unsatisfiable formula. For example, the formula F A -F is obviously unsatisfiable, since F and -F cannot be both true. The satisfiability problem, whose solution also determines the unsatisfiability of a Boolean formula, has been shown to be NP-complete [3]. Hence, the QElsevier Science Publishing Co., Inc. 1987 52 Vanderbilt Ave., New York, NY 10017

0020-0255/87/$03.50

WEN-TSUEN

62

CHEN AND LUNG-LUNG

LIU

theorem-proving problem in propositional logic is hard in the worst case. However, that should not prevent us from inventing algorithms which may be quite efficient in most of the other cases. Actually, since the early 196Os, there have been many algorithms proposed. A survey of them in the past 25 years indicated that most of them are concerned with refinement or restriction about the deduction procedures [4]. Few of them are related to parallel processing, which is usually efficient in problem solving. In this paper, we propose a parallel approach for theorem proving in propositions logic. Both a parallel algorithm and an execution model are introduced. The basic ideas in the approach are to apply the divide-and-conquer strategy [5, 61 and to use a pipelined discipline [7]. The former is to create independent subproblems that can be processed in parallel, and the latter is to achieve overlapped parallelism among hierarchically dependent subproblems. The algorithm is logically complete and sound. In other words, it is correct for theorem proving in propositional logic. Pipelining is used to further improve the performance of parallel processing. We shall show that by applying the divide-and-conquer strategy together with a pipelined execution model, the problem of theorem proving in propositions logic could be solved in U(mn) time, where m is the number of clauses and n is the number of distinct Boolean variables in a given formula. In Section 2, applying the divide-and-conquer strategy to theorem proving is demonstrated by examples. In Section 3, a major theorem which supports the strategy is given. The parallel algorithm const~cted by using the strategy is formally described, and its effectiveness is then shown. In Section 4, a pipelined execution model which is specially efficient for our parallel algorithm is introduced. In Section 5, the time complexity of the parallel algorithm is analyzed. Lastly, conclusions and suggestions for future work are given in Section 6.

2.

APPLYING

THE DIVIDE-AND-CONQUER

STRATEGY

As we noted in the previous section, proving a theorem Fi A F2 A . - . A F, to proving that the negated formula Fl A F2 A . . . A F, A -G is unsatisfiable. Without loss of generality, we let the formula be in clausal form [l, 2, 81. That is, each of the formulas F,, F2,. . . , F, and -G is a clause (or a disjunction of distinct positive or negated Boolean variables), and the original formula can be represented as a set of clauses. In the following, we are to prove that a given set S of clauses is unsatisfiable. In order to prove that a clause set S is unsatisfiable, we are to deduce new clauses from S. If the new clauses together with the clauses in S are unsatisfiable, then S must be unsatisfiable. Generally, we use inference rules to deduce + G is equivalent

THEOREM PROVING IN PROPOSITIONAL LOGIC

63

TABLE 1 P

[PA{--PvQK+Q

Q F T F T

F F T T

T T T T

TABLE 2 P

Q

F F T T

F T F T

K-PvQ)A(-Q>I-

-P

T T T T

these clauses. Tbe following are the commonly used inference rules (with their truth tables given to show consistency): (1) (2) (3) (4) which

From clauses P and -P V Q we can deduce Q (Table I). From clauses -P v Q and -Q we can deduce -P (Table 2). From clauses -P v Q and -Q v R we can deduce -P v R (Table 3). From clauses P and -P we can deduce the empty clause (denoted as 01, is itself unsatisfiable (Table 4).

By using these inference rules, we are to deduce the empty clause from S and thus prove that S is unsatisfiable. The deductions used to prove S form a TABLE 3 P

0

R

F F F F T T T T

F F T T F F T T

F T F T F T F T

I(-PVQ)A(-QVR)]-, T T T T T T T T

TABLE 4 P

-P

F T

T F

PA(-P) F F

-PVR

WEN-TSUEN

64

CHEN AND LUNG-LUNG

LIU

proof of S. There may be a number of different proofs for S if different inference rules are used. Robinson proposed a simple powerful inference rule, called the resolution principle, for clause deduction [9]. It can be shown that it implies the above four inference rules. The resolution principle can be stated as follows: Let a clause C, contain a Boolean variable P, and let another clause C, contain the negated Boolean variable -P. Then, from clauses C, and C, we can deduce the clause C,, which is the disjunction of C, and C, with their respective P and -P deleted. EXAMPLE

1. Let S be given as follows:

PvQ -PvQ Rv -Q -R v -Q. By using the resolution the following steps:

principle, we may easily prove that S is unsatisfiable

in

(1) From the clauses P V Q and -P v Q, we deduce the clause

Q. (2) From the clauses RV -Q and -R v -Q, we deduce the clause

-Q. (3) From the unit clauses Q and -Q, we deduce the clause

Thus, we prove that S is unsatisfiable. In the example, the deductions of the clauses Q and -Q are independent; hence they can be processed in parallel. However, it may be difficult to detect the independent deductions in a proof. In the following, we shall introduce our parallel approach to deduce the empty clause from S. The deductions are performed implicitly on the clauses, as was done sequentially in the DavisPutnam procedure [S, lo]. The basic idea is to apply the divide-and-conquer strategy. In general, the strategy is to divide a problem into several independent subproblems. After solving these subproblems, the strategy then merges the solutions of the subproblems to obtain the solution of the original problem. If the subproblems

THEOREM

PROVING

IN PROPOSITIONAL

65

LOGIC

are exactly in the same form as the original problem, these subproblems can be solved by using the same strategy recursively. Since the subproblems are independent, we can often obtain parallel algorithms in applying the strategy

WI. We now see how the theorem-proving problem can be solved by using the divide-and-conquer strategy. Let P be a Boolean variable which appears in a clause set S. We define the following clause sets: DEFINITION. S, is the set of clauses containing DEFINITION. S_, is the set of clauses containing

P in S.

-P

DEFINITION. SXp is the set of clauses not containing DEFINITION. S; is the set S, with all occurrences

P or -P

in S.

of P deleted.

DEFINITION. SLp is the set S_, with all occurrences DEFINITION. S(P)

in S.

of -P deleted.

is the union of S; and SXp.

DEFINITION. S( -P)

is the union of SLp and SXp.

Note that if the occurrence of P (or -P) is deleted from a clause containing only the Boolean variable P (or the negated Boolean variable -P), then the remaining clause is the empty clause 0. EXAMPLE

2. Let S be given as follows:

-i”P -P Q. Then, we can obtain the clause sets as follows: S, contains the clause -Q v P, S_, contains the clause -P, Sxp contains the clauses R and Q, Sj contains the clause -Q, and SLp contains the empty clause 0. The clause set S(P)

is

66

WEN-T?XJEN CHEN AND LUNG-LUNG LIU

and the clause set S( -P) is

We shall show in the next section that S is unsatisfiable if and only if both S(P) and S( -P) are unsatisfiable, for an arbitrarily chosen P. Thus, in order to prove that S is unsatisfiable, we can transform the problem into two subproblems, namely, to prove that S(P) is satisfiable and to prove that S( -P) is unsatisfiable. The results of the subproblems then determine the result of the original problem. Since the subproblems are in the same form as the original problem, they can be solved by applying the same strategy recursively. Hence the divide-and-conquer strategy is applicable to theorem proving, and parallel algorithms can be constructed. EXAMPLE 3. Let S be given as follows: -Pv R -QVP -R Q,

and we are to prove that S is ~~atisfiable by using the diode-Ed-conquer strategy. The clause set S(P) is ’

-Q -R

Q, and S( -P) is R -R Q.

We now recursively apply the divide-and-conquer strategy to prove that S(P) is unsatisfiable. Let the Boolean variable Q in S(P) be chosen. Then the clause set S(P)(Q) is

THEOREM

PROVING

and S( P)( -Q)

IN PROPOSITIONAL

LOGIC

67

is 0

-R. Clearly, both S(P)(Q) and S(P)( -Q) are unsatisfiable, since they contain the empty clause, and hence S(P) is proved to be unsatisfiable. Similarly, we can Let the Boolean variable R in S( -P) be prove that S( -P) is unsatisfiable. chosen. Then the set S( -P)(R) is

and S( -P)(

-R)

is Cl

Q Both S( -P)(R) and S( -P)( -R) are unsatisfiable, and hence S( -P) is unsatisfiable. Since both S(P) and S( -P) are unsatisfiable, we have proved that S is unsatisfiable. 3.

THEOREMS

AND THE ALGORITHM

In this section we shall prove a main theorem to support our divide-and-conquer strategy and formally describe our parallel algorithm for theorem proving in propositional logic. LEMMA1. If S(P) is unsatisfiable, clause P can be deduced from S.

then either S is unsatisjiable or a unit

Proof. If S(P) is unsatisfiable, there must be at least one deduction of Cl from clauses in S(P). Consider every such deduction. There are two cases: Case (1). For all such deductions, no clause involved in these deductions is in S;. In this case, we see that Sxp is unsatisfiable, since the clauses involved in the deductions must be in Sxp. S is unsatisfiable because Sxp is a subset of S. Case (2). For some deduction, some clauses involved are in S;. In this case, if we put P back to these clauses, then the resulting clauses arc in S, and hence in S. We now consider the same deduction again. The deduction, which involves clauses in either Sxp or S,, will deduce the unit clause P instead of 0.

WEN-TSUEN

CHEN AND LUNG-LUNG

LIU

Since S,, and S, are subsets of S, then we have proved that a unit clause P n can be deduced from S. LEMMA 2. Zf S( -P) is unsatisfiable, then either S is unsatisfiable or a unit clause -P can be deduced from S. Proof. Similar to that for Lemma 1.

m

THEOREM 1. S is unsatisfiable if and only if for an arbitrarily chosen Boolean variable P in S, both S(P) and S( -P) are unsatisfiable.

by Lemma 1 we have that S is Proof. (=: Since S(P) is unsa~fiable, unsatisfiable or the unit clause P can be deduced from S. Similarly, since S( -P) is unsatisfiable, by Lemma 2 we have that S is unsatisfiable or the unit clause -P can be deduced from S. According to these facts, we can directly have that S is unsatisfiable, or we can have that both unit clauses P and -P can be deduced from S. The latter case also implies that S is unsatisfiable, since from clauses P and -P we can deduce the empty clause. 3 : We shall prove this by contradiction. That is, we assume that S(P) or S( -P) is satisfiable for some P, and we are to prove that S is satisfiable. Let S(P) be satisfiable. Then, there exists an ~si~ent of TRUE/FALSE values to the Boolean variables in S(P) such that all clauses in S(P) are evaluated to TRUE. We let such an assignment be A, and we shall define an assignment A’ that can make S satisfiable. Let the assignment A be similar to A except that (1) P = FALSE is added, and (2) X= TRUE is added for every Boolean variable not in S, or SxP.

X appearing

in S_P but

Then all the clauses in S(P) are evaluated to TRUE with the assignment A’, because the newly added TRUE/FALSE values are irrelevant to the evaluation. Only the values in the assignment A are used. Clearly, the clauses in S,, are evaluated to TRUE with the assignment A’, because SxP is a subset of S(P). The clauses in S, are also evaluated to TRUE with the assignment A’, because S; is a subset of S(P) and the clauses in S, are those in Sj with P added. Now we consider the clause in S_, with the assignment A’. All the clauses in S+ are evaluated to TRUE, since each of them contains the negated Boolean variable -P and P = FALSE.According to the fact that S is the union of S,, S xP, and S_P, we have that S is satisfiable, since the assignment A’ cm make every clause in S TRUE. A similar proof can be constructed if we let S( -P) be n satisfiable. By Theorem 1, we see that the divide-and-conquer strategy is applicable to theorem proving in propositional logic. A parallel algorithm which is based on the strategy can be constructed. In the following, we shall describe the algorithm formally.

THEOREM

PROVING

IN PROPOSITIONAL

69

LOGIC

ALGORITHMS. Input:

A set S of clauses.

Output:

Return YES if the empty clause can be deduced return No.

from S. Otherwise,

Procedure:

Step (1).

Check the clauses in S. If S is an empty set, then return Otherwise, if there is an empty clause 0, then return YES.

Step (2).

Select a Boolean variable sets S(P) and S( -P).

Step (3).

Perform

the following procedures

(3.1) Apply this algorithm (3.2) Apply this algorithm Step (4).

Compare

P which appears

in S, and construct

NO.

the

in parallel:

to the set S(P). to the set S( -P).

the two values returned

YES, then return YES. Otherwise,

from step (3). If both of them are return NO.

In the following we shall show that our parallel algorithm for theorem proving in propositional logic is logically complete and sound. In other words, the algorithm is correct. All the proofs are based on Theorem 1. DEFINITION. A theorem-proving procedure (algorithm) is logically complete if it can always prove the unsatisfiability of an unsatisfiable formula. THEOREM

2. Algorithm 1 is logically complete.

Proof. Let S be an unsatisfiable set of clauses. Now apply Algorithm 1 with S and some Boolean variable P in S. According to Theorem 1, both the constructed clause sets S(P) and S( -P) are unsatisfiable. Since the number of distinct Boolean variables in S(P) [and also in S( -P)] is less than that in S, after recursively applying Algorithm 1 the empty clause will be eventually produced. A YES is always obtainable from Algorithm 1. Thus, it is logically H complete. DEFINITION. A theorem-proving procedure (algorithm) is logically sound if whenever it declares the unsatisfiability of a formula, the formula is indeed unsatisfiable. THEOREM

3. Algorithm 1 is logically sound.

Proof. Assume that Algorithm 1 returns a YES for some input clause set S and thus declares that S is unsatisfiable. There are only two possible cases. One is that the empty clause is in S [see step (l)], and the other is that both the two values returned from step (3) are YES [see step (4)]. In the first case S is unsatisfiable because q is unsatisfiable. In the second case S is unsatisfiable n according to Theorem 1.

70

WEN-TSUEN

CHEN AND LUNG-LUNG

DEFINITION. An algorithm is procedurally correct if it will terminate produce the desired results for a problem to be solved. THEOREM

procedurally

4. For theorem proving correct.

in propositional

logic, Algorithm

LIU and

1 is

Proof. In Step (1) the termination condition in the algorithm is specified. Since at each recursion a Boolean variable is entirely deleted from the input set, and the total number of Boolean variables is decreased in each step, the termination condition is guaranteed to be met. According to Theorem 1, we see that the four steps properly construct S(P) and S( -P), handle the recursive calls with termination condition, and merge the values returned from the subproblems to obtain the result. Thus, Algorithm 1 is procedurally correct. w

4.

THE PIPELINED

EXECUTION

MODEL

In this section, we shall point out that in addition to the parallel processing of independent subproblems (which are produced by applying the divide-andconquer strategy), overlapped parallelism among hierarchically dependent subproblems can be further exploited. With this parallelism, a pipelined execution model for theorem proving in propositional logic is then built up. The overlapped parallelism is observed as follows: Assume that a clause C, contains P in S. Then, a clause Ci which is C, with P deleted is defined to belong to S(P). We put the clause Ci into S(P) immediately. Since the checking of the occurrence of a Boolean variable in a clause in S is independent of that in S(P), the checking operations can be performed in parallel if there are clauses in S and S(P). In other words, there can be an overlapped parallelism. A pipelining discipline is based on the overall view of the overlapped parallelism among a series of hierarchically dependent subproblems. To demonstrate the pipelined operation, we logically assume that a binary tree is constructed when the parallel algorithm is recursively used to solve a theoremproving problem. In the binary tree, the root represents the clause set for the original problem, and the other nodes represent those for the subsequent subproblems. The edges in the tree represent the hierarchical dependence of the subproblems. For example, the logical binary tree constructed for proving the formula given in Example 3 is depicted in Figure 1. Now we assume that in the tree the clauses are passed via the edges from the root to its descendent nodes. Initially, the clauses in S are passed to the root. Since P in S can be arbitrarily chosen, we simply choose P as the first Boolean variable of the first (in input sequence) clause of S. The clauses belonging to S(P) and those belonging to S( -P) are then properly passed into the nodes

THEOREM PROVING IN PROPOSITIONAL LOGIC -P

71

v R

'QvP

S

“R

Q

R

"Q “R

'R

S(P)

St-P)

Q

Q

l

-R I3

SiPI

(Q)

S(P)

cl

0

cl ‘R

Q

Q (“0)

St-PI

(R)

St-PI

Fig. 1. The logical binary tree constructed by applying the divide-and-conquer

L (“RI strategy.

representing S(P) and S( -P), respectively. With the concept of overlapped parallelism, each path from the root to a leaf node in the tree can function as a pipeline if clauses are ~n~uo~ly passed on the edges of the path. The pipelined execution model is described by a nmber of concurrent process activities. A process is responsible for handling a subproblem (or the origiual problem). Its activities include checking an input clause, sending proper clauses to its two subordinate processes, and receiving and returning the result (YE.3or No). At the beginning of solving a theorem-proving problem, there is only one process created and there is no pipeline at all. The process then begins to handle the problem, and the clauses in S are checked, one at a time. The first Boolean variable P in the first input clause in S is chosen. If a clause is firstly determined to belong to S(P) [or S( -P)], then another process is requested and a link between these two processes is constructed. Subsequent clauses which belong to S(P) [or S( -P)] are then passed via the link until an empty clause is encountered. In this case, the link is blocked, and from then on no more clauses are passed. T&e pipelines grow as the processes are dynamically created and the links are continuously constructed. The processes and the pipelines will finally form a binary tree which corresponds to the logical binary tree constructed by subproblems and relations obtained by using the parallel algorithm. A step-by-step

WEN-TSUEN

72

CHEN AND LUNG-LUNG

Q

-R -Q -P

” ”

LIU

-::

P R

-Q

v P

II l

Fig. 2. Pipelined operation for Example 3. Oval: active process; * : blocked process; -: clause moving; -: pipeline. (a) Initial clause set; (b) step 1; (c) step 2; (d) step 3; (e) step 4; (f) step 5; (g) step 6; (h) step 7; (i) step 8.

THEOREM

PROVING

IN PROPOSITIONAL

LOGIC

*

73

*

(9 Fig. 2. Continued.

demonstration of the pipelined operation for proving the formula given in Example 3 is depicted in Figure 2(a) through (i). The pipelined execution model is efficient for theorem proving in propositional logic because (1) independent subproblems are solved explicitly in parallel, and (2) hierarchically dependent subproblems are solved by overlapped processing.

parallel

With this model, suitable machine architectllres can also be considered. A tvnical hybrid architecture, which is composed of a tree machine and a simple ring-typed dataflow machine, has ‘-men c suggested for parallel theorem proving

WI. 5. ANALYSIS

OF TIME COMPLEXITY

OF THE ALGORITHM

In this section we shall analyze the processin time of the parallel algorithm. For an algorithm constructed by applying the ditide-and-conquer strategy, the processing time for a given problem can be defined by accumulating the time for dividing the problem, the time for solving the subproblems, and the time for merging the results obtained from the subproblems to obtain the result of the original problem. Since in general the subproblems can be solved by using the same strategy recursively, the processing time is usually expressed as a recurrent formula. Let r( m, n) be the processing time for our parallel algorithm performed without pipelined operation to prove a set S of m clauses with n distinct Boolean variables. With a chosen Boolean variable P, T( m, n) is the sum of the

WEN-TSUEN CHEN AND LUNG-LUNG LIU

14

following terms: (1) the time to construct S(P) and S( -P), (2) the larger of the times for solving the two subproblems (the left one with mL clauses and nL distinct Boolean variables, and the right one with mR clauses and nR distinct Boolean variables), and (3) the time to compare the results of the subproblems. The time for constructing S(P) and S( -P) is exactly the time to check the occurrences of P or -P in each of the m clauses in S. Obviously, it is less than or equal to cnm if the time for handling a Boolean variable in a clause is assumed to be a constant c. The comparison time at each recursion stage can be assumed to be a constant b. ‘Ihe recurrent formula for calculating T( m, n) is then expressed as follows: for

T(m,n)~cnm-tmax{T(m,,n,),~(m,,~,)}+b,

n>l,

m>l,

where mL,mR
and

nr,nR<~

and T(l,n)

= cn,

T( m,l) = cm. The upper bound of the recurrent formula is calculated as follows: T(m,n)


~cn(m+m,+m,+ gcn(m+m+m+

.- ~)+T(m,,l)+b(l+l+l+ .* .)+cm+b(l+l+l+

e*+) *..)

~c~(rn~)+b~~-1) = 0( mn*), where m, and n, are respectively the number of clauses and the number of distinct Boolean variables of the subproblem which is produced at each

THEOREM

PROVING

IN PROPOSITIONAL

LOGIC

75

recursion stage i (i==1,2,..., x < n) and has the longest processing time. Note that m, < m for all i. By applying the divide-and-conquer strategy, we have time complexity of 0( mn*) for the theorem-proving problem in propositional logic. In the following we shall point out that when the pipelined execution model is further incorporated in performing the parallel algorithm, the processing time can be improved to O(mn). Assume that it takes K time units to solve a certain problem in sequential processing. However, the problem can be solved with L-stage pipelined processing. Then, with this pipelined operation, the problem is solved only in K/L time units. In our case, we let K be O(mn*) and let L be n. Clearly, the processing time is improved to 0( mn). Note that the upper bounds on the processing time refer to the worst case only. In other words, in all other cases the time may be less than that. The number of processes created in performing our parallel algorithm is independent of whether we use the pipelined operation or not. In the worst case, it is 2”. However, in most of the cases it is less than that. We note again that the theorem proving problem in propositional logic is NP-complete, and it is hard in the worst case. 6.

CONCLUSIONS

AND FUTURE

WORK

In this paper we have proposed a parallel approach for theorem proving in propositional logic by applying the divide-and-conquer strategy and the pipelining discipline. A parallel algorithm has been constructed, and it has been proved to be logically complete and sound. The parallel algorithm can be efficiently performed with a pipelined execution model. With this model, the processing time of the algorithm is of 0( mn), where m is the number of clauses and n is the number of distinct Boolean variables in a given formula. In a comparison with the other approaches which use the general resolution principle as the inference rule, we have the following conclusions: (1) Our parallel approach is simpler than the others in that no explicit inference rule is used. Only checking and deleting operations are performed for each individual clause. (2) The number of Boolean variables in each clause is nonincreasing as our algorithm proceeds. The resolution principle may cause the number of Boolean variables in some clause to increase, thus making the clause set more complicated to handle and more inefficient to process. (3) There is a high degree of parallelism in the approach, because both independent subproblems and dependent subproblems are solved with parallel processing.

76

WEN-TSUEN

CHEN AND LUNG-LUNG

LIU

Two related problems are currently under study. One of them is the extension of the approach to parallel theorem proving in first-order logic. Preliminary results show that formulas with finite Herbrand universe can be proved with our parallel approach. The other problem is to analyze the average number of processes created for proving formulas in propositional logic. We thank Professor R. C. T. Lee for his suggestions and comments during writing of this paper.

REFERENCES 1. C. L. Chang

and

R. C. T. Lee,

Symbolic

Logic and Mechanical

Theorem

Proving,

Academic, 1973. 2. D. W. Loveland,

Automated Theorem Proving: A Logic Basis, North-Holland, 1978. 3. S. A. Cook, The Complexity of Theorem-Proving Procedures, in Proceedings of the 3rd Annual ACM Symposium on Theory of Computation, 1971, pp. 151-158. 4. D. W. Loveland, Automated theorem proving: A quarter century review, in Contemporary Mathematics, Vol. 29, Amer. Math. Sot. Press, 1984. 5. E. Horowitz and S. Sahni, Fundamentals of Computer Algorithms, Computer Science Press, 1978. 6. A. V. Aho, J. E. Hopcroft, and J. D. Ullman, The Design and Analysis of Computer Algorithms, Addison-Wesley, 1975. 7. K. Hwang and F. A. Briggs, Computer Architecture and Parallel Processing, McGraw-Hill, 1984. 8. M. Davis and H. Putnam, A computing procedure for quantification theory, J. Assoc. Comput. Mach. 7(7):201-215 (1960). 9. J. A. Robinson, A machine-oriented logic based on the resolution principle, J. Assoc. Comput. Much. 12(1):23-41 (1965). 10. M. Davis, G. Logemann, and D. W. Loveland, A machine program for theorem proving, Comm. ACM 5(7):394-397 (1962). 11. J. L. Bentley, An introduction to algorithm design, IEEE Computer, Feb. 1979, pp. 66-78. 12. W. T. Chen and L. L. Liu, Parallel machine architectures for theorem proving in propositional logic, in Proceedings of ‘85 NCS, R.O.C., 1985, pp. 1502-1515. Received

I4 May 1986; revised 19 July 1986, 8 October 1986