NegationNegation

Chapter 5Chapter 5

Stating Negative ConditionsStating Negative Conditions

Sometimes you want to say that some Sometimes you want to say that some condition does notcondition does not holdhold

Prolog allows thisProlog allows this– not/1not/1 this is a predicatethis is a predicate– \+/1\+/1 this is a prefix operatorthis is a prefix operator

\+ is the preferred way to go\+ is the preferred way to go not is the traditional way to gonot is the traditional way to go

Non-MembersNon-Members

a is not a member of [q, w, e, r, t, y]a is not a member of [q, w, e, r, t, y]?- ?- \+ member(a, [q,w,e,r,t,y]).\+ member(a, [q,w,e,r,t,y]).YesYes Admission prices revisedAdmission prices revisedadmission(Member, 2) :-admission(Member, 2) :-

club_member(Member).club_member(Member).admission(NonMember, 5) :-admission(NonMember, 5) :-

\+ club_member(NonMember).\+ club_member(NonMember).

How Not WorksHow Not Works

““Negation by failure”Negation by failure”– not tries to prove its argumentnot tries to prove its argument– if the argument fails, not succeedsif the argument fails, not succeeds

\+ club_member(mark).\+ club_member(mark).– tries to prove club_member(mark).tries to prove club_member(mark).– if club_member(mark) succeeds, \+ failsif club_member(mark) succeeds, \+ fails– if club_member(mark) fails, \+ succeedsif club_member(mark) fails, \+ succeeds

Definition of NotDefinition of Not

\+ G :-\+ G :-G, !, failG, !, fail;;true.true.

Some dialects require Some dialects require \+ G :-\+ G :-

call(G), !, failcall(G), !, fail;;true.true.

Not versus CutNot versus Cut

Not is generally less efficient than cutNot is generally less efficient than cut– club_member called twice for non-membersclub_member called twice for non-members

Not is more logical than cutNot is more logical than cut– can rearrange clauses so not-clause comes firstcan rearrange clauses so not-clause comes first

Exercise: rewrite costToBuy/3 using \+ Exercise: rewrite costToBuy/3 using \+ instead of !instead of !

Variables Under the NotVariables Under the Not

Handled by the predicate callHandled by the predicate call?- \+ parent(jim, X).?- \+ parent(jim, X).X = _G301X = _G301YesYes Tried to find an X that jim was parent ofTried to find an X that jim was parent of

– that failedthat failed– \+ succeeded\+ succeeded– X remains unbound (OK – no child of jim)X remains unbound (OK – no child of jim)

Variables Under the NotVariables Under the Not

Failure results in no variable bindings Failure results in no variable bindings

?- \+ parent(bob, X).?- \+ parent(bob, X).

NoNo Tried to find an X that bob was parent ofTried to find an X that bob was parent of

– that succeeded (X = ann)that succeeded (X = ann)– so \+ failedso \+ failed– answer was No, so no bindings printedanswer was No, so no bindings printed

Not Not NeverNever Binds Variables Binds Variables

No bindings printed for \+ questionsNo bindings printed for \+ questions– success means no values were foundsuccess means no values were found– failure means no bindings survivefailure means no bindings survive

Can’t use \+ or not to generate counter-Can’t use \+ or not to generate counter-examplesexamples– can’t say “find an X such that bob is not the can’t say “find an X such that bob is not the

parent of X”parent of X”

Finding Bob’s Non-ChildrenFinding Bob’s Non-Children

Need to make X into someone firstNeed to make X into someone firstperson(X) :- parent(X, _).person(X) :- parent(X, _).person(X) :- parent(_, X).person(X) :- parent(_, X).nonparent(X, Y) :-nonparent(X, Y) :-

person(X), person(Y), \+ parent(X, Y).person(X), person(Y), \+ parent(X, Y). Now can find nonparentsNow can find nonparents?- ?- nonparent(bob, X).nonparent(bob, X).X = pamX = pam

Not Does Not CommuteNot Does Not Commute

\+’s variables should be as instantiated as \+’s variables should be as instantiated as necessary when callednecessary when called– otherwise it may prevent solutions being foundotherwise it may prevent solutions being found?- ?- \+ parent(X, Y), X = jim, Y = bob.\+ parent(X, Y), X = jim, Y = bob.NoNo?- ?- X = jim, Y = bob, \+ parent(X, Y).X = jim, Y = bob, \+ parent(X, Y).X = jim, Y = bobX = jim, Y = bobYesYes

ExerciseExercise

Write clauses for likes/2 for MicheleWrite clauses for likes/2 for Michele– Michele likes animalsMichele likes animals– except spiders and snakesexcept spiders and snakes– except she likes Sammy (who is a snake)except she likes Sammy (who is a snake)

Use \+ instead of cut, fail and disjunctionUse \+ instead of cut, fail and disjunctionlikes(michele, X) :-likes(michele, X) :-

……

Using Negation to Block CyclesUsing Negation to Block Cycles

Monkey example very “fragile”Monkey example very “fragile”– change order of actions – get infinite recursionchange order of actions – get infinite recursion– put walking first, monkey just tries walking all put walking first, monkey just tries walking all

over the place, never climbs on or pushes boxover the place, never climbs on or pushes box Want to avoid monkey going into a loopWant to avoid monkey going into a loop

– getting into a state he was in beforegetting into a state he was in before– not making progress toward the goalnot making progress toward the goal

Avoiding CyclesAvoiding Cycles

Whenever monkey makes a move…Whenever monkey makes a move… ……he checks to see if he’s been in the new he checks to see if he’s been in the new

state beforestate before– if so, reject that moveif so, reject that move– if not, carry on looking for other movesif not, carry on looking for other moves

Need to keep track of previous statesNeed to keep track of previous states– an extra argumentan extra argument– add previous states as we go alongadd previous states as we go along

Keeping Track of Old StatesKeeping Track of Old States

% canget(State, OldStates):% canget(State, OldStates):% monkey can get banana from State% monkey can get banana from State% without repeating any of his OldStates% without repeating any of his OldStates

canget(state( _, _, _, has)canget(state( _, _, _, has), _, _).).canget(State1canget(State1, OldStates, OldStates) :-) :- move(State1, Move, State2),move(State1, Move, State2), \+ member(State2, OldStates),\+ member(State2, OldStates), canget(State2canget(State2, [State1|OldStates], [State1|OldStates]).).

Passing Down Passing Down vsvs Passing Up Passing Up

Compare above with building list of movesCompare above with building list of movescanget(…, []).canget(…, []).vsvscanget(…, _).canget(…, _).

andand

canget(…, [Move|Moves]) :- … canget(…, Moves).canget(…, [Move|Moves]) :- … canget(…, Moves).vsvscanget(Old, Olds) :- … canget(…, [Old|Olds]).canget(Old, Olds) :- … canget(…, [Old|Olds]).

Head passes upBody passes down

Combining Down & UpCombining Down & Up

Can do it all in PrologCan do it all in Prologcanget(state(_,_,_,has), _, []).canget(state(_,_,_,has), _, []).

canget(Old, Olds, [Move|Moves]) :-canget(Old, Olds, [Move|Moves]) :-move(Old, Move, New),move(Old, Move, New),\+ member(New, Olds),\+ member(New, Olds),canget(New, [Old|Olds], Moves).canget(New, [Old|Olds], Moves).

Hiding ArgumentsHiding Arguments

Can have different number of arguments Can have different number of arguments with same predicate namewith same predicate name– hide arguments that always start out the samehide arguments that always start out the same

canget(StartState, Moves) :-canget(StartState, Moves) :-canget(StartState, [], Moves).canget(StartState, [], Moves).

canget(Moves) :-canget(Moves) :-canget(state(atdoor,onfloor,atwindow,hasnot),canget(state(atdoor,onfloor,atwindow,hasnot),

Moves).Moves).

Compound NotsCompound Nots

Suppose we want to define none_parents/1Suppose we want to define none_parents/1– argument is a list with no parents in itargument is a list with no parents in it

Could go down list & check each elementCould go down list & check each element– just like we did for all_malejust like we did for all_male

But could just say: no member of this list is But could just say: no member of this list is a parenta parent– how do we say that?how do we say that?

Wrong AnswersWrong Answers

none_parents_1(List) :-none_parents_1(List) :-

member(P, List),member(P, List),

\+ parent(P).\+ parent(P).

none_parents_2(List) :-none_parents_2(List) :-

parent(P),parent(P),

\+ member(P, List).\+ member(P, List).

some member is not a parent[pam, bob, ann]

some parent is not a member[pam, bob, liz]tom not there

Correct AnswerCorrect Answer

Not the case that a member is a parentNot the case that a member is a parentnone_parents(List) :-none_parents(List) :-

\+ \+ ((member(P, List), parent(P)member(P, List), parent(P))).. Parentheses around the compound argumentParentheses around the compound argument

– \+ binds closer than ,\+ binds closer than ,– use parentheses to change orderuse parentheses to change order

If there is a member who is a parent, failIf there is a member who is a parent, fail– otherwise, you’re OKotherwise, you’re OK

ExerciseExercise

Write a predicate no_brothers/1Write a predicate no_brothers/1– no one in the argument is brother to anyone else no one in the argument is brother to anyone else

in the argumentin the argument%% no_brothers( +ListOfPeople )%% no_brothers( +ListOfPeople )

First Midterm TestFirst Midterm Test

PrologProlog

First TestFirst Test

Next Thursday (February 7)Next Thursday (February 7) In class (HSH 206)In class (HSH 206) TopicsTopics

– chapters 1 to 5 (in-class material only)chapters 1 to 5 (in-class material only) Closed bookClosed book Closed computerClosed computer More doing than sayingMore doing than saying

DoingDoing

Writing Prolog codeWriting Prolog code– factsfacts– rulesrules– queriesqueries

Reading & interpreting Prolog codeReading & interpreting Prolog code– saying what Prolog’s response would besaying what Prolog’s response would be– ““tracing execution”tracing execution”

Next TimeNext Time

Input and OutputInput and Output– Chapter 6Chapter 6