Tri-Based Set Operations and Selective Computation of Prime Implicates? Andrew Matusiewicz1 , Neil V. Murray1 , and Erik Rosenthal1 Institute for Informatics, Logics, & Security Studies, Department of Computer Science, University at Albany – SUNY, Albany, NY 12222, USA a
[email protected] [email protected] [email protected]
Abstract. A more efficient version of the prime implicate algorithm introduced in [12] that reduces the use of subsumption is presented. The algorithm is shown to be easily tuned to produce restricted sets of prime implicates. Experiments that illustrate these improvements are described.
1
Introduction
Prime implicants were introduced by Quine [15] as a means of simplifying propositional logical formulas in disjunctive normal form (DNF); prime implicates play the dual role in conjunctive normal form (CNF). Implicants and implicates have many applications, including abduction and program synthesis of safety-critical software [8]. All prime implicate algorithms of which the authors are aware make extensive use of clause set subsumption; improvements in both the pi-trie algorithm and its core subsumption operations are therefore relevant to all such applications. Numerous algorithms have been developed to compute prime implicates — see, for example, [1, 2, 4–7, 9, 10, 14, 16, 20, 21]. Most use clause sets or truth tables as input, but rather few allow arbitrary formulas, such as the pi-trie algorithm introduced in [12]. Some are incremental in that they compute the prime implicates of a clause conjoined to a set of prime implicates. This recursive algorithm stores the prime implicates in a trie — i.e., a labeled tree — and has a number of interesting properties, including the property that, at every stage of the recursion, once the subtrie rooted at a node is built, some superset of each branch in the subtrie is a prime implicate of the original formula. This property admits variations of the algorithm that compute restricted sets of prime implicates, such as only positive ones or those not containing specific variables. These variations significantly prune the search space, and experiments indicate that significant speedups are obtained. In this paper, the improvements and properties are introduced and explained; experimental results are provided. Basic terminology and the fundamentals of pi-tries are summarized in Section 2. The analysis that leads to the new pi-trie algorithm is developed in Section 3, and triebased set operations and experiments with them are described in Section 4. The new ?
This research was supported in part by the National Science Foundation under grants IIS0712849 and IIS-0712752, and by the Air Force Research Laboratory, Award No. FA8750-101-0206, Subaward No. 450044-19191.
pi-trie algorithm and the results of experiments that compare the new algorithm with the original are described in Section 5. Useful properties of the algorithm are established in Section 6, and results of experiments that illustrate efficiency improvements are presented in Section 7. Proofs of lemmas and theorems can be found in [13].
2
Preliminaries
The terminology used in this paper for logical formulas is standard: An atom is a propositional variable, a literal is an atom or the negation of an atom, and a clause is a disjunction of literals. Clauses are often referred to as sets of literals; however, it is sometimes convenient to represent them with logical notation. An implicate of a formula is a clause entailed by the formula, and a non-tautological clause is a prime implicate if no proper subset is an implicate. The set of prime implicates of a formula F is denoted P(F). Note that a tautology has no prime implicates, and the empty clause is the only prime implicate of a contradiction. The trie is a tree in which each branch represents the sequence of symbols labeling the nodes (or sometimes edges) on that branch, in descending order. The nodes along each branch represent the literals of a clause, and the conjunction of all such clauses is a CNF equivalent of the formula. If there is no possibility of confusion, the term branch will often be used for the clause it represents. Further, it will be assumed that a variable ordering has been selected, and that nodes along each branch are labeled consistently with that ordering. A trie that stores all prime implicates of a formula is called a prime implicate trie, or simply a pi-trie. It is convenient to employ a ternary representation of pi-tries, with the root labeled 0 and the ith variable appearing only at the ith level. If v1 , v2 , . . . , vn are the variables, then the children of a node at level i are labeled vi+1 , ¬vi+1 , and 0, left to right. With this convention, any subtrie (including the entire trie) is easily expressed as a four-tuple consisting of its root and the three subtries. For example, the trie T can be written hr, T + , T − , T 0 i, where r is the label of the root of T , and T + , T − , and T 0 are the three (possibly empty) subtries. The ternary representation will generally be assumed here. Lemma 1 is well known and stated without proof. Lemma 1. Clause set S is prime iff S is a resolution-subsumption fixed point.
3
2
Prime Implicates under Truth-Functional Substitution
The pi-trie algorithm computes P(F) recursively from P(F[α/v]), where α is a truth constant 0 or 1 and is substituted for every occurrence of the variable v in P(F). When no confusion is possible, F[0/v] and F[1/v] will be denoted F0 and F1 , respectively. To transform P(F0 ) and P(F1 ) into P(F), note first that F ≡ (v ∨ F0 ) ∧ (¬v ∨ F1 ); i.e., P(F) is logically equivalent to (v ∨ P(F0 )) ∧ (¬v ∨ P(F1 )). Let J0 and J1 , respectively, be the clause sets produced by distributing v — respectively, ¬v — over P(F0 ) — respectively, P(F1 ). Observe that J0 and J1 are (separately) resolutionsubsumption fixed points because P(F0 ) and P(F1 ) are. Subsumption cannot hold between one clause in J0 and one in J1 since one contains v and the other ¬v. Thus if J0 ∪J1 is not a resolution-subsumption fixed point, producing a fixed point from it must 2
require resolutions having one parent from each. These can be restricted to resolving on v and ¬v because any other produces a tautology. Note that each such resolvent is the union of a clause from P(F0 ) and one from P(F1 ). This proves Lemma 2. The only useful resolvents in J0 ∪ J1 are on v and ¬v.
2
It turns out to be sufficient to consider all such resolvents but no others: Theorem 1. Let F be a logical formula and let v be a variable in F. Suppose E is a prime implicate of F not containing v. Then E = (C ∪ D), where C ∈ P(F0 ) and D ∈ P(F1 ). 2 Theorem 1 and the discussion leading up to it suggest a method for computing P(F) from P(F0 ) and P(F1 ). From Lemma 2, no useful resolvent can contain v or ¬v. Thus the prime implicates that do are already in J0 ∪ J1 . By Theorem 1 the useful resolvents account for all prime implicates of F that do not contain the variable v. Thus, to produce P(F), it suffices to obtain the subsumption minimal subset of the fully resolved J0 ∪ J1 . Denote P(F0 ) and P(F1 ) by P0 and P1 , respectively, and partition each into two subsets: P0⊇ , the clauses in P0 subsumed by some clause in P1 , and P0./ , the remaining clauses in P0 . Define P1⊇ and P1./ similarly. Theorem 2. Let J0 , J1 , P0 , P1 , P0⊇ , P0./ , P1⊇ , and P1./ be defined as above. Then (∗) P(F) = (v ∨ P0./ ) ∪ (¬v ∨ P1./ ) ∪ P0⊇ ∪ P1⊇ ∪ U where U is the maximal subsumption-free subset of {C ∪ D | C ∈ P0./ , D ∈ P1./ } in which no clause is subsumed by a clause in P0⊇ or in P1⊇ . 2 Observe that if C in P0 strictly subsumes D in P1⊇ , then C is in P0./ : Were C in P0⊇ , the clause in P1 that subsumes C would also subsume D, which is impossible. As a result, C appears in the prime implicate {v} ∪ C, which does not subsume D.
4
Tri-Based Operations
The pi-trie algorithm introduced in [12] used a routine called PIT, which was developed with a branch by branch analysis. The new version of the algorithm uses a new version of PIT. The two appear different but in fact use similar methods to construct P(F) from P0 and P1 . The new one employs the set operations of Theorem 2. The resulting development is arguably more intuitive, and the new algorithm is more efficient. One improvement comes from identifying P0⊇ and P1⊇ before considering any clauses as possible members of U. The details are omitted here, but the result is avoidance of unnecessary subsumption checks. Furthermore, keeping P0⊇ and P0./ as separate sets makes prime marks at the ends of trie branches unnecessary; checking for them in the original algorithm is almost as expensive as the subsumption check itself. Most significantly, clause set operations can be realized recursively on entire sets, represented as tries.1 Experimentally, the advantage increases with the size of the trie. 1
Tries have been employed for (even first order) subsumption [19], but on a clause to trie basis, rather than the trie to trie basis developed here.
3
The operators Subsumed(F, G) = {C ∈ G | C is subsumed by some C 0 ∈ F } and XUnions(F, G) = {C ∪ D | C ∈ F, D ∈ G, C ∪ D is not tautological } on clause sets F and G are defined as set operations, but the pseudocode implements them on clause sets represented as ternary tries. Recall that the trie T can be written hr, T + , T − , T 0 i, where r is the root label of T , and T + , T − , and T 0 are the three subtries. Tries with three empty children are called leaves.
input : Two clausal tries T1 and T2 output: T , a trie containing all the clauses in T2 subsumed by some clause in T1 if T1 = null or T2 = null then T ← null ; else if leaf(T1 ) then T ← T2 ; else T ← new Leaf; T + ← Subsumed(T1+ , T2+ ) ∪ Subsumed(T10 , T2+ ) ; T − ← Subsumed(T1− , T2− ) ∪ Subsumed(T10 , T2− ) ; T 0 ← Subsumed(T10 , T20 ) ; if leaf(T ) then T ← null; end end return T ;
Algorithm 1: Subsumed(T1 ,T2 )
input : Two clausal tries T1 and T2 output: T , a trie of the pairwise unions of the clauses in T1 and T2 if T1 = null or T2 = null then T ← null ; else if leaf(T1 ) then T ← T2 ; else if leaf(T2 ) then T ← T1 ; else T ← new Leaf; T + ← XUnions(T1+ , T2+ ) ∪ XUnions(T10 , T2+ ) ∪ XUnions(T1+ , T20 ) ; T − ← XUnions(T1− , T2− ) ∪ XUnions(T10 , T2− ) ∪ XUnions(T1− , T20 ) ; T 0 ← XUnions(T10 , T20 ); if leaf(T ) then T ← null; end end return T ; Algorithm 2: XUnions(T1 ,T2 ) Experiments involving subsumption testing are reported below. In Section 5, the new and original versions of the pi-trie algorithms are compared. 4
Runtimes for NaiveSubsumed verses Subsumed 16000 NaiveSubsumed Subsumed
14000 12000
# of msecs
10000 8000 6000 4000 2000 0 0
5000
10000
15000
20000
25000
30000
35000
size of input
Fig. 1. Subsumed vs NaiveSubsumed
The input for the experiments depicted in Figure 1 is a pair of n-variable CNF formulas, where n ∈ {10, . . . , 15} with results averaged over 20 trials for each n. Each formula with n variables has b n3 /4c clauses of length 3, b n4 /2c clauses of length 4, 1 and n5 clauses of length 5. This corresponds to 32 of the 2k nk possible clauses of length k for k = 3, 4, 5. The two clause sets are compiled into two tries for the application of Subsumed and into two lists for the application of NaiveSubsumed. (The latter is a straightforward subset test on lists and is not shown.) The ratio of the runtimes changes as the input size increases, suggesting that the runtimes of NaiveSubsumed and Subsumed differ asymptotically. Additional evidence is supplied by Lemma 3: Lemma 3. Subsumed, when applied to two full ternary tries of depth h and combined log 5 h+1 2 size n = 2( 3 2 −1 ), runs in time O(n log 3 ) ≈ O(n1.465 ). This is less than NaiveSubsumed’s obvious runtime of O(n2 ) but still more than linear. Lemma 3 is interesting but the general upper bound may be quite different.
5
The New pi-trie Algorithm
Theorem 2 provides a simpler characterization of the pi-trie algorithm than the one developed in [12]. The algorithm can be viewed in the standard divide-and-conquer framework,2 where each problem F is divided into subproblems F0 , F1 by substitution on the appropriate variable. The base case is when substitution yields a constant, so that P(0) = {{}} or P(1) = {}. The remainder of the algorithm consists of combining P0 and P1 to form P(F). This is done both here and in [12] by a routine called PIT. However, in [12], the subsumption checking is done branch by branch; here, it is performed between entire tries 2
Rudell [17] proposed a similar divide-and-conquer strategy for prime implicants absent of any analysis of precisely when and how subsumption checks are applied.
5
input : A boolean formula F and a list of its variables V = hv1 , . . . , vk i output: The clause set P(F ) — the prime implicates of F if F = 1 then return ∅ ; // Tautologies have no prime implicates. else if F = 0 then return {{}} ; // P(0) is the set of just the empty clause. else F0 ← F [0/v1 ]; F1 ← F [1/v1 ]; V 0 ← hv2 , . . . , vk i; return PIT( prime(F0 , V 0 ) , prime(F1 , V 0 ) , v1 ); end
Algorithm 3: prime(F,V )
denoted by P0 , P1 , P0⊇ , P0./ , P1⊇ , and P1./ . Trie-based operations are employed such as Subsumed and U nions, which were discussed in Section 4.
input : Clause sets P0 = P(F0 ) and P1 = P(F1 ), variable v output: The clause set P = P((v ∨ F0 ) ∧ (¬v ∨ F1 )) P0⊇ ← Subsumed(P1 , P0 ) ; // Initialize P0⊇ P1⊇ ← Subsumed(P0 , P1 ) ; // Initialize P0⊇ P0./ ← P0 − P0⊇ ; P1./ ← P1 − P1⊇ ; U ← XUnions(P0./ , P1./ ); U ← U − SubsumedStrict(U , U); U ← U − Subsumed(P0⊇ , U); U ← U − Subsumed(P1⊇ , U); return ((v ∨ P0./ ) ∪ (¬v ∨ P1./ ) ∪ P0⊇ ∪ P1⊇ ∪ U ) ;
Algorithm 4: PIT(P0 ,P1 ,v)
Figure 2 compares the pi-trie algorithm from [12] to the updated version using the recursive Subsumed and XU nion operators. The input for both algorithms is 15variable 3-CNF with varying numbers of clauses, and the runtimes are averaged over 20 trials. The great discrepancy between runtimes requires that they be presented in log scale; it is explained in part by Figure 1, which compares the runtime of Subsumed to Algorithm 5, a na¨ıve subsumption algorithm. The performance of the two systems converges as the number of clauses increases. With more clauses, formulas are unsatisfiable with probability approaching 1. As a result, the base cases of the prime algorithm are encountered early, and subsumption in the PIT routine plays a less dominant role, diminishing the advantage of the new algorithm. 6
Old vs New pi-trie Algorithms on 15 var 3-CNF Old pi-trie New pi-trie 100000
# of msecs
10000
1000
100
10 10
20
30
40
50
60
70
# of clauses
Fig. 2. Old vs New pi-trie algorithm
6
Selective Computation
It is sometimes useful to restrict attention to a subset of prime implicates having some particular property, such as being positive or having length at most four. The subset can always be selected from the entire set of prime implicates, but generating only the prime implicates of interest is preferable (if this improves efficiency!). If Q is a property that sets may or may not have, and if A and B are sets, then Q is said to be superset invariant if whenever B ⊇ A, Q(A) → Q(B); it is subset invariant if whenever B ⊆ A, Q(A) → Q(B). The complement property, denoted Q, is defined in the obvious way: Q(X) = ¬Q(X). Examples of subset invariant properties of clauses are containing no more than three literals, containing only positive literals, and being a Horn clause. The following lemma is immediate. Lemma 4. If Q is superset (subset) invariant, then Q is subset (superset) invariant. 2 It turns out that the pi-trie algorithm is particularly amenable to being tuned to generate only prime implicates satisfying subset invariant properties. The reason is that clauses computed at any stage of the algorithm always contain as subsets clauses computed at an earlier stage. The main function of the pi-trie algorithm is prime, which returns the set (represented as a trie) of prime implicates of its first argument, F. This set is simply the result of the PIT routine called on the prime implicates of F0 and F1 as actual parameters and represented in PIT by the formal parameters P0 and P1 . Examining the assignment statements in PIT, it is easily verified that P0./ and P1./ consist of subsets of P0 and P1 . Furthermore, every clause initially in U is the union of two clauses from P0./ and P1./ , and hence from P0 and P1 . Subsequent modifications of U are set subtractions. Therefore, in the return statement, each clause of v ∨ P0./ , ¬v ∨ P1./ , P0⊇ ∪ P1⊇ , and U 7
may contain v, ¬v, or neither, and otherwise consists of exactly one clause from either P0 or P1 , or of exactly two clauses – one each from P0 and P1 . This proves Lemma 5. Let C ∈ PIT( prime(F0 , V 0 ) , prime(F1 , V 0 ), v1 ) and let C0 ∈ prime(F0 , V 0 ). Then either C ∩ C0 = ∅ or C ∩ C0 = C0 . Similarly for C1 ∈ prime(F1 , V 0 ). 2 Theorem 3. Let Q be a subset invariant property, and let F be a propositional formula. Construct PITQ to be PIT modified to first delete all clauses in P0 and in P1 having property Q. Let S = prime(F0 , V 0 ) ∪ prime(F1 , V 0 ). Partition S into the prime implicates having property Q, denoted SQ , and those having property Q, denoted SQ . Then the clauses produced by PITQ ( prime(F0 , V 0 ) , prime(F1 , V 0 ), v1 ) include all those produced by PIT( prime(F0 , V 0 ) , prime(F1 , V 0 ), v1 ) having property Q. 2 Observe that the theorem does not guarantee that PIT returns only clauses of SQ . By adding a literal to clauses in P0./ or in P1./ , or by forming a union of clauses with Q, a clause with property Q may result (e.g., when Q is a length restriction.) The point is that clauses with Q are not required to generate clauses with Q. Since PITQ is invoked recursively by prime, each invocation is pruning only the most recently generated clauses with Q. Therefore, the clauses returned by the initial invocation of prime should be pruned one final time, but this is an implementation detail. Restricted sets of prime implicates are useful in several settings. One is abductive reasoning: Finding short non-redundant explanations will result from restricting the length of prime implicates of the theory. Perhaps surprisingly, prime implicates turn out to be useful in the synthesis of correct code for systems having polychronous data flow (both synchronous and asynchronous data flow). In [8], a calculus of epochs is developed which requires computations of prime implicates. The most useful in this setting are positive — no negative literals present — and short — containing only a few literals. Positive, unit prime implicates are particularly useful. Of course, these are all subset invariant properties.
7
Experiments with Subset Invariant Properties
The new pi-trie algorithm — with subset invariant filters for maximum clause length and for designated forbidden literals — is implemented in Java. Its performance has been compared with two others.3 The first comes from a system of Zhuang, Pagnucco and Meyer [22]. The second comparison was made with a somewhat simpler resolutionbased prime implicate generator called ResPrime. Also implemented in Java, it exhaustively iterates resolution and subsumption checking. The input for all experiments is a variable number of random 3-CNF clauses from a constant alphabet size. For a good experimental analysis of prime implicates in random 3-CNF, see [18]. The algorithm from [22] proved to be much slower than the others and could not be illustrated in Figure 3, which shows a comparison of runtimes of ResPrime, pi-trie, and pi-trie filtered to exclude clauses of length greater than 2. While ResPrime outperforms the pi-trie algorithm on small input, the reverse is true on larger input. When the number of clauses is small, the number of possible resolutions 3
It is surprisingly difficult to find publicly available prime implicate generators.
8
on small clause sets is correspondingly small, whereas the pi-trie algorithm does not assume the input to be CNF and thus does not take advantage of this syntactic feature. Probabilistically, as the number of clauses increases, the formulas become less and less satisfiable, and so in general the recursive substitution that drives the pi-trie algorithm requires fewer substitutions to reach a contradiction, allowing faster runtimes. Much of the work so avoided is also avoided by filtering, and this lessens the advantage of filtering itself with formulas whose size is large compared with the number of variables (see Figure 4 below). At the same time, the resolution algorithm is required to process more and more clauses and their resolution pairs, and so runs slower. The pi-trie algorithm with filtering offers dramatic improvements in performance on searches for subset invariant prime implicates. Figure 4 has the results of an experiment with a 13-variable 3-CNF formula. Two filters are used: The first is “max length 2,” and the second excludes clauses containing any of the literals v3 , v5 , v6 , or ¬v7 .
Runtime Comparison for Random 10-var 3-CNF (average of 20 trials) 1400 ResPrime pi-trie algorithm pi-trie filtered, max 2 literals
1200
# of msecs
1000 800 600 400 200 0 10
20
30
40
50
60
# of clauses
Fig. 3. 10 var 3-CNF
Note that especially for the length-limited filter, significant efficiency gains can be attained by applying the filter during generation as opposed to generating all prime implicates and then filtering, as most other algorithms require. In fact, besides [11], which uses a novel integer linear programming approach to discover small prime implicants (easily transformed to a prime implicate algorithm via duality), the authors are not aware of any other algorithms that allow filtering during generation of prime implicates based on size or on designated literals. The results described in Figure 4 for formulas having 20 clauses are noteworthy: The raw pi-trie algorithm averaged 22,430 msecs, whereas the “max length 2” filter averaged only 1,170 msecs. One reason for the runtime advantage is that 13-variable 20-clause formulas have relatively long prime implicates. The average number of prime implicates is 213.3, while the average number with length at most 2 is 0.7. 9
Generating all prime implicates is considerably more difficult than deciding satisfiability — the number of prime implicates of a formula, and thus the size of the output, is typically exponential [3]. These experiments were thus performed on relatively small input compared to the examples that modern DPLL-based SAT solvers can handle.
Runtime Comparison for Random 13-var 3-CNF (average of 20 trials) 30000 pi-trie pi-trie filtered, forbidden literals pi-trie filtered, max 2 literals
25000
# of msecs
20000
15000
10000
5000
0 10
20
30
40
50
# of clauses
Fig. 4. pi-trie Filtering
Suppose now that a filter is applied that prunes all prime implicates having length greater than some fixed k. If n is the number of variables, the number of prime implicates of length k or less is bounded above by nk ·3k which is polynomial in n of degree at most k. This proves Theorem 4. Let F be a formula with n variables, and let Q be a subset invariant property satisfied only by clauses of length k or less. Then if the pi-trie algorithm employs PITQ , it runs in polynomial space. 2 Placing an upper bound on length or restricting prime implicates to consist only of certain designated literals will therefore cause the pi-trie algorithm to run in polynomial space. Note that for any one problem instance, a restriction to designated literals amounts to prohibiting the complement set of literals. But if the problem is parameterized on the size of the complement set, polynomial space computation does not result because for a fixed k, as n increases, so does admissible clause length.
References 1. Guilherme Bittencourt. Combining syntax and semantics through prime form representation. Journal of Logic and Computation, 18:13–33, 2008. 2. Thierry Castell. Computation of prime implicates and prime implicants by a variant of the davis and putnam procedure. In ICTAI, pages 428–429, 1996. 3. A. Chandra and G. Markowsky. On the number of prime implicants. Discrete Mathematics, 24:7–11, 1978.
10
4. O. Coudert and J. Madre. Implicit and incremental computation of primes and essential implicant primes of boolean functions. In 29th ACM/IEEE Design Automation Conference, pages 36–39, 1992. 5. J. de Kleer. An improved incremental algorithm for computing prime implicants. In Proc. AAAI-92, pages 780–785, San Jose, CA, 1992. 6. Peter Jackson. Computing prime implicants incrementally. In Proc. 11th International Conference on Automated Deduction, Saratoga Springs, NY, June, 1992, pages 253–267, 1992. In Lecture Notes in Artificial Intelligence, Springer-Verlag, Vol. 607. 7. Peter Jackson and J. Pais. Computing prime implicants. In Proc. 10th International Conference on Automated Deductions, Kaiserslautern, Germany, July, 1990, volume 449, pages 543–557, 1990. In Lecture Notes in Artificial Intelligence, Springer-Verlag, Vol. 449. 8. B.A. Jose, S.K. Shukla, H.D. Patel, and J.P. Talpin. On the deterministic multi-threaded software synthesis from polychronous specifications. In Formal Models and Methods in Co-Design (MEMOCODE’08), Anaheim, California, June 2008, 2008. 9. A. Kean and G. Tsiknis. An incremental method for generating prime implicants/implicates. Journal of Symbolic Computation, 9:185–206, 1990. 10. V.M. Manquinho, P.F. Flores, J.P.M. Silva, and A.L. Oliveira. Prime implicant computation using satisfiability algorithms. In Proceedings of the IEEE International Conference on Tools with Artificial Intelligence, Newport Beach, U.S.A., November, 1997, pages 232–239, 1997. 11. Joao P. Marques-Silva. On computing minimum size prime implicants. In in International Workshop on Logic Synthesis, 1997. 12. A. Matusiewicz, N.V. Murray, and E. Rosenthal. Prime implicate tries. In Proceedings of the International Conference TABLEAUX 2009 - Analytic Tableaux and Related Methods, Oslo, Norway, July 2009, pages 250–264, 2009. In Lecture Notes in Artificial Intelligence, Springer-Verlag. Vol. 5607. 13. A. Matusiewicz, N.V. Murray, and E. Rosenthal. Tri-based subsumption and selective computation of prime implicates. Technical Report SUNYA-CS-11-01, Department of Computer Science, University at Albany - SUNY, March 2011. 14. T. Ngair. A new algorithm for incremental prime implicate generation. In Proc. IJCAI-93, Chambery, France, (1993), 1993. 15. W. V. Quine. The problem of simplifying truth functions. The American Mathematical Monthly, 59(8):521–531, 1952. 16. Anavai Ramesh, George Becker, and Neil V. Murray. Cnf and dnf considered harmful for computing prime implicants/implicates. Journal of Automated Reasoning, 18(3):337–356, 1997. 17. Richard L. Rudell. Logic Synthesis for VLSI Design. PhD thesis, EECS Department, University of California, Berkeley, 1989. 18. Robert Schrag and James M. Crawford. Implicates and prime implicates in random 3-SAT. Artificial Intelligence, 81(1-2):199–222, 1996. 19. Stephan Schulz. Simple and efficient clause subsumption with feature vector indexing. In Proceedings of the IJCAR 2004 Workshop on Empirically Successful First-Order Theorem Proving, Cork, Ireland, July 2004, 2004. 20. J. R. Slagle, C. L. Chang, and R. C. T. Lee. A new algorithm for generating prime implicants. IEEE transactions on Computers, C-19(4):304–310, 1970. 21. T. Strzemecki. Polynomial-time algorithm for generation of prime implicants. Journal of Complexity, 8:37–63, 1992. 22. Zhi Qiang Zhuang, Maurice Pagnucco, and Thomas Meyer. Implementing iterated belief change via prime implicates. In Australian Conference on Artificial Intelligence, pages 507– 518, 2007.
11
