- 94 Views
- Uploaded on
- Presentation posted in: General

For Wednesday

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

- Read chapter 10
- Prolog Handout 4

- Monday
- Take home due at the exam

- reverse(List,ReversedList)
- evenlength(List)
- oddlength(List)

- Some variables only appear once in a rule
- Have no relationship with anything else
- Can use _ for each such variable

- 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

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

- 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

- Definition of length/2length([], 0).length([_ | Tail], N) :-length(Tail, N1),N is 1 + N1.
- Note: all loops must be implemented via recursion

- 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).

- A way to prevent backtracking.
- Used to simplify and to improve efficiency.

- Can’t say something is NOT true
- Use a closed world assumption
- Not simply means “I can’t prove that it is true”

- 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.

- assert and variants
- retract
- Fails if there is no clause to retract

- retractall
- Doesn’t fail if no clauses

- Propositional version.
{a Ú b, ¬b Ú c} |- a Ú c OR {¬aÞ b, b Þ c} |- ¬a Þ c

Reasoning by cases OR transitivity of implication

- Firstorder form
- For two literals pj and qk in two clauses
- p1Ú ... pj ... Ú pm
- q1Ú ... qk ... Ú qn
such that q=UNIFY(pj , ¬qk), derive

SUBST(q, p1Ú...pj1Úpj+1...ÚpmÚq1Ú...qk1 qk+1...Úqn)

- For two literals pj and qk in two clauses

- 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Ú...Ú¬pmÚq1Ú...ÚqnÛ

p1Ù... Ù pmÞ q1Ú ...Ú qn

- 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).

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)

- 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)

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)

- 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

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

- 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.

- 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

- 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 truthpreserving transformation.
"x1 P(x1) Ú $x2 P(x2) -> "x1$x2 (P(x1) Ú P(x2))

- 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 nary function over these universally quantified variables.
"x1$x2(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.

- 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.

- Distribute Ù over Ú to convert to conjunctions of clauses
(aÙb) Ú c -> (aÚc) Ù (bÚc)

(aÙb) Ú (cÙd) -> (aÚc) Ù (bÚc) Ù (aÚd) Ù (bÚd)

- 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

"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)) Ù$y(Book(y) Ù Has(x,y))))

"x((¬Prof(x) Ù ¬Student(x)) Ú ($y(Class(y) Ù Has(x,y)) Ù$z(Book(z) Ù Has(x,z))))

"x$y$z((¬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))))

(¬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))))

- 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?

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)

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