1. Logic Programming Automated Reasoning in practice

2. 2  But: people seldom reason monotonically !  First order logic is monotone: G T ’ Motivation: monotonicity T|=F1 F2 F3 + Fred is a penguin Birds fly + Fred is a bird Fred flies

3. 3 Default reasoning:  Is a form of reasoning that we’d like to use permanently  otherwise the rules are far too complex!  Is usually supported by hierarchy, inheritance and exceptions in OOP  also an early AI-formalism  CANNOT be expressed in FOL  independent on the knowledge representation !!  CAN be expressed in some FOL extensions  non-monotone logics  the simplest one of those is … …

4. 4 Logic Programming  Resolution-based automated reasoning:  restricted to Horn clauses  restricted to backwards linear resolution  BUT: with 3 important new extensions:  return Answer Substitutions  Least-model semantics instead of standard FOL model semantics  Extending Horn clause logic with Negation as Finite Failure

5. Answer substitutions The link to programming

6. 6 Answer substitutions anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v) false  parent(x1,z1)  anc(z1,y1) (2) {u/x1,v/y1} false  anc(B,y1) (3) {x1/A,z1/B} false  parent(B,y1) (1) {x2/B, y2/y1} false  (4) {y1/C} Answer: Yes,  u  v anc(u,v) That is: u = A and v = C (composition of all mgu’s applied to the goal variables)

7. 7 The third answer: u = B and v = C Another answer: u = A and v = B And computes ALL answers false  anc(u,v) false  parent(x1,y1) (1) {u/x1,v/y1} false  (3) {x1/A,y1/B} false  (4) {x1/B,y1/C} anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v)

8. 8 Logic PROGRAMMING  By computing answer substitutions Logic Programming serves as a de basis for a number of “general purpose” programming languages.  Prolog, Mercury, XSB, …  with an efficiency comparable with C !  and even faster for some programs.

9. 9 Practical programming?  Example arithmetic: double_plus_1(x,y)  y is 2*x + 1  Example lists: append([], list, list)  append([x|list1], list2, [x|list3])  append(list1, list2, list3) false  double_plus_1(3,z) Yes: z=7 false  double_plus_1(2,5) Yes false  append([1,2], [3,4,5], z) Yes: z= [1,2,3,4,5] false  append([1,2], y, [1,2,3]) Yes: y= [3] false  append(x, y, [1,2]) Yes: x = [], y = [1,2] x = [1], y = [2] x = [1], y = [2] …

10. Least model semantics Specify in a more compact way

11. 11 Least model semantics  Example: a database: celebrity(Crabé)celebrity(Jambers)celebrity(Peeters) celebrity(Lisa)celebrity(Tieleman)celebrity(Samson)  Is DeSchreye a celebrity ?? false  celebrity(DeSchreye)  We get no proof of inconsistency !  FOL semantics says: celebrity(DeSchreye) is not logically entailed, thus: we do not know if it is true or not!  Least model semantics says: ~ celebrity(DeSchreye)

12. 12  What are the atomic consequences of theory T? T  In FOL: Formally: the idea Consequences are in the intersection: p en ~r. We do not know anything about the truth of q and s. model 3 q ~s model 2 p ~r ~q s model 1  In LP: Consequences are in the intersection: p en ~r. Other predicates are NOT true: ~q and ~s.

13. 13 Relation with FOL celebrity(Crabé)celebrity(Jambers)celebrity(Peeters) celebrity(Lisa)celebrity(Tieleman)celebrity(Samson)  The logic program: celebrity(Crabé)celebrity(Jambers)celebrity(Peeters)~celebrity(DeSchreye)~celebrity(Janssens)… celebrity(Lisa)celebrity(Tieleman)celebrity(Samson)~celebrity(Cobain)~celebrity(Dali)…  is equivalent to the infinite FOL theory:  x celebrity(x)  (x = Crabé)  (x = Jambers)  (x = Peeters)  (x = Lisa)  ( x = Tieleman)  (x = Samson) (x = Lisa)  ( x = Tieleman)  (x = Samson)  or also to:

14. 14 The “closed” assumption  Logic programming provides a compact way to express ‘complete knowledge’ on some subject.  If you do not say that something is true, than it is false.  In other words: Logic Programming supports formulating definitions of the concepts.  Not just state what is true about these concepts (=FOL) !  The Closed World Assumption !  (= everything not entailed by the theory is false)

15. 15 How relevant is the change of semantics?  In FOL: {smart(Kelly)} implies neither strong(Kelly) nor ~strong(Kelly)  In LP: {smart(Kelly)} implies ~strong(Kelly)  In particular: LP is a non-monotone logic !!  In {smart(Kelly), strong(Kelly)}, ~strong(Kelly) is no longer entailed.  Knowledge is differently represented in these 2 formalisms.  Also: some concepts can be completely axiomatized in LP but not in FOL.  Ex.: the natural numbers !

16. Negation as finite failure

17. 17 Negation as finite failure  The basic idea:  extending the representation power of Logic Programming beyond the Horn Clauses logic  How?  equivalent:  allow disjunctions in the heads  allow negation before the body atoms –both give complete predicate logic ! –(but: with the least model semantics we will get something different from FOL!) Here: Introduce negations in bodies !

18. 18  Not the meaning of standard negation Meaning of negation as finite failure If all attempts to prove B using linear LP-resolution, fail in a finite time, conclude than not(B)  not(B) means:  This is meaningful only with the least model semantics (where everything that is not proven to be ‘true’, is considered to be ‘false’)

19. 19  Try to prove that “anc(John,B)” holds! false  anc(John,B) The ancestor example anc(x,y)  parent(x,y) (1) anc(x,y)  parent(x,z)  anc(z,y) (2) parent(A,B) (3) parent(B,C) (4) false  anc(u,v)  Conclusion: not anc(John,B) false  parent(John,B) (1) {x/John,y/B}fails false  parent(John,z)  anc(z,B) (2) {x/John,y/B}fails

20. 20 even(0) even(s(s(x)))  even(x) odd(y)  not even(y) false  odd(s(s(s(0)))) false  even(s(s(s(0)))) Another example false  not even(s(s(s(0)))) false  even(s(0)) {x/s(0)} fails Proof for even(s(s(s(0)))) fails: conclusion not even(s(s(s(0)))) false 

21. 21 q  q p  not q false  p false  q And another example  But ~q is true according to the least model semantics! false  not q false  q … Proof for q goes into infinite derivation: no conclusion for q no answer

22. 22 {x/Fly} false <- locomotion(Fred,x) false <- abnormal1(Fred) Default reasoning in LP (1): locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) Also known: isa(Fred,Bird), Prove that:  x locomotion(Fred,x) false <- isa(Fred,Bird), not abnormal1(Fred) false <- not abnormal1(Fred) false <- fails false <- isa(Fred,Ostrich)

23. 23 Default reasoning in LP (2): Also known: isa(Fred,Ostrich), Prove that:  x locomotion(Fred,x) locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) isa(Fred,Bird) {x/Fly} false <- locomotion(Fred,x) false <- abnormal1(Fred) false <- isa(Fred,Bird), not abnormal1(Fred) false <- not abnormal1(Fred) false <- isa(Fred,Ostrich) false <- fails (for this branch) backtracking: the 2nd branch

24. 24 Default reasoning (3): Also known: isa(Fred,Ostrich), Prove that:  x locomotion(Fred,x) locomotion(x,Fly)  isa(x,Bird), not abnormal1(x) locomotion(x,Walk)  isa(x,Ostrich), not abnormal2(x) isa(x,Bird)  isa(x,Ostrich) abnormal1(x)  isa(x,Ostrich) isa(Fred,Bird) {x/Walk} false <- locomotion(Fred,x) false <- abnormal2(Fred) false <- isa(Fred,Ostrich), not abnormal2(Fred) false <- not abnormal2(Fred) false <- fails

25. 25  A specific programming language based on LP. Prolog  Uses a depth-first strategy to search linear resolution proofs.  incomplete  can get stuck in infinite branches  Has a bunch of built-in predicates (sometimes without logical meaning) for:  Numerical computations, input-output, changing the search strategy, meta-programming, etc.  More recent LP languages: Goedel, Mercury, Hal,..

26. 26 Beyond FOL and Logic Programming  Logic Programming is very useful if you have a COMPLETE knowledge over your predicates  FOL is very useful if your knowledge is INCOMPLETE  Combine !  Open Logic Programming  LP-definitions for the part for which you have a complete knowledge,  FOL formulae for the rest.

27. 27 Constraint Logic Programming  Integrate constraint processing techniques (consistency, forward checking, looking ahead, …) with Logic Programming.  Advantages of Logic for knowledge representation  Advantages of Constraint solving for efficient problem solving  A number of languages: CHIP, Eclipse, Sicsus, etc.