Chapter 15 An Introduction to PROLOG

1. Chapter 15 An Introduction to PROLOG Contents • Syntax for Predicate Calculus • Abstract Data Types (ADTs) in PROLOG • A Production System Example in PROLOG • Designing Alternative Search Strategies Artificial Intelligence

2. Represent Facts and Rules • Facts (propositions): e.g. male(philip). • Rules (implications): e.g. parent(X, Y) := father(X, Y). parent(X, Y) := mother(X, Y). parent(X, Y) := father(X, Y); mother(X, Y). • Questions (start point of execution): e.g. ?-parent(X, Y). Artificial Intelligence

3. Prolog as Logic • Horn clause – a subset of first-order logic • Logic formula: • Description – A – e.g. philip is male. • Logic OR – A  B : A; B. • Logic AND – A  B : A, B. • Logic NOT -- A : not A. • Logic implication: A  B : B :- A. • Each expression terminates with a . • Deductive inference – Modus ponents A A  B -------- B Artificial Intelligence

4. A Simple Rule English description: If X is male, F is the father of X, M is the mother of X, F is the father of Y, M is the mother of Y Then X is a brother of Y Logic formula: male(X)  father(F, X)  mother(M, X)  father(F, Y)  mother(M, Y)  brother(X, Y) Prolog: brother(X, Y) :- male(X), father(F,X), mother(M,X), father(F,Y), mother(M, Y). Artificial Intelligence

5. A Simple Program A Prolog program is a sequence of facts and rules brother(X, Y) :- male(X), parent(P, X), parent(P, Y). parent(X, Y):- father(X, Y); mother(X, Y). male(philip). father(bill, philip). ?- brother(philip, jane). Artificial Intelligence

6. Program Execution • Start from the question • Matching – match the question with facts and rules by substitution (try) • Unification – looking for unified solution (consistent solution) • Backtracking – once fails, go back to try another case • Divide-and-conquer • divide problem into sub problems • solve all sub problems • integrate sub solutions to build the final solution • Solutions to all sub problems must be consistent Artificial Intelligence

7. Program Trace Tree Artificial Intelligence

8. Another Example • Facts mother(jane, george). father(john, george). Brother(bill, john). • Rules: parent(X, Y) :- mother(X, Y). parent(X, Y) :- father(X, Y). uncle(X, Y) :- parent(P, Y), brother(X, P). • Question: ?- uncle(X, george). Artificial Intelligence

9. Program Execution Trace uncle(X, george) Y/george parent(P, Y) brother(X, P) X/bill, P/john P/X, Y/george mother(X, Y) father(X, Y) brother(bill, john) X/jane X/john mother(jane, george) father(john, george) Artificial Intelligence

10. Unification and Backtracking • First matching (dashed line): • parent(jane, george) -- P jane • brother(bill, john) -- P  john which is not consistent. • Backtracking (solid line): • parent(john, george) -- P  john • Brother(bill, john) -- P  john which is unified • Multiple solutions • Interactive program • Interpreter • Once the program outputs, the user can respond with ; to ask for more solutions • If no more solutions, the program answers “no” Artificial Intelligence

11. Prolog Environment • Add new predicates • assert(P) – add new predicate P to database • asserta(P) – add P to the beginning of database • assertz(P) – add P to the end of database • Delete predicates • retract(P) – remove P fromdatabase • Import database from a file • consult(File) • Input/output • read(X) – read a term from the input stream to X • write(X) – put the term X in the output stream • see(File) – open a file for reading (input stream) • tell(File) – open a file for writing (output stream) Artificial Intelligence

12. Prolog Program Execution Tracing • List all clauses with the predicate name • listing(P) – regardless of the number of arguments • Monitor the program progress • trace – print every goal • exit – when a goal is satisfied • retry – if more matches • fail – enforce fail • notrace – stop the trace • Trace Predicates • spy – print all uses of predicates • More predicates exist and are version-dependent Artificial Intelligence

13. Recursion • Base case – a set of rules for direct solution • Normal case – another set of rules for indirection solution • E.g. child(X, Y) :- mother(Y, X). child(X, Y) :- father(Y, X). descendant(X, Y) :- child(X, Y).  base case descendent(X, Y) :- child(X, Z), descendent(Z, Y). • E.g. Fibnacci number: fib(0) = 0, fib(1) = 1,  base case fib(n) = fib(n-1) + fib(n-2)  normal case • Prolog program: Facts: fib(0, 0). fib(1, 1). Rules: fib(X, N) :- N > 1, N1 is N - 1, N2 is N – 2, fib(Y, N1), fib(Z, N2), X is Y + Z. Question: ? :- fib(X, 5). X = 5. ? :- fib(5, N). N = 5. ? :- fib(X, 8). X = 21. Artificial Intelligence

14. Data Representation • Atom – numbers, strings, etc. • Structured data – pattern • Format: functor(parameter-list) where parameters in the list are either atom or structured data separated with “,” • E.g. person(name) student(person(name), age) male(bill) female(jane) • Special functor dot (.) • Represents list: .(p, .pattern) • Special .pattern: .()  [], empty list • E.g.: .(p, .(q, .(r, .(s, .())))) • List: [p, q, r, s] • Operations: [X|Y]  pattern • Anonyous variable: underscore (_) • E.g. member(X, [X|_]) :- !. member(X, [_|Y]) :- member(X, Y). Artificial Intelligence

15. Lists • A sequence of elements separated by comma and enclosed by [ and ] • List elements can be other lists • Examples: [1, 2, 3, 4] [a, george, [b, jack], 3] • Empty list: [] • Non-empty lists consists of two parts • Header – the first element • Tail – the list containing all elements except the first • Can be written [Header|Tail] • Example: for list [a, 1, b, 2] • Header: a • Tail: [1, b, 2] • Match: • headers match and tails match • Match [a, 1, b, 2] with [H|T] • H = a • T = [1, b, 2] Artificial Intelligence

16. List and Recursion • Recursively process all elements in a list • Usually the base case is the Empty list • Normal cases • Process the header • Recursion on the tail • Example: membership test member(X, [X|T]). member(X, [_|T]) :- member(X, T). ?- member(a, [a, b, c, d]). Yes ; no ?- member(a, [1, [a, b], 2, [c, d]). no ?- member(X, [a, b, c] X = a ; X = b ; X = c ; no Artificial Intelligence

17. More Recursion Examples • Write out a list one element to a line writelist([]). writelist([H|T) :- write(H), nl, writelist(T). • Write out a list in reverse order Reverse_writelist([]). Reverse_writelist([H|T]) :- reverse_writelist(T), write(H), nl. • Append a list to another append([], L, L). append([H|T], L, [H|X]) :- append(T, L, X). • Reverse a list reverse([], []). reverse([H|T], X) :- reverse(T, Y), append(Y, [H], X). Artificial Intelligence

18. Count the number of elements • Count the number of elements in a list • Base case: if the list is empty, then number of elements is 0 • Normal case: the number of elements in the list is the number of elements in the tail plus 1 • Rules? Artificial Intelligence

19. Count the number of elements • Find the number of elements in a list length:-length([], 0) :- !. length([X|Y], N) :- length(Y, M), N is M+1. Artificial Intelligence

20. Recursive Search • Depth-first search with backtracking • Ordering of facts and rules affect the problem-solving efficiency • Search a subgoal: • Top  down: matching facts and heads of rules • Decomposition of goals: • Left  right • Backtracking: • Matching: Top  down • Subgoals: right  left Artificial Intelligence

21. Closed-world assumption and negation (NOT) • Question: ?- X. • Assumption: • If you prove X then X is true. • Otherwise X is false. • Question: ?- not X. • Assumption: • If you can prove not X then not X is true; • Otherwise not X is false, meaning X is true. • So, if can not prove either X or not X, then ?- X. and ?- not X. both false (true). Artificial Intelligence

22. Stop (cut) Backtracking • ! – success once and only once • Efficiency – cut backtracking • E.g. fib(0, 0) :- !. fib(1, 1) :- !. fib(X, N) :- N1 = N-1, N2=N-2, fib(Y, N1), fib(Z, N2), X=Y+Z. • Two uses: • Control the shape of the search tree • Control recursion Artificial Intelligence

23. Abstract Data Types in Prolog • ADT • A set of operations • No data structure specified • ADT building components • Recursion, list, and pattern matching • List handing and recursive processing are hidden in ADTs • Typical ADTs • Stack, Queue, Set, Priority Queue Artificial Intelligence

24. The ADT Stack • Characteristics • LIFO (Last-in-first-out) • Operations • Empty test • Push an element onto the stack • Pop the top element from the stack • Peek to see the top element • Member_stack to test members • Add_list to add a list of elements to the Stack • Implementation • empty_stack([]). • stack(Top, Stack, [Top|Stack]). • Push – bind first two elements and free the third element • Pop – bind the third element and free the first two • Peek – same as Pop but keep the third element • member_stack(Element, Stack) :- member(Element, Stack). • add_list_to_stack(List, Stack, Result):-append(List, Stack, Result). Artificial Intelligence

25. Print a Stack in Reverse Order empty_stack([]). stack(Top, Stack, [Top|Stack]). member_stack(E, Stack) :- member(E, Stack). add_list_to_stack(L, S, R) :- append(L, S, R). reverse_print_stack(S) :- empty_stack(S), !. reverse_print_stack(S) :- stack(H, T, S), reverse_print_stack(T), write(H), nl. ?- reverse_print_stack([1, 2, 3, 4, 5]). Artificial Intelligence

26. The ADT Queue • Characteristics • FIFO (First-in-first-out) • Operations • Empty test • Enqueue – add an element to the end • Dequeue – remove the first element • Peek – see the first element • Member test • Merge two queues • Implementation • empty_queue([]). • enqueue(E, [], [E]). enqueue(E, [H|T], [H|Tnew]) :- enqueue(E, T, Tnew). • dequeue(E, [E|T], T). • dequeue(E, [E|T], _). % peek • member_queue(E, Q) :- member(E, Q). • Add_list_to_queue(L, Q, R) :- append(Q, L, R). Artificial Intelligence

27. The ADT Priority Queue • Characteristics • Each element is associated with a priority • Always remove the “smallest” one • Operations • Empty test • Member test • Add an element to the priority queue • Min – find the minimum element • Remove the minimum element • Add a list to a priority queue • Implementation • empty_pq([]). • member_pq(X, P) :- member(X, P). • insert_pq(E, [], [E]) :- !. insert_pq(E, [H|T], [E, H|T]) :- E < H. insert_pq(E, [H|T], [H|Tnew]) :- insert_pq(E, T, Tnew). • min_pq(E, [E|_]). • remove_min_pq(E, [E|T], T). • add_list_pq([], L. L). add_list_pq([H|T], L, R) :- insert_pq(H, L, L2), add_list_pq(T, L2, Lnew). Artificial Intelligence

28. The ADT Set • A collection of elements • No order • No duplicates • Operations • Empty test • Member test • Add an element to the set • Remove an element from the set • Union two sets • Intersect two sets • Difference two sets • Subset test • Equality test Artificial Intelligence

29. The Set Implementation • empty_set([]). • member_set(E, S) :- member(E, S). • delete_from_set(E, [], []). delete_from_set(E, [E|T], T) :- !. delete_from_set(E, [H|T], [E|Tnew]) :- delete_from_set(E, T). • add_to_set(E, S, S) :- member(E, S), !. add_to_set(E, S, [X|S]). • union([], S, S). union([H|T], S, R) :- union(T, S, S2), add_to_set(H, S2, R). • subset([], _). subset([H|T], S) :- member(H, S), subset(T, S). • intersection([], _, []). intersection([H|T], S, [H|R]) :- member(H, S), intersection(T, S, R), !. intersection([_|T], S, R) :- intersection(T, S, R), !. • Set_diff([], _, []). set_diff([H|T], S, R) :- member(H,S), set_diff(T, S, R), !. set_diff([H|T], S, [H|R]) :- set_diff(T, S, R), !. • equal_set(S1, S2) :- subset(S1, S2), subset(S2, S1). Artificial Intelligence

30. A Production System in Prolog • Farmer, wolf, goat, and cabbage problem • A farmer with his wolf, goat, and cabbage come to the edge of a river they wish to cross. There is a boat at the river’s edge, but, of course, only the farmer can row. The boat also can carry only two things, including the rower, at a time. If the wolf is ever left alone with the goat, the wolf will eat the goat; similarly if the goat is left alone with the cabbage, the goat will eat the cabbage. Devise a sequence of crossings of the river so that all four characters arrives safely on the other side of the river. • Representation • state(F, W, G, C) describes the location of Farmer, Wolf, Goat, and Cabbage • Possible locations are e for east bank, w for west bank • Initial state is state(w, w, w, w) • Goal state is state(e, e, e, e) • Predicates opp(X, Y) indicates that X and y are opposite sides of the river • Facts: opp(e, w). opp(w, e). Artificial Intelligence

31. Sample crossings for the farmer, wolf, goat, and cabbage problem. Artificial Intelligence

32. Portion of the state space graph of the farmer, wolf, goat, and cabbage problem, including unsafe states. Artificial Intelligence

33. Production Rules in Prolog • Unsafe states unsafe(state(X, Y, Y, C)) :- opp(X, Y). unsafe(state(X, W, Y, Y)) :- opp(X, Y). • Move rules move(state(X, X, G, C), state(Y, Y, G, C))) :- opp(X, Y), not(unsafe(state(Y, Y, G, C))), writelist([‘farms takes wolf’, Y, Y, G, C]). move(state(X, W, X, C), state(Y, W, Y, C)) :- opp(X, Y), not(unsafe(state(Y, W, Y, C))), writelist([‘farmers takes goat’, Y, W, Y,C]). move(state(X, W, G, X), state(Y, W, G, Y)) :- opp(X, Y), not(unsafe(state(Y, W, G, Y))), writelist(‘farmer takes cabbage’, Y, W, G, Y]). move(state(X, W, G, C), state(Y, W, G, C)) :-opp(X, Y), not(unsafe(state(Y, W, G, C))), writelist([‘farmer takes self’, Y, W, G, C]). move(state(F, W, G, C), state(F, W, G, C)) :- writelist([‘Backtrack from ‘, F, W, G, C]), fail. Artificial Intelligence

34. Production Rules in Prolog • Path rules path(Goal, Goal, Stack) :- write(‘Solution Path Is: ‘), nl, reverse_print_stack(Stack). path(State, Goal, Stack) :- move(State, Next), not(member_stack(Next, Stack)), stack(Next, Stack, NewStack), path(Next, Goal, NewStack), !. • Start rule go(Start, Goal) :- empty_stack(EmptyStack), stack(Start, EmptyStack, Stack), path(Start, Goal, Stack). • Question ?- go(state(w, w, w, w), state(e, e, e, e) Artificial Intelligence