Download - A First Look At Prolog
![Page 1: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/1.jpg)
A First Look At Prolog
Chapter Nineteen Modern Programming Languages, 2nd ed. 1
Spring 2012
![Page 2: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/2.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 2
![Page 3: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/3.jpg)
Terms
Everything in Prolog is built from terms:Prolog programsThe data manipulated by Prolog programs
Three kinds of terms:Constants: integers, real numbers, atomsVariablesCompound terms
Chapter Nineteen Modern Programming Languages, 2nd ed. 3
![Page 4: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/4.jpg)
Constants
Integer constants: 123 Real constants: 1.23 Atoms:
A lowercase letter followed by any number of additional letters, digits or underscores: fred
A sequence of non-alphanumeric characters: *, ., =, @#$
Plus a few special atoms: []
Chapter Nineteen Modern Programming Languages, 2nd ed. 4
![Page 5: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/5.jpg)
Atoms Are Not Variables
An atom can look like an ML or Java variable:i, size, length
But an atom is not a variable; it is not bound to anything, never equal to anything else
Think of atoms as being more like string constants: "i", "size", "length"
Chapter Nineteen Modern Programming Languages, 2nd ed. 5
![Page 6: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/6.jpg)
Variables
Any name beginning with an uppercase letter or an underscore, followed by any number of additional letters, digits or underscores: X, Child, Fred, _, _123
Most of the variables you write will start with an uppercase letter
Those starting with an underscore, including _, get special treatment
Chapter Nineteen Modern Programming Languages, 2nd ed. 6
![Page 7: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/7.jpg)
Compound Terms
An atom followed by a parenthesized, comma-separated list of one or more terms: x(y,z), +(1,2), .(1,[]), parent(adam,seth), x(Y,x(Y,Z))
A compound term can look like an ML function call: f(x,y)
Again, this is misleading Think of them as structured data
Chapter Nineteen Modern Programming Languages, 2nd ed. 7
![Page 8: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/8.jpg)
Terms
All Prolog programs and data are built from such terms
Later, we will see that, for instance, +(1,2) is usually written as 1+2
But these are not new kinds of terms, just abbreviations
Chapter Nineteen Modern Programming Languages, 2nd ed. 8
<term> ::= <constant> | <variable> | <compound-term><constant> ::= <integer> | <real number> | <atom><compound-term> ::= <atom> ( <termlist> )<termlist> ::= <term> | <term> , <termlist>
![Page 9: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/9.jpg)
Unification
Pattern-matching using Prolog terms Two terms unify if there is some way of
binding their variables that makes them identical
For instance, parent(adam,Child) and parent(adam,seth) unify by binding the variable Child to the atom seth
More details later: Chapter 20
Chapter Nineteen Modern Programming Languages, 2nd ed. 9
![Page 10: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/10.jpg)
The Prolog Database
A Prolog language system maintains a collection of facts and rules of inference
It is like an internal database that changes as the Prolog language system runs
A Prolog program is just a set of data for this database
The simplest kind of thing in the database is a fact: a term followed by a period
Chapter Nineteen Modern Programming Languages, 2nd ed. 10
![Page 11: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/11.jpg)
Example
A Prolog program of six facts Defining a predicate parent of arity 2 We would naturally interpret these as facts
about families: Kim is the parent of Holly and so on
Chapter Nineteen Modern Programming Languages, 2nd ed. 11
parent(kim,holly).parent(margaret,kim).parent(margaret,kent).parent(esther,margaret).parent(herbert,margaret).parent(herbert,jean).
![Page 12: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/12.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 12
![Page 13: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/13.jpg)
SWI-Prolog
Prompting for a query with ?- Normally interactive: get query, print result,
repeat
Chapter Nineteen Modern Programming Languages, 2nd ed. 13
Welcome to SWI-Prolog …
For help, use ?- help(Topic). or ?- apropos(Word).
?-
![Page 14: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/14.jpg)
The consult Predicate
Predefined predicate to read a program from a file into the database
File relations (or relations.pl) contains our parent facts
Chapter Nineteen Modern Programming Languages, 2nd ed. 14
?- consult(relations).% relations compiled 0.00 sec, 852 bytestrue.
?-
![Page 15: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/15.jpg)
Simple Queries
A query asks the language system to prove something
Some turn out to be true, some false (Some queries, like consult, are executed
only for their side-effects)
Chapter Nineteen Modern Programming Languages, 2nd ed. 15
?- parent(margaret,kent).true.
?- parent(fred,pebbles).false.
?-
![Page 16: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/16.jpg)
Final Period
Queries can take multiple lines If you forget the final period, Prolog
prompts for more input with |
Chapter Nineteen Modern Programming Languages, 2nd ed. 16
?- parent(margaret,kent)| .true.
?-
![Page 17: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/17.jpg)
Queries With Variables
Any term can appear as a query, including a term with variables
The Prolog system shows the bindings necessary to prove the query
Chapter Nineteen Modern Programming Languages, 2nd ed. 17
?- parent(P,jean).P = herbert.
?- parent(P,esther).false.
![Page 18: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/18.jpg)
Flexibility
Normally, variables can appear in any or all positions in a query:parent(Parent,jean) parent(esther,Child)parent(Parent,Child)parent(Person,Person)
Chapter Nineteen Modern Programming Languages, 2nd ed. 18
![Page 19: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/19.jpg)
Multiple Solutions
When the system finds a solution, it prints the binding it found
If it could continue to search for additional solutions, it then prompts for input
Hitting Enter makes it stop searching and print the final period…
Chapter Nineteen Modern Programming Languages, 2nd ed. 19
?- parent(Parent,Child).Parent = kim,Child = holly .
![Page 20: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/20.jpg)
Multiple Solutions … entering a
semicolon makes it continue the search
As often as you do this, it will try to find another solution
In this case, there is one for every fact in the database
Chapter Nineteen Modern Programming Languages, 2nd ed. 20
?- parent(Parent,Child).Parent = kim,Child = holly ;Parent = margaret,Child = kim ;Parent = margaret,Child = kent ;Parent = esther,Child = margaret ;Parent = herbert,Child = margaret ;Parent = herbert,Child = jean.
![Page 21: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/21.jpg)
Conjunctions
A conjunctive query has a list of query terms separated by commas
The Prolog system tries prove them all (using a single set of bindings)
Chapter Nineteen Modern Programming Languages, 2nd ed. 21
?- parent(margaret,X), parent(X,holly).X = kim .
![Page 22: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/22.jpg)
Chapter Nineteen Modern Programming Languages, 2nd ed. 22
?- parent(Parent,kim), parent(Grandparent,Parent).Parent = margaret,Grandparent = esther ;Parent = margaret,Grandparent = herbert ;false.
?- parent(esther,Child),| parent(Child,Grandchild),| parent(Grandchild,GreatGrandchild).Child = margaret,Grandchild = kim,GreatGrandchild = holly .
![Page 23: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/23.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 23
![Page 24: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/24.jpg)
The Need For Rules
Previous example had a lengthy query for great-grandchildren of Esther
It would be nicer to query directly:greatgrandparent(esther,GGC)
But we do not want to add separate facts of that form to the database
The relation should follow from the parent relation already defined
Chapter Nineteen Modern Programming Languages, 2nd ed. 24
![Page 25: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/25.jpg)
A Rule
A rule says how to prove something: to prove the head, prove the conditions
To prove greatgrandparent(GGP,GGC), find some GP and P for which you can prove parent(GGP,GP), then parent(GP,P) and then finally parent(P,GGC)
Chapter Nineteen Modern Programming Languages, 2nd ed. 25
greatgrandparent(GGP,GGC) :- parent(GGP,GP), parent(GP,P), parent(P,GGC). conditions
head
![Page 26: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/26.jpg)
A Program With The Rule
A program consists of a list of clauses A clause is either a fact or a rule, and ends
with a period
Chapter Nineteen Modern Programming Languages, 2nd ed. 26
parent(kim,holly).parent(margaret,kim).parent(margaret,kent).parent(esther,margaret).parent(herbert,margaret).parent(herbert,jean).greatgrandparent(GGP,GGC) :- parent(GGP,GP), parent(GP,P), parent(P,GGC).
![Page 27: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/27.jpg)
Example
This shows the initial query and final result Internally, there are intermediate goals:
The first goal is the initial queryThe next is what remains to be proved after
transforming the first goal using one of the clauses (in this case, the greatgrandparent rule)
And so on, until nothing remains to be provedChapter Nineteen Modern Programming Languages, 2nd ed. 27
?- greatgrandparent(esther,GreatGrandchild).GreatGrandchild = holly .
![Page 28: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/28.jpg)
Chapter Nineteen Modern Programming Languages, 2nd ed. 28
greatgrandparent(esther,GreatGrandchild)
1. parent(kim,holly).2. parent(margaret,kim).3. parent(margaret,kent).4. parent(esther,margaret).5. parent(herbert,margaret).6. parent(herbert,jean).7. greatgrandparent(GGP,GGC) :- parent(GGP,GP), parent(GP,P), parent(P,GGC).
parent(esther,GP), parent(GP,P), parent(P,GreatGrandchild)
parent(margaret,P), parent(P,GreatGrandchild)
parent(kim,GreatGrandchild)
Clause 7, binding GGP to esther and GGC to GreatGrandChild
Clause 4, binding GP to margaret
Clause 2, binding P to kim
Clause 1, binding GreatGrandchild to holly
We will see more about Prolog’s model of execution in Chapter 20
![Page 29: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/29.jpg)
Rules Using Other Rules
Same relation, defined indirectly Note that both clauses use a variable P The scope of the definition of a variable is
the clause that contains it
Chapter Nineteen Modern Programming Languages, 2nd ed. 29
grandparent(GP,GC) :- parent(GP,P), parent(P,GC).
greatgrandparent(GGP,GGC) :- grandparent(GGP,P), parent(P,GGC).
![Page 30: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/30.jpg)
Recursive Rules
X is an ancestor of Y if:Base case: X is a parent of YRecursive case: there is some Z such that Z is a
parent of Y, and X is an ancestor of Z Prolog tries rules in the order you give
them, so put base-case rules and facts first
Chapter Nineteen Modern Programming Languages, 2nd ed. 30
ancestor(X,Y) :- parent(X,Y).ancestor(X,Y) :- parent(Z,Y), ancestor(X,Z).
![Page 31: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/31.jpg)
Chapter Nineteen Modern Programming Languages, 2nd ed. 31
?- ancestor(jean,jean).false.
?- ancestor(kim,holly).true .
?- ancestor(A,holly).A = kim ;A = margaret ;A = esther ;A = herbert ;false.
![Page 32: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/32.jpg)
Core Syntax Of Prolog
You have seen the complete core syntax:
There is not much more syntax for Prolog than this: it is a very simple language
Syntactically, that is!
Chapter Nineteen Modern Programming Languages, 2nd ed. 32
<clause> ::= <fact> | <rule><fact> ::= <term> .<rule> ::= <term> :- <termlist> .<termlist> ::= <term> | <term> , <termlist>
![Page 33: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/33.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 33
![Page 34: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/34.jpg)
The Procedural Side
A rule says how to prove something:To prove greatgrandparent(GGP,GGC), find some GP and P for which you can prove parent(GGP,GP), then parent(GP,P) and then finally parent(P,GGC)
A Prolog program specifies proof procedures for queries
Chapter Nineteen Modern Programming Languages, 2nd ed. 34
greatgrandparent(GGP,GGC) :- parent(GGP,GP), parent(GP,P), parent(P,GGC).
![Page 35: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/35.jpg)
The Declarative Side
A rule is a logical assertion:For all bindings of GGP, GP, P, and GGC, if parent(GGP,GP) and parent(GP,P) and parent(P,GGC), then greatgrandparent(GGP,GGC)
Just a formula – it doesn’t say how to do anything – it just makes an assertion:
Chapter Nineteen Modern Programming Languages, 2nd ed. 35
GGCGGP
GGCPPGPGPGGPGGCPGPGGP
,parentgreatgrand
,parent,parent,parent.,,,
![Page 36: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/36.jpg)
Declarative Languages
Each piece of the program corresponds to a simple mathematical abstractionProlog clauses – formulas in first-order logicML fun definitions – functions
Many people use declarative as the opposite of imperative, including both logic languages and functional languages
Chapter Nineteen Modern Programming Languages, 2nd ed. 36
![Page 37: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/37.jpg)
Declarative Advantages
Imperative languages are doomed to subtle side-effects and interdependencies
Simpler declarative semantics makes it easier to develop and maintain correct programs
Higher-level, more like automatic programming: describe the problem and have the computer write the program
Chapter Nineteen Modern Programming Languages, 2nd ed. 37
![Page 38: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/38.jpg)
Prolog Has Both Aspects
Partly declarativeA Prolog program has logical content
Partly proceduralA Prolog program has procedural concerns:
clause ordering, condition ordering, side-effecting predicates, etc.
It is important to be aware of both
Chapter Nineteen Modern Programming Languages, 2nd ed. 38
![Page 39: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/39.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 39
![Page 40: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/40.jpg)
Operators
Prolog has some predefined operators (and the ability to define new ones)
An operator is just a predicate for which a special abbreviated syntax is supported
Chapter Nineteen Modern Programming Languages, 2nd ed. 40
![Page 41: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/41.jpg)
The = Predicate The goal =(X,Y) succeeds if and only if X
and Y can be unified:
Since = is an operator, it can be and usually is written like this:
Chapter Nineteen Modern Programming Languages, 2nd ed. 41
?- =(parent(adam,seth),parent(adam,X)).X = seth.
?- parent(adam,seth)=parent(adam,X).X = seth.
![Page 42: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/42.jpg)
Arithmetic Operators
Predicates +, -, * and / are operators too, with the usual precedence and associativity
Chapter Nineteen Modern Programming Languages, 2nd ed. 42
?- X = +(1,*(2,3)).X = 1+2*3.
?- X = 1+2*3.X = 1+2*3.
Prolog lets you use operator notation, and prints it out that way, but the underlying term is still +(1,*(2,3))
![Page 43: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/43.jpg)
Not Evaluated
The term is still +(1,*(2,3)) It is not evaluated There is a way to make Prolog evaluate
such terms, but we won’t need it yet
Chapter Nineteen Modern Programming Languages, 2nd ed. 43
?- +(X,Y) = 1+2*3.X = 1,Y = 2*3.
?- 7 = 1+2*3.false.
![Page 44: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/44.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 44
![Page 45: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/45.jpg)
Lists in Prolog
A bit like ML lists The atom [] represents the empty list A predicate . corresponds to ML’s ::
operator
Chapter Nineteen Modern Programming Languages, 2nd ed. 45
ML expression Prolog term
[] []
1::[] .(1,[])
1::2::3::[] .(1,.(2,.(3,[])))
No equivalent. .(1,.(parent(X,Y),[]))
![Page 46: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/46.jpg)
List Notation
ML-style notation for lists These are just abbreviations for the
underlying term using the . Predicate Prolog usually displays lists in this notation
Chapter Nineteen Modern Programming Languages, 2nd ed. 46
List notation Term denoted
[] []
[1] .(1,[])
[1,2,3] .(1,.(2,.(3,[])))
[1,parent(X,Y)] .(1,.(parent(X,Y),[]))
![Page 47: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/47.jpg)
Example
Chapter Nineteen Modern Programming Languages, 2nd ed. 47
?- X = .(1,.(2,.(3,[]))).X = [1, 2, 3].
?- .(X,Y) = [1,2,3].X = 1,Y = [2, 3].
![Page 48: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/48.jpg)
List Notation With Tail
Last in a list can be the symbol | followed by a final term for the tail of the list
Useful in patterns: [1,2|X] unifies with any list that starts with 1,2 and binds X to the tail
Chapter Nineteen Modern Programming Languages, 2nd ed. 48
List notation Term denoted[1|X] .(1,X)[1,2|X] .(1,.(2,X))[1,2|[3,4]] same as [1,2,3,4]
?- [1,2|X] = [1,2,3,4,5].X = [3, 4, 5].
![Page 49: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/49.jpg)
The append Predicate
Predefined append(X,Y,Z) succeeds if and only if Z is the result of appending the list Y onto the end of the list X
Chapter Nineteen Modern Programming Languages, 2nd ed. 49
?- append([1,2],[3,4],Z).Z = [1, 2, 3, 4].
![Page 50: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/50.jpg)
Not Just A Function
append can be used with any pattern of instantiation (that is, with variables in any positions)
Chapter Nineteen Modern Programming Languages, 2nd ed. 50
?- append(X,[3,4],[1,2,3,4]).X = [1, 2] .
![Page 51: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/51.jpg)
Not Just A Function
Chapter Nineteen Modern Programming Languages, 2nd ed. 51
?- append(X,Y,[1,2,3]).X = [],Y = [1, 2, 3] ;X = [1],Y = [2, 3] ;X = [1, 2],Y = [3] ;X = [1, 2, 3],Y = [] ;false.
![Page 52: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/52.jpg)
An Implementation
Chapter Nineteen Modern Programming Languages, 2nd ed. 52
append([], B, B).append([Head|TailA], B, [Head|TailC]) :- append(TailA, B, TailC).
![Page 53: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/53.jpg)
Other Predefined List Predicates
All flexible, like append Queries can contain variables anywhere
Chapter Nineteen Modern Programming Languages, 2nd ed. 53
Predicate Description
member(X,Y) Provable if the list Y contains the element X.
select(X,Y,Z) Provable if the list Y contains the element X, and Z is the same as Y but with one instance of X removed.
nth0(X,Y,Z) Provable if X is an integer, Y is a list, and Z is the Xth element of Y, counting from 0.
length(X,Y) Provable if X is a list of length Y.
![Page 54: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/54.jpg)
Using select
Chapter Nineteen Modern Programming Languages, 2nd ed. 54
?- select(2,[1,2,3],Z).Z = [1, 3] ;false.
?- select(2,Y,[1,3]).Y = [2, 1, 3] ;Y = [1, 2, 3] ;Y = [1, 3, 2] ;false.
![Page 55: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/55.jpg)
The reverse Predicate
Predefined reverse(X,Y) unifies Y with the reverse of the list X
Chapter Nineteen Modern Programming Languages, 2nd ed. 55
?- reverse([1,2,3,4],Y).Y = [4, 3, 2, 1].
![Page 56: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/56.jpg)
An Implementation
Not an efficient way to reverse We’ll see why, and a more efficient
solution, in Chapter 21
Chapter Nineteen Modern Programming Languages, 2nd ed. 56
reverse([],[]).reverse([Head|Tail],X) :- reverse(Tail,Y), append(Y,[Head],X).
![Page 57: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/57.jpg)
Non-Terminating Queries
Asking for another solution caused an infinite loop
Hit Control-C to stop it, then a for abortreverse cannot be used as flexibly as append
Chapter Nineteen Modern Programming Languages, 2nd ed. 57
?- reverse(X,[1,2,3,4]).X = [4, 3, 2, 1] ;
^CAction (h for help) ? abort% Execution Aborted?-
![Page 58: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/58.jpg)
Flexible and Inflexible
Ideally, predicates should all be flexible like append
They are more declarative, with fewer procedural quirks to consider
But inflexible implementations are sometimes used, for efficiency or simplicity
Another example is sort…
Chapter Nineteen Modern Programming Languages, 2nd ed. 58
![Page 59: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/59.jpg)
Example
A fully flexible sort would also be able to unsort—find all permutations
But it would not be as efficient for the more common task
Chapter Nineteen Modern Programming Languages, 2nd ed. 59
?- sort([2,3,1,4],X).X = [1, 2, 3, 4].
?- sort(X,[1,2,3,4]).ERROR: Arguments are not sufficiently instantiated
![Page 60: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/60.jpg)
The Anonymous Variable
The variable _ is an anonymous variable Every occurrence is bound independently of
every other occurrence In effect, much like ML’s _: it matches any
term without introducing bindings
Chapter Nineteen Modern Programming Languages, 2nd ed. 60
![Page 61: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/61.jpg)
Example
This tailof(X,Y) succeeds when X is a non-empty list and Y is the tail of that list
Don’t use this, even though it works:
Chapter Nineteen Modern Programming Languages, 2nd ed. 61
tailof([_|A],A).
tailof([Head|A],A).
![Page 62: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/62.jpg)
Dire Warning
Don’t ignore warning message about singleton variables
As in ML, it is bad style to introduce a variable you never use
More importantly: if you misspell a variable name, this is the only warning you will see
Chapter Nineteen Modern Programming Languages, 2nd ed. 62
append([], B, B).append([Head|TailA], B, [Head|TailC]) :- append(TailA, B, Tailc).
![Page 63: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/63.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 63
![Page 64: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/64.jpg)
The not Predicate
For simple applications, it often works quite a bit logical negation
But it has an important procedural side…
Chapter Nineteen Modern Programming Languages, 2nd ed. 64
?- member(1,[1,2,3]).true .
?- not(member(4,[1,2,3])).false.
![Page 65: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/65.jpg)
Negation As Failure
To prove not(X), Prolog attempts to prove X
not(X) succeeds if X fails The two faces again:
Declarative: not(X) = ¬XProcedural: not(X) succeeds if X fails, fails if X succeeds, and runs forever if X runs forever
Chapter Nineteen Modern Programming Languages, 2nd ed. 65
![Page 66: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/66.jpg)
Example
Chapter Nineteen Modern Programming Languages, 2nd ed. 66
sibling(X,Y) :- parent(P,X), parent(P,Y), not(X=Y).
?- sibling(X,Y).X = kim,Y = kent ;X = kent,Y = kim ;X = margaret,Y = jean ;X = jean,Y = margaret ;false.
sibling(X,Y) :- not(X=Y), parent(P,X), parent(P,Y).
?- sibling(kim,kent).true .
?- sibling(kim,kim).false.
?- sibling(X,Y).false.
![Page 67: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/67.jpg)
Outline
Terms Using a Prolog language system Rules The two faces of Prolog Operators Lists Negation and failure What Prolog is good for
Chapter Nineteen Modern Programming Languages, 2nd ed. 67
![Page 68: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/68.jpg)
A Classic Riddle
A man travels with wolf, goat and cabbage Wants to cross a river from west to east A rowboat is available, but only large
enough for the man plus one possession Wolf eats goat if left alone together Goat eats cabbage if left alone together How can the man cross without loss?
Chapter Nineteen Modern Programming Languages, 2nd ed. 68
![Page 69: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/69.jpg)
Configurations
Represent a configuration of this system as a list showing which bank each thing is on in this order: man, wolf, goat, cabbage
Initial configuration: [w,w,w,w] If man crosses with wolf, new state is [e,e,w,w] – but then goat eats cabbage, so we can’t go through that state
Desired final state: [e,e,e,e]
Chapter Nineteen Modern Programming Languages, 2nd ed. 69
![Page 70: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/70.jpg)
Moves
In each move, man crosses with at most one of his possessions
We will represent these four moves with four atoms: wolf, goat, cabbage, nothing
(Here, nothing indicates that the man crosses alone in the boat)
Chapter Nineteen Modern Programming Languages, 2nd ed. 70
![Page 71: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/71.jpg)
Moves Transform Configurations
Each move transforms one configuration to another
In Prolog, we will write this as a predicate: move(Config,Move,NextConfig)Config is a configuration (like [w,w,w,w])Move is a move (like wolf)NextConfig is the resulting configuration (in
this case, [e,e,w,w])
Chapter Nineteen Modern Programming Languages, 2nd ed. 71
![Page 72: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/72.jpg)
The move Predicate
Chapter Nineteen Modern Programming Languages, 2nd ed. 72
change(e,w).change(w,e).
move([X,X,Goat,Cabbage],wolf,[Y,Y,Goat,Cabbage]) :- change(X,Y).move([X,Wolf,X,Cabbage],goat,[Y,Wolf,Y,Cabbage]) :- change(X,Y).move([X,Wolf,Goat,X],cabbage,[Y,Wolf,Goat,Y]) :- change(X,Y).move([X,Wolf,Goat,C],nothing,[Y,Wolf,Goat,C]) :- change(X,Y).
![Page 73: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/73.jpg)
Safe Configurations A configuration is safe if
At least one of the goat or the wolf is on the same side as the man, and
At least one of the goat or the cabbage is on the same side as the man
Chapter Nineteen Modern Programming Languages, 2nd ed. 73
oneEq(X,X,_).oneEq(X,_,X).
safe([Man,Wolf,Goat,Cabbage]) :- oneEq(Man,Goat,Wolf), oneEq(Man,Goat,Cabbage).
![Page 74: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/74.jpg)
Solutions
A solution is a starting configuration and a list of moves that takes you to [e,e,e,e], where all the intermediate configurations are safe
Chapter Nineteen Modern Programming Languages, 2nd ed. 74
solution([e,e,e,e],[]).solution(Config,[Move|Rest]) :- move(Config,Move,NextConfig), safe(NextConfig), solution(NextConfig,Rest).
![Page 75: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/75.jpg)
Prolog Finds A Solution
Note: without the length(X,7) restriction, Prolog would not find a solution
It gets lost looking at possible solutions like [goat,goat,goat,goat,goat…]
More about this in Chapter 20
Chapter Nineteen Modern Programming Languages, 2nd ed. 75
?- length(X,7), solution([w,w,w,w],X).X = [goat, nothing, wolf, goat, cabbage, nothing, goat] .
![Page 76: A First Look At Prolog](https://reader030.vdocuments.net/reader030/viewer/2022032708/56812eae550346895d945228/html5/thumbnails/76.jpg)
What Prolog Is Good For
The program specified a problem logically It did not say how to search for a solution to
the problem – Prolog took it from there That’s one kind of problem Prolog is
especially good for More examples to come in Chapter 22
Chapter Nineteen Modern Programming Languages, 2nd ed. 76