Lab Lecture4 Lecturer Sheriff Nafisa TA Mubarakah Otbi

Lab Lecture#4 Lecturer : Sheriff Nafisa TA : Mubarakah Otbi, Duaa al Ofi , Huda al Hakami

In this Lab. Lecture Matching Things Up: Unification Backtracking Visual Prolog's Relentless Search for Solutions Controlling the Search for Solution Using the fail Predicate Preventing Backtracking: The Cut

Matching Things Up: Unification • When Visual Prolog tries to fulfill the goal it must test each clause in the program for a match. • Visual Prolog will search from the top of the program to the bottom. • When it finds a clause that matches the goal, it binds values to free variables so that the goal and the clause are identical; the goal is said to unify with the clause. This matching operation is called unification.

Unification (contd) • Working definition: • Two terms unify if they are the same term or if they contain variables that can be uniformly instantiated with terms in such a way that the resulting terms are equal.

/* Program exunify. pro */ DOMAINS title, author = symbol pages = unsigned PREDICATES book(title, pages) nondeterm written_by(author, title) nondeterm long_novel(title) CLAUSES written_by(fleming, "DR NO"). written_by(melville, "MOBY DICK"). book("MOBY DICK", 250). book("DR NO", 310). long_novel(Title): written_by(_, Title), book(Title, Length), Length > 300.

written_by( X , Y ). | | written_by(fleming, "DR NO"). Visual Prolog makes a match, X becomes bound to fleming, and becomes bound to "DR NO. " Visual Prolog displays first solution: X=fleming, Y=DR NO Next: written_by( X , Y ). | | written_by(melville, "MOBY DICK"). Visual Prolog displays the second solution X=melville, Y=MOBY DICK 2 Solutions

give the program the goal: written_by(X, "MOBY DICK"). Visual Prolog will attempt a match with the first clause for written_by: written_by( X , "MOBY DICK"). | | written_by(fleming, "DR NO"). Since "MOBY DICK" and "DR NO" do not match, the attempt at unification fails.

Example 2 vertical( line(point(X, Y), point(X, Z))). horizontal( line(point(X, Y), point(Z, Y))). ? - vertical(line(point(1, 1), point(1, 3))). yes ? ? - vertical(line(point(1, 1), point(3, 2))). no ? -

? - horizontal(line(point(1, 1), point(1, Y))). Y = 1; No ? - horizontal(line(point(2, 3), Point)). Point = point(_554, 3); no ? -

Backtracking • Visual Prolog uses backing-up-and-trying-again method, called backtracking, to find a solution to a given problem. • Visual Prolog begins to look for a solution to a problem (or goal), it might have to decide between two possible cases. • It sets a marker at the branching spot (known as a backtracking point) and selects the first subgoal to pursue. • If that subgoal fails (equivalent to reaching a dead end), Visual Prolog will backtrack to the back-tracking point and try an alternate subgoal.

Backtracking(contd) eats(fred, pears). eats(fred, t_bone_steak). eats(fred, apples). "What are all the things that fred eats". To answer this I can use variables again. Thus I can type in the query ? - eats(fred, Food. Item). As we have seen earlier, Prolog will answer with Food. Item = pears

This is because it has found the first clause in the database. At this point Prolog allows us to ask if there are other possible solutions. When we do so we get the following. Food. Item = t_bone_steak if I ask for another solution, Prolog will then give us. Food. Item = apples If we ask for further solutions, Prolog will answer no, since there are only three ways to prove fred eats something. The mechanism for finding multiple solution is called backtracking.

Backtracking in Rules We can also have backtracking in rules. For example consider the following program. hold_party(X): birthday(X), happy(X). birthday(tom). birthday(fred). birthday(helen). happy(mary). happy(jane). happy(helen). If we now pose the query ? - hold_party(Who). X=helen

The Four Basic Principles of Backtracking • Subgoals must be satisfied in order, from top to bottom. • Predicate clauses are tested in the order they appear in the program, from top to bottom. • When a subgoal matches the head of a rule, the body of that rule must be satisfied next. The body of the rule then constitutes a new set of subgoals to be satisfied. • A goal has been satisfied when a matching fact is found for each of the extremities (leaves) of the goal tree.

Controlling the Search for Solutions • Visual Prolog provides two tools that allow you to control the backtracking mechanism: • the fail predicate, which is used to force backtracking, and • the cut (signified by !), which is used to prevent backtracking.

Using the fail Predicate DOMAINS name = symbol PREDICATES nondeterm father(name, name) everybody CLAUSES father(leonard, katherine). father(carl, jason). father(carl, marilyn). everybody: father(X, Y), write(X, " is ", Y, "'s fathern"), fail. everybody.

The object of the predicate everybody is to produce a cleaner response from program runs. Compare the answers to the two preceding goals: Goal father(X, Y). X=leonard, Y=katherine X=carl, Y=jason X=carl, Y=marilyn 3 Solutions and Goal everybody. leonard is katherine's father carl is jason's father carl is marilyn's father Yes

The predicate everybody uses backtracking to generate more solutions for father(X, Y) by forcing Prolog to backtrack through the body of the everybody rule: father(X, Y), write(X, " is ", Y, "'s fathern"), fail can never be satisfied (it always fails), so Visual Prolog is forced to backtrack. When backtracking takes place, Prolog backtracks to the last call that can produce multiple solutions. Such a call is labeled non-deterministic. A non-deterministic call contrasts with a call that can produce only one solution, which is a deterministic call.

Preventing Backtracking: The Cut • Visual Prolog contains the cut, which is used to prevent backtracking; it's written as an exclamation mark (!). • The effect of the cut is simple: It is impossible to backtrack across a cut. • r 1 : - a, b, !, c. • There are two main uses of the cut: a green cut : that certain possibilities will never give rise to meaningful solutions. a red cut : When the logic of a program demands the cut, to prevent consideration of alternate subgoals.

Cut: Example PREDICATES buy_car(symbol, symbol) nondeterm car(symbol, integer) colors(symbol, symbol) CLAUSES buy_car(Model, Color): car(Model, Color, Price), colors(Color, bright), !, Price > 25000. car(maserati, green, 25000). car(corvette, black, 24000). car(corvette, red, 26000). car(porsche, red, 24000). colors(red, bright). colors(black, mean). colors(green, preppy).

Given the goal: buy_car(corvette, Y) Visual Prolog calls car, the first subgoal to the buy_car predicate. It makes a test on the first car, the Maserati, which fails. It then tests the next car clauses and finds a match, binding the variable Color with the value black. It proceeds to the next call and tests to see whether the car chosen has a bright color. Black is not a bright color in the program, so the test fails. Visual Prolog backtracks to the call to car and once again looks for a Corvette to meet the criteria. It finds a match and again tests the color. This time the color is bright, and Visual Prolog proceeds to the next subgoal in the rule: the cut. The cut immediately succeeds and effectively "freezes into place" the variable bindings previously made in this clause.

Visual Prolog now proceeds to the next (and final) subgoal in the rule: the comparison Price < 25000. This test fails, and Visual Prolog attempts to backtrack in order to find another car to test. Since the cut prevents backtracking, there is no other way to solve the final subgoal, and the goal terminates in failure.