First-Order Logic. Cholwich Nattee. Sirindhorn International Institute of Technology Thammasat University. Lecture 9: First-Order Logic 1/60

Transcription

1 First-Order Logic Cholwich Nattee Sirindhorn International Institute of Technology Thammasat University Lecture 9: First-Order Logic 1/60

2 Pros and Cons of Propositional Logic Propositional logic is declarative. Propositional logic can deal with partial information using disjunctive and negation. Propositional logic is compositional. The meaning of a sentence comes from the meaning of its parts. For example, Round Square Meaning in propositional logic is context-independent. Propositional logic has very limited expressive power. Lecture 9: First-Order Logic 2/60

3 First-Order Logic (FOL) Whereas propositional logic assumes the world contains facts. FOL defines the world with: Objects Relations Functions Lecture 9: First-Order Logic 3/60

4 Models for FOL: Example crown person brother brother on head person king R $ J left leg left leg Lecture 9: First-Order Logic 4/60

5 Terminology Objects are elements in the domain, e.g. Richard, John, etc. A relation is the set of tuples of objects that are related. For example, brother = { Richard, John, John, Richard } on head = { the crown, John } king = { John } person = { John, Richard } A function is a kind of relations that a given object must be related to exactly one object. For example, a unary function left leg includes: Richard Richard s left leg John John s left leg Lecture 9: First-Order Logic 5/60

6 FOL: Basic Elements Type Examples Constants SIIT, Student, Somchai,... Predicates StudyAt, >, Brother,... Functions LeftLegOf, Sqrt,... Variables x, y, a, b,... Connectives,,,, Equality = Quantifier, Lecture 9: First-Order Logic 6/60

7 FOL: Atomic Sentences AtomicSentence = predicate(term 1, term 2,..., term n ) or term 1 = term 2 term = function(term 1,..., term m ) or or constant variable For example, Brother(John, Richard) > (Length(LeftLegOf (Richard)), Length(LeftLegOf (John))) Lecture 9: First-Order Logic 7/60

8 FOL: Complex Sentences In the same manner as propositional logic, complex sentences are made from atomic sentences using connectives. S, S 1 S 2, S 1 S 2, S 1 S 2, S 1 S 2 For example, Sibling(John, Richard) Sibling(Richard, John) >(1, 2) (1, 2) >(1, 2) >(1, 2) Lecture 9: First-Order Logic 8/60

9 Truth in FOL Sentences are true with respect to a model and an interpretation. Model contains objects and relations among objects. Interpretation specifies referents for constant symbols objects predicate symbols relations function symbols functional relations objects An atomic sentence predicate(term 1,..., term n ) is true, if and only if the objects referred by term 1,..., term n are in the relation referred by predicate. Lecture 9: First-Order Logic 9/60

10 Universal Quantification The universal quantifier ( ) is used to describe situation/things that are true about all objects For example, Every one studying at SIIT is smart. x StudyAt(x, SIIT) Smart(x) x P is true in a model m iff P is true with x being each possible object in the model. Roughly speaking, equivalent to the conjunction of instantiations of P... StudyAt(John, SIIT) Smart(John) StudyAt(Richard, SIIT) Smart(Richard) StudyAt(SIIT, SIIT) Smart(SIIT) Lecture 9: First-Order Logic 10/60

11 A common mistake to avoid Typically, is the main connective with. Common mistake: using as the connective with : x StudyAt(x, SIIT) Smart(x) It means Everyone is studying at SIIT and everyone is smart. Lecture 9: First-Order Logic 11/60

12 Existential Quantification The existential quantifier ( ) is used to state properties of some objects without naming it. For example, Someone studying at SIIT is smart. x StudyAt(x, SIIT) Smart(x) x P is true in a model m iff P is true with x being some possible object in the model. Roughly speaking, equivalent to the disjunction of instantiations of P... StudyAt(John, SIIT) Smart(John) StudyAt(Richard, SIIT) Smart(Richard) StudyAt(SIIT, SIIT) Smart(SIIT) Lecture 9: First-Order Logic 12/60

13 Another common mistake to avoid Typically, is the main connective with. Common mistake: using as the connective with : x StudyAt(x, SIIT) Smart(x) It is true if there is anyone who is not at SIIT. Lecture 9: First-Order Logic 13/60

14 Nested Quantifiers The order of quantification is very important: x y Loves(x, y) means Everybody loves somebody. or For every person, there is someone that person loves. y x Loves(x, y) means There is someone who is loved by everyone. Lecture 9: First-Order Logic 14/60

15 Connections between and Both quantifiers are connected with each other through negation. x Likes(x, Broccoli) x Likes(x, Broccoli) x Like(x, IceCream) x Likes(x, IceCream) De Morgan rules for quantified sentences: x P x P x P x P x P x P x P x P Lecture 9: First-Order Logic 15/60

16 Equality term 1 = term 2 is true under a given interpretation iff term 1 and term 2 refer to the same object. For example, x, y Brother(x, Richard) Brother(y, Richard) (x = y) means Richard has at least two brothers. Lecture 9: First-Order Logic 16/60

17 Exercises Represent the following sentences in FOL: Every student who takes French passes it. The best score in Greek is always higher than the best score in French. No person buys an expensive policy. Politicians can fool some of the people all of the time, and they can fool all of the people some of the time, but they can t fool all of the people all of the time. Source: Lecture 9: First-Order Logic 17/60

18 Prolog Prolog (Programming in Logic) is based on FOL calculus but it allows only Horn clauses. Prolog provides a way to develop a knowledge base and conduct inferences using first-order resolution. Prolog is widely used in various artificial intelligence applications, such as natural language processing, legal, medical and financial domains. Lecture 9: First-Order Logic 18/60

19 Prolog Programs A Prolog program = a set of facts and rules Facts = terms that are true in the knowledge base. Facts are written in a form of constants or predicates. For example, green(grass). mother(susan, john). All contants and predicates must start with a lower-case letter. Each fact must end with a period (.) Rules = FOL Horn clauses. For example, Parent(x, y) Female(x) Mother(x, y) Anyway, we usually write them using the connective. For example, Mother(x, y) Parent(x, y) Female(x) In Prolog, mother(x,y) :- parent(x,y), female(x). Lecture 9: First-Order Logic 19/60

20 Rules in Prolog [1] mother(x,y) :- parent(x,y), female(x). Left-hand side of :- is called head, the rest is body. The head will be true, if all parts of the body is true. Any literals starting with an upper-case letter is considered variables, e.g., X, Y, Person, etc. All variables in head are assumed to be universally quantified. Thus, the above sentence means For all X and Y, if X is a parent of Y and X is female then X is a mother of Y. Lecture 9: First-Order Logic 20/60

21 Rules in Prolog [2] Note that function is not allowed in Prolog. Every function is considered as a predicate. Variables in body can be considered universally quantified or existentially quantified. For example, hasachild(x) :- parent(x,y). 1. For all X and Y, if X is a parent of Y then X has a child. 2. For all X, X has a child if there exists Y such that X is a parent of Y. Lecture 9: First-Order Logic 21/60

22 Exercises Write the following statements into Prolog rules: 1. Everybody who has a child is happy. 2. For all X, if X has a child who has a sister then X has two children. (introduce a predicate hastwochildren) 3. For all X and Y, X is a grandfather of Y, if there exists Z that X is a parent, and Z is a parent of Y. 4. For all X, if X is written in a death note then X dies. Lecture 9: First-Order Logic 22/60

23 Recursive Rules [1] Let us consider a relation predecessor. We want to define it in terms of the parent relation. There are two definitions for predecessor: direct predecessor, and indirect predecessor. Direct predecessor: predecessor(x,y) :- parent(x,y). Indirect predecessor: X is a predecessor of Y, if there is a parentship chain of people between X and Y. predecessor(x,y) :- parent(x,z), parent(z,y). predecessor(x,y) :- parent(x,z), parent(z,a), predecessor(x,y) :-... parent(a,y). Lecture 9: First-Order Logic 23/60

24 Recursive Rules [2] A correct formulation of predecessor relation is needed to be correct at any depth. The key idea is to define it in terms of itself. predecessor(x,y) :- parent(x,y). (1) predecessor(x,y) :- parent(x,z), predecessor(z,y). (2) X is a predecessor of Y if either the rule (1) or (2) is true. Anyway, we need both of them to make the stopping condition for the recursive rule. Lecture 9: First-Order Logic 24/60

25 Prolog Interpreters Nowadays, there are several Prolog interpreters developed in both commercial and open-source software. We will use an open-source Prolog interpreter. YAP (Yet Another Prolog) is developed by LIACC/Universidade do Porto and at COPPE Sistemas/UFRJ. YAP is ported to several platforms: GNU/Linux: most distros provide a binary package. Mac OS X: via DarwinPorts MS Windows: Lecture 9: First-Order Logic 25/60

26 Using Prolog Interpreter [1] Before start the interpreter, we need to prepare the knowledge base for the Prolog. The prepared KB must be a text file containing facts, and rules. For example, family.pl parent(pam, bob). parent(tom, bob). parent(tom, liz). parent(bob, ann). parent(bob, pat). parent(pat, jim). female(pam). male(tom). male(bob). female(liz). female(ann). female(pat). male(jim). mother(x, Y) :- parent(x, Y), female(x). predecessor(x, Y) :- parent(x, Y). predecessor(x, Y) :- parent(x, Z), predecessor(z, Y). Lecture 9: First-Order Logic 26/60

27 Using Prolog Interpreter [2] Then, start the interpreter, it will show a prompt?- waiting for a query. Typhoon:~ cholwich$ yap % Restoring file /usr/local/lib/yap/startup YAP version Yap-5.1.1?- To exit, input a built-in fact halt.?- halt. To load the KB from file, use consult?- consult(family). If the file is ended with.pl, just put the file name. Otherwise,?- consult( family.pl ). Lecture 9: First-Order Logic 27/60

28 Querying After loading the KB into Prolog, we infer some conclusion from the KB by using querying. A query maybe a simple predicate,?- parent(tom,liz). yes A query may contain some variables, for example, we can ask Who is Tom s child? using a predicate parent,?- parent(tom,x). X = bob? ; X = liz? ; no Lecture 9: First-Order Logic 28/60

29 How Prolog answers questions? [1] A query in Prolog = a sequence of one or more goals. Prolog tries to satisfy all the goals. To satisfy all goals means to demonstrate that KB = α where α is the query. For example,?- predecessor(tom,pat). Prolog gets and evaluates the first rule having the same head (same number of arguments). predecessor(x,y) :- parent(x,y). predecessor(tom,pat) {X=tom, Y=pat} parent(tom,pat) no Lecture 9: First-Order Logic 29/60

30 How Prolog answers questions? [2] Prolog tries the next rule if the first rule does not satisfy the goal. predecessor(tom,pat) {X=tom, Y=pat} parent(tom,pat) no {X=tom, Y=pat} parent(tom,z), predecessor(z,pat). {Z=bob} predecessor(bob,pat). parent(bob,pat). yes Lecture 9: First-Order Logic 30/60

31 How Prolog answers questions? [3] :- predecessor(tom,pat). :- parent(tom,z), predecessor(z,pat). predecessor(x,y) :- parent(x,z), predecessor(z,y). {X=tom,Y=pat} parent(tom,bob) {Z=bob} :- predecessor(bob,pat). Lecture 9: First-Order Logic 31/60

32 How Prolog answers questions? [4] :- predecessor(bob,pat). predecessor(x,y) :- parent(x,y). :- parent(bob,pat). {X=bob,Y=pat} parent(bob,pat). Lecture 9: First-Order Logic 32/60

33 How Prolog answers questions? [5] Basically, Prolog conducts a backtracking search in order to satisfy the goal/query. Thus, each rule matched with the query will be tested one by one. Given 2 terms, they match if: they are identical the variables in both terms can be instantiated to objects to make the terms become identical. For example, date(d,m,2007) and date(d1,may,y1) parent(x,liz) and parent(x,y) Lecture 9: First-Order Logic 33/60

34 Matching General rules to decide matching between two terms S and T: 1. If S and T are constants then they match only if they are the same object. 2. If S is a variable, and T is anything, then they match, and S is instantiated to T. 3. If S and T are structures then they match only if 3.1 S and T have the same principle functor, and 3.2 all their corresponding components match. For example, triangle(point(1,1), A, point(2,3)) triangle(x, point(4,y), point(2,z)) Lecture 9: First-Order Logic 34/60

35 Exercises Will the following matching operations succeed or fail? 1. point(a,b) = point(1,2) 2. point(a,b) = point(x,y,z) 3. plus(2,2) = (2,D) = +(E,2) 5. triangle(p(-1,0),p2,p3) = triangle(point(x,y), p(1,1), P4) Lecture 9: First-Order Logic 35/60

36 Querying in Prolog: More Example Prolog uses backtracking in querying to check whether the given literal is true, or binding constants to variables. For example, if our KB contains two clauses: 1. member(x,[x T]). 2. member(x,[h T]) :- member(x,t). Case 1: user inputs a query member(a,[b,a,c]). 1. Match the given clause with the head of the first clause. This is unmatched (member(a,[b [a,c]]) member(x,[x T])) because X cannot be bound to two different values. 2. Match with the second clause. This is matched. Thus, X=a, H=b, and T=[a,c]. Then, Prolog needs to prove member(a,[a,c]). 2.1 Match member(a,[a [c]]) with the first clause. This is matched, then member(a,[a [c]]) is true. 3. Thus, member(a,[b,a,c]) is true. 4. Prolog answers yes. Lecture 9: First-Order Logic 36/60

37 Querying in Prolog: More Complicated Example Case 2: user inputs a query member(x,[a,b]). 1. Match with the head of the first clause. Then, member(a,[a [b]]). and X is bound to a. Prolog answers X=a. If the user wants more answers, he/she then inputs ;. 2. Prolog continues matching the rest which is the second clause. Then, It matches member(x,[a [b]]), and H=a, T=[b]. Then, member(x,t) is called recursively. Thus, Prolog needs to satisfy member(x,[b]). 2.1 Match the first clause. Then, member(b,[b []]) or X=b. 2.2 If the user still wants more answers, Prolog try to match the second clause. Thus, it matches member(x,[b []]) and calls member(x,[]) which cannot be matched with any clauses. 2.3 Thus, Prolog answers no. Lecture 9: First-Order Logic 37/60

38 Data Structure in Prolog The common and simple data structure in Prolog is list. Basically, a list is represented by a sequence of atoms in brackets. For example, [ann, tennis, tom, skiing], [],... Internally, lists are defined recursively. A list composes of two parts: head and tail as.(head, Tail). Head is the first item of the list; Tail is the list for the remaining part. We may write in form of [Head Tail]. Lecture 9: First-Order Logic 38/60

39 List Representation: Example [a,b,c,d] =.(a,.(b,.(c,.(d, [])))) = [a [b [c [ d []]]]] = [a,b [c,d]] a b c d [] Lecture 9: First-Order Logic 39/60

40 List Membership We can write Prolog rules/program to manipulate lists. Implement a rule member(x,l) that is true when object X is a member of list L. For example, member(a,[a,b,c]) is true member(a,[b,a,c]) is true member(a,[b,c,[a]]) is not true member([b,c],[a,[b,c]]) is true By thinking recursively, X is a member of L if either: 1. X is the head of L, or 2. X is a member of the tail of L. member(x,[x T]). member(x,[h T]) :- member(x,t). Lecture 9: First-Order Logic 40/60

41 Exercises 1. Write Prolog rules for concat(l1,l2,l3). that is true when concatenating two lists (L1 and L2) yields a list L3. For example, concat([a,b],[c],[a,b,c]) is true. 2. Write Prolog rules for last(x,l). that is true when X is the last member of L. For example, last(a,[b,c,a]) is true. Lecture 9: First-Order Logic 41/60

42 More Exercises 1. Define the relation reverse(list, ReversedList) that reverses lists. For example, reverse([a,b,c,d], [d,c,b,a]). 2. Define the predicate palindrome(list). A list is palindrome if it reads the same in the forward and in the backward direction. For example, palindrome([m,a,d,a,m]). 3. Define the relation shift(list1, List2) so that List 2 is List 1 shifted rotationally by one element to the left. For example, shift([1,2,3,4,5], [2,3,4,5,1]). Lecture 9: First-Order Logic 42/60

43 Arithmetic in Prolog [1] Some predefined operators can be used in Prolog: + addition - subtraction * multiplication / division ** power // integer division mod modulo Note that = in Prolog means term equality.?- X=1+2. X=1+2 The is operator will force evaluation.?- X is 1+2. X=3 Lecture 9: First-Order Logic 43/60

44 Arithmetic in Prolog [2] The comparison operators are also predefined in Prolog: > greater than < less than >= greater than or equal =< less than or equal =:= equal =\= not equal Lecture 9: First-Order Logic 44/60

45 Exercise 1. Define the relation length(list, N) that N is the number of members of List. 2. Define the predicate maxlist(list, Max) that Max is the maximum number in the list. 3. Define the predicate ordered(list) that is true when List is an ordered list of numbers. For example, ordered(1,3,4,5,7). 4. Define the predicate quicksort(list, SortedList) that conducts the quick sort on List yielding SortedList. Lecture 9: First-Order Logic 45/60

46 Structured Data and Data Abstraction [1] We can use Prolog for defining a logical database, and manipulating data structures. For example, using a Prolog program to manage studying/teaching time table. Lecture 9: First-Order Logic 46/60

47 Structured Data and Data Abstraction [2] courses.pl teaches(lecturer(cholwich), its451). sections(its451,[section(1, [time(tu,10,12):room(bkd,2401), time(th,10,12):room(bkd,2401)]), section(2, [time(mo,10,12):room(bkd,3216), time(th,14,16):room(bkd,3216)])]). teaches(lecturer(thanaruk), its453). sections(its453,[section(1, [time(tu,14,16):room(bkd,2401), time(th,13,15):room(bkd,2401)])]). Lecture 9: First-Order Logic 47/60

48 Structured Data and Data Abstraction [3] courses.pl :- use_module(library(lists)). occupied(room,day,time) :- sections(x,l), member(section(_,tr),l), member(time(day,s,f):r, TR), Room=R, S=<Time, F>=Time. Lecture 9: First-Order Logic 48/60

49 Exercises Add rules defining the following relations: 1. busy(lecturer,day,time) 2. teach_at(lecturer, Day, Time, Room) Lecture 9: First-Order Logic 49/60

50 Controlling Backtracking Uncontrolled backtracking causes inefficient program. Cut (!) is used to control backtracking. From a clause H :- B1, B2,..., Bm,!,..., Bn. If the user inputs a query H, each literal in the body of H will be executed one by one. At the moment that the cut is being executed, the system found some solution of the goals B1,..., Bm. When the cut is executed, the current solution of B1,..., Bm becomes frozen and all possible remaining alternatives are discarded. The system continues executing until Bn is satisfied. Then, H is satisfied. If the user still wants more answers, the system will try to backtrack to get alternative solutions. However, the literals B1,..., Bm will not be re-executed. Lecture 9: First-Order Logic 50/60

51 Cut: Example max(x,y,x) :- X>=Y. max(x,y,y) :- X<Y. This is a predicate to find the larger of two numbers denoted by X and Y. It means If X Y then Max = X. If X < Y then Max = Y. We can write another version of this predicate using cut: max(x,y,x) :- X>=Y,!. max(x,y,y). Prolog will try to satisfy the first rule. If Prolog can satisfy X Y, it will execute the cut. This means the solution will be frozen, no alternative solutions will be generated. However, if Prolog cannot satisfy the first rule, the second rule will be executed, and automatically Max = Y. Note that the rule order is important in this case. Lecture 9: First-Order Logic 51/60

52 Knowledge Engineering Knowledge engineering is the general process for constructing knowledge base. A knowledge engineer investigates a problem domain, learns what concepts are important in the domain, and creates a formal representation of the objects and relations in the domain. Domain Expert Knowledge Engineer Knowledge Acquisition Knowledge Base Lecture 9: First-Order Logic 52/60

53 Knowledge Engineering Process Knowledge engineering projects include the following steps: 1. Identify the task: Determining the range of questions that the KB will support. Determining the kinds of facts being available for each specific problem instance. 2. Assemble the relevant knowledge: Conducting knowledge acquisition to understand the scope of the KB and how the domain actually works. 3. Decide on a vocabulary of predicates, functions, and constants 4. Encode general knowledge about the domain 5. Encode a description of the specific problem instance 6. Pose queries to the inference procedure and get answers 7. Debug the knowledge base Lecture 9: First-Order Logic 53/60

54 Knowledge Engineering Example Identify the task C1 1 2 X1 X2 1 3 A2 A1 O1 2 We aim to analyze the circuit s functionality. For example, if all the inputs are 1, what is the output of gate A2? Lecture 9: First-Order Logic 54/60

55 Electronic Circuits Assemble the relevant knowledge Digital circuits compose of wires and gates. Signals flow along wires to the input terminals of gates. Each gate produces a signal on the output terminal that flows along another wire. There are four types of gates: AND, OR, XOR, and NOT which has only one input terminal. All gates have one output terminal. We focus on reasoning about functionality and connectivity. Thus, we do not talk about the wires, such as the paths the wires take, size or shape of the wires. Lecture 9: First-Order Logic 55/60

56 Electronic Circuits Decide on a vocabulary We need to distinguish a gate from other gates by using constants e.g. x1, x2, a1, o1, etc. Each gate has its type. We can set a predicate type(gate,gatetype) to refer to the type of the gate. For example, type(x1,xor), or type(a1,and). We use two predicates: in1 and in2 to specify inputs, and predicate out for output. For example, in1(x1,1), in2(x1,0). We need a predicate to show connectivity between gates such as connected(x1,o1,1) means the output of gate x1 is connected to the first input of gate o1. Finally, we need a predicate table for evaluation. For example, table(or,0,0,0). Lecture 9: First-Order Logic 56/60

57 Electronic Circuits Encode general knowledge of the domain Some rules and facts are needed to be prepared: circuit.pl in1(g,x) :- connected(g1,g,1), out(g1,x),!. in1(g,x) :- out(g,z), type(g,t), in2(g,y),!, table(t,x,y,z). in2(g,x) :- connected(g1,g,2), out(g1,x),!. in2(g,x) :- out(g,z), type(g,t), in1(g,y),!, table(t,y,x,z). out(g,z) :- type(g,t), in1(g,x), in2(g,y),!, table(t,x,y,z). table(or,0,0,0). table(or,0,1,1). table(or,1,0,1). table(or,1,1,1).... Lecture 9: First-Order Logic 57/60

58 Electronic Circuit Encode the specific problem instance We define the following circuit: 1 X1 0 O1 1 type(x1,xor). type(o1,or). in1(x1,1). in2(x1,1). connected(x1,o1,2). out(o1,1). circuit2.pl Lecture 9: First-Order Logic 58/60

59 Electronic Circuit Pose queries to the inference engine We then load the prepared KB to the Prolog interpreter, and we can query the KB. For example,?- in1(o1,x). X = 0 ; X = 1 ; no Debug the knowledge base We may need to debug the KB, if the KB does not work as we want. Lecture 9: First-Order Logic 59/60

60 References Ivan Bratko, Prolog: Programming for Artificial Intelligence, Pearson Education/Addison-Wesley, ISBN: Leo Sterling and Ehud Shapiro, The Art of Prolog, MIT Press, ISBN: Lecture 9: First-Order Logic 60/60