PROLOG: Recursion And Lists In Prolog
10 likes7,375 views
The document discusses recursion and lists in Prolog. It covers recursive definitions, clause ordering and termination, lists, members, and recursing down lists. Recursive definitions allow a predicate to refer to itself in its own definition. Clause ordering can impact termination and procedural meaning. Lists are a fundamental recursive data structure in Prolog, consisting of elements separated by commas and enclosed in brackets. The member predicate checks if an element is in a list by recursively working down the list. Recursing down lists is common for tasks like comparing lists or copying elements between lists.
![Listslists, an important recursive data structure widely used in computational linguistics.It is a finite sequence of elements. Here are some examples of lists in Prolog:[mia, vincent, jules, yolanda][mia, robber(honey_bunny), X, 2, mia][][mia, [vincent, jules], [butch, girlfriend(butch)]][[], dead(zed), [2, [b, chopper]], [], Z, [2, [b, chopper]]]](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-8-320.jpg)
![ListsWe can specify lists in Prolog by enclosing the elements of the list in square brackets(that is, the symbols [ and ]). The elements are separated by commas.All sorts of Prolog objects can be elements of a list and the same item may occur more than once in the same list.The empty list(as its name suggests) is the list that contains no elements.lists can contain other lists as elements.Any non-empty list can be thought of as consisting of twoparts: the head and the tail. The head is simply the first item in the list; the tail is everything else.](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-9-320.jpg)
![MembersMember is a fundamental Prolog tool for manipulating lists, and to introduce the idea of recursing down lists.consider a program that, when given as inputs an arbitrary object X and a list L, tells us whether or not X belongs to L. The program that does this is usually called member. Here it is:member(X,[X|T]).member(X,[H|T]) :- member(X,T).one fact (namely member(X,[X|T])) and one rule (namely member(X,[H|T]) :- member(X,T)). But note that the rule is recursive (after all, the functor member occurs in both the rule's head and tail)](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-10-320.jpg)
![MembersSuppose we posed the following query:? -member(yolanda,[yolanda,trudy,vincent,jules]).Prolog will immediately answer `Yes'. Because it can unify yolanda with both occurrences of X in the first clause (the fact) in the definition of member/2, so it succeeds immediately.](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-11-320.jpg)
![Recursing Down ListsMember works by recursively working down a list, doing something to the head, and then recursively doing the same thing to the tail. Recursing down a list (or indeed, several lists) in this way is extremely common in Prolog.When working with lists, we often want to compare one list with another, or to copy bits of one list into another, or to translate the contents of one list into another, or something similar.Ex: Let's suppose we need a predicate a2b/2 that takes two lists as arguments, and succeeds if the first argument is a list of as, and the second argument is a list of bs of exactly the same length.If we pose the following querya2b([a,a,a,a],[b,b,b,b]).we want Prolog to say `yes'.](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-12-320.jpg)
![Recursing Down ListsIf we pose the querya2b([a,a,a,a],[b,b,b]) or the querya2b([a,c,a,a],[b,b,5,4]).we want Prolog to say `no'.For longer lists, think recursively. So when should a2b/2 decide that two non-empty lists are a list of as and a list of bs of exactly the same length?](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-13-320.jpg)
![Simple: when the head of the first list is an a, and the head of the second list is a b, and a2b/2 decides that the two tails are lists of as and bs of exactly the same length! This immediately gives us the following rule:a2b([a|Ta],[b|Tb]) :- a2b(Ta,Tb).The a2b/2 predicate should succeed if its first argument is a list with head a, its second argument is a list with head b, and a2b/2 succeeds on the two tails.Now, this definition make good sense declaratively.](https://image.slidesharecdn.com/recursionandlistsinprolog-100328214015-phpapp01/85/PROLOG-Recursion-And-Lists-In-Prolog-14-320.jpg)
PROLOG: Recursion And Lists In Prolog
- 1. Recursion and Lists in Prolog
- 2. OVERVIEWRecursive definitionsClause ordering, goal ordering, and termination.ListsMembersRecursing Down Lists
- 3. Recursive definitionsA predicate is recursively defined if one or more rules in its definition refers to itself.Ex: is_digesting(X,Y) :- just_ate(X,Y).is_digesting(X,Y) :-just_ate(X,Z),is_digesting(Z,Y).just_ate(mosquito,blood(john)).just_ate(frog,mosquito).just_ate(stork,frog). It's just a knowledge base containing two facts andtwo rules. But the definition of the is_digesting/2 predicate is recursive.
- 4. Another way of writing numerals, which is sometimes used in mathematical logic is to makes use of just four symbols: 0, succ, and the left and right brackets. This style of numeral is defined by the following inductive definition:1. 0 is a numeral.2. If X is a numeral, then so is succ(X).This definition in prolog program is written as:numeral(0).numeral(succ(X)) :- numeral(X).So, on posing the query numeral(succ(succ(succ(0)))).We get Yes.Now on running the following querynumeral(X).we can have the following dialogue with Prolog:X = 0 ;X = succ(0) ;X = succ(succ(0)) ;X = succ(succ(succ(0))) ;X = succ(succ(succ(succ(0)))) ;X = succ(succ(succ(succ(succ(0))))) ;X = succ(succ(succ(succ(succ(succ(0)))))) ;X = succ(succ(succ(succ(succ(succ(succ(0))))))) ;X = succ(succ(succ(succ(succ(succ(succ(succ(0)))))))) ;X = succ(succ(succ(succ(succ(succ(succ(succ(succ(0))))))))) ;X = succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(0))))))))))YesIt's backtracking through the recursive definition, and actually building numerals using matching.
- 5. Clause ordering, goal ordering, and terminationConsider the following ex:child(martha,charlotte).child(charlotte,caroline).child(caroline,laura).child(laura,rose).descend(X,Y) :- child(X,Y).descend(X,Y) :- child(X,Z),descend(Z,Y).We'll make two changes to it, and call the result descend2.pl:child(martha,charlotte).child(charlotte,caroline).child(caroline,laura).child(laura,rose).descend(X,Y) :- descend(Z,Y),child(X,Z).descend(X,Y) :- child(X,Y).
- 6. we have merely reversed the order of the two rules, and reversed the order of the two goals in the recursive clause. So, viewed as a purely logical definition, nothing has changed.But the procedural meaning has changed dramatically. For example, if you pose the querydescend(martha,rose).you will get an error message (`out of local stack', or something similar).Because descend1.pl and descend2.pl are Prolog knowledge bases with the same declarative meaning but different procedural meanings: from a purely logical perspective they are identical, but they behave very differently.
- 7. The declarative and procedural meanings of a Prolog program can differ, when writing Prolog programs you need to bear both aspects in mind.When you need to think about how Prolog will actually evaluate queries. The following questions must be considered:Are the rule orderings sensible? How will the program actually run?
- 8. Listslists, an important recursive data structure widely used in computational linguistics.It is a finite sequence of elements. Here are some examples of lists in Prolog:[mia, vincent, jules, yolanda][mia, robber(honey_bunny), X, 2, mia][][mia, [vincent, jules], [butch, girlfriend(butch)]][[], dead(zed), [2, [b, chopper]], [], Z, [2, [b, chopper]]]
- 9. ListsWe can specify lists in Prolog by enclosing the elements of the list in square brackets(that is, the symbols [ and ]). The elements are separated by commas.All sorts of Prolog objects can be elements of a list and the same item may occur more than once in the same list.The empty list(as its name suggests) is the list that contains no elements.lists can contain other lists as elements.Any non-empty list can be thought of as consisting of twoparts: the head and the tail. The head is simply the first item in the list; the tail is everything else.
- 10. MembersMember is a fundamental Prolog tool for manipulating lists, and to introduce the idea of recursing down lists.consider a program that, when given as inputs an arbitrary object X and a list L, tells us whether or not X belongs to L. The program that does this is usually called member. Here it is:member(X,[X|T]).member(X,[H|T]) :- member(X,T).one fact (namely member(X,[X|T])) and one rule (namely member(X,[H|T]) :- member(X,T)). But note that the rule is recursive (after all, the functor member occurs in both the rule's head and tail)
- 11. MembersSuppose we posed the following query:? -member(yolanda,[yolanda,trudy,vincent,jules]).Prolog will immediately answer `Yes'. Because it can unify yolanda with both occurrences of X in the first clause (the fact) in the definition of member/2, so it succeeds immediately.
- 12. Recursing Down ListsMember works by recursively working down a list, doing something to the head, and then recursively doing the same thing to the tail. Recursing down a list (or indeed, several lists) in this way is extremely common in Prolog.When working with lists, we often want to compare one list with another, or to copy bits of one list into another, or to translate the contents of one list into another, or something similar.Ex: Let's suppose we need a predicate a2b/2 that takes two lists as arguments, and succeeds if the first argument is a list of as, and the second argument is a list of bs of exactly the same length.If we pose the following querya2b([a,a,a,a],[b,b,b,b]).we want Prolog to say `yes'.
- 13. Recursing Down ListsIf we pose the querya2b([a,a,a,a],[b,b,b]) or the querya2b([a,c,a,a],[b,b,5,4]).we want Prolog to say `no'.For longer lists, think recursively. So when should a2b/2 decide that two non-empty lists are a list of as and a list of bs of exactly the same length?
- 14. Simple: when the head of the first list is an a, and the head of the second list is a b, and a2b/2 decides that the two tails are lists of as and bs of exactly the same length! This immediately gives us the following rule:a2b([a|Ta],[b|Tb]) :- a2b(Ta,Tb).The a2b/2 predicate should succeed if its first argument is a list with head a, its second argument is a list with head b, and a2b/2 succeeds on the two tails.Now, this definition make good sense declaratively.
- 15. Visit more self help tutorialsPick a tutorial of your choice and browse through it at your own pace.The tutorials section is free, self-guiding and will not involve any additional support.Visit us at www.dataminingtools.net