# Logic Programming

Document Sample

```					Logic Programming

Chapter 15
Part 2
Search
• Suppose a query has compound goals
(several propositions must be satisfied)
• Depth-first searches prove the first goal
before looking at the others.
• Breadth-first works on goals in parallel.
• Prolog uses the depth-first approach.
Backtracking
• When a compound goal is being proved, it
may be that a subgoal cannot be shown
true.
• In that case, Prolog will back up and try to
find another solution to a previous
subgoal.
A Partial Family Tree
Figure 15.3
A Small Family “Tree”
Figure 15.4
Processing Queries

• ?- father(X, sue)
Satisfied with the first
comparison. X is
instantiated with john.
• ?- mother(sue, X)
Satisfied with X = nancy,
X = jeff
• ?- mother(alice,
ron)
Fails
?- grandparent(Who, ron).
Instantiating grandparent rule from query:
Grandparent(Who,ron):-

parent(Who,X),parent(X,ron).

First, find a fact that satisfies
parent (Who,X)
This entails finding a fact to satisfy either
mother (Who, X) or
father(Who, X)
First try: mother(mary, sue)
(“mother” rule is first)
Next, find a fact that satisfies
parent(sue, ron)
By satisfying either
mother(sue, ron) or
father(sue, ron)
Prolog Lists
• The list is Prolog‟s basic data structure
• Lists are a series of Prolog terms,
separated by commas
• Each list element can be a(n)
– atom
– variable
– sublist
– etc.
Examples of Lists

• The empty list:        []
• List with embedded list: [girls, [like, boys]]
• List with variables:    [x, V1, y, V2, [A, B]]
– V1, V2, A, and B are variables that may be
instantiated with data at a later time.
• Multi-type lists:         [boy, [1, 2, 3], ran]
• [A, _, Z]
– The _ means “don‟t care” – sometimes referred to as
an unbound variable.
Working with Lists
– Head represents the first list element, Tail
represents everything else.
– Head can be any Prolog term (list, variable,
atom, predicate, etc.)
– If L = [a, b, c] then Head = a and Tail = [b,c]
– Tail is always another list.
• What is the head of [a]? The tail?
• Compare to car and cdr in Lisp, Scheme
The append Function
• append is a built-in Prolog function that
concatenates two lists.
• append(A, B, L)
concatenates the lists A and B and returns them
as L.
• append([my, cat], [is, fat], L).
yields
L = [my, cat, is, fat]
• Compare to Scheme function
The Append Function
• append(L1, L2, L3):
append([], X, X). %base case
:- append(Tail, Y, Z).

• This definition says:
– The empty list concatenated with any list (X)
returns an unchanged list (X again).
– If Tail is concatenated with Y to get Z, then a
list one element larger [Head | Tail] can be
concatenated with Y to get [Head | Z].
?- Append([english, russian], [spanish], L).

H=english, T=[russian], Y=[spanish], L=[english,Z]
1                           and Z = [russian, spanish]
Append([russian],[spanish], [Z]).

H = russian, T=[ ], Y=[spanish], Z=[russian|Z1]
2
Append([ ], [spanish], [Z1]).         So Z1= [spanish]

X=[spanish], Z1=[spanish]
3
Append([ ], [spanish], [spanish]).
Using append
prefix(X, Z) :- append(X, Y, Z).
(finds all prefixes of a list Z)

suffix(Y, Z) :- append(X, Y, Z).
(finds all suffixes of Z)
Recursion/ member
• The function returns „yes‟ or „true‟ if X is a
member of a given list.

member(X, [X | _ ]).
member(X, [ _ | Y]) :- member(X, Y).
Member(X,Y)
• The test for membership succeeds if
either:
– X is the head of the list [X |_]
– X is not the head of the list [_| Y] , but X is a
member of the list Y.
• Notes: pattern matching governs tests for
equality.
• Don’t care entries (_) mark parts of a list
that aren’t important to the rule.
Naming Lists
• Defining a set of lists:
a([single]).
a([a, b, c]).
a([cat, dog, sheep]).
• When a query such as a(L), prefix(X, L). Is
posed, all three lists will be processed.
• Other lists, such as b([red, yellow, green]),
would be ignored.
A Sample List Program

a([single]).
a([a, b, c]).
a([cat, dog, sheep]).

prefix(X, Z) :- append(X, _, Z).
suffix(Y, Z) :- append(_, Y, Z).

% To make queries about lists in the database:
% suffix(X, [the, cat, is, fat]).
% a(L), prefix(X, L).
Sample Output             ?- a(L), prefix(X, L).

L = [single]
X = [] ;

L = [single]
Based on the program on
X = [single] ;
the previous slide.
L = [a, b, c]
X = [] ;

L = [a, b, c]
X = [a] ;

L = [a, b, c]
X = [a, b] ;

L = [a, b, c]
X = [a, b, c] ;

L = [cat, dog, sheep]
X = []
Sample Output
35 ?- a(L), append([cat], L, M).

L = [single]
M = [cat, single] ;

L = [a, b, c]
M = [cat, a, b, c] ;

L = [cat, dog, sheep]
M = [cat, cat, dog, sheep] ;
Recursive Factorial Program
To see the dynamics of a function call, use the trace
function. For example,given the following function:

factorial(0, 1).
factorial(N, Result):-
N > 0,
M is N-1,
factorial(M, SubRes),
Result is N * SubRes. %is ~ assignment
Logic Programming

15.2.2: Practical Aspects
15.3: Example Applications
Using the Trace Function
• At the prompt, type “trace.”
• Then type the query.
• Prolog will show the rules it uses and the
instantiation of unbound constants.
• Useful for understanding what is
happening in a search process, or in a
recursive function.
These are
Tracing Output                            temporary
?- trace(factorial/2).                    variables
?- factorial(4, X).
Call: ( 7) factorial(4, _G173)
Call: ( 8) factorial(3, _L131)
Call: ( 9) factorial(2, _L144)
Call: ( 10) factorial(1, _L157)
Call: ( 11) factorial(0, _L170)
Exit: ( 11) factorial(0, 1)
Exit: ( 10) factorial(1, 1)
Exit: ( 9) factorial(2, 2)
Exit: ( 8) factorial(3, 6)
Exit: ( 7) factorial(4, 24)       These are
levels in the
X = 24                            search tree
Tracing
2 ?- trace(factorial/2).
%         factorial/2: [call, redo, exit, fail]
true.

[debug] 3 ?-   factorial(3,   Result).
T Call: (6)   factorial(3,   _G521)
T Call: (7)   factorial(2,   _G599)
T Call: (8)   factorial(1,   _G602)
T Call: (9)   factorial(0,   _G605)
T Exit: (9)   factorial(0,   1)
T Exit: (8)   factorial(1,   1)
T Exit: (7)   factorial(2,   2)         User-entered commands
T Exit: (6)   factorial(3,   6)         are in red; other output is
Result = 6                               generated by the Prolog
runtime system.
%remove() removes an element from a list.
%To Call: remove(a, List, Remainder).
% or remove(X, List, Remainder).
% First parameter is the removed item,
% 2nd parameter is the original list,
% third is the final list

remove(X, [X|R], R).
remove(X, [H|R], [H|S]):- remove(X, R, S).
18 ?- trace.

Yes
18 ?- remove(a, [b, d, a, c], R).
Call: (7) remove(a, [b, d, a, c], _G545) ? creep
Call: (8) remove(a, [d, a, c], _G608) ? creep
Call: (9) remove(a, [a, c], _G611) ? creep
Exit: (9) remove(a, [a, c], [c]) ? creep
Exit: (8) remove(a, [d, a, c], [d, c]) ? creep
Exit: (7) remove(a, [b, d, a, c], [b, d, c]) ? creep

R = [b, d, c]
Revisiting The Factorial Function

Evaluation of clauses is from left to right.
Note the use of is to temporarily assign
values to M and Result
Trace of Factorial (4)
Simple Arithmetic
• Integer “variables” and integer operations
are possible, but imperative language
“assignment statements” don‟t exist.
Sample Program
speed(fred, 60).
speed(carol, 75).
time(fred, 20).
time(carol, 21).

distance(X, Y) :- speed(X, Speed),
time(X, Time), Y is Speed * Time.

area_square(S, A) :- A is S * S.
Prolog Operators
• is can be used to cause a variable to be
temporarily instantiated with a value.
• Compare to assignment statements in
declarative languages, where variables
are permanently assigned values.
• The not operator is used to indicate goal
failure. For example not(P) is true when
P is false.
Arithmetic
• Originally, used prefix notation +(7, X)
• Modern versions have infix notation
X is Y * C + 3.
• Qualification: Y and C must be instantiated, as in
the Speed program, but X cannot be (It‟s not a
– X = X + Y is illegal.
– X is X + Y is illegal.
“Arguments are not sufficiently
instantiated”

• Example of simple arithmetic, using
something similar to Python‟s calculator
mode (not as part of a program).
– ?- X is 3 + 7.
– X = 10
– Yes
• Arithmetic operators: +, -, *, /, ^ (exponentiation)
• Relational operators: <, >, =, =<, >=, \=
The cut & not Operators

• The cut (!) is used to control backtracking.
• It tells Prolog not to retry the series of goals
that precede the cut symbol (if the goals
have succeeded once).
• Reasons: Faster execution, saves memory
• Not(P) will succeed when P fails.
– In some places it can replace the ! Operator.
Example: Revised Factorial

factorial(N, 1):- N < 1, !.
factorial(N, Result):- M is N – 1,
factorial(M, P),
Result is N * P.

factorial(N, 1):- N < 1.
factorial(N, Result):- not(N < 1),
M is N–1,
factorial(M, P),
Result is N * P.
When Cut Might Be Used
(Clocksin & Mellish)

•   To tell Prolog that it has found the right rule:
– “if you get this far, you have picked the correct rule for
this goal.”
•   To tell Prolog to fail a particular goal without trying
other solutions:
– “if you get to here, you should stop trying to satisfy the
goal.”
•   “if you get to here, you have found the only
solution to this problem and there is no point in
ever looking for alternatives.”
• ?- assert(mother(jane, joe)).
adds another fact to the database.
• More sophisticated: assert can be
embedded in a function definition so
new facts and rules can be added to the
database in real time.
– Useful for learning programs, for example.
Symbolic Differentiation Rules
Figure 15.9
Prolog Symbolic Differentiator
Figure 15.10
Search Tree for the Query d(x, 2*x+1, Ans)
Figure 15.11
Executing a Prolog Program
• Create a file containing facts and rules;
e.g., familytree.pl
• Follow instructions in handout, which will
be available Wednesday.
SWIplEdit “compile” error
• If SWI-Prolog finds an error in the .pl file it
will give a message such as

ERROR:
c:/temp/prologprogs/remove.pl:
18:0: Syntax error: Illegal
start of term

(18 is the line number)
Runtime Error Message
• The function samelength was called with
one parameter when it needed 2:

21 ?- samelength(X).
ERROR:Undefined procedure:
samelength/1
ERROR:However, there are
definitions for: samelength/2
Runtime Errors
• Here, the error is an error of omission:

22 ?- samelength([a, b, c,],[a, b])
|
Queries must end with a period. If you hit
enter without typing a period SWIpl just
thinks you aren‟t through.
Using SWI Prolog
• If there is an error that you can‟t figure out
(for example you don‟t get any answers,
you don‟t get a prompt, typing a semicolon
doesn‟t help) try “interrupt” under the Run
button.
• If changes are made to the program, don‟t
forget to save the file and “consult” again.

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 2 posted: 7/7/2011 language: English pages: 46