Knowledge Representation using First-Order Logic (Part II)

1. Knowledge Representation using First-Order Logic(Part II) Reading: R&N Chapters 8, 9

2. Outline • Review: KB |= S is equivalent to |= (KB  S) • So what does {} |= S mean? • Review: Follows, Entails, Derives • Follows: “Is it the case?” • Entails: “Is it true?” • Derives: “Is it provable?” • Review: FOL syntax • Finish FOL Semantics, FOL examples • Inference in FOL • Next Tuesday (1 June) is Review/Catch-up; Homework#7 is due • Next Thursday (3 June) NO CLASS; I’m reviewing grants for NIH • Next Friday (4 June) PROJECT REPORTS & CODE is due • Following Thursday (10 June) FINAL EXAM; 1:30-3:30pm

3. Review: KB |= S means |= (KB  S) • KB |= S is read “KB entails S.” • Means “S is true in every world (model) in which KB is true.” • Means “In the world, S follows from KB.” • KB |= S is equivalent to |= (KB  S) • Means “(KB  S) is true in every world (i.e., is valid).” • And so: {} |= S is equivalent to |= ({}  S) • So what does ({}  S) mean? • Means “True implies S.” • Means “S is valid.” • In Horn form, means “S is a fact.” p. 256 (3rd ed.; p. 281, 2nd ed.) • Why does {} mean True here, but False in resolution proofs?

4. Review: (True  S) means “S is a fact.” • By convention, • The null conjunct is “syntactic sugar” for True. • The null disjunct is “syntactic sugar” for False. • Each is assigned the truth value of its identity element. • For conjuncts, True is the identity: (A  True)  A • For disjuncts, False is the identity: (A  False)  A • A KB is the conjunction of all of its sentences. • So in the expression: {} |= S • We see that {} is the null conjunct and means True. • The expression means “S is true in every world where True is true.” • I.e., “S is valid.” • Better way to think of it: {} does not exclude any worlds (models). • In Conjunctive Normal Form each clause is a disjunct. • So in, say, KB = { {P Q} {Q R} {} {X Y Z} } • We see that {} is the null disjunct and means False.

5. Side Trip: Functions AND, OR, and null values(Note: These are “syntactic sugar” in logic.) function AND(arglist) returns a truth-value return ANDOR(arglist, True) function OR(arglist) returns a truth-value return ANDOR(arglist, False) function ANDOR(arglist, nullvalue) returns a truth-value /* nullvalue is the identity element for the caller. */ if (arglist = {}) then returnnullvalue if ( FIRST(arglist) = NOT(nullvalue) ) then return NOT(nullvalue) return ANDOR( REST(arglist) )

6. Review: Schematic for Follows, Entails, and Derives Derives Inference Sentences Sentence If KB is true in the real world, then any sentence entailed by KB and any sentence derived from KB by a sound inference procedure is also true in the real world.

7. Schematic Example: Follows, Entails, and Derives “Mary is Sue’s sister and Amy is Sue’s daughter.” “Mary is Amy’s aunt.” Derives Inference “An aunt is a sister of a parent.” Is it provable? “Mary is Sue’s sister and Amy is Sue’s daughter.” “Mary is Amy’s aunt.” Entails Representation “An aunt is a sister of a parent.” Is it true? Sister Mary Sue Follows Mary World Daughter Is it the case? Aunt Amy Amy

8. Review: Models (and in FOL, Interpretations) • Models are formal worlds in which truth can be evaluated • We say mis a model of a sentence α if α is true in m • M(α) is the set of all models of α • Then KB ╞ α iff M(KB)  M(α) • E.g. KB, = “Mary is Sue’s sister and Amy is Sue’s daughter.” • α = “Mary is Amy’s aunt.” • Think of KB and α as constraints, and of models m as possible states. • M(KB) are the solutions to KB and M(α) the solutions to α. • Then, KB ╞ α, i.e., ╞ (KB  a) , when all solutions to KB are also solutions to α.

9. Review: Wumpus models • KB = all possible wumpus-worlds consistent with the observations and the “physics” of the Wumpus world.

10. Review: Wumpus models α1 = "[1,2] is safe", KB ╞ α1, proved by model checking. Every model that makes KB true also makes α1 true.

11. Review: Syntax of FOL: Basic elements • Constants KingJohn, 2, UCI,... • Predicates Brother, >,... • Functions Sqrt, LeftLegOf,... • Variables x, y, a, b,... • Connectives , , , ,  • Equality = • Quantifiers , 

12. Syntax of FOL: Basic syntax elements are symbols • Constant Symbols: • Stand for objects in the world. • E.g., KingJohn, 2, UCI, ... • Predicate Symbols • Stand for relations (maps a tuple of objects to a truth-value) • E.g., Brother(Richard, John), greater_than(3,2), ... • P(x, y) is usually read as “x is P of y.” • E.g., Mother(Ann, Sue) is usually “Ann is Mother of Sue.” • Function Symbols • Stand for functions (maps a tuple of objects to an object) • E.g., Sqrt(3), LeftLegOf(John), ... • Model (world)= set of domain objects, relations, functions • Interpretation maps symbols onto the model (world) • Very many interpretations are possible for each KB and world! • Job of the KB is to rule out models inconsistent with our knowledge.

13. Syntax of FOL: Terms • Term = logical expression that refers to an object • There are two kinds of terms: • Constant Symbols stand for (or name) objects: • E.g., KingJohn, 2, UCI, Wumpus, ... • Function Symbols map tuples of objects to an object: • E.g., LeftLeg(KingJohn), Mother(Mary), Sqrt(x) • This is nothing but a complicated kind of name • No “subroutine” call, no “return value”

14. Syntax of FOL: Atomic Sentences • Atomic Sentences state facts (logical truth values). • An atomic sentence is a Predicate symbol, optionally followed by a parenthesized list of any argument terms • E.g., Married( Father(Richard), Mother(John) ) • An atomic sentence asserts that some relationship (some predicate) holds among the objects that are its arguments. • An Atomic Sentence is true in a given model if the relation referred to by the predicate symbol holds among the objects (terms) referred to by the arguments.

15. Syntax of FOL: Connectives & Complex Sentences • Complex Sentences are formed in the same way, and are formed using the same logical connectives, as we already know from propositional logic • The Logical Connectives: •  biconditional •  implication •  and •  or •  negation • Semantics for these logical connectives are the same as we already know from propositional logic.

16. Syntax of FOL: Variables • Variables range over objects in the world. • A variable is like a term because it represents an object. • A variable may be used wherever a term may be used. • Variables may be arguments to functions and predicates. • (A term with NO variables is called a ground term.) • (A variable not bound by a quantifier is called free.)

17. Syntax of FOL: Logical Quantifiers • There are two Logical Quantifiers: • Universal:  x P(x) means “For all x, P(x).” • The “upside-down A” reminds you of “ALL.” • Existential:  x P(x) means “There exists x such that, P(x).” • The “upside-down E” reminds you of “EXISTS.” • Syntactic “sugar” --- we really only need one quantifier. •  x P(x)   x P(x) •  x P(x)   x P(x) • You can ALWAYS convert one quantifier to the other. • RULES:    and    • RULE: To move negation “in” across a quantifier, change the quantifier to “the other quantifier” and negate the predicate on “the other side.” •  x P(x)   x P(x) •  x P(x)   x P(x)

18. Existential Quantification  • Existential quantification is equivalent to: • Disjunction of all sentences obtained by substitution of an object for the quantified variable. • Spot has a sister who is a cat. • x Sister(x, Spot)  Cat(x) • Disjunction of all sentences obtained by substitution of an object for the quantified variable: Sister(Spot, Spot)  Cat(Spot)  Sister(Rick, Spot)  Cat(Rick)  Sister(LAX, Spot)  Cat(LAX)  Sister(Shayama, Spot)  Cat(Shayama)  Sister(France, Spot)  Cat(France)  Sister(Felix, Spot)  Cat(Felix)  …

19. Combining Quantifiers --- Order (Scope) The order of “unlike” quantifiers is important.  x  y Loves(x,y) • For everyone (“all x”) there is someone (“exists y”) whom they love • y  x Loves(x,y) - there is someone (“exists y”) whom everyone loves (“all x”) Clearer with parentheses:  y (  x Loves(x,y) ) The order of “like” quantifiers does not matter. x y P(x, y)  y x P(x, y) x y P(x, y)  y x P(x, y)

20. De Morgan’s Law for Quantifiers Generalized De Morgan’s Rule De Morgan’s Rule Rule is simple: if you bring a negation inside a disjunction or a conjunction, always switch between them (or and, and  or).

21. FOL (or FOPC) Ontology: What kind of things exist in the world? What do we need to describe and reason about? Objects --- with their relations, functions, predicates, properties, and general rules. Reasoning Representation ------------------- A Formal Symbol System Inference --------------------- Formal Pattern Matching Syntax --------- What is said Semantics ------------- What it means Schema ------------- Rules of Inference Execution ------------- Search Strategy This lecture Next lecture

22. Semantics: Worlds • The world consists of objects that have properties. • There are relations and functions between these objects • Objects in the world, individuals: people, houses, numbers, colors, baseball games, wars, centuries • Clock A, John, 7, the-house in the corner, Tel-Aviv • Functions on individuals: • father-of, best friend, third inning of, one more than • Relations: • brother-of, bigger than, inside, part-of, has color, occurred after • Properties (a relation of arity 1): • red, round, bogus, prime, multistoried, beautiful

23. Semantics: Interpretation • An interpretation of a sentence (wff) is an assignment that maps • Object constant symbols to objects in the world, • n-ary function symbols to n-ary functions in the world, • n-ary relation symbols to n-ary relations in the world • Given an interpretation, an atomic sentence has the value “true” if it denotes a relation that holds for those individuals denoted in the terms. Otherwise it has the value “false.” • Example: Kinship world: • Symbols = Ann, Bill, Sue, Married, Parent, Child, Sibling, … • World consists of individuals in relations: • Married(Ann,Bill) is false, Parent(Bill,Sue) is true, …

24. Truth in first-order logic • Sentences are true with respect to a model and an interpretation • Model contains objects (domainelements) and relations among them • Interpretation specifies referents for constantsymbols → objects predicatesymbols → relations functionsymbols → functional relations • An atomic sentence predicate(term1,...,termn) is true iff the objects referred to by term1,...,termn are in the relation referred to by predicate

25. Semantics: Models • An interpretation satisfies a wff (sentence) if the wff has the value “true” under the interpretation. • Model: A domain and an interpretation that satisfies a wff is a model of that wff • Validity: Any wff that has the value “true” under all interpretations is valid • Any wff that does not have a model is inconsistent or unsatisfiable • If a wff w has a value true under all the models of a set of sentences KB then KB logically entails w

26. Models for FOL: Example

32. Using FOL • We want to TELL things to the KB, e.g. TELL(KB, ) TELL(KB, King(John) ) These sentences are assertions • We also want to ASK things to the KB, ASK(KB, ) these are queries or goals The KB should return the list of x’s for which Person(x) is true: {x/John,x/Richard,...}

33. FOL Version of Wumpus World • Typical percept sentence:Percept([Stench,Breeze,Glitter,None,None],5) • Actions:Turn(Right), Turn(Left), Forward, Shoot, Grab, Release, Climb • To determine best action, construct query: a BestAction(a,5) • ASK solves this and returns {a/Grab} • And TELL about the action.

34. Knowledge Base for Wumpus World • Perception • s,b,g,x,y,t Percept([s,Breeze,g,x,y],t)  Breeze(t) • s,b,x,y,t Percept([s,b,Glitter,x,y],t)  Glitter(t) • Reflex action • t Glitter(t)  BestAction(Grab,t) • Reflex action with internal state • t Glitter(t) Holding(Gold,t)  BestAction(Grab,t) Holding(Gold,t) can not be observed: keep track of change.

35. Deducing hidden properties Environment definition: x,y,a,b Adjacent([x,y],[a,b])  [a,b]  {[x+1,y], [x-1,y],[x,y+1],[x,y-1]} Properties of locations: s,t At(Agent,s,t)  Breeze(t)  Breezy(s) Squares are breezy near a pit: • Diagnostic rule---infer cause from effect s Breezy(s)  r Adjacent(r,s)  Pit(r) • Causal rule---infer effect from cause (model based reasoning) r Pit(r)  [s Adjacent(r,s)  Breezy(s)]

39. Set Theory in First-Order Logic Can we define set theory using FOL? - individual sets, union, intersection, etc Answer is yes. Basics: - empty set = constant = { } - unary predicate Set( ), true for sets - binary predicates: x  s (true if x is a member of the set x) s1 s2 (true if s1 is a subset of s2) - binary functions: intersection s1 s2, union s1 s2 , adjoining{x|s}

40. A Possible Set of FOL Axioms for Set Theory The only sets are the empty set and sets made by adjoining an element to a set s Set(s)  (s = {} )  (x,s2 Set(s2)  s = {x|s2}) The empty set has no elements adjoined to it x,s {x|s} = {} Adjoining an element already in the set has no effect x,s x  s  s = {x|s} The only elements of a set are those that were adjoined into it. Expressed recursively: x,s x  s  [ y,s2 (s = {y|s2}  (x = y  x  s2))]

41. A Possible Set of FOL Axioms for Set Theory A set is a subset of another set iff all the first set’s members are members of the 2nd set s1,s2 s1 s2 (x x  s1 x  s2) Two sets are equal iff each is a subset of the other s1,s2 (s1 = s2)  (s1 s2 s2 s1) An object is in the intersection of 2 sets only if a member of both x,s1,s2 x  (s1 s2)  (x  s1 x  s2) An object is in the union of 2 sets only if a member of either x,s1,s2 x  (s1 s2)  (x  s1 x  s2)

42. Knowledge engineering in FOL • Identify the task • Assemble the relevant knowledge • Decide on a vocabulary of predicates, functions, and constants • Encode general knowledge about the domain • Encode a description of the specific problem instance • Pose queries to the inference procedure and get answers • Debug the knowledge base

43. The electronic circuits domain One-bit full adder Possible queries: - does the circuit function properly? - what gates are connected to the first input terminal? - what would happen if one of the gates is broken? and so on

44. The electronic circuits domain • Identify the task • Does the circuit actually add properly? • Assemble the relevant knowledge • Composed of wires and gates; Types of gates (AND, OR, XOR, NOT) • Irrelevant: size, shape, color, cost of gates • Decide on a vocabulary • Alternatives: Type(X1) = XOR (function) Type(X1, XOR) (binary predicate) XOR(X1) (unary predicate)

45. The electronic circuits domain • Encode general knowledge of the domain • t1,t2 Connected(t1, t2)  Signal(t1) = Signal(t2) • t Signal(t) = 1  Signal(t) = 0 • 1 ≠ 0 • t1,t2 Connected(t1, t2)  Connected(t2, t1) • g Type(g) = OR  Signal(Out(1,g)) = 1 n Signal(In(n,g)) = 1 • g Type(g) = AND  Signal(Out(1,g)) = 0 n Signal(In(n,g)) = 0 • g Type(g) = XOR  Signal(Out(1,g)) = 1  Signal(In(1,g)) ≠ Signal(In(2,g)) • g Type(g) = NOT  Signal(Out(1,g)) ≠ Signal(In(1,g))

46. The electronic circuits domain • Encode the specific problem instance Type(X1) = XOR Type(X2) = XOR Type(A1) = AND Type(A2) = AND Type(O1) = OR Connected(Out(1,X1),In(1,X2)) Connected(In(1,C1),In(1,X1)) Connected(Out(1,X1),In(2,A2)) Connected(In(1,C1),In(1,A1)) Connected(Out(1,A2),In(1,O1)) Connected(In(2,C1),In(2,X1)) Connected(Out(1,A1),In(2,O1)) Connected(In(2,C1),In(2,A1)) Connected(Out(1,X2),Out(1,C1)) Connected(In(3,C1),In(2,X2)) Connected(Out(1,O1),Out(2,C1)) Connected(In(3,C1),In(1,A2))

47. The electronic circuits domain • Pose queries to the inference procedure What are the possible sets of values of all the terminals for the adder circuit? i1,i2,i3,o1,o2 Signal(In(1,C_1)) = i1 Signal(In(2,C1)) = i2 Signal(In(3,C1)) = i3 Signal(Out(1,C1)) = o1 Signal(Out(2,C1)) = o2 • Debug the knowledge base May have omitted assertions like 1 ≠ 0

48. Syntactic Ambiguity • FOPC provides many ways to represent the same thing. • E.g., “Ball-5 is red.” • HasColor(Ball-5, Red) • Ball-5 and Red are objects related by HasColor. • Red(Ball-5) • Red is a unary predicate applied to the Ball-5 object. • HasProperty(Ball-5, Color, Red) • Ball-5, Color, and Red are objects related by HasProperty. • ColorOf(Ball-5) = Red • Ball-5 and Red are objects, and ColorOf() is a function. • HasColor(Ball-5(), Red()) • Ball-5() and Red() are functions of zero arguments that both return an object, which objects are related by HasColor. • … • This can GREATLY confuse a pattern-matching reasoner. • Especially if multiple people collaborate to build the KB, and they all have different representational conventions.

49. Summary • First-order logic: • Much more expressive than propositional logic • Allows objects and relations as semantic primitives • Universal and existential quantifiers • syntax: constants, functions, predicates, equality, quantifiers • Knowledge engineering using FOL • Capturing domain knowledge in logical form • Inference and reasoning in FOL • Next lecture • Required Reading: • All of Chapter 8 • Next lecture: Chapter 9