Prolog Cut: Summary. CSC324 Logic & Relational Programming Illustrated in Prolog. Prolog Cut: Summary. Non-deterministic Programming

Transcription

1 Prolog Cut: Summary CSC324 Logic & Relational Programming Illustrated in Prolog Afsaneh Fazly Cut (! ) can be used to: remove duplicate (& unnecessary) responses. remove incorrect responses. improve efficiency of Prolog programs, e.g., when two clauses of the same predicate (and hence their corresponding search trees) are mutually exclusive. Winter, Cut achieves the above by: Prolog Cut: Summary pruning the search tree, hence making the search space smaller. removing subtrees that will fail or result to incorrect or duplicate responses. Note: by using Cut we may commit to a certain usage of a predicate. Non-deterministic Programming Non-determinism is powerful for defining and implementing algorithms. Intuitively, a non-deterministic machine can choose its next operation correctly when faced with several alternatives. Non-determinism can be simulated/approximated by Prolog s sequential search and backtracking. Note: Non-determinism cannot truly be achieved. 3 4

2 Non-determinism In the theory of logic programming: try all possible computations in arbitrary order, keep the successful ones. In Prolog: computations are more deterministic because of the ordering of clauses, and the ordering of antecedents within a clause. But Prolog retains some degree of non-determinism because multiple rules/clauses can be defined for a predicate, and because the control of the program is determined at run-time by backtracking. Towers of Hanoi Setup: 3 pegs ( left, centre, right ). In the initial state one peg (let s say the left peg) has N rings on it, stacked from largest to smallest. Task: Move N disks from the left peg to the right peg using the centre peg as an auxiliary holding peg. At no time can a larger disk be placed upon a smaller disk. (High-level) Solution: Move N-1 disks from left (source) to centre (auxiliary), Move one remaining disk from left to right (destination), Move N-1 disks from centre to right. 5 6 Towers of Hanoi % move(+n,?x,?y,?z) iff it is possible to move N disks % from peg X to peg Y using peg Z as an auxiliary peg. % As a side effect, print out the sequence of moves. move(1,x,y,_) :- write( Move top disk from ), write(x), write( to ), write(y), nl. Non-deterministic Programming Can you think of other problems / games where you can specify the rules of the game in Prolog and Prolog will solve it for you? Can we achieve non-deterministic programming using Java, Python, or any other imperative language? move(n,x,y,z) :- N > 1, M is N-1, move(m,x,z,y), move(1,x,y,_), move(m,z,y,x). 7 8

3 Bottom-up (or forward) reasoning: starting from the given facts, apply rules to infer everything that is true. e.g., Suppose the fact B and the rule A B are given. Then infer that A is true. Top-down (or backward) reasoning: starting from the query, apply the rules in reverse, attempting only those lines of inference that are relevant to the query. e.g., Suppose the query is A, and the rule A B is given. Then to prove A, try to prove B. Which of the above reasoning methods Prolog uses? How is this implemented? top-down, implemented using backtracking plus goal-reduction. Compare Prolog s reasoning method (top-down) to program execution in imperative languages: Top-down search naturally models program execution in imperative languages, where main program calls subprograms, which call sub-subprograms, etc Bottom-up search has: very early access to the axioms of inference, which often results in greater speed (because variables are bound early, which creates opportunities for failure). But it is not goal-oriented many useless facts may be derived along the way. Top-down search is: very goal-oriented, but it often has problems with termination and efficiency, as it may explore many lines of reasoning that fail The two methods are logically equivalent. There are many hybrid search strategies, too. The best combination depends on the empirical domain being modelled. Think about how bottom-up and top-down reasoning/search differ for the following two examples: a :- b. a :- c. b :- d. b :- e. c :- f. c :- g. g.?- a. c :- bn. b1 :- a1.... bn :- an. a1.... an.?- c

4 Questions: Under which conditions do you think bottom-up reasoning is more efficient than top-down reasoning? Under which conditions do you think top-down reasoning is more efficient? Computations in a Programming Language (PL) Logic: answering queries (unification), plus search by backtracking. Imperative: assignment of values to variables, plus iteration. Functional: evaluating expressions, plus functional calls. Why do you think designers of Prolog chose top-down reasoning over bottom-up? Semantics of PLs Consider the following Python-like code: from myfile import myproc def newproc(x, y, z): if myproc(x) == y: z = x * y else: z = x / y def main(): read (a, b, c) from input write newproc(a, b, c) Question: What is the semantics of write newproc(a, b, c)? What are the steps required for you to answer this question? Semantics of PLs Now consider the following Prolog-like code: mysort([], []). mysort(oldlist, NewList) :- permutation(oldlist, NewList), sorted(newlist). sorted([x]). sorted([x,y Rest]) :- X =< Y, sorted(rest). permutation([], []). permutation([h Rest], L) :- member(h, L), remove(h, L, Lnew), permutation(rest, Lnew). Questions: What is the semantics of mysort(oldlist, NewList)? How would you write mysort in Java or Python? 15 16

5 Semantics of PLs Logic PLs have declarative semantics: programs specify what the desired result is. The language determines how the result should be computed. Imperative PLs are procedural: semantics of a statement depends on its run-time context. Functional PLs (FPLs) mainly procedural, somewhat declarative: programmer needs to specify steps of computation, FPLs have no side-effects (no assignment statements) semantics of a statement is independent of context. 17