Logic Programming – Part Logic Programming – Part 22• Lists• Backtracking Optimization (via the cut
operator)• Meta-Circular Interpreters
Lists – Basic ExamplesLists – Basic Examples[] – The empty list[X,2,f(Y)] – A 3 element list[X|Xs] – A list starting with X. Xs
is a list as well.
Example - [3,5] may be written as [3|5|[]]
Lists – CFG with PrologLists – CFG with Prolog
Question: Which sentences can be constructed using this grammar?
s -> np vpnp -> det nvp -> v np | vdet -> a | then -> woman | manv -> shoots
Lists – CFG with PrologLists – CFG with Prolog
Lets make relations out of it:s(Z) :- np(X), vp(Y), append(X,Y,Z). np(Z) :- det(X), n(Y), append(X,Y,Z). vp(Z) :- v(X), np(Y), append(X,Y,Z).vp(Z) :- v(Z). det([the]).det([a]). n([woman]).n([man]). v([shoots]).
s -> np vpnp -> det nvp -> v np | vdet -> a | then -> woman | manv -> shoots
Lists – CFG with PrologLists – CFG with PrologWe can ask simple queries like:
Prolog generates entire sentences!
s([a,woman,shoots,a,man]).true
?-s(X). X = [a,woman,shoots,a,woman] ;X = [a,woman,shoots,a,man] ;X = [a,woman,shoots,the,woman] ;X = [a,woman,shoots,the,man] ;X = [a,woman,shoots] …
?-s([the,man|X]). X = [shoots,a,woman] ;X = [shoots,a,man] ;X = [shoots,the,woman] …
Lists – CFG with PrologLists – CFG with PrologQuestion: Add a few rules to the grammar
What should we change in the code?Answer: we add the following code
s -> np vpnp -> det n | det adj nvp -> v np | vdet -> a | then -> woman | manv -> shootsadj -> vicious | marvelous
np(Z) :- det(X), adj(W), n(Y), append([X,W,Y],Z).adj([vicious]).adj([marvelous]).
In this example we’ll work with dates
We assume, for simplicity that a date comprises of a week day and an hour
We define the possible week days and hours with lists:
week_day(['Sun', 'Mon', 'Tue','Wed','Thu','Fri','Sat']).
hour([0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23]).
Lists – The date RelationLists – The date Relation
Q: How can we tell if hour 2 is before 9?
A: 1.A < relation isn’t really possible to implement.
(More details in the PS document)
2.We can only do so by checking precedence in the lists above.
week_day(['Sun', 'Mon', 'Tue','Wed','Thu','Fri','Sat']).
hour([0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23]).
Lists – The date RelationLists – The date Relation
Lists – The date RelationLists – The date Relation
Example queries:
date([H,W]) :- hour(Hour_list), member(H, Hour_list), week_day(Weekday_list), member(W, Weekday_list). dateLT( date([_,W1]), date([_,W2]) ) :- week_day(Weekday_list), precedes(W1,W2,Weekday_list).dateLT( date([H1,W]), date([H2,W]) ) :- hour(Hour_list), precedes(H1,H2,Hour_list).
?- date([1,'Sun']).true dateLT(date([5,'Mon']), date([1,'Tue'])).true
precedes is defined using append /2
precedes(X,Y,Z) :- append( [_,[X],_,[Y],_] , Z ).
Lists – The date RelationLists – The date Relation
Notice that the first argument is a list of lists
This version of append is a strong pattern matcher
Lists – Merging date ListsLists – Merging date ListsMerge 2 ordered date-lists
% Signature: merge(Xs, Ys, Zs)/3% purpose: Zs is an ordered list of dates obtained% by merging the ordered lists of dates Xs and Ys.merge([X|Xs] , [Y|Ys] , [X|Zs]) :- dateLT(X,Y), merge(Xs, [Y|Ys] ,Zs).merge([X|Xs] , [X|Ys] , [X,X|Zs]) :- merge(Xs, Ys, Zs).merge([X|Xs],[Y|Ys],[Y|Zs]) :- dateLT(Y,X), merge( [X|Xs] ,Ys, Zs). merge(Xs,[ ], Xs). merge([ ],Ys, Ys).?- merge( [date([5,'Sun']), date([5,'Mon'])], X,
[date([2, 'Sun']), date([5,'Sun']), date([5, 'Mon'])]).X = [date([2, 'Sun'])]
merge([d1,d3,d5],[d2,d3],Xs)
{X_1=d1,Xs_1=[d3,d5], Y_1=d2,Ys_1=[d3],Xs=[d1|Zs_1] } Rule 1 dateLT(d1,d2),
merge([d3,d5], [d2,d3] ,Zs_1)
merge([d3,d5], [d2,d3] ,Zs_1)
true
merge([d3,d5], [d3] ,Zs_2)
dateLT(d2,d3), merge([d3,d5], [d3] ,Zs_2)
Rule 2 – failure branch…Rule 1 – failure branch…
{ X_3=d3,Xs_3=[d5],Ys_3=[],Zs_2=[d3,d3|Zs_3] } Rule 2
Rule 1 – failure branch…
merge([d5], [] ,Zs_3)
{ Xs_4=[d5], Zs_3=[d5] } Fact 4
Rule 2 – failure branch…
Rule 3 – failure branch…
Rule 3 – failure branch…
{ X_2=d3,Xs_2=[d5],Y_2=d2,Ys_2=[d3],Zs_1=[d2|Zs_2]} Rule 3
Backtracking Optimization Backtracking Optimization - Cut- CutThe cut operator (denoted ‘!’) allows to prune trees from unwanted branches.
A cut prunes all the goals below itA cut prunes all alternative solutions of goals to the left of itA cut does not affect the goals to it’s right
The cut operator is a goal that always succeeds
Backtracking Optimization Backtracking Optimization - Cut- Cut
Example - Merge with CutExample - Merge with Cut In the merge example, only 1 of the 3 first
rules can be true. There is no reason to try the others.
Modify rule 1:merge([X|Xs] ,[Y|Ys], [X|Zs]) :- dateLT(X,Y), !, merge (Xs, [Y |Ys],Zs).
merge([d1,d3,d5],[d2,d3],Xs)
dateLT(d1,d2),!, merge([d3,d5], [d2,d3] ,Zs_1)
merge([d3,d5], [d2,d3] ,Zs_1)
!, merge([d3,d5], [d2,d3] ,Zs_1)
Rule 2 – failure branch…
Rule 3 – failure branch…
Another ExampleAnother ExampleHow many results does this query
return?
Why does this happen?The query fits both rules 4 and 5How can we avoid this?Add cut to rule 4
?- merge([],[],X) .
merge(Xs, [ ],Xs) :- !.
X = [];X = [];No
Meta-Circular Interpreter Meta-Circular Interpreter Version 1Version 1
clause finds the first rule unifying with A with body B
% Signature: solve(Goal)/1% Purpose: Goal is true if it is true when posed to the original program P.
solve(true) :- !.solve( (A, B) ) :- solve(A), solve(B).solve(A) :- clause(A, B), solve(B).
?- clause( parent(X,isaac),Body).X = abraham Body = true
?- clause(ancestor(abraham, P),Body).P = Y, Body = parent(abraham, Y) ;P = Z, Body = parent(abraham, Y), ancestor(Y, Z)
{A_1 = ancestor(abraham, P)}Rule 3 solve
solve(ancestor(abraham, P))
clause(ancestor(abraham, P), B_1), solve(B_1)
{ B_1 = parent(abraham, P), X_2 = abraham, Y_2 = P }Rule 1 ancestor
solve(parent(abraham, P))
{A_3 = parent(abraham, P)}Rule 3 solve
{P = issac, B_3 =true}Fact 1 parent
solve(parent(abraham,Y_2), ancestor(Y_2, P))
{ B_1 = parent(abraham,Y_2), ancestor(Y_2, P) }Rule 2 ancestor
{A_3 = parent(abraham,Y_2)B_3 = ancestor(Y_2, P}Rule 2 solve
clause(parent(abraham, P), B_3), solve(B_3).
solve(true)
!
solve( parent(abraham,Y_2)), solve(ancestor(Y_2, P))
clause(parent(abraham, Y_2), B_4), solve(B_4)
solve(ancestor(Y_2, P))Fact 1 solve
{P = issac}
{A_4 = parent(abraham,Y_2)}Rule 3 solve
{Y_2 = issac, B_4 =true}Fact 1 parent solve(true) ,
solve(ancestor(issac, P))
true
Meta-Circular Interpreter Meta-Circular Interpreter Version 2Version 2In this version we control the
goal selection order by using a stack of goals
Preprocessing – The given program is converted into a program with a single predicate rule containing only facts
Queries are checked against the new program
Meta-Circular Interpreter Meta-Circular Interpreter Version 2Version 2
Sample converted program:
% Signature: solve(Goal)/1% Purpose: Goal is true if it is true when posed to the original program P.1. solve(Goal) :- solve(Goal, []). % Signature: solve(Goal, Rest_of_goals)/21. solve([],[]).2. solve([],[G | Goals]):- solve(G, Goals).3. solve([A|B],Goals):- append(B, Goals, Goals1), solve(A, Goals1).4. solve( A, Goals) :- rule(A, B), solve(B, Goals).
%rule (Head, BodyList)/21. rule( member(X, [X|_] ), [] ).2. rule( member(X, [_|Ys] ), [member(X, Ys)] ).
{ X_3=X,Ys_3=[b, c],B_2 = [member(X, [b,c])]} Rule 2 rule
{ A_4= member(X, [b,c]), B_4=[], Goals_4=[] } Rule 3 rule
{ Goals1_4=[]}Rule of append
{ A_5=member(X,[b,c]), Goals_5=[]}Rule 4 solve
{ X=b,X_6 = b,B_5 = [] } Rule 1 rule
{Goal_1 = member(X, [a, b, c])}Rule 1 solve
solve(member(X, [a, b, c]))
solve(member(X, [a, b, c]), [])
{ A_2 = member(X, [a, b, c], Goals_1 = [] }Rule 4 solve
rule(member(X, [a, b, c], B_2), solve(B_2, [])
solve([],[])
{ X=a,X_3 = a, Xs_3=[b, c],B_2 = [] }Rule 1 rule
true
{X=a}
Rule 1 solve
solve([member(X, [b,c])], [])
append([], [], Goals1_4), solve(member(X, [b,c]), Goals1_4).
solve(member(X, [b,c]), []).
rule(member(X,[b,c]), B_5), solve(B_5, [])
solve([],[])
true
{X=b}
Rule 1 solve