For Monday

• Read “lectures” 6,9-12 of Learn Prolog Now: http://www.coli.uni-saarland.de/~kris/learn-prolog-now/

• Prolog Handout 2

Exam 1• Next Monday

• Covers through chapter 9

• Topics include:– History

– Agents/Environments

– Search

– Logic/Inference

– No Prolog

• Take home handed out Wednesday, due at the exam

Resolution

• Propositional version.

{a b, ¬bc} |- ac OR {¬a b, bc} |- ¬a c

Reasoning by cases OR transitivity of implication • First order form

– For two literals pj and qk in two clauses

• p1 ... pj ... pm

• q1 ... qk ... qn

such that =UNIFY(pj , ¬qk), derive

SUBST(, p1...pj 1pj+1...pmq1...qk 1 qk+1...qn)

Implication form

• Can also be viewed in implicational form where all negated literals are in a conjunctive antecedent and all positive literals in a disjunctive conclusion.

¬p1...¬pmq1...qn

p1... pm q1 ... qn

Conjunctive Normal Form (CNF)

• For resolution to apply, all sentences must be in conjunctive normal form, a conjunction of disjunctions of literals

(a1 ... am)

(b1 ... bn)

.....

(x1 ... xv)

• Representable by a set of clauses (disjunctions of literals) • Also representable as a set of implications (INF).

Example

Initial CNF INF

P(x) Q(x) ¬P(x) Q(x) P(x) Q(x)

¬P(x) R(x) P(x) R(x) True P(x) R(x)

Q(x) S(x) ¬Q(x) S(x) Q(x) S(x)

R(x) S(x) ¬R(x) S(x) R(x) S(x)

Resolution Proofs

• INF (CNF) is more expressive than Horn clauses. • Resolution is simply a generalization of modus

ponens. • As with modus ponens, chains of resolution steps

can be used to construct proofs. • Factoring removes redundant literals from clauses

– S(A) S(A) -> S(A)

Sample Proof

P(w) Q(w) Q(y) S(y)

{y/w}

P(w) S(w) True P(x) R(x)

{w/x}

True S(x) R(x) R(z) S(z) {x/A, z/A}

True S(A)

Refutation Proofs• Unfortunately, resolution proofs in this form are still

incomplete. • For example, it cannot prove any tautology (e.g. P¬P)

from the empty KB since there are no clauses to resolve.

• Therefore, use proof by contradiction (refutation, reductio ad absurdum). Assume the negation of the theorem P and try to derive a contradiction (False, the empty clause). – (KB ¬P False) KB P

Sample Proof

P(w) Q(w) Q(y) S(y)

{y/w}

P(w) S(w) True P(x) R(x)

{w/x}

True S(x) R(x) R(z) S(z) {z/x}

S(A) False True S(x)

{x/A}

False

Resolution Theorem Proving

• Convert sentences in the KB to CNF (clausal form)

• Take the negation of the proposed theorem (query), convert it to CNF, and add it to the KB.

• Repeatedly apply the resolution rule to derive new clauses.

• If the empty clause (False) is eventually derived, stop and conclude that the proposed theorem is true.

Conversion to Clausal Form• Eliminate implications and biconditionals by rewriting them. p q -> ¬p q

p q > (¬p q) (p ¬q) • Move ¬ inward to only be a part of literals by using

deMorgan's laws and quantifier rules. ¬(p q) -> ¬p ¬q

¬(p q) -> ¬p ¬q

¬x p -> x ¬p

¬x p -> x ¬p

¬¬p -> p

Conversion continued

• Standardize variables to avoid use of the same variable name by two different quantifiers.

x P(x) x P(x) -> x1 P(x1) x2 P(x2)

• Move quantifiers left while maintaining order. Renaming above guarantees this is a truth preserving transformation.

x1 P(x1) x2 P(x2) -> x1 x2 (P(x1) P(x2))

Conversion continued• Skolemize: Remove existential quantifiers by replacing each

existentially quantified variable with a Skolem constant or Skolem function as appropriate. – If an existential variable is not within the scope of any universally quantified

variable, then replace every instance of the variable with the same unique constant that does not appear anywhere else.

x (P(x) Q(x)) -> P(C1) Q(C1)

– If it is within the scope of n universally quantified variables, then replace it with a unique n ary function over these universally quantified variables.

x1x2(P(x1) P(x2)) -> x1 (P(x1) P(f1(x1)))

x(Person(x) y(Heart(y) Has(x,y))) ->

x(Person(x) Heart(HeartOf(x)) Has(x,HeartOf(x))) – Afterwards, all variables can be assumed to be universally quantified, so remove

all quantifiers.

Conversion continued• Distribute over to convert to conjunctions of clauses

(ab) c -> (ac) (bc)

(ab) (cd) -> (ac) (bc) (ad) (bd)

– Can exponentially expand size of sentence.

• Flatten nested conjunctions and disjunctions to get final CNF (a b) c -> (a b c)

(a b) c -> (a b c)

• Convert clauses to implications if desired for readability

(¬a ¬b c d) -> a b c d

Sample Clause Conversionx((Prof(x) Student(x)) y(Class(y) Has(x,y))

y(Book(y) Has(x,y))))

x(¬(Prof(x) Student(x)) y(Class(y) Has(x,y)) y(Book(y) Has(x,y))))

x((¬Prof(x) ¬Student(x)) (y(Class(y) Has(x,y)) y(Book(y) Has(x,y))))

x((¬Prof(x) ¬Student(x)) (y(Class(y) Has(x,y)) z(Book(z) Has(x,z))))

xyz((¬Prof(x)¬Student(x)) ((Class(y) Has(x,y)) (Book(z) Has(x,z))))

(¬Prof(x)¬Student(x)) (Class(f(x)) Has(x,f(x)) Book(g(x)) Has(x,g(x))))

Clause Conversion(¬Prof(x)¬Student(x)) (Class(f(x)) Has(x,f(x))

Book(g(x)) Has(x,g(x))))

(¬Prof(x) Class(f(x)))

(¬Prof(x) Has(x,f(x)))

(¬Prof(x) Book(g(x)))

(¬Prof(x) Has(x,g(x)))

(¬Student(x) Class(f(x)))

(¬Student(x) Has(x,f(x)))

(¬Student(x) Book(g(x)))

(¬Student(x) Has(x,g(x))))

Sample Resolution Problem

• Jack owns a dog.

• Every dog owner is an animal lover.

• No animal lover kills an animal.

• Either Jack or Curiosity killed Tuna the cat.

• Did Curiosity kill the cat?

In Logic Form

A) x Dog(x) Owns(Jack,x)

B) x (y Dog(y) Owns(x,y)) AnimalLover(x))

C) x AnimalLover(x) (y Animal(y) ¬Kills(x,y))

D) Kills(Jack,Tuna) Kills(Cursiosity,Tuna)

E) Cat(Tuna)

F) x(Cat(x) Animal(x))

Query: Kills(Curiosity,Tuna)

In Normal Form

A1) Dog(D)

A2) Owns(Jack,D)

B) Dog(y) Owns(x,y) AnimalLover(x)

C) AnimalLover(x) Animal(y) Kills(x,y) False

D) Kills(Jack,Tuna) Kills(Curiosity,Tuna)

E) Cat(Tuna)

F) Cat(x) Animal(x)

Query: Kills(Curiosity,Tuna) False

Resolution Proof

Logic Programming

• Also called declarative programming

• We write programs that say what is to be the result

• We don’t specify how to get the result

• Based on logic, specifically first order predicate calculus

Prolog

• Programming in Logic

• Developed in 1970’s

• ISO standard published in 1996

• Used for:– Artificial Intelligence: expert systems, natural

language processing, machine learning, constraint satisfaction, anything with rules

– Logic databases– Prototyping

Bibliography

• Clocksin and Mellish, Programming in Prolog

• Bratko, Prolog Programming for Artificial Intelligence

• Sterling and Shapiro, The Art of Prolog

• O’Keefe, The Craft of Prolog

Working with Prolog

• You interact with the Prolog listener.

• Normally, you operate in a querying mode which produces backward chaining.

• New facts or rules can be entered into the Prolog database either by consulting a file or by switching to consult mode and typing them into the listener.

Prolog and Logic

• First order logic with different syntax

• Horn clauses

• Does have extensions for math and some efficiency.

The parent Predicate

• Definition of parent/2 (uses facts only)

%parent(Parent,Child).parent(pam, bob).parent(tom, liz).parent(bob, ann).parent(bob, pat).parent(pat, jim).

Constants in Prolog

• Two kinds of constants:– Numbers (much like numbers in other

languages)– Atoms

• Alphanumeric strings which begin with a lowercase letter

• Strings of special characters (usually used as operators)

• Strings of characters enclosed in single quotes

Variables in Prolog

• Prolog variables begin with capital letters.

• We make queries by using variables:?- parent(bob,X).X = ann

• Prolog variables are logic variables, not containers to store values in.

• Variables become bound to their values.

• The answers from Prolog queries reflect the bindings.

Query Resolution

• When given a query, Prolog tries to find a fact or rule which matches the query, binding variables appropriately.

• It starts with the first fact or rule listed for a given predicate and goes through the list in order.

• If no match is found, Prolog returns no.

Backtracking

• We can get multiple answers to a single Prolog query if multiple items match:

?- parent(X,Y).

• We do this by typing a semi-colon after the answer.

• This causes Prolog to backtrack, unbinding variables and looking for the next match.

• Backtracking also occurs when Prolog attempts to satisfy rules.

Rules in Prolog

• Example Prolog Rule:

offspring(Child, Parent) :-parent(Parent, Child).

• You can read “:-” as “if”• Variables with the same name must be

bound to the same thing.

Rules in Prolog• Suppose we have a set of facts for male/1

and female/1 (such as female(ann).).

• We can then define a rule for mother/2 as follows:mother(Mother, Child) :-

parent(Mother, Child),female(Mother).

• The comma is the Prolog symbol for and.

• The semi-colon is the Prolog symbol for or.

Recursive Predicates

• Consider the notion of an ancestor.

• We can define a predicate, ancestor/2, using parent/2 if we make ancestor/2 recursive.

Lists in Prolog

• The empty list is represented as [].

• The first item is called the head of the list.

• The rest of the list is called the tail.

List Notation

• We write a list as: [a, b, c, d]

• We can indicate the tail of a list using a vertical bar:

L = [a, b, c,d],L = [Head | Tail],L = [ H1, H2 | T ].

Head = a, Tail = [b, c, d], H1 = a, H2 = b, T = [c, d]

Some List Predicates

• member/2

• append/3

Try It

• reverse(List,ReversedList)

• evenlength(List)

• oddlength(List)

The Anonymous Variable

• Some variables only appear once in a rule

• Have no relationship with anything else

• Can use _ for each such variable

Arithmetic in Prolog

• Basic arithmetic operators are provided for by built-in procedures:

+, -, *, /, mod, //

• Note carefully:?- X = 1 + 2.X = 1 + 2?- X is 1 + 2.X = 3

Arithmetic Comparison

• Comparison operators:><>==< (note the order: NOT <=)=:= (equal values)=\= (not equal values)

Arithmetic Examples

• Retrieving people born 1950-1960:?- born(Name, Year), Year >= 1950, Year =< 1960.

• Difference between = and =:=?- 1 + 2 =:= 2 + 1.yes?- 1 + 2 = 2 + 1.no?- 1 + A = B + 2.A = 2B = 1

Length of a List

• Definition of length/2

length([], 0).length([_ | Tail], N) :-

length(Tail, N1),N is 1 + N1.

• Note: all loops must be implemented via recursion

Counting Loops

• Definition of sum/3sum(Begin, End, Sum) :-

sum(Begin, End, Begin, Sum).sum(X, X, Y, Y).sum(Begin, End, Sum1, Sum) :-

Begin < End,Next is Begin + 1,Sum2 is Sum1 + Next,sum(Next, End, Sum2, Sum).

The Cut (!)

• A way to prevent backtracking.

• Used to simplify and to improve efficiency.

Negation

• Can’t say something is NOT true

• Use a closed world assumption

• Not simply means “I can’t prove that it is true”

Dynamic Predicates

• A way to write self-modifying code, in essence.

• Typically just storing data using Prolog’s built-in predicate database.

• Dynamic predicates must be declared as such.

Using Dynamic Predicates

• assert and variants

• retract– Fails if there is no clause to retract

• retractall– Doesn’t fail if no clauses