First Order Logic (FOL) and Inference

Transcription

1 First Order Logic (FOL) and Inference CE417: Introduction to Artificial Intelligence Sharif University of Technology Spring 2018 Soleymani Artificial Intelligence: A Modern Approach, 3 rd Edition, Chapter 8 & 9

2 Why FOL? To represent knowledge of complex environments concisely Expressive enough to represent a good deal of of our knowledge E.g., pits cause breezes in adjacent squares needs many rules in propositional logic but one rule in FOL 2

3 Natural language elements & FOL elements Some basic elements of natural language (included also in FOL): Nouns and noun phrases referring to objects (squares, pits, wumpus) Some of objects are defined as functions of other objects Verbs and verb phrases referring to relation among objects (is breezy, is adjacent to, shoot) Examples: Objects: people, houses, numbers, baseball games, Relations Unary relation or property: red, round, prime, n-ary: brother of, bigger than, inside, part of, owns, comes between, Functions: father of, best friend, one more than, beginning of, FOL does not include all elements of natural language. 3

4 Symbols & interpretations Types of symbols Constant for objects Predicate for relations Function for functional relations 4

5 Example Brother(Richard, John) Father(John) = Henry Married(Father(Richard), Mother(John)) x King x Person x x Crown x OnHead x, John x, y Brother x, Richard Brother y, Richard (x = y) King(Richard) King(John) x, y Sibling(x, y) [ x = y m, f (m = f) Parent(m, x) Parent(f, x) Parent(m, y) Parent(f, y)] 5

6 Syntax of FOL: Basic elements Logical elements Connectives,,,, Quantifiers, Domain specific elements Constants John, Richard, Predicates Brother,... Functions LeftLegOf,... Non-logical general elements Variables x, y, a, b, Equality = 6

7 Syntax of FOL: Atomic sentences Atomic Sentence Predicate Predicate (Term,, Term) Term=Term Term Constant variable Function(Term, ) Object Relation 1) Brother(Richard, John) Constant Richard A X 1 Variable a x s Function Mother LeftLeg 2) Father(John) = Henry 3) Married(Father(Richard), Mother(John)) Predicate True False After Loves Hascolor. 7

8 Syntax of FOL (BNF Grammar) Sentence Atomic Sentence ComplexSentence Atomic Sentence Predicate Predicate (Term,, Term) Term=Term ComplexSentence ( Sentence ) Sentence Sentence Sentence Sentence Sentence Sentence Sentence Sentence Sentence Quantifier variable, Sentence Term Function(Term, ) Constant variable Quantifier Constant A X 1 Variable a x s Predicate True False After Loves Hascolor. Function Mother LeftLeg 8 Operator Precedence:, =,,,,

9 Universal quantification x P(x) is true in a model m iff P(x) is true with x being each possible object in the model conjunction of instantiations of P(x) 9

10 Existential quantification x P(x) is true in a model m iff P(x) is true with x being some possible object in the model disjunction of instantiations of P(x) 10

11 Properties of quantifiers x y P is the same as y x P x y P is the same as y x P x y P is not the same as y x P x y Mother(x, y) There is a person who is mother of everyone in the world y x Mother(x, y) Everyone in the world has a mother Quantifier duality x P xp x P x P 11

12 FOL: Kinship domain example Objects people Functions Predicates 12

13 FOL: Kinship domain example Objects: people Functions: Mother, Father Predicates: Unary: Male, Female Binary:Parent, Sibling, Brother, Sister, Child, Daughter, Son, Spouse, Wife, Husband, Grandparent, Grandchild, Cousin, Aunt, Uncle 13

14 FOL: Kinship domain example Sample sentences: m, c Mother c = m (Female(m) Parent(m, c)) p, c Parent p, c Child(c, p) g, c Grandparent g, c p Parent g, p Parent p, c x, y Sibiling x, y x y p Parent p, x Parent p, x 14

15 Assertions & queries in FOL KBs Assertions: sentences added to KB using TELL Tell(KB, King(John)) Tell(KB, ( x King x Person x )) Queries or goals: questions asked from KB using ASK ASK KB, King John ASK KB, x King x Substitution or binding list: AskVars 15 In KB of Horn clauses, every way of making the query true will bind the variables to specific values AskVars(KB, King(x)): answer {x/john} If KB contains King John King(Richard), there is no binding although ASK KB, x King x is true

16 FOL: Set domain example Objects: sets, elements Functions: s 1 s 2, s 1 s 2, {x s} Predicates: Unary: Set Binary: x s, s 1 s 2 s Set(s) (s = {}) ( x, s 2 Set(s 2 ) s = {x s 2 }) x, s {x s} = {} x, s x s s = {x s} x, s x s y, s 2 (s = {y s 2 } (x = y x s 2 ))] s 1, s 2 s 1 s 2 (x xs 1 x s 2 ) s 1, s 2 (s 1 = s 2 ) (s 1 s 2 s 2 s 1 ) x, s 1, s 2 x (s 1 s 2 ) (x s 1 x s 2 ) x, s 1, s 2 x (s 1 s 2 ) (x s 1 x s 2 ) 16

17 FOL: Wumpus world example Environment Objects: pairs identifying squares [i, j], Agent, Wumpus Relations: Pit, Adjacent, Breezy, Stenchy, Percept, Action, At, HaveArrow, 17

18 FOL: Wumpus world example Perceptions: perceives a smell, a breeze, and glitter at t = 5: Percept Stench, Breeze, Glitter, None, None, 5 Actions: Turn(Left), Turn(Right), Forward, Shoot, Grab, Climb Perceptions implies facts about current state t, s, g, m, c Percept( s, Breeze, g, m, c, t) Breeze(t) Simple reflex behavior t Glitter(t) BestAction(Grab, t) AskVars( a BestAction(a, 5)) Binding list: e.g., {a/grab} 18

19 FOL: Wumpus world example Samples of rules: x, y, a, b Adj x, y, a, b x = a y = b 1 y = b 1 At Agent, s, t x, y t At(Wumpus, [x, y], t) s, t At Agent, s, t Breeze t Breezy s y = b x = a 1 x = a + 1 x, s 1, s 2, t At Agent, s 1, t At Agent, s 2, t s 1 = s 2 s, t Breezy s r Adj r, s Pit r One successor-state axiom for each predicate t HaveArrow t + 1 ( HaveArrow t Action Shoot, t ) 19

20 Knowledge Engineering (KE) in FOL 1) Identify the task 2) Assemble the relevant knowledge 3) Decide on a vocabulary of predicates, functions, and constants (Ontology) 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 20

21 Inference in FOL Reducing first-order inference to propositional inference Potentially great expense Lifting inference (direct inference in FOL) Unification Generalized Modus Ponens KB of Horn clauses Forward chaining Backward chaining General KB Resolution 21

22 FOL to PL FOL to PL conversion First order inference by converting the knowledge base to PL and using propositional inference. How to remove universal and existential quantifiers? Universel Instantiation Existential Instantiation 22

23 Universal instantiation (UI) Every instantiation of a universally quantified sentence is entailed by it: v Subst( α v g, α) Example α: x King(x) Greedy(x) Evil(x) Subst x John, α King(John) Greedy(John) Evil(John) Subst x Richard, α King Richard Greedy Richard Evil Richard Subst x Father John, α King(Father(John)) Greedy(Father(John)) Evil(Father(John)) 23

24 Existential instantiation (EI) For any sentence α, variable v, and a new constant symbol k: v Subst( α v k, α) Example, α: x Crown(x) OnHead(x, John) Subst x C 1, α Crown(C 1 ) OnHead(C 1, John) C 1 is a new constant symbol, called a Skolem constant EI can be applied one time (existentially quantified sentence can be discarded after it) 24

25 Reduction to propositional inference: Example KB of FOL sentences: x King x Greedy x Evil x King John Greedy John Brother Richard, John x Crown(x) OnHead(x, John) A universally quantified sentence is replaced by all possible instantiations & an existentially quantified sentence by one instantiation: King(John) Greedy(John) Evil(John) King(Richard) Greedy(Richard) Evil(Richard) King(John) Greedy(John) Brother(Richard, John) Crown C 1 OnHead C 1, John 25

26 Propositionalization Every FOL KB and query can be propositionalized Algorithms for deciding PL entailment can be used Problem: infinitely large set of sentences Infinite set of possible ground-term substitution due to function symbols Solution: e.g., Father( Father(Father(John))) Theorem (Herbrand, 1930): If a sentence α is entailed by an FOL KB, it can be entailed by a finite subset of its propositionalized KB 26 for n = 0 to do Generate all instantiations with depth n nested symbols if α is entailed by this KB then return true

27 Propositionalization (Cont.) Problem: When procedure go on and on, we will not know whether it is stuck in a loop or the proof is just about to pop out Theorem (Turing-1936, Church-1936): Deciding entailment for FOL is semidecidable Algorithms exist that say yes to every entailed sentence, but no algorithm exists that also says no to every non-entailed sentence. 27

28 Propositionalization is inefficient Generates lots of irrelevant sentences Example: King Richard Greedy Richard Evil Richard KB x King x Greedy x Evil x King John Greedy John Brother Richard, John is irrelevant. Query Evil(x) p k-ary predicates and n constants p n k instantiations 28

29 Lifting & Unification Lifting: raising inference rules or algorithms from ground (variable-free) PL to FOL. E.g., generalized Modus Ponens Unification: Lifted inference rules require finding substitutions that make different expressions looks identical. Instantiating variables only as far as necessary for the proof. All variables are assumed universally quantified. 29

30 Unification: Simple example Example: Infer immediately when finding a substitution θ such that King(x) and Greedy(x) match King(John) and Greedy(y) KB x King x Greedy x Evil x King John y Greedy y Brother Richard, John Query Evil(x) 30

31 Unification: examples UNIFY p, q = θ where Subst θ, p = Subst(θ, q) p Knows(John, x) Knows(John, x) Knows(John, x) Knows(John, x) q Knows(John, Jane) Knows(y, Bill) Knows(y, Mother(y)) Knows(x, Elizabeth) θ {x/jane} { x Bill, y/john} { x Mother(John), y/john} fail 31

32 Unification: examples UNIFY p, q = θ where Subst θ, p = Subst(θ, q) p Knows(John, x) Knows(John, x) Knows(John, x) Knows(John, x) q Knows(John, Jane) Knows(y, Bill) Knows(y, Mother(y)) Knows(x, Elizabeth) θ {x/jane} { x Bill, y/john} { x Mother(John), y/john} fail 32

33 Unification: complications Complications Two sentences using the same variable name Standardizing apart: renaming the variables causing name clashes in one of sentences More than one unifier Most General Unifier (MGU) p Knows(John, x) Knows(John, x) q Knows(x, Elizabeth) Knows(x 2, Elizabeth) θ fail { x Elizabeth, x 2 /John} 33

34 Unification (MGU) UNIFY( Knows John, x, Knows y, z ) θ 1 = {y/john, x/z } θ 2 = {y/john, x/john, z/john} θ 1 is more general There is a single most general unifier (MGU) that is unique up to renaming of variables. 34

35 Generalized Modus Ponens (GMP) For atomic sentences p i, p i, q & Subst θ, p i = Subst θ, p i for all i p 1, p 2,, p n, (p 1 p 2 p n q) Subst(θ, q) p 1 : King(John) p 1 : King(x) p 2 : Greedy(y) p 2 : Greedy(x) q: Evil(x) θ = {x/john, y/john} Subst(θ, q) is Evil(John) KB King x Greedy x Evil x King John Greedy y Query Evil(x) 35

36 GMP is sound p 1, p 2,, p n, (p 1 p 2 p n q) Subst(θ, q) Universal instantiation: p Subst(θ, p) 1) p 1 p n Subst θ, p 1 Subst(θ, p n ) 2) p 1 p 2 p n q Subst θ, p 1 Subst θ, p n Subst(θ, q) 3) Subst(θ, q) follows by Modus Ponens since we have Subst θ, p i = Subst θ, p i. 36

37 KB of definite clauses Definite clause: disjunctions of literals of which exactly one is positive. Atomic: P 1, P 2, Implication: P 1 P 2 P k P k+1 First order definite clause examples: King x Greedy x Evil x King(John) Brother(John, Richard) 37

38 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. Question: Prove that Colonel West is a criminal 38

39 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. American(x) Weapon(y) Sells(x, y, z) Hostile(z) Criminal(x) 39

40 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. Enemy(Nono, America) 40

41 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. x Owns(Nono, x) Missile(x) Owns(Nono, M 1 ) Missile(M 1 ) 41

42 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. Missile(x) Owns(Nono, x) Sells(West, x, Nono) 42

43 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. American(West) 43

44 KB of first order definite clauses: Example The law says that it is a crime for an American to sell weapons to hostile nations. The country Nono, an enemy of America, has some missiles, and all of its missiles were sold to it by Colonel West, who is American. We need to know missiles are weapons: We need to know an enemy of America counts as hostile : 44 Missile(x) Weapon(x) Enemy(x, America) Hostile(x)

45 KB of first order definite clauses: Example American(x) Weapon(y) Sells(x, y, z) Hostile(z) Criminal(x) Enemy(Nono, America) Owns(Nono, M 1 ) Missile(M 1 ) Missile(x) Owns(Nono, x) Sells(West, x, Nono) American(West) Missile(x) Weapon(x) Enemy(x, America) Hostile(x) 45

46 FC algorithm function FOL_FC_ASK(KB, α) returns a substitution or false 46 inputs: KB, a set of first-order definite clauses α, the query, an atomic sentence repeat until new = {} new = {} for each rule in KB do (p 1 p n q) STANDARDIZE_VARS(rule) for each θ such that SUBST θ, p 1 p n = SUBST(θ, p 1 p n ) q SUBST(θ, q) for some p 1,, p n in KB if q does not unify with some sentence already in KB or new then add q to new add new to KB return false φ UNIFY(q, α) if φ is not fail then return φ

47 FC: example Known facts 1) American West 2) Owns Nono, M 1 Missile M 1 3) Enemy(Nono, America) 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 47

48 FC: example 1) Missile x Owns Nono, x Sells West, x, Nono {x/m 1 } 2) American x Weapon y Sells x, y, z Hostile z Criminal x 3) Missile x Weapon x 4) Enemy(x, America) Hostile(x) {x/m 1 } {x/nono} 48

49 FC: example 1) Missile x Owns Nono, x Sells West, x, Nono 2) American x Weapon y Sells x, y, z Hostile z Criminal x 3) Missile x Weapon x 4) Enemy(x, America) Hostile(x) {x/m 1 } {x/west, y/m 1,z/Nono} {x/m 1 } {x/nono} 49

50 Properties of FC Sound Complete (for KBs of first-order definite clauses) For Datalog KBs, proof is fairly easy. Datalog KBs contain first-order definite clauses with no function symbols FC reaches a fix point for Datalog KBs after finite number of iterations It may not terminate in general if α is not entailed (query has no answer) entailment with definite clauses is also semi-decidable 50

51 More efficient FC Heuristics for matching rules against known facts E.g., conjunct ordering Incremental forward chaining to avoid redundant rule matching Every new fact inferred on iteration t must be derived from at least one new fact inferred on iteration t 1. Check a rule only if its premise includes a newly inferred fact (at iteration t 1) Avoid drawing irrelevant facts (to the goal) 51

52 Backward Chaining (BC) Works backward from the goal, chaining through rules to find known facts supporting the proof AND-OR search OR: any rule lhs goal in KB can be used to prove the goal AND: all conjuncts in lhs must be proved. It is used in logic programming (Prolog) 52

53 BC algorithm (depth-first recursive proof search) function FOL_BC_ASK(KB, query) returns a generator of substitutions return FOL_BC_OR(KB, query, {}) generator FOL_BC_OR(KB, goal, θ) yields a substitution for each rule (lhs rhs) in FETCH_RULES_FOR_GOAL(KB, goal) do (lhs, rhs) STANDARDIZE_VARS(lhs, rhs) for each θ in FOL_BC_AND(KB, lhs, UNIFY(rhs, goal, θ) do yield θ generator FOL_BC_AND(KB, goals, θ) yields a substitution 53 if θ = failure then return else if LENGTH goals else do first FIRST goals rest REST goals = 0 then yield θ for each θ in FOL_BC_OR(KB, SUBST θ, first, θ) do for each θ in FOL_BC_AND(KB, rest, θ ) do yield θ

54 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 54

55 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 55

56 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 56

57 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 57

58 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 58

59 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 59

60 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 60

61 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 61

62 Backward chaining example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) 62

63 Properties of BC Space is linear in the size of the proof Suffers from repeated states and incompleteness Repeated subgoals (both success and failure) Solution: caching of previous results Incompleteness due to infinite loops Solution: checking current goal against every goal on stack 63

64 Resolution algorithm General theorem proving Apply resolution rule to CNF(KB α) Refutation-complete for FOL 64

65 Resolution PL resolution: l i and m j are complement l 1 l 2 l k, m 1 m 2 m n l 1 l i 1 l i+1 l k m 1 m j 1 m j+1 m n First-order resolution UNIFY l i, m j = θ Clauses are assumed to be standardized apart (sharing no variables). l 1 l 2 l k, m 1 m 2 m n SUBST(θ, l 1 l i 1 l i+1 l k m 1 m j 1 m j+1 m n ) Example: Rich x Unhappy x, Rich(Ken) Unhappy(Ken) θ = {x/ken} 65

66 Converting FOL sentence to CNF Example: everyone who loves all animals is loved by someone x [ y Animal(y) Loves(x, y)] [y Loves(y, x)] 1) Eliminate implications (P Q P Q) x [ y Animal y Loves(x, y)] [y Loves(y, x)] 2) Move inwards: x p to x p, x p to x p x [ y ( Animal y Loves(x, y))] [y Loves(y, x)] x [ y Animal(y) Loves(x, y)] [y Loves(y, x)] x [ y Animal(y) Loves(x, y)] [y Loves(y, x)] 3) Standardize variables (avoiding same names for variables) x [ y Animal(y) Loves(x, y)] [z Loves(z, x)] 66

67 Converting FOL sentence to CNF 4) Skolemize: a more general form of existential instantiation. Each existentially quantified variable is replaced by a Skolem function of the enclosing universally quantified variables. x [Animal(F(x)) Loves(x, F(x))] Loves(G(x), x) 5) Drop universal quantifiers: [Animal(F(x)) Loves(x, F(x))] Loves(G(x), x) 6) Distribute over : [Animal(F(x)) Loves(G(x), x)] [ Loves(x, F(x)) Loves(G(x), x)] 67

68 Properties of resolution Resolution Complete when used in combination with factoring Extend factoring to FOL Factoring in PL: reduces two literals to one if they are identical Factoring in FOL: reduces two literals to one if they are unifiable.the unifier must be applied to the entire clause 68

69 Resolution: definite clauses example 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy(x, America) Hostile(x) Convert to CNF 1) Enemy(Nono, America) 2) Owns Nono, M 1 Missile M 1 3) American West 4) Missile x Owns Nono, x Sells West, x, Nono 5) American x Weapon y Sells x, y, z Hostile z Criminal x 6) Missile x Weapon x 7) Enemy x, America Hostile(x) 69

70 Resolution: definite clauses example KB α 70

71 Resolution: general example Every one who loves all animals is loved by someone. x [ y Animal(y) Loves(x, y)] [y Loves(y, x)] Anyone who kills an animal is loved by no one. x [ z Animal(z) Kills(x, z)] [ y Loves(y, x)] Jack loves all animals. x Animal(x) Loves(Jack, x) Either Jack or Curiosity killed the cat, who is named Tuna. Kills Jack, Tuna Kills(Curiosity, Tuna) Cat(Tuna) Query: Did Curiosity kill the cat? Kills(Curiosity, Tuna) 71

72 Resolution: general example CNF (KB α): Animal(F(x)) Loves(G(x), x) Loves(x, F(x)) Loves(G(x), x) Loves(y, x) Animal(z) Kills(x, z) Animal(x) Loves(Jack, x) Kills Jack, Tuna Kills(Curiosity, Tuna) Cat(Tuna) Kills(Curiosity, Tuna) Query: Who killed the cat? α: w Kills(w, Tuna) The binding {w/curiosity} in one of steps 72

73 Resolution: general example Query: Who killed the cat? α: w Kills(w, Tuna) The binding {w/curiosity} in one of steps 73

74 Prolog (Programming in logic) Basis: backward chaining with Horn clauses Depth-first, left-to-right BC Program = set of clauses Fact e.g., american(west). Rule: head :- literal 1,,literal n. e.g., criminal(x) :- american(x), weapon(y), sells(x,y,z), hostile(z). 74

75 Prolog: Example Appending two lists to produce a third: append([],y,y). append([x L],Y,[X Z]) :- append(l,y,z). query: append(a,b,[1,2])? answers: A=[] B=[1,2] A=[1] B=[2] A=[1,2] B=[] 75

76 Summary First order logic Inference Lifting and unification Inference on KB of definite clauses Forward chaining Backward chaining Inference on general KB of FOL Resolution 76