Prime implicants, prime implicates and consequence finding.

1. Prime implicants, prime implicates and consequence finding. Material from: • A new algorithm for generating prime implicants [J.Slagle et al.]. • An improved incremental algorithm for generating prime implicates [J. de Kleer]. • A new method for consequence finding and compilation in restricted languages [del Val]. Digested by: Alexandre Klementiev.

2. Prime Implicants and Implicates • Prime implicantαof a formula φ is a conjunction of literals s.t. α |=φ, but deprived of a literal α |≠φ. • Prime implicateβof a formula φ is a clause s.t. φ |=β and there is no other implicate β’ s.t. β’ |=β. • Property: Prop. formulae are equivalent iff they have the same set of prime implicates/implicants.

3. Prime Implicants and Implicates: Motivation • Reduce prop. formula φ to its simplest equivalent. • Many applications: digital circuits, logic, etc. • Define simplifying φ as finding the simplest equivalent in some normal form. • Every φ can be represented by disjunction of all of its prime implicants. • However, we may not need all prime implicants.

4. Prime Implicants and Implicates: Objective • Generate the set of all prime implicates/implicants of φ. • Known to be NP-complete, but we can do much better than brute force. • If φ if redundant - get rid of unnecessary prime implicates/implicants.

5. Consequence Finding: Motivation and Objective • Given a knowledge base Δ, derive a set of formulas logically implied by Δ. • May wan to derive some subset of the set of all implicates of Δ. • Provide restrictions to guide the search. • Such task is called consequence finding.

6. Outline of the rest of the talk • Slagle et. al. (1970) • Generating prime implicants and implicates. • Finding minimal sum. • de Kleer (1992) • Generating prime implicates. • del Val (1999) • Consequence finding.

7. Approach I: Slagle et. al. • Start with φ in CNF. • Think of φ as a set of clauses. Remove clauses containing complimentary literals. Call new set S. • Choose literal ordering OS for S (e.g. based on literal “frequency”).

8. S . . . a b c d S1 • If Si = Ø – create terminal success node. • Else, delete from clauses in Si xi and all literals preceding xi in OS. • If Si contains an empty clause – create terminal failure node. • Else – create non-terminal node Si. S = 4. Build a “semantic tree”. • Start with S as a root node. • For each literal in OS, sprout a node from S. • For xi, create a set Si by deleting all clauses in S containing xi. S1 =

9. Start with S as a root node. S S1 S2 S3 S4 a d b d c d v v v v v x x • If Si = Ø – create terminal success node. • Else, delete from clauses in Si xi and all literals preceding xi in OS. • If Si contains an empty clause – create terminal failure node. • Else – create non-terminal node Si. S11 S12 S13 S21 S22 S31 S32 S33 S311 d c d S1 = S31 = S2 = S3 = S4 = 4. Build a “semantic tree”. • For each literal in OS, sprout a node from S. . . . a b c d x • For xi, create a set Si by deleting all clauses in S containing xi. v

10. Start with S as a root node. S S1 S2 S3 S4 a d b d c d v v v v v x x • If Si = Ø – create terminal success node. • Else, delete from clauses in Si xi and all literals preceding xi in OS. • If Si contains an empty clause – create terminal failure node. • Else – create non-terminal node Si. S11 S12 S13 S21 S22 S31 S32 S33 S311 d d c 4. Build a “semantic tree”. • For each literal in OS, sprout a node from S. . . . a b c d x • For xi, create a set Si by deleting all clauses in S containing xi. v W(S) =

11. What we have so far… • Slagle proves that: • Every element of W(S) is an implicant. • Every prime implicant is in W(S). • Shows that a symmetric algorithm used to obtain prime implicates if φ is in DNF (A). • May still be interested in finding the minimal sum. • Can use the algorithm again…

12. Minimal sum • How do we find the minimum sum? • Back to example: W(S) = • Put it in a table [McCluskey, 1956]…

13. McCluskey: Select the fewest rows such that each column has at least one cross in each selected row. • Slagle: Use the “semantic tree” algorithm again. First, represent table as a product of factors: • R = (P7+P8)(P5+P8)(P4+P5)(P6+P7)(P3+P6)(P3+P4)(P2+P5)P1 (P1+P2+P4+P5)P2(P1+P3)(P1+P2+P3+P4)

14. SR P1 P2 P3 P4 P5 P6 P7 P8 P7 P4 P4 P5 P8 P6 v v P8 P8 P6 P7 v v v v only success nodes shown • (P1, P2, P3, P5, P7) or Minimal sum • Represent table as a product of factors. (P7+P8)(P5+P8)(P4+P5)(P6+P7)(P3+P6)(P3+P4)(P2+P5) P1(P1+P2+P4+P5)P2(P1+P3)(P1+P2+P3+P4) • Come up with ordering OR using heuristic. • E.g. lower weight (e.g. fewer literals) – earlier. • Use algorithm again to construct tree. • Each element of W(SR) is a consistent table row set. • One of the elements corresponds to the minimal sum.

15. Slagle: Summary / Remarks • An algorithm to compute all prime + some non-prime implicates. • Use subsumption to get rid of non-primes. • A heuristic attempt to find minimal sum. • Any ordering OS works, practically frequency ordering generates fewer non-primes.

16. Approach II: de Kleer • Some resolution strategies are complete in proof finding, others in consequence finding. • Example: pure literal removal resolutions are not deduction complete. • Deduction complete resolution strategies will find all prime implicates of formula φ in CNF. • [Tison, de Kleer, etc.]: use deduction complete resolution to generate prime implicates of φ.

17. Approach II: de Kleer Brute force attempt: • Start with Δ in clausal form. • Repeatedly resolve pairs of clauses of Δ. • Add the result of resolution back to Δ, while removing all subsumed clauses.

18. Improving Efficiency • Many redundant resolutions. • E.g. for 3 resolvable clauses α, β, γ there are 3 ways to resolve r(α, r(β, γ)), r(r(α, β), γ), and r(r(α, γ), β). • Number of ways to derive result grows quickly. • Key idea [Tison]: place ordering on symbols, and iterate over these symbols in order. • Once all resolutions for a symbol are done, it is never necessary to resolve with respect to that symbol even for new resolution results produced later.

19. Improving Efficiency Consider 3 clauses: and order literals: a, b, c.

20. N S Improved Algorithm S is the current set of clauses, and N is the current set of prime implicates. Gist: Pick one clause (C) at a time from S, and for every literal in C (in order) resolve with N. Add new clauses to N.

21. Remove the next C = from S, add to N, and let Σ = {C}. N S Σ Improved Algorithm: Iteration 2 For each literal x in C, create Nx = clauses in N which resolve with x.

22. N S Σ Improved Algorithm: Iteration 2 • For each literal x in C: • Resolve each clause in Σ (which is still in N) with each clause in Nx (which is still in N). • For every new clause, discard it if it is subsumed by N U S, or remove any clauses it subsumes from N U S. Add it to N and Σ.

23. N S Σ Improved Algorithm: Iteration 3 • For each literal x in C: • Resolve each clause in Σ (which is still in N) with each clause in Nx (which is still in N). • For every new clause, discard it if it is subsumed by N U S, or remove any clauses it subsumes from N U S. Add it to N and Σ. Considers literals in order avoiding many redundant resolution steps

24. Subsumption • This algorithm (and many others) uses subsumption checking heavily. • For clauses subsumption check is a subset check. • e.g. a+b subsumes a+b+c • However, de Kleer can do better.

25. Subsumption For our algorithm, we are interested in three operations: • Check if clause x is subsumed by some clause in the Δ. • Add clause x to the Δ. • Remove all clauses from Δ which are subsumed by x.

26. a b b d d b+d a+d c a+b+c Subsumption: Representation • Order literals, turn clauses into lists of literals according to the chosen order. • Build a discrimination tree (trie). c+b+a d+b a+d [ [ [ a b a b d d c ] ] ] Choose order : a,b,c,d

27. c Subsumption: Checking Checking if clause x is subsumed by some clause in Δ can be done in one go. x = c + b + d a b [ ] b d b d d c v b+d a+d a+b+c subsumed by b + d

28. d c a+b+d Subsumption: Addition Adding a new (not subsumed) clause x to the knowledge base is easy. x = a + b + d a b [ ] a b d d b d b+d a+d a+b+c

29. b d b+d d c a+b+d Subsumption: Deletion To remove clauses subsumed by clause x - search trie in left-to-right depth-first fashion removing all clauses containing x. a x = b+d b d [ ] b d a+d a+b+c

30. de Kleer: Summary • Part 1: Existing [Tison] idea for reducing unnecessary resolutions. • Part 2: New idea: more efficient subsumption using the trie representation.

31. Consequence Finding: del Val • A clausal knowledge base Δ is written over some clausal language L. • We may be interested in all implicates of Δ or only those that belong to some LT L (LT implicates). • Consequence finding is the task of finding LT implicates.

32. skip or s(a+c) (a + c) kernel or k(a+c) Write (a+c) as a[c] Kernel Resolution • Recall Tison’s approach: ordered literals – fewer resolutions. Idea: any clause C can be resolved only upon literals (kernel of C) appearing later in the ordering then literal used to obtain C. and order: a, b, c. a b c d

33. Kernel Resolution In kernel resolution deductions every literal resolved upon is in its clause’s kernel.

34. Kernel Resolution: Example After C10 clauses containing d are deleted (subsumed).

35. Skip-filtered Kernel Resolution • What about consequence finding (finding implicates or restricted language LT)? • Extension of kernel resolution. • Produce resolvent C only if skip(C) LT. C is called LT– acceptable. • For any implicate of Δ in LT, we produce a logically stronger implicate. • Need a strategy to find all deductions for LT.

36. Search Strategy: Bucket Elimination • Associate buckets with each variable xi: b[xi]. • Each bucket contains clauses Ck containing xi only if resolving Ck upon xi can generate LT– acceptable clause. • Process buckets in order x1… xn. • Compute all resolvents on xi for ith bucket. • LT– acceptable resolvents are added in corresponding buckets.

37. Search Strategy: Incremental Saturation • Idea: take one clause at a time, process it until no more unsubsumed LT– acceptable resolvents can be generated. • Two sets of buckets: active and passive. • Put Δ into passive buckets. • For each clause of Δ • Put in active buckets, use BE (over active/passive) • When done, dump active buckets into passive.

38. del Val: Summary • Extended the Tison’s approach to consequence finding. • Approach is agnostic to search strategy of of LT-acceptable deductions. • Two search strategies (BE and IS) suggested. • IS may be preferred if Δ grows.

39. S . . . b a x x b a e a v v x x x x c d a c e a v Appendix A: Slagle for prime implicate generation back