009.moreprolog reasoning by analogy

8/13/2019 009.MoreProlog Reasoning by Analogy

1/20

more Prolog

test vs. find

built-in predicates

list operations: member, append, nth0, reverse,

not, default vs. logical negation

comparison operators, arithmetic

user-defined operators

position, precedence, associativity

Dave Reed


2/20

Test vs. find

?- member(X, [a, b, c]).

X = a ;

X = b ;

X = c ;

No

?- member(a, X).

X = [a|_G260] ;

X = [_G259,a|_G262]

Yes

?- member(X, Y).

X = _G209

Y = [_G209|_G270] ;

X = _G209

Y = [_G275,_G209|_G278]Yes

Prolog programs define relations:

query w/ constants: "test" whether relation holds between the constants

query w/ variables: "find" values for which the relation holds

with a variable as first argument, the query is used

to "find" members of the given list

with a variable as the second argument, the query

is used to "find" lists that have the given item as

member

with both variables, the query is used to "find"

general schemas for list membership


3/20

Append predicate

?- append([a,b], [c,d], L).

L = [a,b,c,d]

Yes

?- append(L1, L2, [a,b,c,d]).L1 = []

L2 = [a,b,c,d] ;

L1 = [a]

L2 = [b,c,d] ;

L1 = [a,b]

L2 = [c,d] ;

L1 = [a,b,c]

L2 = [d] ;

L1 = [a,b,c,d]

L2 = [] ;

No

another useful predefined predicate for list manipulation

append(L1,L2,L3): L3 is the result of

placing the items in L1at the front of L2

can be used in reverse to partition a list

again, we could define append ourselves:

append([], L, L).

append([H|T], L, [H|A]) :-append(T, L, A).

as we saw with ancestor example,

clause ordering is important with

recursive definitions if put rule first, infinite loop possible


4/20

Other list predicates?- L = [a,b,c,d],

length(L, Len), nth1(Len, L, X).

L = [a,b,c,d]

Len = 4X = d

Yes

?- reverse([a,b,a,c], Rev),

delete(Rev, a, Del).

Rev = [c,a,b,a]

Del = [c,b]

Yes

?- select(a, [a,b,a,c], R).

R = [b,a,c] ;

R = [a,b,c] ;

No

?- select(a, L, [b,c]).

L = [a,b,c] ;

L = [b,a,c] ;

L = [b,c,a] ;

No

is_list(Term): succeeds if Termis a list

length(List,Len): Len is the number of

items in List

nth0(Index,List,Item): Item is the item

at index Indexof List(starting at 0)

nth1(Index,List,Item): Item is the itemat index Indexof List(starting at 1)

reverse(List,RevList): RevList is List

with the items in reverse order

delete(List,Item,NewList): NewList is

the result of deleting every occurrence of

Itemfrom List

select(Item,List,Remain): Remain is

the Listwith an occurrence of Item

removed


5/20

notpredicate

notdefines the (default) negation

of conditional statements

when applied to relations with novariables, it is equivalent to logicalnegation ()

in reality, it returns the opposite ofwhatever its argument would return

if X would succeed as a query,then not(X) fails

if X would fail as a query,then not(X) succeeds

anything Prolog can't prove true itassumes to be false!

?- is_list([]).

Yes

?- not(is_list([])).

No

?- member(d, [a,b,c]).

No

?- not(member(d, [a,b,c])).

Yes

?- member(X, [a,b,c]).

X = a

Yes

?- not(member(X, [a,b,c])).

No

?- X = d, not(member(X, [a,b,c])).

X = d

Yes

?- not(member(X, [a,b,c])), X = d.No


6/20

Programming exercises

suppose we want to define a relation to test if a list is palindromic

palindrome(List): succeeds if Listis a list whose elements are the same

backwards & forwards

palindrome([]).

palindrome(List) :- reverse(List, Rev), List = Rev.

suppose we want to define relation to see if a list has duplicates

has_dupes(List): succeeds if List has at least one duplicate element

has_dupes([H|T]) :- member(H, T).

has_dupes([_|T]) :- has_dupes(T).

suppose we want the opposite relation, that a list has no dupes

no_dupes(List): succeeds if List has no duplicate elements

no_dupes(List) :- not( has_dupes(List) ).


7/20

Built-in comparison operators

X = Y does more than test equality, it matches Xwith Y, instantiating variables if necessary

X \= Y determines whether X & Y are not unifiable

for ground terms, this means inequality

can think of as: not(X = Y) again, doesn't make a lot of sense for variables

Note: arithmetic operators (+, -, *, /) are not evaluated

4 + 2 +(4, 2)

can force evaluation using 'is'

?- X = 4 + 2. ?- X is 4 + 2.

X = 4+2 X = 6

Yes Yes

?- foo = foo.

Yes

?- X = foo.

X = foo

Yes

?- [H|T] = [a,b,c].

H = a

T = [b,c]

Yes

?- foo \= bar.

Yes

?- X \= foo.

No

?- 4+2 = 6.

No


8/20

Arithmetic operations

arithmetic comparisons automatically evaluate expressions

X =:= Y X and Y must both be arithmetic expressions (no variables)X =\= YX > Y ?- 12 =:= 6+6.X >= Y Yes

X < Y

X =< Y ?- X =:= 6+6.

ERROR: Arguments are not sufficiently instantiated

Example:sum_of_list(ListOfNums, Sum): Sumis the sum of numbers in ListOfNums

sum_of_list([], 0).

sum_of_list([H|T], Sum) :-

sum_of_list(T,TailSum), Sum is H + TailSum.


9/20

Programming exercise

suppose we want to define relation to see how many times an itemoccurs in a list

num_occur(Item,List,N): Itemoccurs Ntimes in List

num_occur(_,[],0).

num_occur(H, [H|T], N) :-

num_occur(H, T, TailN), N is TailN+1.

num_occur(H, [_|T], N) :-

num_occur(H, T, TailN), N is TailN.

is the first answer supplied by this relation correct?

are subsequent answers obtained via backtracking correct?


10/20

User-defined operators

it is sometimes convenient to write functors/predicates as operators

predefined: +(2, 3) 2 + 3

user defined? likes(dave, cubs) dave likes cubs

operators have the following characteristics

position of appearance

prefix e.g., -3

infix e.g., 2 + 3postfix e.g., 5!

precedence

2 + 3 * 4 2 + (3 * 4)

associativity

8

5 - 2

8

(5

2)


11/20

op

new operators may be defined as follows

:- op(Prec, PosAssoc, Name).

Name is a constant

Prec is an integer in range 01200 (lower number binds tighter)

PosAssoc is a constant of the formxf, yf (postfix)fx, fy (prefix)xfx, xfy, yfx, yfy (infix)

the location off

denotes the operator positionxmeans only operators of lowerprecedence may appear hereyallows operators of loweror equalprecedence

Example: :- op(300, xfx, likes).


12/20

Operator example

%%% likes.pro

likes(dave, cubs).

likes(kelly, and(java,

and(scheme,prolog))).

?- likes(dave, X).

X = cubs

Yes

?- likes(Who, What).

Who = daveWhat = cubs ;

Who = kelly

What = and(java, and(scheme,prolog)) ;

No

%%% likes.pro

:- op(300, xfx, likes).

:- op(250, xfy, and).

dave likes cubs.

kelly likes java and scheme and prolog.

?- dave likes X.

X = cubs

Yes

?- Who likes What.

Who = daveWhat = cubs ;

Who = kelly

What = java and scheme and prolog ;

No

by defining functors/predicates as operators, can make code more English-like


13/20

SWI-Prolog operators

the following

standardoperators are

predefined in

SWI-Prolog

to define newoperators Name& Type

are easy

Precedenceistricky, mustdetermine placein hierarchy

Note: always

define ops at top

of the program

(before use)

1200 xfx -->, :-

1200 fx :-, ?-

1150 fx dynamic, multifile, module_transparent,

discontiguous, volatile, initialization

1100 xfy ;, |

1050 xfy ->

1000 xfy ,

954 xfy \

900 fy \+

900 fx ~

700 xfx =, @=, \=, \==, is

600 xfy :

500 yfx +, -, /\, \/, xor

500 fx +, -, ?, \

400 yfx *, /, //, , mod, rem

200 xfx **

200 xfy ^


14/20

IQ Testchoose the most likely

answer by analogyis to as is to

A) B) C)

Question 1:

is to as is to

A) B) C)

Question 2:

is to as is to

A) B) C)

Question 3:


15/20

Analogy reasoner

want to write a Prolog program for reasoning by analogy (Evans, 1968)

need to decide on a representation of pictures

constants: small, large, triangle, square, circle

functor/operator: sized

sized(small, triangle) OR small sized trianglesized(large, square) OR large sized square

functors: inside, above

inside(small sized circle, large sized square).above(large sized triangle, small sized square).

need to represent questions as well

operators:is_to, as (bind looser than sized, so higher prec #)

predicate:question

question(Name, F1 is_to F2 as F3 is_to [A1,A2,A3]).


16/20

IQ test questions

:- op(200, xfy, is_to).

:- op(200, xfy, as).

:- op(180, xfy, sized).

question(q1,

inside(small sized square, large sized triangle) is_to

inside(small sized triangle, large sized square) as

inside(small sized circle, large sized square) is_to

[inside(small sized circle, large sized triangle),

inside(small sized square, large sized circle),

inside(small sized triangle, large sized square)]).

question(q2,

inside(small sized circle, large sized square) is_to

inside(small sized square, large sized circle) as

above(small sized triangle, large sized triangle) is_to

[above(small sized circle, large sized circle),

inside(small sized triangle, large sized triangle),above(large sized triangle, small sized triangle)]).

question(q3,

above(small sized square, large sized circle) is_to

above(large sized square, small sized circle) as

above(small sized circle, large sized triangle) is_to

[above(large sized circle, small sized triangle),

inside(small sized circle, large sized triangle),above(large sized triangle, small sized square)]).


17/20

Analogy transformations

transform(invertPosition,

inside(small sized Figure1, large sized Figure2) is_to

inside(small sized Figure2, large sized Figure1)).

transform(invertPosition,

above(Size1 sized Figure1, Size2 sized Figure2) is_to

above(Size2 sized Figure2, Size1 sized Figure1)).

transform(invertSizes,

inside(small sized Figure1, large sized Figure2) is_to

inside(small sized Figure2, large sized Figure1)).

transform(invertSizes,

above(Size1 sized Figure1, Size2 sized Figure2) is_to

above(Size2 sized Figure1, Size1 sized Figure2)).

also need to represent transformations

predicate:transform

transform(Name, F1 is_to F2).

Note: different but related transformations can have the same name


18/20

Analogy reasoner

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%% analogy.pro Dave Reed 1/23/02%%%

%%% A program based on Evans' analogy reasoner.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:- op(200, xfy, is_to).

:- op(200, xfy, as).

:- op(180, xfy, sized).

analogy(Question, Solution) :-

question(Question, F1 is_to F2 as F3 is_to Answers),

transform(Rule, F1 is_to F2),

transform(Rule, F3 is_to Solution),

member(Solution, Answers).

%%% questions (as before)

%%% transformations (as before)

to find an answer:

1. look up the questionbased on its name

2. find a transformationthat takes F1 to F2

3. apply that rule to F3 toobtain a potentialsolution

4. test to see if thatsolution is among theanswers to choose from


19/20

Analogy reasoner

?- analogy(q1, Answer).

Answer = inside(small sized square, large sized circle) ;

Answer = inside(small sized square, large sized circle) ;

No


Answer = above(large sized triangle, small sized triangle) ;

Answer = above(large sized triangle, small sized triangle) ;

No


Answer = above(large sized circle, small sized triangle) ;

No

Note: Questions 1 & 2 yield the same answer twice. WHY?

Is it possible for a questions to have different answers?


20/20

Handling ambiguities

Question 4:


Answer = above(small sized triangle, large sized circle) ;

Answer = above(small sized circle, large sized triangle) ;

No

it is possible for 2 different

transformations to produce different

answers

must either1. refine the transformations (difficult)

2. use heuristics to pick most likely

answer (approach taken by Green)

is to as is to

A) B) C)

009.moreprolog reasoning by analogy

Documents