Download presentation

Presentation is loading. Please wait.

Published byAlex Carlton Modified about 1 year ago

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.

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google