prolog programming
TRANSCRIPT
![Page 1: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/1.jpg)
Prolog Programming
![Page 2: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/2.jpg)
2
Prolog ProgrammingProlog Programming DATA STRUCTURES IN PROLOG PROGRAMMING TECHNIQUES CONTROL IN PROLOG CUTS
![Page 3: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/3.jpg)
3
DATA STRUCTURES IN PROLOG Lists in Prolog
List notation is a way of writing terms Terms as Data
Term correspond with list
![Page 4: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/4.jpg)
4
Lists in Prolog
The simplest way of writing a list is to enumerate its elements.
The list consisting of the 3 atoms a, b and c can be written as[a, b, c]The list that doesn’t have elements called empty list denoted as [ ]
![Page 5: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/5.jpg)
5
Lists in Prolog
We can also specify an initial sequence of elements and a trailing list, separated by |
The list [a, b, c] can also be written as[a, b, c | [ ] ][a, b | [c] ][a | [b, c] ]
![Page 6: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/6.jpg)
6
Lists : Head & Tail
A special case of this notation is a list with head H and tail T, written as [H|T]
The head is the first element of a list, and The tail is the list consisting of the remaining
elements.
The list [a, b, c] can also be separated as• Head:The first element is a• Tail:The list of remaining elements = [b, c]
![Page 7: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/7.jpg)
7
Lists : Unification
Unification can be used to extract the components of a list, so explicit operators for extracting the head and tail are not needed. The solution of the query
Bind variable H to the head and variable T to the tail of list [a, b, c].
?- [H | T] = [a, b, c].H = aT = [b, c]
![Page 8: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/8.jpg)
8
Lists : Specified terms The query (partially specified terms)
The term [ a | T ] is a partial specification of a list with head a and unknown tail denoted by variable T.
Similarly, [ H, b, c] is a partial specification of a list with unknown head H and tail [b, c].
These two specification to unify H = a, T =[b,c]
?- [a | T] = [H, b, c].T = [b, c]H = a
![Page 9: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/9.jpg)
9
Lists in Prolog
Example 2 The append relation on lists is defined by the following rules:Append([ ], Y, Y).Append([H | X], Y, [H | Z]) :- append(X,Y,Z).
In words, The result of appending the empty list [ ] and a list Y is Y.If the result of appending X and Y is Z, then the result of appending [H | X] and Y is [H | Z]
![Page 10: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/10.jpg)
10
Lists : Compute Arguments
The rules for append can be used to compute any one of the arguments from the other two:
Inconsistent arguments are rejected
?- append([a, b], [c, d], Z). Z = [a, b, c, d]?- append([a, b], Y, [a, b, c, d]). Y = [c, d]?- append(X, [c, d], [a, b, c, d]). X = [a, b]
?- append(X, [d, c], [a, b, c, d]). no
![Page 11: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/11.jpg)
11
Terms as Data
The Dot operator or functor ‘.’ corresponds to make list with H and T.
[H | T ] is syntactic sugar for the term .(H,T) Lists are terms. The term for the list [a, b, c] is
.(H,T)
.(a, .(b, .(c, [])))
![Page 12: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/12.jpg)
12
Terms as Data following terms can be drawn a tree
There is a one-to-one correspondence between trees and terms
.(a, .(b, .(c, [])))
∙∙
∙a
b
c []
![Page 13: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/13.jpg)
13
Terms : Binary Tree
Binary trees can be written as terms An atom leaf for a leaf A functor nonleaf with 2 arguments
leaf
nonleaf(leaf,leaf)
nonleaf(nonleaf(leaf,leaf), nonleaf(leaf,leaf))
nonleaf(nonleaf(leaf,leaf),leaf)
nonleaf(leaf,nonleaf(leaf,leaf))
![Page 14: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/14.jpg)
14
List : tree
Example 3 A binary search tree is either empty, or it consists of a node with two binary search trees as subtrees. Each node holds an integer. Smaller elements appear in the left subtree of
a node and larger elements appear in the right subtree.
Let a term node(K,S,T) represent a tree K
S T
![Page 15: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/15.jpg)
15
Binary search trees
15
2 16
10
129
0
3
19
10
2 12
9
153
0 16
3
![Page 16: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/16.jpg)
16
Binary search trees
The rules define a relation member to test whether an integer appear at some node in a tree. The two arguments of member are an integer and a tree.member(K,_,_).member(K, node(N,S,_)) :- K < N, member(K, S).member(K, node(N,_,T)) :- K > N, member(K, T).
![Page 17: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/17.jpg)
17
PROGRAMMING TECHNIQUES
The strengths of Prolog namely, backtracking and unification. Backtracking allows a solution to be found if
one exists Unification allows variables to be used as
placeholders for data to be filled in later. Careful use of the techniques in this section
can lead to efficient programs. The programs rely on left-to-right evaluation of subgoals.
![Page 18: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/18.jpg)
18
Guess and Verify
A guess-and-verify query has the form
Where guess(S) and verify(S) are subgoals. Prolog respond to a query by generating
solutions to guess(S) until a solution satisfying verify(S) is found. Such queries are also called generate-and-test queries.
Is there an S such that guess(S) and verify(S)?
![Page 19: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/19.jpg)
19
Guess and Verify
Similarly, a guess-and-verify rule has the following form:
Example
Conslusion(…) if guess(…,S,…) and verify(…,S,…)
overlap(X, Y) :- member(M, X), member(M, Y).
Two lists X and Y overlap if there is some M that is a member of both X and Y. The first goal member(M, X) guesses an M from list X, and the second goal member(M, Y) verifies that M also appears in list Y.
![Page 20: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/20.jpg)
20
The rules for member are
member(M, [M |_]).Member(M, [_ |T]) :- member(M, T).
The first rule says that M is a member of a list with head M. The second rule says that M is a member of a list if M is a member of its tail T.
![Page 21: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/21.jpg)
21
Consider query
These query
The first goal in this query generates solutions and the second goal tests to see whether they are acceptable.
?- overlap([a,b,c,d],[1,2,c,d]). yes
?- member(M,[a,b,c,d]),member(M,[1,2,c,d]).
![Page 22: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/22.jpg)
22
Consider query
The solutions generated by the first goal are
Test the second goal
?- member(M,[a,b,c,d]). M = a; M = b; M = c; M = d; no
?- member(a,[1,2,c,d]). no?- member(b,[1,2,c,d]). no?- member(c,[1,2,c,d]). yes
![Page 23: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/23.jpg)
23
Hint
Since computation in Prolog proceeds from left to right, the order of the subgoals in a guess-and-verify query can affect efficiency.
Choose the subgoal with fewer solutions as the guess goal.
Example of the effect of goal order
?- X = [1,2,3], member(a,X). no?- member(a,X), X = [1,2,3]). [infinite computation]
![Page 24: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/24.jpg)
24
Variables as Placeholders in Terms
Variables have been used in rules and queries but not in terms representing objects.
Terms containing varibales can be used to simulate modifiable data structures;
The variables serve as placeholders for subterms to be filled in later.
![Page 25: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/25.jpg)
25
Represent Binary Trees in Terms
The terms leaf and nonleaf(leaf,leaf) are completely specified.
leaf
nonleaf(leaf,leaf)
![Page 26: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/26.jpg)
26
Partially specified list
The example list [a, b | X] has Its first element : a Its second element : b Do not yet know what X represents
“Open list” if its ending in a variable, referred “end marker variable”
“Close list” if it is not open.
![Page 27: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/27.jpg)
27
How prolog know variable
Prolog used machine-generated variables, written with a leading underscore (“_”) followed by an integer.
?- L = [a, b | X].L = [a, |_G172]X = _G172 Yes
![Page 28: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/28.jpg)
28
Prolog generates fresh variables each time it responds to a query or applies a rule.
An open list can be modified by unifying its end marker
?- L = [a, b | X], X = [c,Y].L = [a,b,c |_G236]X = [c,_G236]Y = _G236 Yes
![Page 29: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/29.jpg)
29
Extending an open list by unifying its end marker.
a b
L X
_172
a b
L X
_236
c(a) Before X is bound. (b) After X = [c | Y].
![Page 30: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/30.jpg)
30
Unification of an end-marker variable is akin to an assignment to that variable.
List L changes from [a, b | _172] [a, b, c | _236]
when _172 unifies with [c | _236] Advantage of working with open lists is that
the end of a list can be accessed quickly.
![Page 31: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/31.jpg)
31
Open list implement queues
when a queue is created, where L is an open list with end marker E
When element a enters queue Q, we get queue R.
When element a leaves queue Q, we get queue R.
q(L,E)
enter(a,Q,R)
leave(a,Q,R)
![Page 32: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/32.jpg)
32
Open list implement queue
?- setup(Q).?- setup(Q), enter(a,Q,R).?- setup(Q), enter(a,Q,R), leave(S,R,T).?- setup(Q), enter(a,Q,R), enter(b,R,S),
leave(X,S,T),leave(Y,T,U), wrapup(q([],[])).
setup(q(X,X)).enter(A, q(X,Y), q(X,Z)) :- Y = [A | Z].leave(A, q(X,Z), q(Y,Z)) :- Y = [A | Y].wrapup(q([],[])).
![Page 33: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/33.jpg)
33
Test queue
?-setup(Q),enter(a,Q,R),enter(b,R,S),leave(X,S,T),leave(Y,T,U),wrapup(U).
Q = q([a, b], [a, b])R = q([a, b], [b])S = q([a, b], [])X = aT = q([b], [])Y = bU = q([], [])
Yes?-
![Page 34: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/34.jpg)
34
Operations on a queue
Q
_1
R
_2
a
a
T
_3
b
Q
Q R
setup(Q)
enter(a,Q,R)
enter(b,R,S)
![Page 35: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/35.jpg)
35
Operations on a queue
a
T_3
b
Xleave(X,S,T)
a
T_3
b
Yleave(Y,T,U)
![Page 36: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/36.jpg)
36
Internal Prolog
A queue q(L,E) consists of open list L with end marker E.
The arrows from Q therefore go to the empty open list _1 with end marker _1.
setup(q(X,X)).
?-setup(Q). Q = q(_1,_1)yes
![Page 37: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/37.jpg)
37
Second goal
To enter A into a queue q(X,Y),bind Y to a list [A|Z],where Z is a fresh end marker,and return q(X,Z).
enter(A,q(X,Y),q(X,Z)):- Y = [A|Z].
?-setup(Q),enter(a,Q,R).Q = q([a|_2], [a|_2])R = q([a|_2], _2)
Unifies _1 with [a|_2],where _2 is a fresh end marker
![Page 38: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/38.jpg)
38
When an element leaves a queue q(L,E), the resulting queue has the tail of L in place of L. Note in the diagram to the right of leave(X,S,T) that the open list for queue T is the tail of the open list for S.
The final goal wrapup(U) checks that the enter and leave operations leave U in an initial state q(L,E), where L is an empty openlist with end marker E.
![Page 39: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/39.jpg)
39
Difference Lists
Difference List are a technique for coping with such changes.
Difference List consists of a list and its suffix. We write this difference list as
dl(L,E).
![Page 40: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/40.jpg)
40
Contents of Difference List
The contents of the difference list consist of the elements that are in L but not in E.
Examples of difference lists with contents [a,b] are
dl([a,b],[]).Dl([a,b,c],[c]).Dl([a,b|E],E).Dl([a,b,c|F],[c|F]).
![Page 41: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/41.jpg)
41
CONTROL IN PROLOG
In the informal equation
“Logic” refers to the rules and queries in a logic program and
“control” refers to how a language computes a response to a query.
algorithm = logic + control
![Page 42: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/42.jpg)
42
CONTROL IN PROLOG
Control in Prolog is characterized by two decisions Goal order : Choose the leftmost subgoal. Rule order : Select the first applicable rule.
The response to a query is affected both by goal order within the query and by rule order with in the database of facts and rules.
![Page 43: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/43.jpg)
43
CONTROL IN PROLOGstart with a query as the current goal;while the current goal is nonempty do
choose the leftmost subgoal; if a rule applies to the subgoal then select the first applicable rule; form a new current goal
else backtrack
end ifend while;succeed
![Page 44: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/44.jpg)
44
Example
A sublist S of Z can be specified in the following seemingly equivalent ways: preffix X of Z and suffix S of X. suffix S of X and prefix X of Z.
appen1([],Y,Y).appen1([H|X],Y,[H|Z]):- appen1(X,Y,Z).Prefix(X,Z) :- appen1(X,Y,Z).Suffix(Y,Z) :- appen1(X,Y,Z).appen2([H|X],Y,[H|Z]):- appen2(X,Y,Z).appen2([],Y,Y).
![Page 45: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/45.jpg)
45
Queries
The corresponding queries usually produce the same responses.
Rule order can also make a difference.
?-prefix(X,[a,b,c]),suffix([e],X).no?-suffix([e],X),prefix(X,[a,b,c]).[infinite computation]
![Page 46: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/46.jpg)
46
Queries
?- appen1(X,[c],Z).X = []Z = [c] ;
X = [_G230]Z = [_G230, c] ;
X = [_G230, _G236]Z = [_G230, _G236, c] ;?- appen2(X,[c],Z).
New Solutions are produced on demand for
![Page 47: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/47.jpg)
47
Unification an Substitutions
Unification is central to control in Prolog Substitution is a function from variables to
terms
![Page 48: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/48.jpg)
48
Applying a Rule to a Goal
A rule applies to a subgoal G if its head A unifies with G
Variables in the rule are renamed before unification to keep them distinct from variables in the subgoal.
A :- B1, B2, …, Bn
![Page 49: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/49.jpg)
49
A computation that succeeds without backtracking
GOALSuffix([a],L),prefix(L,[a,b,c]).
suffix([a],L) if append(_1,[a],L).Append(_1,[a],L),prefix(L,[a,b,c]).
{_1[],L[a]} append([],[a],[a]).Prefix([a],[a,b,c]).
prefix([a],[a,b,c]) if append([a],_2,[a,b,c])append([a],_2,[a,b,c]).
prefix([a],[a,b,c]) if append([],_2,[b,c])Append([],_2,[b,c]).
{_2[b,c]} append([],[b,c],[b,c])yes
![Page 50: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/50.jpg)
50
Prolog Search Trees
![Page 51: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/51.jpg)
51
Goal Order Changes Solutions
![Page 52: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/52.jpg)
52
Cuts
A cut prunes or “cuts out” and unexplored part of a Prolog search tree.
Cuts can therefore be used to make a computation more efficient by eliminating futile searching and backtracking.
Cuts can also be used to implement a form of negation
![Page 53: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/53.jpg)
53
Cuts
A cut, written as !, appears as a condition within a rule. When rule
is applied, the cut tells control to backtrack past Cj-1,…,C1,B, without considering any remaining rules for them.
B :- C1,…, Cj-1, !,Cj+1,…,Ck
![Page 54: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/54.jpg)
54
A cut as the First Condition
Consider rules of the form
If the goal C fails, then control backtracks past B without considering any remaining rules for B. Thus the cut has the effect of making B fail if C fails.
B :- !, C.
![Page 55: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/55.jpg)
55
Example
b :- c.b :- d.b :- e.
b,G
c,G e,G
X
d,G!,d,G
d,G
b :- c.b :- !,d.b :- e.
![Page 56: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/56.jpg)
56
Example
?-a(X).
a(1) :- b;a(2) :- e;b :- c.b :- d.
a(1) :- b;a(2) :- e;b :- !,c.b :- d.
a(X)
b e
c d YesX=2Yes
X=1backtrack
a(X)
b e
!c d YesX=2
backtrackc
![Page 57: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/57.jpg)
57
The Effect of Cut
As mentioned earlier, when a rule
is applied during a computation The cut tells control to backtrack past Cj-
1,..C1,B without considering any remaining rules for them.
The effect of inserting a cut in the middle of a guess-and-verify rule.
B :- C1,…, Cj-1, !,Cj+1,…,Ck
![Page 58: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/58.jpg)
58
The Effect of Cut
The right side of a guess-and-verify rule has the form guess(S), verify(S), where guess(S) generates potential solutions until one satisfying verify(S) is found.
The effect of insering a cut between them, as
is to eliminate all but the first guess.
Conclusion(S) :- guess(S), !, verify(S)
![Page 59: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/59.jpg)
59
a(X) :- b(X).a(X) :- f(X).b(X) :- g(X),v(X).b(X) :- X = 4, v(X).g(1).g(2).g(3).v(X).f(5)
a(X) :- b(X).a(X) :- f(X).b(X) :- g(X),!,v(X).b(X) :- X = 4, v(X).g(1).g(2).g(3).v(X).f(5)
(a) (b)
![Page 60: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/60.jpg)
60
a(Z)
b(Z) f(5)
g(Z),v(Z) v(4)
v(1) v(2) v(3)
a(Z)
b(Z) f(5)
g(Z),!,v(Z) v(4)
!v(X)
v(1)
v(2) v(3)
(a) (b)
![Page 61: Prolog programming](https://reader035.vdocuments.net/reader035/viewer/2022081604/589f19c71a28ab7b208b4f47/html5/thumbnails/61.jpg)
61
Negation as Failure
The not operator in Prolog is implemented by the rules
not(X) :- X, !, fail.not(_).