Download
prime implicants prime implicates and consequence finding n.
Skip this Video
Loading SlideShow in 5 Seconds..
Prime implicants, prime implicates and consequence finding. PowerPoint Presentation
Download Presentation
Prime implicants, prime implicates and consequence finding.

Prime implicants, prime implicates and consequence finding.

744 Views Download Presentation
Download Presentation

Prime implicants, prime implicates and consequence finding.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  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