Why FOPC

If your thesis is utter vacuousUse first-order predicate calculus.With sufficient formalityThe sheerest banality

Will be hailed by the critics: "Miraculous!"

11/4

Qns/comments/Concerns on how the semester is going?Project 2 returned; Avg 52/65

Project 3 due;Project 4 assigned.

Apt-pet

• An apartment pet is a pet that is small

• Dog is a pet

• Cat is a pet

• Elephant is a pet

• Dogs and cats are small.

• Some dogs are cute

• Each dog hates some cat

• Fido is a dog )(

),()()(

)()(

)()(

)()(

)()(

)()(

)()(

)()()(

fidodog

yxhatesycatyxdogx

xcutexdogx

xsmallxcatx

xsmallxdogx

xpetxelephantx

xpetxcatx

xpetxdogx

xaptPetxpetxsmallx

Notes on encoding English statements to FOPC

• You get to decide what your predicates, functions, constants etc. are. All you are required to do it be consistent in their usage.

• When you write an English sentence into FOPC sentence, you can “double check” by asking yourself if there are worlds where FOPC sentence doesn’t hold and the English one holds and vice versa

• Since you are allowed to make your own predicate and function names, it is quite possible that two people FOPCizing the same KB may wind up writing two syntactically different KBs

• If each of the DBs is used in isolation, there is no problem. However, if the knowledge written in one DB is supposed to be used in conjunction with that in another DB, you will need “Mapping axioms” which relate the “vocabulary” in one DB to the vocabulary in the other DB.

• This problem is PRETTY important in the context of Semantic Web

The “Semantic Web” Connection

Caveat: Decide whether a symbol is predicate, constant or function…

• Make sure you decide what are your constants, what are your predicates and what are your functions

• Once you decide something is a predicate, you cannot use it in a place where a predicate is not expected! In the previous example, you cannot say

)(DogSmall

Caveat: Order of quantifiers matters

),( yxlovesyx),( yxlovesxy

)],(),([

)],(),([

)],(),([),(

)],(),([

)],(),([

)],(),([),(

TweetyTweetylovesTweetyFidoloves

FidoTweetylovesFidoFidoloves

yTweetylovesyFidolovesyyxlovesxy

TweetyTweetylovesFidoTweetyloves

TweetyFidolovesFidoFidoloves

TweetyxlovesFidoxlovesxyxlovesyx

TweetyandFidowithworldaConsider

“either Fido loves both Fido and Tweety; or Tweety loves both Fido and Tweety”

“ Fido or Tweety loves Fido; and Fido or Tweety loves Tweety”

Loves(x,y) means x loves y

More on writing sentences

• Forall usually goes with implications (rarely with conjunctive sentences)

• There-exists usually goes with conjunctions—rarely with implications

Everyone at ASU is smart

Someone at UA is smart

)(),(

)(),(

xSmartASUxxAt

xSmartASUxAtx

)(),(

)(),(

xSmartUAxAtx

xSmartUAxAtx

Two different Tarskian Interpretations

This is the same as the one on The left except we have green guy for Richard

Problem: There are too darned many Tarskian interpretations. Given one, you can change it by just substituting new real-world objects Substitution-equivalent Tarskian interpretations give same valuations to the FOPC statements (and thus do not change entailment) Think in terms of equivalent classes of Tarskian Interpretations (Herbrand Interpretations)

Herbrand Interpretations• Herbrand Universe

– All constants• Rao,Pat

– All “ground” functional terms • Son-of(Rao);Son-of(Pat);• Son-of(Son-of(…(Rao)))….

• Herbrand Base– All ground atomic sentences made with

terms in Herbrand universe• Friend(Rao,Pat);Friend(Pat,Rao);Friend(

Pat,Pat);Friend(Rao,Rao)• Friend(Rao,Son-of(Rao));• Friend(son-of(son-of(Rao),son-of(son-

of(son-of(Pat))– We can think of elements of HB as

propositions; interpretations give T/F values to these. Given the interpretation, we can compute the value of the FOPC database sentences

))(,(

),(

),(),(,

RaoofsonPatFriend

PatRaoFriend

yxLikesyxFriendyx

If there are n constants; andp k-ary predicates, then --Size of HU = n --Size of HB = p*nk

But if there is even one function, then |HU| is infinity and so is |HB|. --So, when there are no function symbols, FOPC is really just syntactic sugaring for a (possibly much larger) propositional database

Let us think of interpretations for FOPC that are more like interpretations for prop logic

Proof-theoretic Inference in first order logic

• For “ground” sentences (i.e., sentences without any quantification), all the old rules work directly (think of ground atomic sentences as propositions)

– P(a,b)=> Q(a); P(a,b) |= Q(a)– ~P(a,b) V Q(a) resolved with P(a,b) gives Q(a)

• What about quantified sentences?– May be infer ground sentences from them….– Universal Instantiation (a universally quantified statement entails every

instantiation of it)

– Existential instantiation (an existentially quantified statement holds for some term (not currently appearing in the KB).

• Can we combine these (so we can avoid unnecessary instantiations?) Yes. Generalized modus ponens

• Needs UNIFICATION

)(),()(),( aQbaentailsPxQyxyPx

)(),();(),( bqentailsbaPxQyxyPx

)1()( SKPentailsxxP

11/6

90 AU from earth .. Going a million miles a day .. Should reach the neighboring star anyday now (okay, in about ~40,000 years)

11/6

UI can be applied several times to add new sentences --The resulting KB is equivalent to the old one

EI can only applied once --The resulting DB is not equivalent to the old one BUT will be satisfiable only when the old one is

How about knows(x,f(x)) knows(u,u)? x/u; u/f(u)leads to infinite regress (“occurs check”)

GMP can be used in the “forward” (aka “bottom-up”) fashion where we start from antecedents, and assert the consequent or in the “backward” (aka “top-down”) fashion where we start from consequent, and subgoal on proving the antecedents.

Forward (bottom-up) vs. Backward (top-down) chaining

• Forward chaining fires rules starting from facts– Using P, derive Q– Using Q & R, derive S– Using S, derive Z– Using Z, Q, derive W– Using Q, derive J– No more inferences. Check if J

holds. It does. So proved

• Backward chaining starts from the theorem to be proved– We want to prove J. – Using Q=>J, we can subgoal

on Q– Using P=>Q, we can subgoal

on P– P holds. We are done.

Suppose we have P => Q Q & R =>S S => Z Z & Q => W Q => J P RWe want to prove J

Forward chaining allows parallel derivation of many facts together; but it may derive facts that are not relevant for the theorem.Backward chaining concentrates on proving subgoals that are relevant to the theorem. However, it proves theorems one at a time.

Some similarity with progression vs. regression…

Datalog and Deductive Databases• A deductive database is a generalization of

relational database, where in addition to the relational store, we also have a set of “rules”.

– The rules are in definite clause form (universally quantified implications, with one non-negated head, and a conjunction of non-negated tails)

• When a query is asked, the answers are retrieved both from the relational store, and by deriving new facts using the rules.

• The inference in deductive databases thus involves using GMP rule.

• Since deductive databases have to derived all answers for a query, top-down evaluation winds up being too inefficient.

• So, bottom-up (forward chaining) evaluation is used (which tends to derive non-relevant facts

• A neat idea called magic-sets allows us to temporarily change the rules (given a specific query), such that forward chaining on the modified rules will avoid deriving some of the irrelevant facts.

Base factsP(a,b),Q(b)

R(c)..

RulesP(x,y),Q(y)=>R(y)

?R(z)

RDBMS

R(c); R(b)..

This stuff was discussed in the class at a high-level, and is a One slide summary of CSE 513

Apt-pet

• An apartment pet is a pet that is small

• Dog is a pet• Cat is a pet• Elephant is a pet• Dogs, cats and skunks are

small. • Fido is a dog• Louie is a skunk• Garfield is a cat• Clyde is an elephant• Is there an apartment pet?

)(?

)(.11

)(.10

)(.9

)(.8

)()(.7

)()(.6

)()(.5

)()(.4

)()(.3

)()(.2

)()()(.1

xaptPet

clydeelephant

garfieldcat

louieskunk

fidodog

xsmallxdog

xsmallxcat

xsmallxskunk

xpetxelephant

xpetxcat

xpetxdog

xaptPetxpetxsmall

)(?

)(.11

)(.10

)(.9

)(.8

)()(.7

)()(.6

)()(.5

)()(.4

)()(.3

)()(.2

)()()(.1

xaptPet

clydeelephant

garfieldcat

louieskunk

fidodog

xsmallxdog

xsmallxcat

xsmallxskunk

xpetxelephant

xpetxcat

xpetxdog

xaptPetxpetxsmall

Generate compilable matchers for each pattern, and use them