:-

4 Arithmetic and
Nondeterminism
Prolog arithmetic can be a little surprising; you need to be
aware of modes. Sometimes nondeterminism needs to be
managed.
1. Arithmetic
2. Operators
3. Modes and Arithmetic
4. Expressions
5. Managing Nondeterminism
6. Arithmetic and Lists
85
:-
4.1 Arithmetic
In most languages 3 + 4 is an expression that has a value
In Prolog, 3 + 4 is just a term whose functor is + and
arguments are 3 and 4
Its not code, its data
The Prolog builtin = just unies (matches) two terms, it
does not evaluate expressions
?- X = 3 + 4.
X = 3+4 ;
No
86
:-
Arithmetic (2)
Use the built in is/2 predicate to compute the value of an
arithmetic expression:
?- is(X, 3+4).
X = 7 ;
No
is(X, Y) holds when X is a number and Y is an arithmetic
expression and X is the value of Y
87
:-
4.2 Operators
is is actually an inx operator in Prolog
This means that instead of writing is(X,3+4) we could also
have written X is 3+4
This is easier to read, so it preferred, although both work
Similarly, + is an operator; 3+4 is the same as +(3,4)
Operators in Prolog are not exclusively for arithmetic, they
are part of Prologs syntax
Prolog has many other standard operators; some we have
already seen, including :- , ; mod
Operators only aect syntax, not meaning
You can dene your own operators
88
:-
4.2.1 Precedence and Associativity
Operators have precedence and associativity
Use parentheses for grouping
E.g. * and / have higher precedence than + and -; they all
associate to the left
?- X is 3 + 4 * 5, Y is (3 + 4) * 5.
X = 23
Y = 35
Yes
?- X is 5 - 3 - 1, Y is 5 - (3 - 1).
X = 1
Y = 3
Yes
89
:-
4.2.2 Display
The built-in predicate display/1 is useful for understanding
how your input will be parsed when it includes operators
display/1 prints a term as Prolog understands it, using
only the standard form with the functor rst, and
arguments between parentheses
?- display(3 + 4 * 5), nl, display((3 + 4) * 5).
+(3, *(4, 5))
*(+(3, 4), 5)
Yes
?- display(5 - 3 - 1), nl, display(5 - (3 - 1)).
-(-(5, 3), 1)
-(5, -(3, 1))
Yes
90
:-
4.3 Modes and Arithmetic
We could code a predicate to compute a square like this:
square(N, N2) :- N2 is N * N.
?- square(5, X).
X = 25 ;
No
?- square(X, 25).
ERROR: Arguments are not sufficiently instantiated
We cant use this denition to compute a square root!
91
:-
Modes and Arithmetic (2)
Unfortunately, is/2 only works when the second argument
is ground
The rst argument can be unbound or bound to a number
?- X is 3 + Y.
ERROR: Arguments are not sufficiently instantiated
?- 7 is 3 + 4.
Yes
?- 9 is 3 + 4.
No
?- 2 + 5 is 3 + 4.
No
92
:-
4.4 Expressions
Some arithmetic expressions understood by is/2:
E1 + E2 addition float(E1) oat equivalent of E1
E1 - E2 subtraction E1 << E2 left shift
E1 * E2 multiplication E1 >> E2 right shift
E1 / E2 division E1 /\ E2 bitwise and
E1 // E2 integer division E1 \/ E2 bitwise or
E1 mod E2 modulo (sign of E1) \ E1 bitwise complement
-E1 unary minus min(E1, E2) minimum
abs(E1) absolute value max(E1, E2) maximum
integer(E1) truncate toward 0
93
:-
Expressions (2)
Some useful arithmetic predicates:
E1 < E2 less than
E1 =< E2 equal or less Danger : not <= !!!
E1 >= E2 greater or equal
E1 > E2 greater than
E1 =:= E2 equal (only numbers)
E1 =\= E2 not equal (only numbers)
All of these take ground arithmetic expressions as both
arguments
94
:-
4.5 Managing Nondeterminism
A common Prolog programming error is treating multiple
clauses as if they formed an if-then-else construct
This is an erroneous denition of absolute_value:
absolute_value(X, X) :- X >= 0.
absolute_value(X, Y) :- Y is -X.
?- absolute_value(-3, V).
V = 3 ;
No
?- absolute_value(42, V).
V = 42 ;
V = -42 ;
No
Why do +ve numbers have two absolute values, one of
them -ve?
95
:-
Managing Nondeterminism (2)
The problem is that the second clause promises that
[n[ = n
for any n, regardless of its sign
The correct denition:
absolute_value(X, X) :- X >= 0.
absolute_value(X, Y) :- X < 0, Y is -X.
?- absolute_value(-3, V).
V = 3 ;
No
?- absolute_value(42, V).
V = 42 ;
No
96
:-
Exercise
Dene a Prolog predicate maximum(X,Y,Z) such that Z is the
larger of X and Y
97
:-
4.5.1 Fibonacci numbers
Fibonacci numbers: 1, 1, 2, 3, 5, 8, 13, . . .
fib(0, 1).
fib(1, 1).
fib(N, F) :-
N > 1,
N1 is N - 1,
N2 is N - 2,
fib(N1, F1),
fib(N2, F2),
F is F1 + F2.
What if we change the order of goals? What if we do F is
F1 + F2 rst?
Note: each call makes two recursive calls. Are there better
ways to compute Fibonacci numbers?
98
:-
4.6 Lists and Arithmetic
Summing a list combines arithmetic with list processing:
sumlist([], 0). % sum([]) = 0
sumlist([X[Xs], Sum) :- % sum([X[Xs]) = Sum if
sumlist(Xs, Sum1), % sum(Xs) = Sum1 and
Sum is Sum1 + X. % Sum = Sum1 + X
This can be done more eciently:
sumlist([], Sum, Sum). % sum([]) + Sum = Sum
sumlist([X[Xs], Sum0, Sum):-% sum([X[Xs]) + Sum0 = Sum if
Sum1 is Sum0 + X, % Sum1 = Sum0 + X, and
sumlist(Xs, Sum1, Sum).% sum(Xs) + Sum1 = Sum
See the lecture on eciency for more on this
99
:-
4.6.1 List Maximum
Compute the maximum element of a list
maxlist([X], X).
maxlist([X[Xs], Max) :-
maxlist(Xs, Max1),
maximum(Max1, X, Max).
Note: no clause for []! Base case is singleton list because
[] has no maximum
100
:-
4.6.2 List Length
The length/2 built-in relates a list to its length
?- length([a,b,c], 3).
Yes
?- length([a,b,c], N).
N = 3 ;
No
?- length(L, 3).
L = [_G263, _G266, _G269] ;
No
?- length(L, N).
L = []
N = 0 ;
L = [_G278]
N = 1
Yes
It is not straightforward to implement length/2 with
exible modes; covered later
101
:-
4.6.3 List Handling
Many other list predicates can be dened using append,
length.
member/2 could be dened just in terms of append:
member(X, L) :- % X is a member of L, if L of form
append(_, [X|_], L). % any list ++ [X] ++ any list
E is the N
th
element of list L (counting from 0):
element(N, L, E) :- % E is the Nth element of L
append(F, [E|_], L), % if exists F where L = F ++ [E] ++ any
length(F, N). % and the length of F is N
102
:-
List Handling (2)
T is a list taking the rst N elements of L:
take(N, L, T) :- % T is the first N elements of L
append(T, _, L), % if L = T ++ any list
length(T, N). % and the length of T in N
T is what is left after removing the rst N elements of L:
drop(N, L, T) :- % T is the first N elements of L
append(F, T, L), % if L = T ++ any list
length(F, N). % and the length of T in N
L is a list all of whose elements are E:
listof([], _). % [] is a list of anything
listof([E|Es], E) :- % [E|Es] is a list of Es if
listof(Es, E). % Es is
103
104
105
106
107
108
:-
5 Coding in Prolog
We work through examples to illustrate how to write
Prolog code
Our goal: support code for a computerized card game
1. Data and Representation
2. Generating a deck of cards
3. Shuing
4. Dealing
109
:-
5.1 Data
For any language, rst determine:
what data we manipulate,
how they are related,
what are their attributes, and
what are their primitive operations
We need to represent a (partial) deck of cards, a hand,
individual cards, suits, ranks
Assume we dont need jokers for this game
110
:-
Data (2)
Suits and Ranks have no attributes
Their primitive operations are only distinguishing them and
possibly enumerating them
A card comprises a suit and a rank those are its
attributes
Constructing a card from rank and suit, and nding a
cards rank and suit are its only primitive operations
A deck is just an (ordered) sequence of cards
Primitive operations include removing the top card or
adding a card on top; all other operations can be
implemented in terms of those
111
:-
5.2 Representation
Simplest Prolog representations for types without attributes
are atoms and numbers, e.g., hearts, jack, 10, etc
Good idea to write a predicate for each type to specify
what are members of the type
Same code can enumerate values
suit(clubs). suit(diamonds).
suit(hearts). suit(spades).
rank(2). rank(3). rank(4).
rank(5). rank(6). rank(7).
rank(8). rank(9). rank(10).
rank(jack). rank(queen).
rank(king). rank(ace).
112
:-
Representation (2)
Simplest Prolog representation for type with attributes is
compound term, one argument for each attribute
For playing card: card(R, S), where R is a rank and S is a
suit
card(card(R,S)) :-
suit(S),
rank(R).
Since rank and suit will enumerate the ranks and suits, this
code will enumerate the cards of a deck
113
:-
Representation (3)
Deck is just a sequence of any number of cards
Prolog has good support for lists good representation
for sequences
List is a deck if each element is a card, i.e., if empty, or if
rst element is a card and rest is a deck
deck([]).
deck([C|Cs]) :-
card(C),
deck(Cs).
This representation does not ensure a full deck, nor that
there are no repeated cards
114
:-
Exercise: Bridge Hand Evaluation
In Bridge, a hand has 4 high card points for each ace, 3,
for each king, 2 for each queen, and 1 for each jack.
Write a predicate to determine how many high card points
a hand has.
115
:-
5.3 Generating a Full Deck of Cards
deck predicate holds for any deck; we need a full deck
card predicate generates all cards in a deck:
?- card(C).
C = card(2, clubs) ;
C = card(3, clubs) ;
C = card(4, clubs) ;
C = card(5, clubs) ;
C = card(6, clubs) ;
C = card(7, clubs)
Just need a way to collect all solutions to a query
116
:-
5.3.1 All Solutions Predicates
Prolog has built-in predicates for collecting solutions
findall(T, G, L) L is a list of all terms T that satisfy
goal G in the order solutions are found; variables in G are
left uninstantiated; deterministic
setof(T, G, L) L is a non-empty list of all terms T that
satisfy goal G; L is sorted with duplicates removed;
variables appearing only in G can be instantiated; can be
nondeterministic (with dierent variable instantiations)
bagof(T, G, L) like setof/3 but without the sorting
NB: Template term T is left uninstantiated by all of these
predicates
117
:-
All Solutions Predicates (2)
?- bagof(C, card(C), Deck).
C = _G151
Deck = [card(2, clubs), card(3, clubs), card(4, clubs),
card(5, clubs), card(6, clubs), card(7, clubs),
card(8, clubs), card(9, clubs), card(..., ...)|...]
?- setof(C, card(C), Deck).
C = _G151
Deck = [card(2, clubs), card(2, diamonds), card(2, hearts),
card(2, spades), card(3, clubs), card(3, diamonds),
card(3, hearts), card(3, spades), card(..., ...)|...]
findall/3 has the same solution: no variables occur only in
G and the list of solutions is not empty
118
:-
All Solutions Predicates (3)
We dont care about order, and card predicate generates
each card exactly once, so either will work
Use bagof: no point sorting if not needed
new_deck(Deck) :-
bagof(C, card(C), Deck).
Call it new deck because it only holds for lists of all 52 cards
in the order of a brand new deck
NB: setof and bagof fail if goal G has no solutions you
dont get the empty list
119
:-
All Solutions Predicates (4)
NB: When goal G includes some variables not appearing in
template T, setof and bagof generate a dierent list L for
each distinct binding of those variables
?- setof(S, borders(State,S), Neighbors).
S = _G152
State = vic
Neighbors = [nsw, sa] ;
S = _G152
State = act
Neighbors = [nsw] ;
S = _G152
State = qld
Neighbors = [nsw, nt, sa]
To just get a list of states that border any state, use
State^borders(State,S) for G
120
:-
5.4 Coding Tips
Prolog lists are very exible, used for many things
Can do a lot with just length/2 and append/3
When writing list processing predicates, often have one
clause for [] and one for [X|Xs]
It is often easier to write a predicate if you pretend all
arguments are inputs
Think of it as checking correctness of output, rather than
generating output
Then consider whether your code will work in the modes
you want
121
:-
Exercise: Selecting the n
th
Element
Implement select nth1(N, List, Elt, Rest) such that Elt is
the N
th
element of List, and Rest is all the other elements
of List in order. It need only work when N is bound.
122
:-
5.5 Shuing
Dont want to faithfully simulate real shuing would
not be random
Shuing really means randomly permute list order
Simple method: repeatedly randomly select one card from
deck as next card until all cards selected
shuffle([], []).
shuffle(Deck0, [C|Deck]) :-
random_element(Deck0, C, Deck1),
shuffle(Deck1, Deck).
Important: random element must fail for empty deck
NB: Cannot work in reverse mode!
123
:-
5.5.1 Selecting a Random Card
Need to know size of deck to know probability of selecting
any one card
Then we can pick a random number n where 1 n length
and remove element n of the deck
Must give back remainder of deck as well as random card,
since we cannot destructively remove card from deck
random_element(List, Elt, Rest) :-
length(List, Len),
Len > 0,
random(1, Len, Rand),
select_nth1(Rand, List, Elt, Rest).
124
:-
5.5.2 Random Numbers
No such thing as a random number ; its how the number is
selected that is random
No standard random number predicate in Prolog
Good practice: dene reasonable interface, then look in
manual for built-ins or libraries to implement it
This makes maintenance easier
SWI denes random/1 function (not really a function!)
random(Lo, Hi, Rand) :-
Rand is Lo+random(Hi-Lo+1).
125
:-
5.6 Dealing
Interface for dealing:
deal(Deck, Numhands, Numcards, Hands, Rest)
Hands is a list of Numhands lists, each with Numcards cards
All cards come from the front of Deck; Rest is leftover cards
126
:-
Dealing (2)
Easiest solution: take rst Numcards cards from Deck for
rst player, next Numcards for next player, etc
Use append and length to take top (front) of Deck
deal(Deck, 0, _, [], Deck).
deal(Deck, N, Numcards, [H|Hs], Rest) :-
N > 0,
length(H, Numcards),
append(H, Deck1, Deck),
N1 is N - 1,
deal(Deck1, N1, Numcards, Hs, Rest).
127
128
129
130
131
132
:-
6 Determinism
Deterministic Prolog code is much more ecient than
nondeterministic code. It can make the dierence between
running quickly and running out of stack space or time.
1. Prolog implementation
2. Determinacy
3. If-then-else
4. Indexing
133
:-
6.1 Prolog implementation
Actual implementation of Prolog predicates is stack-based
a :- b, c.
b :- d, e.
b :- e.
c :- fail.
d :- e.
e.
To execute a, we invoke b, then c
While executing b, we must remember to go on to c; Like
most languages, Prolog uses a call stack
While executing rst clause of b, we must remember if we
fail, we should try the second
Prolog implements this with a separate stack, the
choicepoint stack
When a choicepoint is created, the call stack must be
frozen: cannot overwrite current call stack entries because
they may be needed after choicepoint is popped
134
:-
6.1.1 Stack Example
call
stack
choicepoint
stack
10
11
12
0
1
2
3
a :
b,
c.
b :
d,
b :
d :
4
5
6
7
8
9
e.
e.
e.
c :
fail.
e.
2
135
:-
Stack Example (2)
call
stack
choicepoint
stack
10
11
12
0
1
2
3
a :
b,
c.
b :
d,
b :
d :
4
5
6
7
8
9
e.
e.
e.
c :
fail.
e.
2 6
5
136
:-
Stack Example (3)
call
stack
choicepoint
stack
10
11
12
0
1
2
3
a :
b,
c.
b :
d,
b :
d :
4
5
6
7
8
9
e.
e.
e.
c :
fail.
e.
2 6
NB: call stack not popped!
137
:-
Stack Example (4)
call
stack
choicepoint
stack
10
11
12
0
1
2
3
a :
b,
c.
b :
d,
b :
d :
4
5
6
7
8
9
e.
e.
e.
c :
fail.
e.
138
:-
6.2 Determinacy
Pushing a choicepoint causes current call stack to be
frozen
We cant write over frozen part of call stack, so it must be
kept around indenitely
One choicepoint can freeze a large amount of stack space
So avoiding choicepoints is important to eciency
A predicate with multiple solutions should leave a
choicepoint
A predicate with only one solution should not
139
:-
6.3 Indexing
Indexing makes Prolog programs more deterministic than
you might expect them to be
Indexing takes a sequence of adjacent clauses whose
rst argument is bound and constructs an index to
quickly select the right clause(s)
When a goal has a non-variable rst argument, indexing
allows Prolog to immediately choose the clause(s) whose
rst argument matches the goals rst argument
Other clauses are not even considered
Indices are constructed automatically; no special action
needed
You can ask SWI Prolog to index on arguments other than
the rst using the index or hash declarations
140
:-
6.3.1 Indexing Example
For example, for the code
capital(tas, hobart). capital(vic, melbourne).
capital(nsw, sydney). capital(sa, adelaide).
capital(act, canberra). capital(qld, brisbane).
capital(nt, darwin). capital(wa, perth).
and the goal
?- capital(vic, X)
Prolog will jump immediately to the second clause
More importantly, after trying the second clause, Prolog
will know no other clause can possibly match, so will not
leave a choicepoint
For a goal such as capital(X, Y), the index will not be
used; Prolog will try every clause
141
:-
6.3.2 Indexing for Determinism
When possible, use indexing to avoid unnecessary
choicepoints
On most Prolog systems, only the outermost constructor
of the rst argument is indexed, e.g. with code:
foo(bar(a), 1). foo(bar(b), 2). foo(bar(c), 3).
foo(bar(b), X) would still leave a choicepoint
For eciency, rewrite to get indexing:
foo(bar(X), N) :- foobar(X, N).
foobar(a, 1). foobar(b, 2). foobar(c, 3).
142
:-
Indexing for Determinism (2)
Indexing is used even on predicates with only two clauses:
it allows many predicates to avoid choicepoints
append([], L, L).
append([J|K], L, [J|KL]) :-
append(K, L, KL).
Indexing allows append never to leave a choicepoint when
the rst argument is bound
143
:-
6.4 If-Then-Else
Our denition of absolute_value/2 from slide 96 was a bit
unsatisfying because both clauses compare X to 0:
absolute_value(X, X) :- X >= 0.
absolute_value(X, Y) :- X < 0, Y is -X.
Prolog actually performs the comparison twice
Arithmetic comparisons are cheap, but suppose the test
were something time consuming: we would not want to do
it twice
Conventional programming languages provide an
if-then-else construct which evaluates the condition only
once
144
:-
If-Then-Else (2)
Prolog also has an if-then-else construct, whose syntax is
( A -> B ; C )
This means: execute A; if it succeeds, then execute B;
otherwise, execute C instead
It also commits to the rst solution to A; see caution
below!
A form of negation dened in Prolog:
% "not provable"
\+ G :- (G -> fail ; true).
% a form of inequality: "not unifiable"
X \= Y :- \+ X=Y.
145
:-
If-Then-Else (3)
Dening absolute_value/2 with only one comparison:
absolute_value(X, Y) :-
( X < 0 ->
Y is -X
; Y = X
).
One clause which lls the role of both clauses in prev. defn.
?- absolute_value(-3, V).
V = 3 ;
No
?- absolute_value(42, V).
V = 42 ;
No
146
:-
If-Then-Else (4)
If-then-elses can be nested to give an if-then-elseif-else
structure.
comparison(X, Y, Rel) :-
( X < Y -> Rel = less
; X = Y -> Rel = equal
; Rel = greater
).
?- comparison(3, 4, X).
X = less ;
No
?- comparison(4, 3, X).
X = greater ;
No
?- comparison(4, 4, X).
X = equal ;
No
147
:-
6.4.1 Caution
If-then-else commits to the rst solution to the
condition goal, eliminating any other solutions
If-then-else works by removing choicepoints
This may limit the modes that code can be used in
This may cause code to simply be wrong
Use if-then-else with caution!
148
:-
6.4.2 Cautionary Example
Example: list_end(List, Sublist, End) holds when Sublist
is the End end of List, and End is front or back
Buggy implementation:
list_end(List, Sublist, End) :-
( append(Sublist, _, List) ->
End = front
; append(_, Sublist, List) ->
End = back
).
Note no else part; this is equivalent to an else part of fail
149
:-
Cautionary Example (2)
This code works in simple cases:
?- list_end([a,b,c,d], [a,b], End).
End = front ;
No
?- list_end([a,b,c,d], [d], End).
End = back ;
No
but gets it wrong when Sublist is found at both ends of
List
?- list_end([a,b,c,a,b], [a,b], End).
End = front ;
No
The use of if-then-else means that the code will never
admit that the sublist is at both ends of the list
150
:-
Cautionary Example (3)
There is a bigger aw: the if-then-else commits to the rst
solution of append
In many modes this is completely wrong
?- list_end([a,b,c], Sublist, End).
Sublist = []
End = front ;
No
?- list_end([a,b,c], Sublist, back).
No
151
:-
Cautionary Example (4)
Correct implementation does not use if-then-else at all
list_end(List, Sublist, front) :- append(Sublist, _, List).
list_end(List, Sublist, back) :- append(_, Sublist, List).
?- list_end([a,b], Sublist, End).
Sublist = []
End = front ;
Sublist = [a]
End = front ;
Sublist = [a, b]
End = front ;
Sublist = [a, b]
End = back ;
Sublist = [b]
End = back ;
Sublist = []
End = back ;
No
152
:-
6.4.3 Removing Unnecessary Choicepoints
Suppose a ground list L represents a set
member(foo,L) checks if fooL, but leaves a choicepoint
because there may be more than 1 way to prove foo l
( member(foo, L) -> true ; fail )
is equivalent, but will not leave a choicepoint
If we want to know whether there exists any X such that
foo(X) l, and we do not care about what X is, then
( member(foo(_), L) -> true ; fail )
will stop after rst match, removing choicepoint
Caution: only correct when L is ground
153
:-
6.4.4 When to Use If-Then-Else
Its safe to use if-then-else when:
The semantics (a b) (a c) is what you want; and
The condition is always ground when it is executed (be
careful!)
More generally, when:
The semantics (v
1
v
2
. . . (a b)) (v
1
v
2
. . . a c) is
what you want; and
v
1
, v
2
, . . . are all the variables in a when it is executed
(careful!); and
the condition is deterministic
We will see later how if-then-else can be used to make
predicates work in more modes than they otherwise would
154
155
156
:-
7 Search
Prologs ecient built-in search mechanism makes it ideal
for solving many sorts of problems that are tricky in
conventional languages
1. Path Finding
2. Iterative Deepening
3. 8 Queens
4. Constraint Programming
157
:-
7.1 Path Finding
Many problems come down to searching for a path through
a graph
For example, we may want to know if a person alice is a
descendant of another person zachary
If we have a relation parent/2 that species who is a
parent of whom, then ancestor/2 is the transitive closure
of parent/2
Transitive closure follows this pattern:
ancestor(A, A).
ancestor(D, A) :-
parent(D, P),
ancestor(P, A).
158
:-
Path Finding (2)
Finding paths in a graph is nding the transitive closure of
the adjacency/edge relation of the graph
Suppose a predicate edge/2 denes a graph:
159
a d
b
c
e
f g
edge(a,b). edge(a,c).
edge(b,d). edge(c,d).
edge(d,e). edge(f,g).
160
connected(N, N).
connected(L, N) :- edge(L, M), connected(M, N).
161
:-
Path Finding (3)
A small change in the graph makes it go badly wrong:
a
d
b c
e
f
g
edge(a,b). edge(a,c).
edge(b,d). edge(c,d).
edge(d,e). edge(f,g).
The graph now has a cycle (cannot happen for
ancestors!)
There is nothing to stop the Prolog code exploring the
innite path
162
:-
Path Finding (4)
?- trace, connected(a,e).
Call: (8) connected(a, e) ? creep
Call: (9) edge(a, _G215) ? creep
Exit: (9) edge(a, b) ? creep
Call: (9) connected(b, e) ? creep
Call: (10) edge(b, _G215) ? creep
Exit: (10) edge(b, d) ? creep
Call: (10) connected(d, e) ? creep
Call: (11) edge(d, _G215) ? creep
Exit: (11) edge(d, c) ? creep
Call: (11) connected(c, e) ? creep
Call: (12) edge(c, _G215) ? creep
Exit: (12) edge(c, a) ? creep
Call: (12) connected(a, e) ? creep
Call: (13) edge(a, _G215) ? creep
Exit: (13) edge(a, b) ?
163
:-
Path Finding (5)
Solution: keep a list of nodes visited along a path, and
dont revisit a node already on the list
connected(M, N) :- connected(M, [M], N).
connected(N, _, N).
connected(L, Path, N) :-
edge(L, M),
\+ member(M, Path),
connected(M, [M|Path], N).
?- connected(a, e).
Yes
Remember: \+ is negation
Also note the algorithmic complexity of this code is O(2
N
)
164
:-
7.2 Word Paths
Sometimes the path is the desired output
Word game: transform one word into another of the same
length by repeatedly replacing one letter of the word with
another so that each step is a valid English word
E.g., tranform big to dog
big bag lag log dog
Here we dont just want to know if it can be done, we
want to know the steps
165
:-
Word Paths (2)
transform(Initial, Final, [Initial|Steps]) :-
word(Initial),
word(Final),
transform(Initial, [Initial], Final, Steps).
transform(Final, _, Final, []).
transform(Initial, History, Final, [Next|Steps]) :-
step(Initial, Next),
word(Next),
\+ member(Next, History),
transform(Next, [Next|History], Final, Steps).
The second argument of transform/4 is used to avoid loops
166
:-
Word Paths (3)
step([_|Rest], [_|Rest]). % all but the first is the same
step([C|Rest0], [C|Rest]) :- % the first is the same but
step(Rest0, Rest). % at most one letter differs in rest
word("bag"). word("big"). word("bog"). word("bug").
word("lag"). word("leg"). word("log"). word("lug").
word("dag"). word("dig"). word("dog"). word("dug").
Also load our strings module from slide 201 for readable
output
167
:-
Word Paths (4)
?- transform("big", "dog", Steps).
Steps = ["big", "dig", "dag", "bag", "lag",
"leg", "log", "bog", "dog"] ;
Steps = ["big", "dig", "dag", "bag", "lag",
"leg", "log", "bog", "bug"|...]
Yes
?- transform("big", "dog",
| ["big","bag","lag","log","dog"]).
Yes
Well see later how to get Prolog to print out lists of
character codes as strings
168
:-
7.3 Iterative Deepening
Often we dont want just any solution; we want a shortest
one
Even if we dont need a shortest solution, we may want to
avoid innite (or just huge) branches in the search space
One way to do this is breadth rst search:
1. Create a list of just a singleton list of the starting
point in it
[["big"]]
2. Repeatedly extend each element in the list with all
possible next elements
[["big","bag"], ["big","bog"], ["big","bug"], ["big","dig"]]
3. Terminate when one list is a solution
169
:-
Iterative Deepening (2)
Breadth rst search is often impractical due to its high
memory usage
Often Iterative Deepening is a simple, practical, ecient
alternative
Iterative deepening works by doing a depth rst search for
a short solution
If this works, great; if not, start over looking for a longer
solution
Repeat until a solution is found
Work is repeated, but often the cost of doing a depth n
search is much smaller than the cost of a depth n + 1
search, so the waste is relatively small
170
:-
7.3.1 Word Paths Again
We can implement a predicate to nd the shortest
solutions to the word game as follows:
First determine the length of the shortest solution
Then commit to that length and nd solutions of exactly
that length
shortest_transform(Word0, Word, Steps) :-
( length(Steps0, Len),
transform(Word0, Word, Steps0) ->
length(Steps, Len),
transform(Word0, Word, Steps)
; fail
).
171
:-
Word Paths Again (2)
?- time(shortest_transform("big","dog",X)).
% 100 inferences, 0.00 CPU in 0.00 seconds (0% CPU, Infinite Lips)
X = ["big", "dig", "dog"] ;
No
LIPS means logical inferences per second
One logical inference is dened to mean one predicate
call
This code is so fast because it never tries to build long
paths
172
:-
7.4 8 Queens
Classic puzzle: place 8 queens on a chess board such that
none attack any others.
Where to put the next queen?
173
:-
8 Queens (2)
The search space for this program is large: 64 choose
8 =
64!
56!
10
14
If we check 1 million candidates per second, it would
take 135 years to check them all
Search space can be signicantly reduced (as usual)
One queen in every row, one in every column
Right representation makes a big dierence in search
performance
Represent board as a list of integers indicating in
which column the queen in that row is placed
Now 8 choose 8 = 8! = 40320 candidates easy
174
:-
8 Queens (3)
To check if a queen attacks another queen, only need
to check the diagonals
Number rows bottom to top, columns left to right
Queens on the same NESW diagonal have same
column row
Queens on the same SENW diagonal have same
column + row
Queens row number is position in list
175
:-
8 Queens (4)
If rst queen attacks second, no point placing any more,
so: add queens to board one at a time, checking after each
addition
Sneaky trick: add new queen in rst row, sliding other
queens down
Another trick: number rows from 0, so column row =
column + row = column
Check if queen in row 0 attacks queens in rows 1 . . . n:
noattack(Q, Qs) :- noattack(Q, 1, Qs).
noattack(_, _, []).
noattack(Q0, Row, [Q|Qs]) :-
Q0 =\= Q + Row,
Q0 =\= Q - Row,
Row1 is Row + 1,
noattack(Q0, Row1, Qs).
176
:-
8 Queens (5)
The main body of the code chooses columns from a list of
all possible columns until all queens have been placed.
Note the the last two arguments of queens/3 are an
accumulator pair.
queens(N, Qs) :-
range(1, N, Columns), % Columns = 1..8
queens(Columns, [], Qs).
queens([], Qs, Qs). % no positions left, done
queens(Unplaced, Safe, Qs) :-
select(Q, Unplaced, Unplaced1), % choose an unused position
noattack(Q, Safe), % check doesnt attack earlier Q
queens(Unplaced1, [Q|Safe], Qs).% continue placing remainder
177
:-
8 Queens (6)
The necessary utility predicates
select(X, [X|Ys], Ys). % X is removed from list leaving Ys
select(X, [Y|Ys], [Y|Zs]) :- % leave first element Y in list and
select(X, Ys, Zs). % select from rest of list
range(Lo, Hi, L) :- % L is the list from Lo .. Hi
( Lo > Hi -> % if Lo > Hi this is
L = [] % the empty list
; L = [Lo|L1], % otherwise the list starts
Next is Lo + 1, % with Lo and then is
range(Next, Hi, L1) % the list Lo+1 .. Hi
).
178
:-
8 Queens (7)
Try it:
?- queens(8, L).
L = [4, 2, 7, 3, 6, 8, 5, 1] ;
L = [5, 2, 4, 7, 3, 8, 6, 1] ;
L = [3, 5, 2, 8, 6, 4, 7, 1]
Yes
?- time(queens(8, L)).
% 4,691 inferences in 0.01 seconds (469100 Lips)
L = [4, 2, 7, 3, 6, 8, 5, 1]
Yes
?- time(queens(20, L)).
% 35,489,394 inferences in 211.64 seconds (167688 Lips)
179
:-
7.5 Constraint Programming
Much better handled by constraint (logic)
programming.
CP can answer 1,000,000 queens!
Current code fails as soon as possible after generating
a bad position
Better: dont generate a bad position in the rst place
Rather than generate and test, employ constrain and
generate:
Add all the constraints rst!
Then search
180
:-
8 Eciency and I/O
Correctness is much more important than eciency, but
once your code is correct, you may want to make it fast.
You may also want to input or output data.
1. Tail Recursion
2. Accumulators
3. Dierence Pairs
181
:-
8.1 Tail Recursion
For eciency, when calling the last goal in a clause body,
Prolog jumps straight to that predicate without pushing
anything on the call stack
This is called last call optimization or tail recursion
optimization
tail recursive means the recursive call is the last goal in the
body
A tail recursive predicate is ecient, as it runs in constant
stack space; it behaves like a loop in a conventional
language
182
:-
8.2 Accumulators
The natural denition of factorial in Prolog:
% F is N factorial
factorial(0, 1).
factorial(N, F) :-
N > 0,
N1 is N - 1,
factorial(N1, F1),
F is F1 * N.
This denition is not tail recursive because it performs
arithmetic after the recursive call.
183
:-
Accumulators (2)
We make factorial tail recursive by introducing an
accumulating parameter, or just an accumulator
This is an extra parameter to the predicate which holds a
partially computed result
Usually the base case for the recursion will specify that the
partially computed result is actually the result
The recursive clause usually computes more of the partially
computed result, and passes this in the recursive goal
The key to getting the implementation correct is specifying
what the accumulator means and how it relates to the nal
result
184
:-
8.2.1 Accumulator Example
A tail recursive denition of factorial using an
accumulator:
factorial(N, F) :- factorial(N, 1, F).
% F is A times the factorial of N
factorial(0, F, F).
factorial(N, A, F) :-
N > 0,
N1 is N - 1,
A1 is N * A,
factorial(N1, A1, F).
Typical structure of a predicate using an accumulator
185
:-
Accumulator Example (2)
To see how to add an accumulator, determine what is done
after the recursive call
Respecify the predicate so it performs this task, too
For factorial, we compute factorial(N1, F1), F is F1 * N,
so we want factorial to perform the multiplication for us
too
% F is A times the factorial of N
new_factorial(N, A, F) :-
factorial(N, FN),
F is FN * A.
186
:-
Accumulator Example (3)
Replace the call to
factorial(N, FN) by the
body: unfold
Simplifying arithmetic:
new_factorial(0, A, F) :-
F is 1 * A.
new_factorial(N, A, F) :-
N > 0,
N1 is N - 1,
factorial(N1, F1),
F2 is F1 * N,
F is F2 * A.
new_factorial(0, F, F).
new_factorial(N, A, F) :-
N > 0,
N1 is N - 1,
factorial(N1, F1),
F is (F1 * N) * A.
187
:-
Accumulator Example (4)
By associativity of
multiplication:
Replace the copy of the
denition of new factorial:
factorial(N1, F1), F is F1 * ?
by call to new_factorial:
fold
new_factorial(0, F, F).
new_factorial(N, A, F) :-
N > 0,
N1 is N - 1,
factorial(N1, F1),
NA is N * A,
F is F1 * NA.
new_factorial(0, F, F).
new_factorial(N, A, F) :-
N > 0,
N1 is N - 1,
NA is N * A,
new_factorial(N1, NA, F).
188
:-
Exercise
Rewrite the mult predicate from an earlier exercise to be
tail recursive. Here is the old code:
mult(0, , 0). % multiplying anything by 0 gives 0
mult(s(X), Y, Z) :-% Z = Y (X + 1) if
mult(X, Y, W), % W = XY
add(W, Y, Z). % and Z = W +Y
189
:-
8.3 Dierence Pairs
Accumulators can be even more useful for building up lists
Recall our rev/2 predicate:
rev([], []).
rev([A|BC], R) :-
rev(BC, CB),
append(CB, [A], R).
The same approach works for this example
First respecify rev to append a list to the result:
% rev(BC, A, CBA)
% CBA is BC reversed with A appended
% to the end
190
:-
8.3.1 Dierence Pairs Example
Next revise the denition of rev
rev(AB, BA) :- rev(AB, [], BA).
rev([], A, A).
rev([B|CD], A, DCBA) :-
rev(CD, [B|A], DCBA).
This denition is tail recursive
Much more importantly, it does not call append
If l is the length of the input list, the original version
performs about l
2
/2 steps, while the new one performs
about l steps
191
:-
Dierence Pairs Example (2)
When working with lists, using accumulators is very
common
Common to have an accumulator for each list being
constructed
Thus lists are often passed as a pair of arguments: one the
actual result, and the other the list to be appended to the
natural result to get the actual result
Can think of the natural result of the operation as the
actual result minus the accumulator argument
Such pairs of arguments are called dierence pairs or
dierence lists
Common to put such pairs in the opposite order,
accumulator second, to emphasize that the accumulator is
the tail end of the actual result
192
:-
Dierence Pairs Example (3)
% tree_list(Tree, List)
% List is a list of the elements of tree,
% in order
tree_list(Tree, List) :-
tree_list(Tree, List, []).
% tree_list(Tree, List, List0)
% List is a list of the elements of tree,
% in order, followed by the list List0
tree_list(empty, List, List).
tree_list(tree(L,V,R), List, List0) :-
tree_list(L, List, [V|List1]),
tree_list(R, List1, List0).
193
:-
8.4 Term I/O
?- write(hello).
hello
Yes
?- write(42).
42
Yes
?- write([a,b,c]).
[a, b, c]
Yes
?- write((3+(4*5)*6)).
3+4*5*6
Yes
write/1 writes any term in its normal format (considering
operators), with mimimal parentheses, to current output
stream.
194
:-
8.4.1 Read Example
?- read(X).
|: [a,b,c].
X = [a, b, c] ;
No
?- read(X).
|: foo(A,3,A /* repeated variable */).
X = foo(_G231, 3, _G231) ;
No
?- read(X).
|: 7
|: .
X = 7 ;
No
195
:-
8.5 Character I/O
An individual character can be written with the put/1
predicate
Prolog represents characters as integers character codes
Can specify character code for a character by preceding it
with 0 (no matching close quote)
?- put(65), nl.
A
Yes
?- put(0a), nl.
a
Yes
?- put(0a), put(0 ), put(0z).
a z
Yes
196
:-
8.5.1 Reading Characters
The built-in get0/1 predicate reads a single chararacter
from the current input stream as a character code
get0/1 returns -1 at end of le
?- get0(C1), get0(C2), get0(C3).
|: hi
C1 = 104
C2 = 105
C3 = 10 ;
No
197
:-
8.5.2 Dening I/O Predicates
A predicate to write a line of text as a list of character
codes:
write_line([]) :- nl.
write_line([C|Cs]) :- put(C), write_line(Cs).
198
:-
Exercise: Read a Line of Input
Write a predicate to read a line of input as a list of
character codes. read line(Line) should read a line from
the current input stream, binding Line to the list of
character codes read, without the terminating newline
character.
199
:-
8.5.3 String Notation
?- read_line(X), write_line(X).
|: hello world!
hello world!
X = [104, 101, 108, 108, 111, 32, 119, 111, 114|...] ;
No
Prolog has a special syntax for lists of character codes:
characters between double quotes
?- X = "hello, world!", write_line(X).
hello, world!
X = [104, 101, 108, 108, 111, 44, 32, 119, 111|...] ;
No
200
:-
8.6 print and portray
Query and debugger output is done with print/1
Mostly the same as writeq/1, but you can reprogram it by
dening predicate user:portray/1
:- multifile user:portray/1.
user:portray(Term) :-
ground(Term),
chars(Term),
!,
put(0"),
putchars(Term),
put(0").
chars([]).
chars([C|Cs]) :-
printable(C),
chars(Cs).
printable(C) :-
integer(C),
( code_type(C, graph)
; code_type(C, space)
).
putchars/1 is like write_line/1 without call to nl/0
Note: ! is called cut. It prevents backtracking to other
clauses (use -> instead if at all possible)
201
:-
print and portray (2)
With this code loaded, Prolog prints lists of character
codes as quoted strings.
Without portray code
?- print("abcd").
[97, 98, 99, 100]
Yes
?- X = "abcd".
X = [97, 98, 99, 100]
Yes
With portray code
?- print("abcd").
"abcd"
Yes
?- X = "abcd".
X = "abcd"
Yes
Code is available in strings.pl
202
:-
8.7 Order Sensitivity
Like arithmetic in Prolog, I/O predicates are sensitive to
the order in which they are executed
write(hello), write(world) always prints out helloworld,
and never worldhello, although conjunction is meant to be
commutative
Backtracking cannot undo I/O, e.g. get0(0a) reads a
character and fails if it is not an a, but does not put
back the character if it fails
Term output puts out a term as it is, so
?- write(foo(X)), X=bar.
foo(_G258)
X = bar ;
No
?- X=bar, write(foo(X)).
foo(bar)
X = bar ;
No
203
:-
8.7.1 Best Practice
Due to the procedural nature of Prolog I/O, it is usually
best to keep the I/O part of an application as isolated as
possible
E.g. write predicates that read in all input and build some
appropriate term to represent it, then write code that
processes the term
E.g. write predicates that build up output in some
appropriate term representation, then have separate code
to perform the actual output
This makes debugging easier: you cannot easily retry goals
that read input, as retry does not automatically rewind
input streams
204
:-
9 Parsing in Prolog
Prolog was originally developed for programming natural
language (French) parsing applications, so it is well-suited
for parsing
1. DCGs
2. DCG Translation
3. Tokenizing
4. Example
205
:-
9.1 DCGs
A parser is a program that reads in a sequence of
characters, constructing an internal representation
Prologs read/1 predicate is a parser that converts
Prologs syntax into Prolog terms
Prolog also has a built-in facility that allows you to
easily write a parser for another syntax (e.g., C or
French or student record cards)
These are called denite clause grammars or DCGs
DCGs are dened as a number of clauses, much like
predicates
DCG clauses use --> to separate head from body,
instead of :-
206
:-
9.1.1 Simple DCG
Could specify a number to be an optional minus sign, one
or more digits optionally followed by a decimal point and
some more digits, optionally followed by the letter e and
some more digits:
number -->
( "-"
; ""
),
digits,
( ".", digits
; ""
),
( "e", digits
; ""
).
number (-[)digits(. digits[)
(e digits[)
207
:-
Simple DCG (2)
Dene digits:
digits -->
( "0" ; "1" ; "2" ; "3" ; "4"
; "5" ; "6" ; "7" ; "8" ; "9"
),
( digits
; ""
).
digit 0[1[2[3[4[
5[6[7[8[9
digits digit digits[digit
A sequence of digits is one of the digit characters followed
by either a sequence of digits or nothing
208
:-
9.1.2 Using DCGs
Test a grammar with phrase(Grammar,Text) builtin, where
Grammar is the grammar element (called a nonterminal)
and Text is the text we wish to check
?- phrase(number, "3.14159").
Yes
?- phrase(number, "3.14159e0").
Yes
?- phrase(number, "3e7").
Yes
?- phrase(number, "37").
Yes
?- phrase(number, "37.").
No
?- phrase(number, "3.14.159").
No
209
:-
Using DCGs (2)
Its not enough to know that "3.14159" spells a number, we
also want to know what number it spells
Easy to add this to our grammar: add arguments to our
nonterminals
Can add actions to our grammar rules to let them do
computations
Actions are ordinary Prolog goals included inside braces {}
210
:-
9.1.3 DCGs with Actions
DCG returns a number N
number(N) -->
( "-" ->
{ Sign = -1 }
; { Sign = 1 }
),
digits(Whole),
( ".", frac(Frac),
{ Mantissa is Whole + Frac }
; { Mantissa = Whole }
),
( "e", digits(Exp),
{ N is Sign * Mantissa * (10 ** Exp) }
; { N is Sign * Mantissa }
).
211
:-
DCGs with Actions (2)
digits(N) -->
digits(0, N). % Accumulator
digits(N0, N) --> % N0 is number already read
[Char],
{ 00 =< Char },
{ Char =< 09 },
{ N1 is N0 * 10 + (Char - 00) },
( digits(N1, N)
; { N = N1 }
).
"c" syntax just denotes the list with 0c as its only member
The two comparison goals restrict Char to a digit
212
:-
DCGs with Actions (3)
frac(F) -->
frac(0, 0.1, F).
frac(F0, Mult, F) -->
[Char],
{ 00 =< Char },
{ Char =< 09 },
{ F1 is F0 + (Char - 00)*Mult },
{ Mult1 is Mult / 10 },
( frac(F1, Mult1, F)
; { F = F1 }
).
Multiplier argument keeps track of scaling of later digits.
Like digits, frac uses accumulator to be tail recursive.
213
:-
Exercise: Parsing Identiers
Write a DCG predicate to parse an identier as in C: a
string of characters beginning with a letter, and following
with zero or more letters, digits, and underscore
characters. Assume you already have DCG predicates
letter(L) and digit(D) to parse an individual letter or digit.
214
:-
9.2 DCG Translation
DCGs are just an alternative syntax for ordinary Prolog
clauses
After clauses are read in by Prolog, they may be
transformed by expand_term(Original,Final) where
Original is the clause as read, and Final is the clause
actually compiled
Clauses with --> as principal functor transformed by
adding two more arguments to the predicate and two
arguments to each call outside { curley braces }
expand_term/2 also calls a predicate term_expansion/2
which you can dene
This allows you to perform any sort of translation you
like on Prolog programs
215
:-
9.2.1 DCG Expansion
Added arguments form an accumulator pair, with the
accumulator threaded through the predicate.
nonterminal foo(X) is translated to foo(X,S,S0)
meaning that the string S minus the tail S0 represents
a foo(X).
A grammar rule a --> b, c is translated to
a(S, S0) :- b(S, S1), c(S1, S0).
[Arg] goals are transformed to calls to built in
predicate C(S, Arg, S1) where S and S1 are the
accumulator being threaded through the code.
C/3 dened as: C([X|Y], X, Y).
phrase(a(X), List) invokes a(X, List, [])
216
:-
9.2.2 DCG Expansion Example
For example, our digits/2 nonterminal is translated into a
digits/4 predicate:
digits(N0, N) -->
[Char],
{ 00 =< Char },
{ Char =< 09 },
{ N1 is N0*10
+ (Char-00) },
( digits(N1, N)
; "",
{ N = N1 }
).
digits(N0, N, S, S0) :-
C(S, Char, S1),
48 =< Char,
Char =< 57,
N1 is N0*10
+ (Char-48),
( digits(N1, N, S1, S0)
; N=N1,
S0=S1
).
(SWI Prologs translation is equivalent, but less clear.)
217
:-
9.3 Tokenizing
Parsing turns a linear sequence of things into a
structure.
Sometimes its best if these things are something
other than characters; such things are called tokens.
Tokens leave out things that are unimportant to the
grammar, such as whitespace and comments.
Tokens are represented in Prolog as terms; must
decide what terms represent which tokens.
218
:-
Tokenizing (2)
Suppose we want to write a parser for English
It is easier to parse words than characters, so we choose
words and punctuation symbols as our tokens
We will write a tokenizer that reads one character at a
time until a full sentence has been read, returning a list of
words and punctuation
219
:-
9.3.1 A Simple Tokenizer
sentence_tokens(Words) :-
get0(Ch),
sentence_tokens(Ch, Words).
sentence_tokens(Ch, Words) :-
( Ch = 10 -> %% end of line
Words = []
; alphabetic(Ch) ->
get_letters(Ch, Ch1, Letters),
atom_codes(Word, Letters),
Words = [Word|Words1],
sentence_tokens(Ch1, Words1)
; get0(Ch1),
sentence_tokens(Ch1, Words)
).
220
:-
A Simple Tokenizer (2)
alphabetic(Ch) :-
( Ch >= 0a, Ch =< 0z ->
true
; Ch >= 0A, Ch =< 0Z ->
true
).
get_letters(Ch0, Ch, Letters) :-
( alphabetic(Ch0) ->
Letters = [Ch0|Letters1],
get0(Ch1),
get_letters(Ch1, Ch, Letters1)
; Ch = Ch0,
Letters = []
).
221
:-
9.4 Parsing Example
Can write parser using standard approach to English
grammar
Many better approaches to parsing natural language
than we use here, this just gives the idea
An english sentence is usually a noun phrase followed
by a verb phrase, e.g. the boy carried the book
Noun phrase is the subject, verb phrase describes the
action and the object (if there is one)
Sentence may be an imperative: just a verb phrase,
e.g. walk the dog
222
:-
9.4.1 DCG Phrase Parser
sentence --> noun_phrase, verb_phrase.
sentence --> verb_phrase.
noun_phrase --> determiner, noun.
noun_phrase --> proper_noun.
verb_phrase --> verb, noun_phrase.
verb_phrase --> verb.
determiner --> word(determiner).
noun --> word(noun).
proper_noun --> word(proper_noun).
verb --> word(verb).
223
:-
9.4.2 Parsing for Meaning
Two problems:
1. no indication of the meaning of the sentence
2. no checking of agreement of number, person, etc
Solution to both is the same: make grammar rules
take arguments
Arguments give meaning
Unication can ensure agreement
224
:-
9.4.3 Parsing for Structure
sentence(action(Verb,Tense,Subject,Object)) -->
noun_phrase(Subject, Number, Person, nominative),
verb_phrase(Verb, Tense, Number, Person, Object).
sentence(action(Verb,Tense,imperative,Object)) -->
verb_phrase(Verb, Tense, _, second, Object).
noun_phrase(count(Thing,Definite,Number), Number, third, _) -->
determiner(Definite,Number),
noun(Thing, Number).
noun_phrase(Thing, Number, third, _) -->
proper_noun(Thing, Number).
noun_phrase(pro(Person,Number,Gender), Number, Person, Case) -->
pronoun(Person, Number, Case, Gender).
225
:-
Parsing for Structure (2)
verb_phrase(Verb, Tense, Number, Person, Object) -->
verb(Verb, Number, Person, Tense),
( noun_phrase(Object, _, _, objective)
; { Object = none }
).
determiner(Definite,Number) -->
word1(determiner(Definite,Number)).
noun(Thing, Number) -->
word1(noun(Thing,Number)).
proper_noun(Thing,Number) -->
word1(proper_noun(Thing,Number)).
pronoun(Person, Number, Case, Gender) -->
word1(pronoun(Person,Number,Case,Gender)).
verb(Verb,Number,Person,Tense) -->
word1(verb(Verb,Ending)),
{ verb_agrees(Ending, Number, Person, Tense) }.
226
:-
9.4.4 Parsing Examples
?- phrase(sentence(Meaning), [the,boy,carried,the,book]).
Meaning = action(carry,past,count(boy,definite,singular),
count(book,definite,singular)) ;
No
?- phrase(sentence(Meaning), [walk,the,dog]).
Meaning = action(walk,present,imperative,
count(dog,definite,singular)) ;
No
?- phrase(sentence(Meaning), [mary,walked]).
Meaning = action(walk, past, mary, none) ;
No
?- phrase(sentence(Meaning), [mary,walk]).
No
227
:-
9.4.5 Generation of Sentences
Carefully designed grammar can run backwards
generating text from meaning
?- phrase(sentence(action(carry, past,
count(boy,definite,singular),
count(book,definite,singular))), Sentence).
Sentence = [the, boy, carried, the, book] ;
No
?- phrase(sentence(action(walk, present,
pro(third,plural,masculine),
count(dog,definite,singular))), Sentence).
Sentence = [they, walk, the, dog] ;
No
?- phrase(sentence(action(walk, present,
count(dog,definite,singular),
pro(third,plural,masculine))), Sentence).
Sentence = [the, dog, walks, them] ;
No
228
:-
10 More on Terms
1. Handling Terms in General
2. Sorting
3. Term comparison
4. Variable and Type Testing
229
:-
10.1 Handling Terms in General
Sometimes it is useful to be able to write predicates that
will work on any kind of term
The =.. predicate, pronounced univ, turns a term into a
list
The rst element of the list is the terms functor; following
elements are the terms arguments, in order
?- p(1,q(3)) =.. X.
X = [p, 1, q(3)] ;
No
?- T =.. [p, 1, q(3)].
T = p(1, q(3)) ;
No
?- 1 =.. X.
X = [1] ;
No
?- [1,2,3] =.. X.
X = [., 1, [2, 3]] ;
No
230
:-
10.1.1 functor/3
Because univ builds a list that is typically not needed, it is
often better to use the separate builtin predicates
functor/3 and arg/3
functor(Term,Name,Arity) holds when the functor of Term is
Name and its arity is Arity
For atomic terms, the whole term is considered to be the
Name, and Arity is 0
Either the Term or both the Name and Arity must be bound,
otherwise functor throws an exception
231
:-
10.1.2 functor/3 in Action
?- functor(p(1,q(3)), F, A).
F = p
A = 2 ;
No
?- functor(T, p, 2).
T = p(_G280, _G281) ;
No
?- functor(1, F, A).
F = 1
A = 0 ;
No
?- functor(X, 42, 0).
X = 42 ;
No
232
:-
10.1.3 arg/3
arg/3 can be used to access the arguments of a term one
at a time
arg(N,Term,Arg) holds if Arg is the N
th
argument of Term
(counting from 1)
Term must be bound to a compound term
For most Prolog systems, N must be bound; SWI Prolog
will backtrack over all arguments of term
arg/3 is deterministic when rst two arguments are bound
233
:-
10.1.4 arg/3 in Action
?- arg(2, foo(a,b), Arg).
Arg = b ;
No
?- arg(N, foo(a,b), Arg).
N = 1
Arg = a ;
N = 2
Arg = b ;
No
?- arg(N, 3, 3).
ERROR: arg/3: Type error: compound expected, found 3
234
:-
10.1.5 Using functor and arg
Collect a list of all the functors appearing anywhere in a
ground term:
all_functors(Term, List) :- all_functors(Term, List, []).
all_functors(Term, List, List0) :-
functor(Term, Name, Arity),
( Arity > 0 ->
List = [Name|List1],
all_functors1(Arity, Term, List1, List0)
; List = List0
).
all_functors1(N, Term, List, List0) :-
( N =:= 0 ->
List = List0
; arg(N, Term, Arg),
all_functors(Arg, List1, List0),
N1 is N - 1,
all_functors1(N1, Term, List, List1)
).
235
:-
Using functor and arg (2)
?- all_functors(foo(bar([1,2],zip,baz(3)),bar(7)), L).
L = [foo, bar, ., ., baz, bar] ;
No
?- X=bar(42), all_functors(foo(X), L).
X = bar(42)
L = [foo, bar] ;
No
?- all_functors(foo(X), L), X=bar(42).
ERROR: Arguments are not sufficiently instantiated
Exception: (11) functor(_G342, _G448, _G449) ? creep
Since Name and Arity are not bound when functor/3 is
called, that goal causes an error if Term is not bound.
236
:-
10.2 Sorting
Our all_functors/2 predicate returns a list of functors
appearing, once for each time they appear
May want to produce a set, with each functor appearing
only once
Easiest way: produce the list and sort it, removing
duplicates
Built-in sort(List,Sorted) predicate holds when Sorted is a
sorted version of List, with duplicates removed
all_functors(Term, List) :-
all_functors(Term, List0, []),
sort(List0, List).
237
:-
10.2.1 keysort/2
keysort(List, Sorted) is like sort, except:
elements of List must be terms of the form Key-Value
only the Key parts of the terms are considered when
sorting
duplicates are not removed, keysort is a stable sort
?- sort([a,a,r,d,v,a,r,k], L).
L = [a, d, k, r, v] ;
No
?- keysort([a,a,r,d,v,a,r,k], L).
No
?- keysort([a-1,a-2,r-3,d-4,v-5,a-6,r-7,k-8], L).
L = [a-1, a-2, a-6, d-4, k-8, r-3, r-7, v-5] ;
No
238
:-
10.3 Term Comparison
The sorting predicates work on lists of any kinds of terms
Built on general term comparison predicates
The predicates @<, @=<, @>, @>=, == \== work like <, =<, >, >=,
=:= =\=, but they work on any terms
Atoms are compared lexicographically, numbers numerically
Compound terms are compared rst by arity, then by
functor, then by the arguments in order
Variables @< numbers @< atoms @< compound terms
Beware variables in terms being sorted!
== and \== check whether terms are identical without
binding any variables
239
:-
Exercise
Why should you beware variables in terms being sorted?
What could happen if you sort a non-ground list?
240
:-
10.4 Variable and Type Testing
Earlier we saw that the simple denition of rev used in the
backwards mode goes into an innite loop after nding
the correct answer
rev([], []).
rev([A|BC], R) :-
rev(BC, CB),
append(CB, [A], R).
Recursive call to rev produces longer and longer reversed
lists; once it has found the right length, no other length
will be correct
241
:-
10.4.1 Variable Testing Example
Can x this by exchanging the calls in the clause body
rev([], []).
rev([A|BC], R) :-
append(CB, [A], R),
rev(BC, CB).
In this order, when R is bound, the call to append/3 has
only one solution, so it solves the problem
But now rev/2 gets in trouble in the forwards mode
Once it nds the solution, asking for more solutions enters
an innite loop
242
:-
10.4.2 Variable Testing
To implement a reversible version of rev/2, we need to
decide which order to execute the goals based on which
arguments are bound.
Prolog has a built in predicate var/1 which succeeds if its
argument is an unbound variable, and fails if not.
?- var(_).
Yes
?- var(a).
No
243
:-
Exercise
Use the var builtin to implement a version of rev that will
work in any mode. Recall that only this version of rev:
rev([], []).
rev([A[BC], R) :- rev(BC, CB), append(CB, [A], R).
works when the second argument is unbound; otherwise
the goals in the body should be swapped
244
:-
10.4.3 Whats Wrong With var/1?
One of the most basic rules of logic is that conjunction is
commutative
p, q should behave exactly the same way as q, p (if they
terminate without error).
var/1 breaks that rule:
?- var(X), X = a.
X = a ;
No
?- X = a, var(X).
No
245
:-
10.4.4 When to use var/1
Irony: sometimes we can only write logical, reversible
predicates by using an extralogical predicate such as var/1
But we must be careful
For rev/2, the code is logically equivalent whether the
var/1 goal succeeds or fails; the only dierence is the order
of the goals
Sometimes we must have other dierence, such as having
X is Y + 1,
when Y is bound, and
Y is X - 1,
when X is.
A better answer for this is constraint programming
X = Y + 1
246
:-
10.4.5 Other Non-logical Builtins
All of the following have the same problem of potentially
making conjunction not commutative
nonvar(X) X is bound.
ground(X) X is bound, and every variable in the term it is
bound to is also ground.
atom(X) X is bound to an atom.
integer(X) X is bound to an integer.
float(X) X is bound to a oat.
number(X) X is bound to a number.
atomic(X) atom(X) ; number(X).
compound(X) X is bound to a compound term.
247
:-
10.4.6 Dening length/2
We can dene length/2 to work when the list is supplied:
len1([], 0).
len1([_|L], N) :-
len1(L, N1),
N is N1 + 1.
and when the length is supplied:
len2([], 0).
len2([_|L], N) :-
N > 0,
N1 is N - 1,
len2(L, N1).
248
:-
Dening length/2 (2)
A version that works in both modes:
len(L,N) :-
( var(N) ->
len1(L,N)
; len2(L,N)
).
NB: dont check if L is var: even if its not, its tail may be!
249
:-
Dening length/2 (3)
?- len(L, 4).
L = [_G242, _G248, _G254, _G260] ;
No
?- len([a,b,c], N).
N = 3 ;
No
?- len(L, N).
L = []
N = 0 ;
L = [_G257]
N = 1 ;
L = [_G257, _G260]
N = 2
Yes
250
251
252
:-
11 Metaprogramming
Prolog has powerful facilities for manipulating and
generating Prolog programs
1. Higher order programming
2. Interpreters
3. Prolog Interpreter
4. Generating Prolog code
253
:-
11.1 Higher order programming
One powerful feature of functional languages is
higher order programming: passing functions or
predicates as arguments
Prolog supports this, too
The built-in predicate call/1 takes a term as argument
and executes it as a goal
?- Goal = append([a,b,c],X,[a,b,c,d,e]),
| call(Goal).
Goal = append([a, b, c], [d, e], [a, b, c, d, e])
X = [d, e] ;
No
We can use any code we like to build goal term
254
:-
11.1.1 call/n
Some Prolog systems, including SWI, also support call of
higher arities
First argument is goal to execute
Extra arguments are given as arguments to the goal
?- Goal = append,
| call(Goal, [a,b,c], X, [a,b,c,d,e]).
Goal = append
X = [d, e] ;
No
Saves the eort of constructing the goal as a term before
calling it
255
:-
11.1.2 Closures
When the goal argument of call/n is a compound term,
later arguments of call are added to the goal
?- Goal = append([a,b,c]),
| call(Goal, X, [a,b,c,d,e]).
Goal = append([a, b, c])
X = [d, e] ;
No
The Goal in this case is a predicate with some, but not all,
of its arguments supplied; other arguments are given when
it is called
This is a closure
256
:-
11.1.3 map/3
Using call/n it is easy to implement the standard higher
order operations of functional languages, e.g.
map(_, [], []).
map(P, [X|Xs], [Y|Ys]) :-
call(P, X, Y),
map(P, Xs, Ys).
?- map(append([a,b]), [[c,d],[e,f,g],[h]], L).
L = [[a, b, c, d], [a, b, e, f, g], [a, b, h]] ;
No
?- map(append([a,b]), L,
[[a,b,c,d],[a,b,c],[a,b,w,x,y],[a,b]]).
L = [[c, d], [c], [w, x, y], []] ;
No
257
:-
Exercise: all/2
Write a predicate all/2 such that all(Pred,L) holds when
every element of L satises Pred. For example,
all(member(c), [[a,b,c],[a,e,i],[a,c]]]
fails, and
all(member(X), [[a,b,c],[a,e,i],[a,c]])
succeeds with X=a.
258
:-
11.2 Interpreters
Some programming problems are best solved by
dening a new minilanguage, a small language
targeted at one specic task
Consider the control of a robot vacuum cleaner
Programming this would be rather complex, involving
separate control of several motors, receiving input from
several sensors, etc.
This task would be far simpler to handle if we dened a
minilanguage for robot control, and then implemented an
interpreter for this language
259
:-
11.2.1 Robot Minilanguage
At the simplest level, we can consider primitive commands
to turn and move forward
These could be represented as Prolog terms:
advance(Distance)
left
right
260
:-
11.2.2 Interpreter Design
An interpreter (simulator) for this language would track
the robots position
Also needs to keep track of the robots heading,
represented as X and Y components, called H
x
and H
y
H
x
= 0
H
y
= 1
H
x
= 1
H
y
= 0
H
x
= 0
H
y
= 1
H
x
= 1
H
y
= 0
H
x
and H
y
are either -1, 0, or 1, and [H
x
[ +[H
y
[ = 1
On moving d units, x = dH
x
and y = dH
y
To turn clockwise (right): H

x
= H
y
, H

y
= H
x
,
anticlockwise (left): H

x
= H
y
, H

y
= H
x
261
:-
11.2.3 Interpreter
% sim(Cmd, X0, Y0, Hx0, Hy0, X, Y, Hx, Hy)
% Robot starts at position X0, Y0, with
% Heading Hx0, Hy0. After command Cmd,
% robot is at position X, Y, with heading
% Hx, Hy
sim(advance(Dist), X0, Y0, Hx, Hy, X, Y, Hx, Hy) :-
X is X0 + Hx * Dist,
Y is Y0 + Hy * Dist.
sim(right, X, Y, Hx0, Hy0, X, Y, Hx, Hy) :-
Hx = Hy0,
Hy is -Hx0.
sim(left, X, Y, Hx0, Hy0, X, Y, Hx, Hy) :-
Hx is -Hy0,
Hy = Hx0.
262
:-
11.2.4 Robot Programs
Construct a robot program as a list of commands:
sim([], X, Y, Hx, Hy, X, Y, Hx, Hy).
sim([C|Cs], X0, Y0, Hx0, Hy0, X, Y, Hx, Hy) :-
sim(C, X0, Y0, Hx0, Hy0, X1, Y1, Hx1, Hy1),
sim(Cs, X1, Y1, Hx1, Hy1, X, Y, Hx, Hy).
263
:-
11.2.5 Walls
The interpreter is simple, so it is easy to extend
Add walls to the room the robot operates in by preventing
X and Y from being less than 0 or more than room width
or height
Just need to replace one sim/9 clause and dene room
width and height
sim(advance(Dist), X0, Y0, Hx, Hy, X, Y, Hx, Hy) :-
room_width(Width),
room_height(Height),
X is max(0, min(Width, X0 + Hx * Dist)),
Y is max(0, min(Height, Y0 + Hy * Dist)).
room_width(400).
room_height(300).
264
:-
11.2.6 Other Possible Extensions
Keep track of minimum and maximum x and y
positions visited, by adding 8 more arguments for
previous and new min and max x and y
Allow robot to turn at angles other than 90

, by
adding a turn(Angle) command that uses trigonometry
to determine new real number H
x
and H
y
Add obstacles to room by dening predicate obstacle
that supplies shapes and positions of each obstacle,
and having advance command nd position of rst
obstacle encountered
265
:-
11.3 Prolog meta-interpreter
We can write an interpreter for any language we can
conceive, including Prolog itself
This is made much easier by the fact that Prolog goals are
ordinary Prolog terms
An interpreter for a language written in the language
itself is called a meta-interpreter
Prolog systems have a built-in interpreter invoked by the
call built-in predicates
Need access to the clauses of the program to be
interpreted; built-in predicate clause(Head,Body) gives this
Body is true for unit clauses
Generally you need to declare predicates dynamic:
:- dynamic foo/3.
266
:-
11.3.1 Simple meta-interpreter
% solve(Goal)
% interpret Goal, binding variables
% as needed.
solve(true).
solve((G1,G2)) :-
solve(G1),
solve(G2).
solve(Goal) :-
clause(Goal, Body),
solve(Body).
267
:-
Simple meta-interpreter (2)
Extend this to handle disjunction, if->then;else, negation:
solve((G1;G2)) :-
( G1 = (G1a->G1b) ->
( solve(G1a) ->
solve(G1b)
; solve(G2)
)
; solve(G1)
; solve(G2)
).
solve(\+(G)) :-
\+ solve(G).
268
:-
Simple meta-interpreter (3)
To handle Prolog builtins, modify the last clause on
slide 267:
solve(Goal) :-
( builtin(Goal) ->
call(Goal)
; clause(Goal, Body),
solve(Body)
).
builtin(_ = _).
builtin(_ is _).
builtin(append(_,_,_)).
.
.
.
269
:-
11.3.2 Extensions
Can modify interpreter to construct a proof
proof(Goal, Proof) :- proof1(Goal, Proof, []).
proof1(true, Proof, Proof).
proof1((G1,G2), Proof, Proof0) :-
proof1(G1, Proof, Proof1),
proof1(G2, Proof1, Proof0).
proof1(Goal, Proof, Proof0) :-
clause(Goal, Body),
proof1(Body, Proof,
[(Goal:-Body)|Proof0]).
.
.
.
Lots of other extensions, e.g. debuggers, other search
strategies
270
:-
11.4 Manipulating Prolog code
The fact that Prolog code is just a Prolog term also makes
it very easy to manipulate
To take advantage of this, the Prolog compiler
automatically calls a predicate term_expansion/2 (if it is
dened) for each term it reads
First argument of term_expansion/2 is a term Prolog read
from a source le; term_expansion/2 should bind the second
to a clause or list of clauses to use in place of what was
read
This is the same mechanism used to convert DCG clauses
into ordinary Prolog clauses
This feature allows programmers to easily write Prolog
code to generate or transform Prolog code
271
:-
11.4.1 Generating Accessor Predicates
Example: automatically generating accessor predicates
Suppose a student is represented as student(Name,Id) in a
large program
Everywhere the name is needed, the code might contain
Student = student(Name,_)
If we later need to also store degree code in student terms,
we must modify every student/2 term in the program
Programmers sometimes dene accessor predicates, e.g.:
student_name(student(Name, _), Name).
student_id(student(_, Id), Id).
then use student_name(Student, Name) instead of
Student = student(Name,_)
272
:-
Generating Accessor Predicates (2)
Using term_expansion, it is easy to write code to
automatically generate accessor predicates
We will transform a directive like
:- struct student(name,id).
into the clauses on the previous slide
:- op(1150, fx, (struct)).
term_expansion((:- struct Term), Clauses) :-
functor(Term, Name, Arity),
functor(Template, Name, Arity),
gen_clauses(Arity, Name, Term, Template, Clauses).
First line tells Prolog that struct is a prex operator
273
:-
Generating Accessor Predicates (3)
gen_clauses(N, Name, Term, Template, Clauses) :-
( N =:= 0 ->
Clauses = []
; arg(N, Term, Argname),
arg(N, Template, Arg),
atom_codes(Argname, Argcodes),
atom_codes(Name, Namecodes),
append(Namecodes, [0_|Argcodes], Codes),
atom_codes(Pred, Codes),
Clause =.. [Pred, Template, Arg],
Clauses = [Clause|Clauses1],
N1 is N - 1,
gen_clauses(N1, Name, Term, Template, Clauses1)
).
274
275
276
Q
12 Propositional Logic
introduce basic ideas of formal logic
dene truth tables for propositions
use of truth tables to establish tautologies,
equivalences
277
Q
Exercise: Knights and Knaves
On the island of Knights and Knaves, everyone is a knight
or knave. Knights always tell the truth. Knaves always lie.
You are a census taker, going from house to house. Fill in
what you know about each house.
house 1 Husband: We are both knaves.
house 2 Wife: At least one of us is a knave.
house 3 Husband: If I am a knight then so is my wife.
House 1 House 2 House 3
Husband Wife Husband Wife Husband Wife
278
Q
12.1 Logic and Reasoning
Logic is about reasoning
All humans have 2 legs
Jane is a human
Therefore Jane has 2 legs
key issue for (any) logic
FORM of an argument versus its MEANING
All dogs have 6 legs
Rex is a dog
Therefore Rex has 6 legs
279
Q
12.1.1 Arguments: Form and Meaning
form is determined by the syntax of the logic.
Both arguments above have correct form, HENCE
both arguments are (logically) correct.
truth depends on meaning relation to the world.
The rst argument has a true conclusion: its premises
are true and the argument is correct.
The second argument has a false conclusion: even
though the argument is correct, its premises are not
true.
280
Q
12.1.2 Propositions

A proposition is a sentence that is either true or

false, but not both
.
use letters to represent basic propositions
e.g. A for I look into the sky, B for I am alert
logical connectives: (not), (and), (or),
(implies), (i)
e.g. A B for I look into the sky and I am alert
rules for forming propositions
(a) a propositional variable is a proposition
(b) if A and B are propositions then so are
(A), (A B), (A B), (A B), (A B)
(c) nothing else is a proposition
281
Q
12.1.3 Improving Readability
Which is more readable?
(P (Q (R)) or P (Q R)
Rules for improving readability:
omit parentheses where possible
precedence from highest to lowest is: , , , ,
all binary operators are left associative.
That is,
P Q R
is an abbreviation for
(P Q) R
Questions:
Is (P Q) R P (Q R)? Is (P Q) R P (Q R)?
Is (P Q) R P (Q R)?
282
Q
12.2 Truth Tables
propositions can be true (T) or false (F)
A truth table for a proposition records its truth value
for all assignments of T or F to its propositional
variables. (see Kelly Section 1.2) e.g.
A B A B A B A
T T T T F
T F F T F
F T F T T
F F F F T
value of (compound) propositions built up from
components
i.e. A and B can be any (compound) proposition
283
Q
12.2.1 Terminology
A proposition is a tautology if it is always true, i.e.
each line in the truth table is T. For example
A B A.
A proposition is satisable if it is sometimes true,
i.e. some line in the truth table is T. For example,
A B.
A proposition is unsatisable if it is always false, i.e.
each line in the truth table is F. For example,
A B A.
Two propositions are equivalent if each line in their
truth tables are the same. For example A is
equivalent to A (A A).
284
Q
12.2.2 Previous Example
Does (A B) C = A (B C)?
A B C A B B C A (B C) (A B) C
T T T T T T T
T T F T F F F
T F T F F F F
T F F F F F F
F T T F T F F
F T F F F F F
F F T F F F F
F F F F F F F
Truth table columns for both propositions are identical:
propositions are equivalent
285
Q
12.3 Implication
Truth Table For Implication:
A B A B
T T T
T F F
F T T
F F T
Terminology:

antecedent: whats to the left of the

consequent: whats to the right of the
Implication is true unless antecedent is true and
consequent is false
286
Q
Exercise
Are (A B) and A B are equivalent?
287
Q
12.3.1 Material Implication
The only time A B evaluates to false is when A is
true and B is false.
This denition is standard in propositional logic and is
termed material implication.
English usage often suggests a causal connection
between antecedent and consequent; this is not
reected in the truth table for material implication
(P P) (Q R) is a tautology and worse still,
(P P) |anything is a tautology.
Other logics (e.g. modal logics, relevance logics)
involve alternative meanings for implication
288
Q
12.3.2 Example (Kelly Example 1.2)
Express in propositional logic:
If I look into the sky and I am alert then either I will
see the ying saucer or if I am not alert then I will not
see the ying saucer.
A I look into the sky
B I am alert
C I will see the ying saucer
(A B) (C (B C))
does the truth of this compound proposition depend
on the individual truth values of A, B, C?
That is, is (A B) (C (B C)) a tautology?
289
Q
Example (Kelly Example 1.2) (2)
Truth Table (Kelly Fig. 1.13)
A B C A B B C B C C (A B) (C
(B C) (B C)
T T T T F F T T T
T T F T F T T T T
T F T F T F F T T
T F F F T T T T T
F T T F F F T T T
F T F F F T T T T
F F T F T F F T T
F F F F T T T T T
290
Q
Example (Kelly Example 1.2) (3)
The truth table contains much unnecessary
information.
How can we reduce our work?
Remember that X Y is false i X is true and Y is
false and A B is false unless A is true and B is true.
So we only need to look at the last two lines of the
truth table (the nal expression in the other six is
always true).
Thus:
A B C A B B C B C C (A B) (C
(B C) (B C))
T T T T F F T T T
T T F T F T T T T
is the simplied truth table for this example.
291
Q
Exercise
Express in propositional logic:
If Michelle wins at the Olympics, everyone will admire her,
and she will get rich; but if she does not win, all her eort
was in vain. Begin by determining the the propositional
variables you will use and what they mean.
292
Q
12.3.3 Knights and Knaves
Express in propositional logic the census taker puzzle, for
house 1.
H : the husband is a knight.
W : the wife is a knight.
H (H W)
H W H W H (H W)
T T F F
T F F F
F T F T
F F T F
Exercise: do the same for houses 2 and 3.
293
Q
12.4 Equivalences (Kelly Section 1.3)
lots of them . . . innitely many!
especially important:
A is equivalent to A
A B is equivalent to A B
(A B) is equivalent to (A B)
(A B) is equivalent to (A B)
The nal two equivalences are De Morgans laws
Exercise: Use truth tables to verify the correctness of
the above four equivalences.
294
Q
12.4.1 More Important Equivalences
Commutativity B A A B
A B B A
Associativity A (B C) (A B) C
A (B C) (A B) C
Distributivity A (B C) (A B) (A C)
A (B C) (A B) (A C)
Absorption A (A B) A
A (A B) A
A (A B) A B
A (A B) A B
See Kelly page 12 for further equivalences
proofs via truth tables (or other equivalences)
295
Q
12.4.2 The Many Faces of Implication
if P then Q
P implies Q
P Q
P only if Q
Q if P
Q is a necessary condition for P
P is sucient for Q
Q P (called the contrapositive of P Q)
P Q
Exercise: Verify the equivalence of P Q and Q P.
296
Q
12.4.3 If and Only If
A if and only if B means A if B and A only if B,
that is, (B A) (A B)
A if and only if B is commonly abbreviated A i B
and written A B
Truth table for :
A B A B B A A B
T T T T T
T F F T F
F T T F F
F F T T T
A B is true exactly when A and B have the same truth
value
297
Q
12.5 How Many Connectives?
(Kelly Section 1.4)
started with:
we can express everything in terms of , so |, is
called a complete set of connectives.
|, is also a complete set of connectives.
exercise: prove this.
Why do we care about how many connectives we
need?
298
Q
12.5.1 NAND
|[ also complete where [ (nand) has truth table
A B A[B
T T F
T F T
F T T
F F T
A can be expressed as A[A
A B can be expressed as (A[B)[(A[B)
How can we express A B?
(Hint: By De Morgans laws A B = . . .)
Exercise: Is |, a complete set of connectives?
Exercise: Give the truth table for the only other
complete connective.
299
Q
12.6 Summary
logic is based on the assumption that reasoning is
based on argument FORM
a valid argument gives a true conclusion if its premises
are (all) true
truth tables dene truth of compound propositions in
terms of components
A is a tautology if all rows of the truth table for A are
TRUE
A and B are equivalent if all rows of the truth table for
A and B are the same
300
Q
13 Arguments
history of logic and logic programming
use of propositional logic to formalize arguments
notions of validity, satisability, consistency
use of these concepts to establish (logical) correctness
of arguments
301
Q
13.1 History
Goal: to systematize reasoning
Propositional logic: George Boole, 1847
Good for basic understanding of
reasoning, but
No ability to reason about properties
of individuals
302
Q
13.2 Terminology

An assignment gives a truth value to each

propositional variable in a formula

A model of a formula is any assignment for which

the formula is true

A proposition is satisable if it is true under some

assignment, i.e. if it has a model
e.g. P Q is satisable because . . .

A proposition is valid if it is true under all possible

assignments (i.e., all assignments are models; it is a
tautology)
e.g. P Q is not valid because . . .
303
Q
Terminology (2)

A set of propositions is consistent if they can be

true simultaneously; i.e. the conjunction of the
propositions is satisable
e.g. |P Q, P Q is consistent because . . .
e.g. |P Q, P Q, P is inconsistent because . . .

A proposition A is a logical consequence of a set S

of propositions if whenever all propositions in S are
true, A is true.
alternative terminology: S semantically entails A
Denoted: S[=A
e.g., P Q [= P
304
Q
Terminology (3)
An argument is valid if its conclusion is semantically
entailed by its premises.
e.g.
P Q P Q
P Q
Q P
is valid is invalid
Thus an argument is valid if premises |conclusion is
inconsistent.
305
Q
13.2.1 Example (Kelly Example 1.4)
S
1
: If the violinist plays the concerto, then crowds will come
if the prices are not too high.
S
2
: If the violinist plays the concerto, the prices will not be
too high.
C: If the violinist plays the concerto, crowds will come.
Is the argument S
1
, S
2
, therefore C valid?
i.e. S
1
, S
2
[= C?
i.e. is |S
1
, S
2
, C inconsistent?
i.e. is S
1
S
2
C unsatisable?
S
1
is P (H A)
S
2
is P H
C is P A
so you can check the truth table of
(P (H A)) (P H) (P A)
306
Q
Example (Kelly Example 1.4) (2)
P A H H A P P H P A (P A) mess
(H A)
T T T T T F T F F
T T F T T T T F F
T F T T T F F T F
T F F F F T F T F
F T T T T T T F F
F T F T T T T F F
F F T T T T T F F
F F F F T T T F F
Note that the mess:
(P (H A)) (P H) (P A) always evaluates to
FALSE. Therefore the argument is valid.
307
Q
13.2.2 Another Example
H
1
: If she studies the sciences then she prepares to earn a
good living.
H
2
: If she studies the humanities, then she prepares for a
good life.
H
3
: If she prepares for a good living or for a good life then
the years are well spent.
H
4
: The years were not well spent.
C: She didnt study science or humanities.
Is the argument H
1
, H
2
, H
3
, H
4
, therefore C valid?
H
1
is S G, H
2
is H L, H
3
is G L W,
H
4
is W, C is (S H)
Check the 2
5
= 32 rows of the truth table
(S G) (H L) (G L W) (W) (S H)
308
Q
13.3 A Better Way
Often we can check validity more easily than lling out
a truth table
What are necessary conditions for
(S G) (H L) (G L W) (W) (S H)
to evaluate to true (and our argument to be invalid)?
Each conjunct must be true. In particular, W must
be true (pick simplest propositions rst)
So W must be false
But G L W must be true, so G L must be false
So G and L must both be false
But S G and H L must both be true, so S and H
need to be false
309
Q
A Better Way (2)
But S H must be true: contradiction!
So the original argument was valid
Simple technique can help with the bookkeeping: write out
the formula and write T or F under each variable and
conective as you determine them; propagate variable values
(S G) (H L) (G L W) ( W) (S H)
F T F T F T F T F F T F T T F T F X F
310
Q
Exercise
Determine whether or not the following formula is
unsatisable. If not, nd values for the variables that make
it satisable.
(p (h c)) (p h) (p c)
311
Q
13.4 Example
WHY WORRY?? There are only two things to worry
about, either youre healthy or youre sick. If youre
healthy there is nothing to worry about and if youre sick,
there are two things to worry about . . . either youll get
well or you wont. If you get well there is nothing to worry
about, but if you dont, youll have two things to worry
about . . . either youll go to heaven or to hell. If you go to
heaven you have nothing to worry about and if you go to
hell youll be so busy shaking hands with all of us youll
have no time to worry.
CONCLUSION: Either youll have nothing to worry about
or youll have no time to worry.
H: you are healthy, S you are sick, W you have something
to worry about, A you will get well, B you wont get well,
C you will go to heaven, D you will go to hell, T you will
have time to worry.
312
Q
13.4.1 Translation to Logic
1. H S healthy or sick
2. H W if healthy then no worries
3. S (A B) if sick then either will get
well or wont
4. A W if get well then no worries
5. B (C D) if wont get well then will
either go to heaven or hell
6. C W if heaven then no worries
7. D T if hell the no time to worry
8. W T therefore, no need to worry
or no time to worry
313
Q
13.4.2 Checking Validity
Begin by negating conclusion and simplifying:
(W T) negation of conclusion
W T De Morgan
W T double negation
So W and T must both be true
Then premise 7 says D T, but since T is true, then D
must be false (check with a truth table)
Similarly, premise 6 says C W, so C must be false,
premise 4 says A W so A, and premise 2 says
H W, so H
314
Q
Checking Validity (2)
Now we know W T D C A H
Premise 5 is B (C D), but we know C D, so we
conclude B
Premise 3 is S (AB), but now we know AB, so S
Premise 1 is H S, but we now know H and S
contradiction!
Conclusion: either some of our premises were false or our
conclusion was true
Argument was valid
315
Q
13.4.3 Caution!
Why have A mean will get well and B mean wont get well?
Why not use A for wont get well?
Answer: will get well and wont get well are not the
only two possibilities could also not be sick
Hint: if youre sick, . . . either youll get well or you wont.
Translation would be S (A A) tautology
Tautologies say nothing new; useless as premise
Could have used H for sick, because sick and healthy are
the only choices
316
Q
13.5 Argument Validity in Prolog
Validity can easily be tested in Prolog
valid(Premise, Conclusion) :- % Argument is valid if
valid(Premise->Conclusion). % premise implies conclusion
valid(Prop) :- % Prop is valid if
unsatisfiable(\+Prop). % negation is unsatisfiable
unsatisfiable(Prop) :- % Prop is unsatisfiable
\+ true(Prop). % if it cant be made true
317
Q
Argument Validity in Prolog (2)
true(v(true)).
true(\+ Prop) :-
false(Prop).
true((X;Y)) :-
( true(X)
; true(Y)
).
true((X,Y)) :-
true(X),
true(Y).
true((X->Y)) :-
( false(X)
; true(Y)
).
true((X<->Y)) :-
( true(X),
true(Y)
; false(X),
false(Y)
).
false(v(false)).
false(\+ Prop) :-
true(Prop).
false((X;Y)) :-
false(X),
false(Y).
false((X,Y)) :-
( false(X)
; false(Y)
).
false((X->Y)) :-
true(X),
false(Y).
false((X<->Y)) :-
( true(X),
false(Y)
; false(X),
true(Y)
).
318
Q
Argument Validity in Prolog (3)
Represent a propositional variable as v(t), where t is either
true or false.
?- valid(((v(P)->v(Q)),(v(Q)->v(R))), v(P)->v(R)).
P = _G157
Q = _G159
R = _G166
Yes
?- valid((v(P)->v(Q))->v(R), v(P)->v(R)).
No
Why is last answer No?
319
Q
Argument Validity in Prolog (4)
Can use false/1 predicate directly to see why
?- false(((v(P)->v(Q))->v(R))-> (v(P)->v(R))).
P = true
Q = false
R = false ;
No
(T F) F is true, yet T F is false
Note: extra parentheses are used in the Prolog goals since
the builtin precedence and associativity of -> diers from
.
320
Q
13.6 Summary: Argument Correctness
general strategy for determining if an argument of the
form
S
1
, S
2
, , S
n
[= C
is valid
investigate the unsatisability of
S
1
S
2
S
n
C
using a truth table, or trying for a contradiction when
C is true.
If this formula is unsatisable, the argument is valid.
If this formula is satisable, the argument is invalid.
321
Q
Summary: Argument Correctness (2)
Non truth-table strategies for determining validity
Motivation: the truth table for a proposition with n
propositional variables has 2
n
rows exponential
growth. (Recall the last example)
Seek a strategy which at least for some situations does
better (though worst case performance still
exponential)
seek to exploit relevant parts of the formula you
are working with, e.g. the previous strategy for the
college example.
322
323
324
Q
14 Axiom Systems for
Propositional Logic
notions of axiomatic system, deduction
particular axiom system for propositional logic
use of this system to establish tautologies,
equivalences, consistency, argument validity
325
Q
Basic Idea (Kelly Ch 4)
so far . . .
truth tables used to dene
tautologies, (in)consistency, validity, . . .
model theory approach
gives the semantics of propositional logic
semantics = considerations involving truth
(meaning)
now . . .
a proof theory approach
axioms, inference rules, proofs, theorems, . . .
later connections between the semantic and proof
theory approaches
326
Q
14.1 Axiomatic Systems (Kelly 4.2)
Proof:
set of initial hypotheses
each step generates a new consequence of the
hypotheses
until the desired proposition is reached.
In Propositional Logic

start with axioms (simple tautological propositions)

each step uses a rule of inference
(Axioms Prolog program; conclusion query.)
Innitely many possible axiom systems; we use AL
327
Q
14.1.1 Syntactic Description
Axiomatic system has 4 parts:
alphabet of symbols; we use , , (, ), P, Q, R, . . .
WF the well formed formulae (w)
Ax the set of axioms, a subset of WF
R the set of rules of deduction
Well Formed Formulae (w):
Any propositional letter (e.g., P, Q, R) is a w
If W and V are w then W V and W are w
Nothing else is a w
Usually want to assume innite number of propositional
letters; assume we can subscript them
328
Q
14.1.2 Axioms
There are innitely many axioms, but all have one of these
forms:
Axiom schemas allow any w for A, B, and C
Ax1 A (B A)
Ax2 (A (B C)) ((A B) (A C))
Ax3 (A B) (B A)
Examples:
P (Q P) is an instance of Ax1.
((D E) S) (S (D E)) is an instance of
Ax3.
329
Q
14.1.3 Inference Rule
One rule of deduction, or inference rule:
modus ponens from A and A B infer B
Given a set of hypotheses H, where H WF, a deduction
is a sequence of w F
1
, F
2
, . . . , F
n
where each F
i
is either:
An axiom (F
i
Ax); or
A hypothesis (F
i
H); or
Follows from earlier steps by a (the) rule of inference
330
Q
Inference Rule (2)
We say a deduction ending in F
n
is a deduction of F
n
from
H or that F
n
is a deductive consequence of H, and write
H F
n
When H = , we write
F
n
and say F
n
is a theorem
331
Q
14.1.4 Trivial Examples
A boring example with a very short proof
P (Q P) Ax1
Another boring example
((D E) S) (S (D E)) Ax3
332
Q
14.1.5 Short Proof (Kelly Theorem 4.1)
A A
1. A ((B A) A) Ax1
2. (A ((B A) A)) ((A (B A)) (A A)) Ax2
3. (A (B A)) (A A) MP 1, 2
4. A (B A) Ax1
5. A A MP 3, 4
Exercise: Prove the following Simplication
MetaTheorems:
(A B) A
(A B) B
Here A B is dened as (A B).
333
Q
14.2 Meta-theorems
We have proved A A, but what about P P?
We havent proved it, but we could: duplicate proof,
replacing A with P
Works because for every axiom with A, theres one with P
Modus ponens works for P as well as for A
Take our theorem as a meta-theorem a theorem
template
As a shortcut, we could use A A as if it were an axiom
schema, because we could always replace it by its proof
Like using subroutines when programming
334
Q
14.2.1 Using A A
Prove B (A A)
1. A A Theorem 4.1
2. (A A) (B (A A)) Ax1
3. B (A A) MP 1, 2
Could replace Theorem 4.1 line with proof of Theorem 4.1:
1. A ((B A) A) Ax1
2. (A ((B A) A)) ((A (B A)) (A A)) Ax2
3. (A (B A)) (A A) MP 1, 2
4. A (B A) Ax1
5. A A MP 3, 4
6. (A A) (B (A A)) Ax1
7. B (A A) MP 5, 6
335
Q
Exercise: Transitive Implication
Fill in the blanks in the following proof of
|A B, B C A C
1. B C
2. (B C) (A (B C))
3. MP 1, 2
4. (A (B C)) ((A B) (A C))
5. (A B) (A C)
6. A B Hypothesis
7. MP 5, 6
This proves implication is transitive; call it TI
336
Q
14.2.2 Using TI
Can use meta-theorems with hypotheses as rules of
inference
First prove instances of hypotheses, then use
meta-theorem to conclude instance of conclusion
Prove A (A B)
1. A (B A) Ax1
2. (B A) (A B) Ax3
3. A (A B) TI 1, 2
Could turn into proper proof by replacing step 3 with proof
of TI, with A substituted for A, (B A) for B and
(A B) for C, and lines 1 and 2 for the hypothesis lines
But this proof is much easier!
337
Q
14.2.3 More Meta-theorems
Kelly proves other useful Meta-theorems
Deduction meta-theorem:
If H |A B then H A B
Proof is more complex (by induction)
338
Q
More Meta-theorems (2)
Use deduction meta-theorem to prove
|A (B C) B (A C):
1. A (B C) Hypothesis
2. A Hypothesis (for sake of proof
3. B C MP 1, 2
4. B Hypothesis (for sake of proof
5. C MP 3, 4
So, |A (B C), A, B C
then |A (B C), B A C Deduction theorem
then |A (B C) B (A C) Deduction theorem
339
Q
14.3 Finding axiomatic proofs
no rm search strategy
proofs generally hard to nd
usually a mixture of seeing what you can do with
the hypotheses you have, and seeing what might
lead to the desired conclusion.
340
Q
14.4 Truth and Deduction (Kelly 4.5)
What is the relationship between truth ([=, see Kelly
chapter 1) and deduction (, see Kelly chapter 4)?
What makes an axiom system useful?
1.
Consistency: if A then , A
Is it impossible to prove a w and its negation?
2.
Soundness: A implies [= A
Is it impossible to prove a w that is not a tautology?
3.
Completeness: [= A implies A
Can everything that is a tautology be proved?
4.
Decidability:
Is there an algorithm to always decide if A?
341
Q
Truth and Deduction (Kelly 4.5) (2)
The AL system of Kelly chapter 4 has all these properties
1. Consistency: follows from soundness (below), and
that [= is consistent
2. Soundness: proof by induction; axioms are tautologies,
and modus ponens only yields tautologies from
tautologies
3. Completeness: complex proof, see Kelly pp. 8790
4. Decidability: AL is complete, so it is enough to decide
if [= A, which can be decided by truth table
342
Q
14.5 Summary
proof system based on axioms and inference rules
denes a computational procedure for verifying
deductions . . . though not necessarily practical for
generating deductions
correctness of proof system with respect to semantics
is guaranteed by soundness, completeness
343
344
345
346
347
348
Q
15 Resolution
Kelly chapter 5
an alternative computational mechanism for
establishing theoremsactually a way of establishing
unsatisability
better suited to computer implementation than
axiomatic methodsthe basis of the Prolog system!
generalises usefully to predicate logic (see later)
to apply the method, w must be in a special form,
clausal form
349
Q
Terminology

A literal is a basic proposition or the negation of a

basic proposition.

conjunctive normal form (CNF)

e.g. (A B) (B C) A
conjunction of disjunctions of literals

disjunctive normal form (DNF)

e.g. (P Q) (Q R) P
disjunction of conjunctions of literals
Theorem: Every Propositional Logic formula can be
expressed in CNF and in DNF.
350
Q
15.1 Converting to CNF or DNF
1. Eliminate using A B equivalent to
(A B) (B A).
2. Eliminate using A B equivalent to A B.
3. Use De Morgans Laws to push inward to
immediately before propositional variables.
4. Eliminate double negations such as A equivalent to
A.
5. Use distributive laws to get the required form.
351
Q
15.1.1 Example (Kelly Example 5.3)
Convert (p (q r)) s to conjunctive normal form.
1. ((p (q r)) s) (s (p (q r)))
2a. ((p (q r)) s) (s (p (q r)))
2b. ((p (q r)) s) (s (p (q r)))
3a. ((p (q r)) s) (s (p (q r)))
3b. ((p (q r)) s) (s (p (q r)))
4. not needed
5a. (((p q) (p r)) s) ((s p) s (q r)))
5b. (p q s) (p r s) (s p) (s q r)
Note that Kelly gives a dierent derivation of this CNF.
See also Kelly Example 5.2.
352
Q
Exercise
Convert the following proposition into CNF:
P (Q R)
353
Q
15.2 The Key to Resolution (Kelly
page 99)
consider the formulae (A B) and (B C)
If B is true then the truth depends only on C.
If B is false then the truth depends only on A.
only one of B, B is true, so
if (A B) and (B C) are both true, then either A
is true or C is true, i.e. (A C) is true: this is the
resolvent of the original two clauses.
A B
u
u
u
u
u
u
u
u
u
u
B C
s
s
s
s
s
s
s
s
s
s
both true

A C this true
354
Q
15.2.1 Resolution Principle.
(Kelly Theorem 5.1, page 102)
If D is a resolvent of clauses C
1
and C
2
, then C
1
C
2
[= D
Proof by formalising the above key idea.
Another view: A B means A B
Remember: A B, B C [= A C
So if A B and B C, then A C must hold
355
Q
15.3 The Key to Refutations
A B
u
u
u
u
u
u
u
u
u
u
B C
s
s
s
s
s
s
s
s
s
s
both true

one false
A C this true
thisfalse
OO
if (A C) is false, then one of (A B) or (B C)
must be false.
(i.e. using the contrapositive of the observation before).
356
Q
15.3.1 Refutations
A B
u
u
u
u
u
u
u
u
u
u
B C
s
s
s
s
s
s
s
s
s
s
one false
A C
this false
OO
repeatedly cancel out B with B and seek (empty
clause).
if you reach , argue backwards to conclude the
starting formulae were inconsistent.
P . . .
h
h
h
h
h
h
h
h
Q. . . P . . .
u
u
u
u
u
u
u
u
u
u
u
u
u
u
u
u
u
u
u
Q. . .
x
x
x
x
x
x
x
x
P
t
t
t
t
t
t
t
t
t
t
P
s
s
s
s
s
s
s
s
s
s

357
Q
15.3.2 Deductions and Refutations (Kelly page
105)
A resolution deduction of clause C from a set S of
clauses is a sequence C
1
, C
2
, . . . , C
n
of clauses such that
C
n
= C and for each i, 1 i n,
C
i
is a member of S, or
C
i
is obtained, by resolution from C
j
and C
k
,
j, k i.
A resolution refutation of a set S of clauses is a
resolution deduction of from S.
358
Q
15.3.3 Resolution Theorem
Given a clause set S, R(S) is the set of all clauses derivable
from S by one resolution step
R

(S) is the set of all clauses obtainable after a nite

number of resolution steps, starting with S.
Resolution theorem: S is unsatisable i R

(S)
Proof. By induction, using the Resolution Principle.
359
Q
15.4 Establishing Validity With
Resolution
Algorithm for establishing formula A is valid
put A in conjunctive normal form
take set of conjuncts and apply resolution
repeatedly
if eventually you get then A unsatisable (so A
is valid); otherwise A is not valid
How can you be sure that this procedure terminates?
360
Q
15.5 Set Representation of Clauses

clause: a nite set of literals representing a

disjunction
e.g. |A, B represents A B

clause set: a set of clauses representing a CNF

formula
e.g. ||A, B, |B, C, |A for (A B) (B C) A
empty clause: |, represent a formula always false
literals L and L are called complementary

resolvent of two clauses containing complementary

literals is their union omitting L and L
361
Q
Set Representation Examples
e.g. C
1
= |A, B, C
2
= |A, E : resolvent |B, E
e.g. C
3
= |A, B, C, C
4
= |A, C
one resolvent of C
3
and C
4
is |B, C, C
another resolvent of C
3
and C
4
is |A, B, A
but |B is not a resolvent of C
3
and C
4
both clauses |B, C, C and |A, B, A are
tautological (always true) and can be ommitted.
362
Q
15.5.1 Example
Remember the disappointed student?
H
1
: If she studies the sciences then she prepares to
earn a good living.
H
2
: If she studies the humanities, then she prepares for
a good life.
H
3
: If she prepares for a good living or for a good life
then the years are well spent.
H
4
: The years were not well spent.
C: She didnt study science or humanities.
Is the argument H
1
,H
2
,H
3
,H
4
, therefore C valid?
363
Q
15.6 Example Proof
H
1
is S G
H
2
is H L
H
3
is G L W
H
4
is W
C is (S H)
We convert
(S G) (H L) (G L W) (W) (S H)
to CNF.
2a. (S G) (H L) ((G L) W) W (S H)
3. (S G) (H L) ((G L) W) W (S H)
5. (S G) (H L) (G W) (L W) W (S H)
364
Q
15.6.1 Example Proof Diagram
S G G W H L L W W
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
i
s
s
s
s
S H
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
n
L
j
j
j
j
j
G
j
j
j
j
j
j
H
S S
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d

1 L W a L W
2 W b W
3 L 1,2 c L a,b
4 G W d H L
5 G 2,4 e H c,d
6 S G
7 S 5,6
365
Q
Exercise
Use resolution to show
||A, B, C, |A, |A, B, C, |A, B
is unsatisable. Show a resolution diagram.
366
Q
15.6.2 Important Results
Theorem. (Soundness of resolution)
If there is a resolution refutation of S, then S is
unsatisable.
Proof: straightforward induction.
Theorem. (Completeness of resolution)
If S is unsatisable, there is a resolution refutation of
S.
Proof: delicate induction, using the compactness
theorem to reduce the problem to a nite one.
367
Q
15.7 Summary: Propositional Logic so
Far
syntax: the shape of legal formulae
semantics: dened using truth tables. A valid i A
unsatisable
proof denitions - axioms, inference rules
notation
A B B is deducible from A
A [= B B is semantically entailed by A
techniques
truth tables
axioms and inference
resolution
key results: A i [= A i there is a resolution refutation of
A
368
Q
15.7.1 Discussion
Any problem that involves deciding amongst a nite
number of choices can be expressed in propositional
satisability.
resolution implementable easily, but no polynomial
time algorithm known (for this or any of the other
techniques)
the satisability problem (SAT) for propositional logic
is typical of a large class of dicult problems
so-called NP-complete problems for which there are
no known ecient algorithms.
however, by limiting expression to restricted forms of
formulae, resolution can lead to a practical
programming language Prolog
369
370
371
372
Q
16 Linear Resolution
present linear resolution a more ecient form of
resolution
show connections between linear (input) resolution and
Prolog
Introduce negation as failure
373
Q
Linear Resolution (2)
Linear resolution is a renement of resolution (restricts
the search space).

A linear (resolution) deduction (Denition 10.1) or

proof of C from S is a sequence of pairs
(C
0
, B
0
), . . . , (C
n
, B
n
) such that C = C
n+1
and
1. C
0
and each B
i
are elements of S or some C
j
with
j < i
2. each C
i+1
, i n is a resolvent of C
i
and B
i
.

A linear refutation (Denition 10.1) is a linear

deduction of from S
374
Q
Linear Resolution (3)
Basic idea: when choosing two clause to resolve, always
make one be the result of the previous resolution
(10.3) centre clauses,
side clauses ancestors
|A, B |A
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
|B |C, B
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
e
|C |C
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d
d

Main result: linear resolution is complete if S is an

unsatisable set of propositional Horn clauses then there is
a linear refutation of S
375
Q
Linear Resolution Illustration
Resolution in general
|A, B
y
y
y
|C

|A
g
g
g
g
g
g
g
g
g
g
|C, B
m
m
m
|B

|B
i
i
i
i
i
i
i

versus
Linear Resolution
|A, B |A
l
l
l
l
l
l
|B |C, B
l
l
l
l
|C |C
k
k
k
k
k
k
k

376
Q
16.1 Horn clauses and Prolog
conjunctive normal form = conjunction of clauses
clause |L
1
, . . . , L
n
represents
(A
1
A
2
A
m
B
1
B
k
) [n = m+k]
which, using DeMorgans laws, can be written
B
1
B
k
A
1
A
2
A
m

a clause with at most one positive literal is called a

Horn clause
B
1
B
k
A
written with : for and , for in Prolog notation
A : B
1
, . . . , B
k
377
Q
Horn clauses and Prolog (2)
with one positive and some negative literals rule e.g.
A : B
1
, . . . , B
k
with no negative literals fact e.g. A
with no positive literals goal e.g. : B
1
, . . . , B
k
.
subgoal
A

: B
1
, . . . , B
j
, . . . , B
k
t
t
t
t
t
t
t
t
t
head neck
body
378
Q
16.2 Propositional Logic Programs
a propositional logic program P is a collection of facts
and rules; typically, we want to know if some other
fact(s) are a logical consequence of P
Example:
mg : mgo, h2. i.e. h2 mgo mg
h20 : mgo, h2. h2 mgo h20
co2 : c, o2. c o2 co2
h2co3 : co2, h2o. co2 h2o h2co3
mgo. mgo
h2. h2
o2. o2
c. c
given these facts and rules, can you prove h2co3 is
generated?
379
Q
16.2.1 Clausal Form of Logic Program
A1 h2 mgo mg h2 mgo mg
A2 h2 mgo h20 h2 mg0 h20
A3 c o2 co2 ?
A4 co2 h2o h2co3 ?
A5 mgo mgo
A6 h2 h2
A7 o2 o2
A8 c c
A9 h2co3 h2co3
380
Q
16.2.2 Propositional Logic Programs and
Resolution
given a propositional logic program P to know if some
other fact(s) are a logical consequence of P
add the conjunction of the facts as the goal clause G
: h2co3
and, using resolution, show that P |G is unsatisable
remember, in clausal form : h2co3 is h2co3
i.e. adding the goal is just adding the negation of the
query
381
Q
16.3 Linear Input Resolution

(Nerode and Shore Denition 10.8) A linear input

(LI) resolution of a Goal G from a set of program
clauses P is a linear resolution refutation of
S = P |G that starts with G and in which all the
side clauses are from P (input clauses).
Theorem (Nerode and Shore Theorem 10.10) For
propositional logic programs, there is a linear
refutation which starts with the goal clause and uses
only clauses from the program as side clauses;
i.e. linear input resolution is complete for propositional
logic programs.
but linear input resolution is not complete for arbitrary
clause sets.
382
Q
16.3.1 Counterexample
e.g. consider given clauses
|p, q, |p, q, |p, q, |p, q
unsatisable, but not detected by linear input
resolution
one attempt looks like . . .
|p, q |p, q
i
i
i
i
i
i
i
|q |p, q
i
i
i
i
i
i
i
i
i
|p |p, q
i
i
i
i
i
i
i
i
|q |p, q
i
i
i
i
i
i
i
i
|p |p, q
g
g
g
g
g
g
g
g
g
g
no attempt will work, because . . .
383
Q
Exercise
Use linear input resolution to refute the clause set:
||q, p, s, |p, r, |r, |s, |q
Show a resolution diagram.
384
Q
16.4 Connections with Prolog
representation . . . a program, with a goal
1. |q, p, s q :- p, s.
2. |p, r p :- r.
2. |p, s p :- t.
4. |s r :- v.
4. |s s.
3. |t t.
5. |q :- q
execution a form of linear input resolution
the system responds YES, which is short for . . .
issues of eciency, completeness . . .
385
Q
16.4.1 (Abstract) Interpreter for Propositional
Prolog
Input: A query Q and a logic program P
Output: TRUE if Q implied by P, FALSE otherwise
To Prove(G1,... Gn):
For each rule from P of the form
G1 :- B1, ... ,Bn:
if we can Prove(B1,...Bn,G2,...Gn):
return TRUE
return FALSE (no rule was satisfiable)
386
Q
16.4.2 SLD Resolution
Selection rule: always resolve on rst literal in clause
Linear resolution: produce linear input refutations
Denite clauses: Horn clauses with exactly one
positive literal
387
Q
16.4.3 SLD Tree
Prove q with earlier example program:
q :- p, s. p :- r. p :- t.
r :- v. s. t.
q
p, s
w
w
w
w
p
p
p
p
r, s
t, s
v, s
s

Branching represents choice points (revisited on

backtracking)
indicates success; underlined goals indicate failure
388
Q
16.4.4 SLDNF Resolution
Prolog actually uses a variation on SLD resolution
called SLDNF

SLDNF resolution is SLD resolution with negation

as failure

negation as failure means a negated literal is

proved by trying to prove the positive literal; if this
succeeds, the negation fails, and vice versa
Negation as failure allows Prolog clauses to have
negations in the body
Never needed for Horn (or denite) clauses
E.g.: p :- t, \+r.
Equivalent to |p, t, r: not Horn
389
Q
Negation as Failure Example
Prove q with updated program:
q :- p, s. p :- r. p :- t, \+r.
r :- v. s. t.
q
p, s
w
w
w
w
v
v
v
v
r, s
t, r, s
v, s
r, s
r
s
v

r is proved because separate proof of r fails

390
Q
16.5 Summary: Linear Resolution and
Prolog
Nerode and Shore Theorem 10.15 ensures that the
resolution method underlying Prolog, SLD-resolution,
is complete; however, Prologs search strategy is not
guaranteed to nd a refutation even if one exists!
All of this needs further care when dealing with
predicate logic programs i.e. admitting variables
more later.
Note: The tree structures in SLD-trees seen in
tracing program execution are generated by searching
the dierent possibilities for side clauses.
391
Q
16.6 Summary: Prolog theory
SLD resolution a renement of linear resolution
SLD resolution is sound and complete
Prolog = SLD resolution + search strategy
Prolog is sound answers indicate logical
consequence
Prolog is not complete will not always give an
answer
other issues with Prolog (undermining soundness!):
occur check, cut, negation, . . .
392
393
394
395
396
x
17 Predicate Logic
Relations and Functions
From English to Predicate Logic
Formal Language of Predicate Logic
397
x
History
Propositional logic can only make
absolute statements, not statements
about some/all individual(s)
Can say if it rains, I will get wet
Cant say if it rains, anyone who is
outside will get wet
Gotlob Frege proposed the Predicate
Calculus in 1879 to solve this problem
can reason about properties of
individuals
can make sweeping statements about
all individuals
can reason about relationships between
individuals
398
x
Examples of Predicate Logic Formulae
every shark eats a tadpole
x(S(x) y(T(y) E(x, y)))
all large white sh are sharks
x(W(x) S(x))
colin is a large white sh living in deep water
W(colin) D(colin)
any tadpole eaten by a deep water sh is miserable
z((T(z) y(D(y) E(y, z))) M(z))
some tadpole(s) are miserable
z(T(z) M(z))
Is this argument valid?
399
x
17.1 Relations and Functions
A relation relates objects in the domain
cf. Prolog predicates
E.g., < is a relation over integers (or reals), is parent
of is a relation on humans
Can relate any number of objects, e.g., are the
lengths of the sides of a right triangle relates triples
of numbers
400
x
17.1.1 Relations
A relation is a set of tuples of objects
E.g., < on the integers is the set:
|/0, 1), /0, 2), . . . , /1, 2), . . . , /1, 0), . . . . . .
E.g., Dierence is:
|/0, 0, 0), /1, 0, 1), . . . /0, 1, 1), . . .
Nothing wrong with innite sets (just dont try to
compute with them!)
Usually write this as, e.g., Less(0, 1), or Dierence(3, 1, 2)
401
x
17.1.2 Functions
A function is a relation where the last element of each
tuple is unique for each combination of the others
Dierence is a function, because given any a and b,
there is only one c such that /a, b, c) Dierence
Less is not a function because, e.g., /0, 1) Less and
/0, 2) Less
Functions are usually written as function applications,
which show all but the last argument, and stand for
the unique value for the last argument given the other
arguments
dierence(3, 1) stands for the unique x such that
dierence(3, 1, x) holds
Function applications can be nested
402
x
17.2 From English to Predicate Logic
Take predicates (i.e. sentences with the subject
abstracted away) and use symbols for them.
e.g. Sentence: He is a man. Predicate: is a man
Symbol for predicate: M( )
x is a man, M(x), cannot be assigned a truth value.
Bill is a man, M(bill), can be assigned a truth value.
Can abstract away sentence object as well as subject:
Bob is taller than Bill T(bob, bill)
Quantier examples:
Every man is mortal x(man(x) mortal(x))
Some cat is mortal x(cat(x) mortal(x))
Usually use with and with
403
x
17.2.1 Examples
Let L(x, y) be x loves y; let I(x, y) be x is y
L(james, jean) James loves Jean
xL(x, jean) Everyone loves Jean (including
Jean!)
x(I(x, jean) L(x, jean)) Jean is loved by everyone else
x(I(x, james) L(x, james) Someone other than James loves
James
x(yL(x, y)) Everybody loves somebody
y(xL(x, y)) Someone is loved by everybody
x(yL(x, y)) Someone loves everybody
404
x
Exercise
Translate the following statement to predicate logic:
Everyone barracks for a footy team
Use the following predicates:
P(x) x is a person
T(x) x is a footy team
B(x, y) x barracks for y
405
x
17.2.2 Word Order
follow word order with care
there is something which is not P:
yP(y)
there is not something which is P (nothing is
P):
yP(y)
all S are not P vs. not all S are P:
x(S(x) P(x)) or x(S(x) P(x))?
consider: all that glitters is not gold
consider: all 255 students are not asleep
406
x
17.2.3 Quantication Order
Order of dierent quantiers is important
xy is not the same as yx
First says each x has a y that satises P(x, y), second
says theres an individual y that satises P(x, y) for
every x
But xy is the same as yx and xy is the same as
yx
407
x
Quantication Order (2)
May help to think of a game where I make a claim and
you try to disprove it
If I claim xyP(x, y), then you can challenge me by
choosing an x and asking me to nd the y that
satises P(x, y), but I get to know the x you chose
If I claim yxP(x, y), then you can challenge me by
asking me to nd the y, then you just have to nd an
x that does not satisfy P(x, y), and you get to know
the y I chose
If I claim xyP(x, y), then I have to nd both x and y,
so it doesnt matter what order they appear
If I claim yxP(x, y), then you get to pick both x and
y, so again it doesnt matter what order they appear
408
x
17.2.4 Implicit Quantiers
Sometimes quantiers are implicit in English
Look for nouns (especially plural) without determiners
(words to indicate which members of a group are intended)
Men are mortal means all men are mortal:
x(Man(x) Mortal(x))
A woman is stronger than a man would usually
mean:
xy((Woman(x) Man(y)) Stronger(x, y))
A woman is stronger than a man could also mean:
xy(Woman(x) Man(y) Stronger(x, y))
Must consider context of statement; ask yourself what
speaker was trying to say
409
x
17.2.5 Ambiguity
Often, English statements are ambiguous; just do your
best to determine what was intended
Logic is unambiguous
A blue-eyed person is a dole bludger could mean
(1)x(Blueeyed(x) Dolebludger(x)) or
(2)x(Blueeyed(x) Dolebludger(x))
If previous sentence is I know several blue-eyed people
who are dole bludgers, then (2) is probably intended
If following sentence is Joe has blue eyes, so Joe is a
dole bludger, then must have intended (1)
410
x
17.2.6 Choice of Predicates
Often there are many ways to encode an idea in predicate
logic
People who live in glass houses shouldnt throw stones
could be expressed in any of these ways:
x((Person(x) Glasshouseresident(x))
Shouldthrowstones(x))
xy((Person(x) Glasshouse(y) Livesin(x, y))
Shouldthrowstones(x))
xyz((Person(x) Glasshouseresident(x) Stone(y)
Throwingaction(z) Performs(x, z, y)) Advisable(z))
Choose predicates to expose important concepts and hide
unimportant detail, depending on your goals
411
x
Exercise
Given the following interpretation, translate the formula
x(P(x) y((P(y) x ,= y) h(x) > h(y)))
to English
P(x) x is a person
x > y x is greater than y
x ,= y x and y are dierent
h(x) the height of x
412
x
17.2.7 What Logic Cannot Handle
Logic is not good with imprecise concepts
Words like many, most, few, usually,
seldom, etc, are not easy to handle
Sentences like most birds can y are dicult to
express in logic
413
x
17.3 The Language of Predicate Logic
Alphabet
constants (c)
variables (x, y in P(x, y))
function letters (f in P(f(x)))
relation symbols (P in P(x, y))
logical connectives ( )
quantiers (, )
punctuation symbols ( , ) and ,
414
x
The Language of Predicate Logic (2)
Understanding Quantiers
xA(x) For each and every thing, A(that thing) is
true
xA(x) There is at least one thing for which
A(that thing) is true
Terms (Kelly 6.4.1)
(i) every constant is a term
(ii) every variable is a term
(iii) If t
1
, . . . , t
n
are terms and f is a function letter of
arity n, then f(t
1
, . . . , t
n
) is a term
(iv) nothing else is a term.
415
x
The Language of Predicate Logic (3)

A predicate symbol of arity n applied to n terms, e.g.

P(t
1
, . . . , t
n
), is called an atom
(note Prolog terminology conicts)
Well formed formulae (w) (Kelly 6.4.1)
(i) An atom is a w
(ii) if A and B are w, so are A, (A B), (A B),
(A B), (A B)
(iii) if A is a w and x is a variable, then xA is a w
(iv) if A is a w and x is a variable, then xA is a w
(v) Nothing else is a w
416
x
17.3.1 Scope, Bound and Free Variables
scope: a quantier applies to the formula immediately
to its right
in x(P(x) Q(x)), x applies to P(x) Q(x)
in xP(x) Q(x), x applies to P(x)
a variable x occuring within the scope of a quantier
x or x is bound
a variable outside the scope of any quantication of
that variable is free
417
x
17.3.2 Bound, Free, Sentences and Formulae
Examples
in xA(x, c), x occurs bound
in x(A(x, c) B(y)), x occurs bound, y occurs free
in x(A(x, y) yB(y)), x occurs bound, y is free in
its rst occurrence and bound in its second
Sentence

a sentence, or closed formula, is a w where every

variable occurrence is bound
e.g xy(A(x, y) z(B(z, y) B(x, z)))
418
x
17.4 Summary
Language of Predicate Logic extends Propositional
Logic with predicates, functions, universal and
existential quantiers
Order of quantiers in formulae is signicant
English is ambiguous, translating to logic is not always
straightforward
Logic is unambiguous, translating to English is OK
In xT and xT, x is bound throughout T
Variable that is not bound is free
419
420
x
18 Determining Truth
Domains of Interpretation
Truth and Satisfaction
Valuations
421
x
18.1 Domains of Interpretation

Truth value of a Predicate Logic formula depends on

the set of things we limit our attention to, called the
domain of interpretation or domain of discourse
A domain of interpretation is a non-empty set
Can be anything: e.g., the students taking this
subject, the integers, the atoms in the universe
Can only make statements about the objects in the
domain
Consider x(x 0):
True if domain is the set of natural numbers
False if domain is the set of integers
422
x
18.1.1 Interpretations
An interpretation relates the constant, function,
and relation symbols of our language to the objects,
functions and relations over the domain
Gives a meaning to our language
Example: language with binary predicate symbols P and Q,
unary function symbol f and constant symbol c
domain U is the set of integers
P
U
the relation |(n, m) : n < m i.e.
|(0, 1), . . . , (23, 12345), . . .
Q
U
the relation |(u, v) : v = u
2
and u > 0 i.e.
|(1, 1), (2, 4), . . .
f
U
(x) = x + 7
c
U
is 0
423
x
Interpretations (2)
We use domains of interpretation all the time without
thinking about it
In a discussion with friends, you might ask has
anyone read The Hitchhikers Guide to the Galaxy?
Of course someone has read it; youre asking if anyone
in the group of friends has read it
Youre implicitly restricting the domain of discourse to
your group of friends
Nobody goes there anymore; its too crowded.
Yogi Berra
Only makes sense if domain of discourse is narrower
than all people
424
x
18.1.2 Valuations

A valuation over an interpretation is an assignment

of domain objects to the free variables of the
language
example: = |x 7, y 2, z 4
A term is assigned a value in the domain under a
valuation.
ex: f(c) under U and is f
U
(c
U
) = 7
ex: f(f(y)) under U and is
f
U
(f
U
((y))) = f
U
(f
U
(2)) = 16.
An atom of the form P(t
1
, , t
n
) is true (or satised)
under interpretation U and valuation if t

i
is the
interpretation of t
i
under U and , and (t

1
, , t

n
) P
U
.
ex: Q(y, z) is true under U and since (2, 4) Q
U
.
ex: P(f(c), x) is not true under U and since
(7, 7) , P
U
.
425
x
18.1.3 Relation to Propositional Logic
Predicate logic has interpretations and valuations
Propositional logic just had assignments
Can think of a proposition as a niladic (0-arity)
predicate
Then an interpretation lls the role of an assignment
With no arguments, no terms and no variables
With no variables, no need for quantiers or valuations
426
x
18.2 Truth and Satisfaction
A formula A is satised by an interpretation U and some
valuation over that interpretation:
an atom is true or not according to the interpretation
U, after applying the valuation
connectives , , , , : as for Propositional Logic
xA: if for every value u in the domain of U, the
interpretation U and the valuation

= ( |x ) |x u satises A(x).
Alternatively A(u
1
) A(u
2
) A(u
N
) is satised
xA: if for some value u in the domain of U, the
interpretation U and the valuation

= ( |x ) |x u satises A(x).
Alternatively A(u
1
) A(u
2
) A(u
N
) is satised
427
x
18.2.1 Truth, Satisability, Validity

A formula A is true in an interpretation if it is

satised by every valuation over that interpretation.
For sentences (closed ws), there are no free variables
so the valuation is irrelevant

A sentence A is satisable if it is true in some

interpretation.

A sentence A is valid, written [= A, if A is true in

every interpretation.
428
x
Truth, Satisability, Validity (2)
example: interpretations U where P(x) is x is a woman :
domain of U is |Mary, Kathleen, Teresa:
xP(x) is true in this interpretation
domain of U is |Mary, Fred, Teresa:
xP(x) is false in this interpretation
So, xP(x) is satisable, but not valid
429
x
Exercise
In the interpretation of slide 423:
domain U is the set of integers
P
U
the relation |(n, m) : n < m
Q
U
the relation |(u, v) : v = u
2
and u > 0
f
U
(x) = x + 7
which of the following are true:
1. xyP(x, y)
2. xyQ(y, x)
3. xxP(x, f(x))
430
x
18.3 Deciding Validity
To determine validity of a sentence:
What to do: For all possible interpretations, use
(propositional) refutation to show that the set of
formulae is unsatisable.
How: For each interpretation:
1. Eliminate quantiers by substituting all values from
the domain for the variables
2. I.e., a big conjunction for and big disjunction for
3. Consider each atom to be a propositional variable
Similarly for determining satisability: try dierent
interpretations until one makes sentence true
431
x
18.3.1 The Problems
There are innitely many interpretations; cant check
them all!
Most interpretations are innite, how to truth of
quantied formulas?

Jacques Herbrand (1929) solved rst

problem: restricted the number of
interpretations that need to be
considered to just one (the Herbrand
interpretation)

J. Alan Robinson (1965) solved second

problem: work with variables directly
using resolution with unication
432
x
18.4 Herbrand Approach
Herbrands Theorem (1929) A set of clauses is
unsatisable i there is a nite subset of ground instances
of its clauses which is unsatisable as propositional logic
formulas
Each ground instance of an atom can be treated as a
separate propositional variable
E.g., P(Mary), P(Fred), P(Teresa) can each be
assigned either true or false
But what about P(x)?
433
x
18.4.1 Herbrand Interpretation
Herbrands Theorem eectively says we dont need to
consider the innite number of possible interpretations
We can consider only the Herbrand Interpretation of
the formula

Given a formula f, the Herbrand Interpretation of

f maps every symbol in f to itself
I.e., instead of having to worry about what each
symbol might mean, we only consider the symbols
themselves
Our domain of interpretation is just the symbols of the
formula
434
x
18.4.2 Herbrand Universe
To nd the Herbrand universe H for a set S of
clauses:
If c is a constant occurring in a clause in S, H
contains c
If no constants occur in any clause in S, add a
new constant symbol to H
if f is a function symbol of arity n occurring in
any clause in S, and H contains t
1
, , t
n
, add
f(t
1
, , t
n
) to H
Repeat ad innitum
If S contains any function symbols, then H is innite
435
x
18.4.3 Herbrand Base
The Herbrand base B of a set S of clauses is
dened as follows
If P is a predicate symbol appearing in t
1
, , t
n
are members of the Herbrand universe of S, then
P(t
1
, , t
n
) is in B
Nothing else is in B
The Herbrand base is the set of all propositions we need
to nd truth assignments for
If the Herbrand universe is innite, so is the Herbrand base
436
x
18.4.4 Example
Fido is a dog
All hungry dogs bark
Fido is hungry
Therefore, Fido barks
D(F)
x(H(x) D(x) B(x))
H(F)
B(F)
Herbrand universe = |F
Herbrand base = |D(F), H(F), B(F)
Only instances of x(H(x) D(x) B(x)) from the
Herbrand base
Thats just H(F) D(F) B(F))
437
x
Example (2)
Now its all just propositional logic easy!
D(F)
H(F) D(F) B(F)
H(F)
B(F)
This is argument is valid
So by Herbrands theorem, the original predicate logic
formula was valid
438
x
18.4.5 On To Resolution
Not always so easy
Usually the Herbrand universe and base are innite
Sadly, Herbrand died aged 23 before he could solve
this problem
Solution to this problem would wait until Robinsons
resolution principle
439
x
18.4.6 Summary
Interpretation of a formula is what each of its symbols
mean
Domain of interpretation is the set of things involved
in interpretation
A formula is valid if it is true in all interpretations
Herbrands theorem says we only need to consider
Herbrand interpretation, which interprets each symbol
as itself
Herbrand universe is the set of all terms that can be
made from functions and constants of the formula
440
441
442
443
444
x
19 Resolution in Predicate Logic
Aim: Use resolution to show that a Predicate Logic
formula is unsatisable
Application: Proving that arguments which are
expressible in predicate logic are correct
Problem: Resolution only dened for Propositional
Logic so far
Strategy: Adapt Propositional techniques to
Predicate Logic
445
x
History
Resolution: J. Alan Robinson, 1965
Computerized theorem prover
Logic Programming: Robert Kowalski,
1974
A program is a conjunction of
implications
Each implication gives one way a
statement can be true
Execution is nding ways a
statement can be true
446
x
History (2)
Prolog: Alain Colmerauer, 1973
Designed for natural language
understanding
Prolog compiler: David H. D. Warren, 1977
Quite ecient
Modern Prolog syntax follows this implementation
Constraint Logic Programming: Jaar
and Lassez, 1987
Generalizes Logic Programming
Developed at University of
Melbourne
447
x
19.0.7 Pre-Processing for Predicate Logic
We extend the algorithm for converting a formula to
conjunctive normal form to enable us to deal with variables
and quantiers.
For each formula:
1. Convert to Prenex Normal Form (CNF with all
quantiers at the start of the formula).
2. Eliminate existential quantiers using Skolemisation.
3. Drop the universal quantiers and convert to clausal
form.
448
x
19.0.8 Prenex Normal Form Algorithm
Stage 1 Use A B (A B) (B A) to eliminate
Stage 2 Use A B A B to eliminate
Stage 3 Use
a) De Morgans Laws
b) xA(x) xA(x)
c) xA(x) xA(x)
to push immediately before atomic w
Simplify formula using A A
Stage 4 Rename bound variables if necessary
Stage 5 Use the equivalences on (Kelly page 192) to bring all
quantiers to the left
Stage 6 Distribute ,
449
x
19.0.9 Example
Convert to Prenex Normal Form:
x

A(x) B(x)

xQ(x)
1.

A(x) B(x)

xQ(x)

xQ(x) x

A(x) B(x)

2.

A(x) B(x)

xQ(x)

xQ(x) x

A(x) B(x)

3a.

A(x) B(x)

xQ(x)

x Q(x) x

A(x) B(x)

3b.

A(x) B(x)

xQ(x)

xQ(x) x

A(x) B(x)

4.

A( w ) B( w )

xQ(x)

y Q( y ) z

A( z ) B( z )

5a. wx

A(w) B(w)

Q(x)

yz

Q(y)

A(z) B(z)

5b. wxyz

`
A(w) B(w)

Q(x)

Q(y) A(z) B(z)

6. wxyz

A(w) Q(x)

B(w) Q(x)

Q(y) A(z) B(z)

450
x
Exercise
Convert the following formula to prenex normal form:
x(P(x) ((yQ(x, y)) (yR(x, y))))
451
x
19.0.10 Skolemisation
Suggested by Thoralf Skolem
Aim: Get rid of quantiers
How: Introduce new constants and functions, not
already existing in the formula, to replace variables
corresponding to existentially quantied variables.
Result is the Skolemisation of the formula.
Denition:
outside : replace by new constant.
xyA(x, y) becomes yA(c, y).
inside : replace by new function with arguments
all variables in outside s.
yxzwA(x, y, z, w) B(y, w) becomes
yzA(f
1
(y), y, z, f
2
(y, z)) B(y, f
2
(y, z))
452
x
19.0.11 Intuition
If xyP(x, y) then there is some x that satises P(x, y)
for every y
But we dont know which x
So we make up a name: we create a new constant and
dene it to be some constant satisfying P
New constant will represent be the same thing as some
old constant, but thats OK
E.g., P(x, y) means y = x +y
Convert to yP(c, y)
c happens to be 0, but we dont need to know that
453
x
Intuition (2)
If yxP(x, y) then for each y there is some x that
satises P(x, y)
Now the x that satises P(x, y) depends on y: its a
function of y
So now we make up a function: for any y, we say that
f(y) satises P(f(y), y)
E.g., P(x, y) means x > y
convert to yP(f(y), y)
f(x) could be x + 1, but we dont care
454
x
19.0.12 Important Result
Theorem. Let A be a formula and A

its Skolemisation.
Then A is satisable i A

is satisable.
A and A

are not (in general) equivalent, since there

can be symbols in A

not occurring in A.
So the Skolemised formula (no quantiers) can be
used in resolution.
Prolog clauses do not allow existentially quantied
variables, so there is no Skolemisation to be done!
(Fortunate, since we generally dont want two distinct
constants representing the same thing in Prolog)
455
x
19.0.13 Clausal Form
To nd the clausal form of a formula:
1. Convert to Prenex normal form and then Skolemise.
2. Drop all quantiers.
3. Convert to clausal form as for Propositional Logic.
Once in Prenex normal form, all variables are
universally quantied and at the front of each clause
Order of same quantiers is unimportant
Drop them, then consider all variables implicitly
universally quantied
Simplies resolution algorithm
456
x
Exercise
Skolemize the following formula, then put it into clausal
form:
yx(P(y) Q(x, y))
457
x
An Example
Use resolution to prove that the following argument is valid.
All hungry animals are caterpillars.
All caterpillars have 42 legs.
Edward is a hungry caterpillar.
Therefore, Edward has 42 legs.
Translation to Logic:
x(H(x) C(x)) H(Edward) C(Edward)
x(C(x) L(x)) L(Edward)
458
x
Prenex Normal Form
x(H(x) C(x)) H(Edward) C(Edward)
x(C(x) L(x)) L(Edward)
Negate conclusion and convert to Prenex Normal Form:
x(H(x) C(x)) H(Edward)
x(C(x) L(x)) C(Edward)
L(Edward)
459
x
Clausal form
x(H(x) C(x)) H(Edward)
x(C(x) L(x)) C(Edward)
L(Edward)
Set of sets representation:

|H(x), C(x), |H(Edward),

|C(x), L(x), |C(Edward),
|L(Edward)

460
x
Resolution Refutation
8
>
>
<
>
>
:
{H(x), C(x)}, {H(Edward)},
{C(x), L(x)}, {C(Edward)},
{L(Edward)}
9
>
>
=
>
>
;
~C(x), L(x) ~L(Ed) C(Ed)
~C(Ed)

~H(x), C(x) H(x)

Just one refutation, there are many.
Why C(Ed) on second line? See in next lecture
461
x
19.0.14 Summary: Herbrand Approach
Problems
set of ground clauses may be innite
no adequate means to guide the search for refutation
validity problem for predicate logic is undecidable
(problem with any method)
462
x
20 Resolution with Unication
How did Robinson solve the problem of detecting
unsatisability in predicate logic, and how did that give rise
to logic programming?
Robinsons Approach
Unication
Resolvents
Resolution Theorems
Horn Clauses and Prolog
Summary: Robinsons Approach
463
x
20.1 Robinsons Approach
Robinsons Theorem (1965) A set of clauses is
unsatisable i it has a resolution refutation, where
unication is used to match complementary literals.
Avoid generating (possibly innitely many) ground
instances of clauses.
Still have search control problem but greatly reduced.
464
x
20.2 Unication

A substitution is a nite set of replacements of

variables by terms, i.e. a set of the form
|t
1
/x
1
, t
2
/x
2
, , t
n
/x
n
, where the x
i
are variables
and the t
i
are terms. If A is a formula, A is the
result of simultaneously making the substitutions t
i
for each occurrence of x
i
.
e.g. if A = |P(x), Q(y, y, b), = |h(y)/x, a/y, c/z then
A = |P(h(y)), Q(a, a, b)
Note similar but not the same as a valuation.

A unier of two literals L

1
and L
2
is a substitution
such that L
1
= L
2
.

L
1
and L
2
are uniable if there exists a unier for L
1
and L
2
465
x
Unication (2)

A most general unier (m.g.u.) for L

1
and L
2
is a
substitution such that is a unier for L
1
and L
2
and every other unier of L
1
and L
2
can be
expressed as for some substitution .
(A is the composition of and applied to A, i.e.
performing rst, then ).
Extend to sets of literals S = |L
1
, . . . , L
n
in the
obvious way.
1
unies L
1
and L
2
,
2
unies L
1

1
and
L
2
, . . . ,
n1
unies L
1

1

n2
and L
n
. The unier
of S is
1

n1
.
Lemma. If a set S is uniable, then it has a most
general unier.
Lemma. A most general unier for a set S (if it
exists) is unique up to renaming of variables.
466
x
20.2.1 Examples
|P(x, a), P(b, c) is not uniable
|P(f(x), y), P(a, w) is not uniable.
|P(x, c), P(b, c) is uniable by |b/x.
|P(f(x), y), P(f(a), w) is uniable by = |a/x, w/y,
= |a/x, a/y, a/w, = |a/x, b/y, b/w
Note that is an m.g.u. and = where =
|P(x), P(f(x)) is not uniable. (c.f. occur check!)
467
x
20.2.2 Unication Algorithm
1. T
1
= L
1
; T
2
= L
2
;
0
= |; i = 0
2. If T
1
is identical to T
2
, terminate with
i
as the most
general unier.
3. Find the leftmost position where T
1
and T
2
dier. If
the two terms at this position are a variable v
i
and a
term t
i
such that v
i
does not occur in t
i
(the occurs
check), then

i+1
=
i
|t
i
/v
i
; T
1
= T
1
|t
i
/v
i
; T
2
= T
2
|t
i
/v
i

Otherwise, terminate as S is not uniable.

4. i = i + 1; resume from step 2.
468
x
Unication Algorithm (2)
T
1
= L
1
= f(x, g(x)) T
2
= L
2
= f(h(y), g(h(z)))

1
= |h(y)/x
T
1
= f(h(y), g(h(y))) T
2
= f(h(y), g(h(z)))

2
= |h(y)/x, y/z
T
1
= f(h(y), g(h(y))) T
2
= f(h(y), g(h(y)))
i.e.
2
is an m.g.u.
469
x
20.2.3 Results on Unication
Theorem. The unication algorithm is correct.
Remark. The occur check can be exponential in the
size of the original terms, so Prolog simply omits this
part of the algorithm.
Question. What does this mean for Prologs
correctness?
Question. What happens when you type the following
queries to Prolog?
?- X = f(X).
?- X = f(X), Y = f(Y), X=Y.
470
x
Exercise
Find the most general unier of the following pairs of
terms, if possible. (a, b are constants, x, y, z are variables.)
1. f(x, y, f(x, y)) f(b, z, z)
2. f(f(x, y), y) f(z, g(a))
471
x
20.3 Resolvents
Recall: For Propositional Logic:
Two literals are complementary if one is L and the
other is L.
The resolvent of two clauses containing
complementary literals L, L is their union
omitting L and L.
For Predicate Logic:
Two literals L and L

are complementary if |L, L

is uniable.
Let be an m.g.u. of complementary literals
|L, L

with L a literal in C
1
and L

a literal in C
2
.
Then the resolvent of C
1
and C
2
is the union of
C
1
and C
2
omitting L and L

.
472
x
20.4 Resolution Theorems
Resolution Principle
If D is a resolvent of clauses C
1
and C
2
, then C
1
C
2
[= D.
Resolution Theorem
A clause set S is unsatisable i R

(S), where R

(S) is
the set of all clauses obtainable after a nite number of
resolution steps, starting with S.
473
x
20.4.1 Example: The Miserable Tadpole
every shark eats a tadpole
x(S(x) y(T(y) E(x, y))) |S(x), T(f(x)), |S(x), E(x, f(x))
all large white sh are sharks
x(W(x) S(x)) |W(x), S(x)
colin is a large white sh living in deep water
W(colin) D(colin) |W(colin), |D(colin)
any tadpole eaten by a deep water sh is miserable
z(T(z) y(D(y) E(y, z) M(z)) |T(z), D(y), E(y, z), M(z)
negation of: some tadpoles are miserable
z(T(z) M(z)) |T(z), M(z)
474
x
20.4.2 Refutation
C1 S(x), T(f(x)) C2 S(x), E(x, f(x))
C3 W(x), S(x) C4 W(c)
C5 D(c) C6 T(z), D(y), E(y, z), M(z)
C7 T(z), M(z)
C8 S(c) C4, C3 |c/x
C9 T(f(c)) C8, C1 |c/x
C10 E(c, f(c)) C8, C2 |c/x
C11 D(y), E(y, f(c)), M(f(c)) C9, C6 |f(c)/z
C12 D(c), M(f(c)) C10, C11 |c/y
C13 M(f(c)) C5, C12
C14 T(f(c)) C7, C13 |f(c)/z
C15 C9, C14
So there is a miserable tadpole the one eaten by colin.
475
x
20.5 Horn Clauses and Prolog
Horn clause = clause with at most one positive literal.
e.g. |p(x), q(x, y), r(x, y)
represents p(x) q(x, y) r(x, y)
rewritten as p(x) (q(x, y) r(x, y))
rewritten as p(x) (q(x, y) r(x, y))
or, in Prolog notation p(X) :- q(X, Y), r(X, Y).
SLD-resolution is Robinsons approach restricted to
linear input resolution.
476
x
20.5.1 Example
Suppose C is the clause set
||q(x), p(x), s(x), |p(x), r(x), |r(a), |r(b), |s(b)
Does C [= q(b)?
check for unsatisability of C |q(b), i.e.
1. |q(x), p(x), s(x)
2. |p(x), r(x)
3. |r(a)
4. |r(b)
5. |s(b)
6. |q(b)
and (in a few steps of linear resolution) you derive
477
x
20.5.2 Linear Resolution Diagram
Example, continued using linear input resolution.
q(b) q(x), p(x), s(x)
p
p
p
p
p
p
p
p
p
p
p
s(b)
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
r
p(x), r(x)
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
t
r(b)
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
v
p(b), s(b)
p(b)
r(b)

478
x
Exercise
Draw a resolution diagram refuting this set of clauses:
|P(a, b) |P(x, y), Q(x, y) |P(x, y), Q(y, x) |Q(b, a)
479
x
20.5.3 (Abstract) Interpreter for Prolog
Input: A query Q and a logic program P
Output: yes if Q implied by P, no otherwise
Initialise current goal set to Q;
While the current goal is not empty do
Choose G from the current goal;
Choose instance of a rule G

:- B
1
, . . . , B
n
from P;
renaming all variables to new symbols giving G

:- B

1
, . . . , B
such that G and G

are uniable, with mgu

(if no such rule exists, exit while loop)
Replace G by B

1
, . . . , B

n
in current goal set;
If current goal set is empty,
output yes;
else output no;
480
x
20.5.4 Prolog in Prolog
A basic Prolog interpreter in Prolog:
solve(true).
solve((G1,G2)) :-
solve(G1),
solve(G2).
solve(Goal) :-
clause(Goal, Body),
solve(Body).
Needs to be expanded to support built-ins, disjunction,
if-then-else, etc.
NB: Prolog takes care of backtracking and creating copies
of clauses with fresh variables for us!
481
x
20.5.5 SLD tree
q(b)

I
I
I
I
I
I
I
|b/x
1

p(b), s(b)
{
{
{
{
{
{
{
{
Y
Y
Y
Y
Y
Y
Y
Y

G
G
G
G
G
G
G
|b/x
2

r(b), s(b)
{
{
{
{
{
s
s
s
s
s
s
s

s(b)

q(x) :- p(x), s(x).

p(x) :- r(x).
r(a).
r(b).
s(b).
branching represents choice points (revisited on
backtracking)
x
1
, x
2
are copies of x from original program
482
x
20.5.6 Summary: Robinsons Approach
based on resolution with unication of complementary
literals
sound and complete inference method
still need search control information to dene an
implementation
Prolog uses this method restricted to Horn clauses and
linear input resolution (plus rule and literal selection
strategy)
483
484
485
486
x
21 Semantics of Logic Programs
It is useful to be able to formally characterize what a logic
program means. This allows us to formally analyze
programs.
1. The Meaning of Meaning
2. The Meaning of a Logic Program
3. Finding Meaning
4. Approximating Meaning
5. Groundness Analysis
487
x
21.1 The Meaning of Meaning
What does this C function mean?
int sq(int n)
{
return n * n;
}
What about this?
int sq(int n)
{
int i, sum;
for (i=0, sum=0; i<n; ++i) {
sum += n;
}
return sum;
}
488
x
The Meaning of Meaning (2)
What does this C function mean?
void hi(void)
{
printf("hello, world!\n");
}
or this:
int count;
void inc(void)
{
count++;
}
Meaning of a C function must include what it does as well
as what it returns
489
x
The Meaning of Meaning (3)
Meaning of a program component gives understanding of
that component
Meaning of Haskell function
fact :: Integer -> Integer
fact n = product [1..n]
is (mathematical) factorial function:
|0 1, 1 1, 2 2, 3 6, 4 24, . . .
Note: meaning is innite set
490
x
21.2 The Meaning of a Logic Program
Meaning of logic program is what it makes true
Ignore Input/Output, assert/retract, etc.
Meaning of a program can be shown as a set of unit
clauses (facts)
This program is its meaning:
capital(tas, hobart). capital(vic, melbourne).
capital(nsw, sydney). capital(sa, adelaide).
capital(act, canberra). capital(qld, brisbane).
capital(nt, darwin). capital(wa, perth).
491
x
The Meaning of a Logic Program (2)
parent(alice, harriet). parent(alice, george).
parent(bob, harriet). parent(bob, george).
parent(harriet, laura). parent(harriet, ken).
grandparent(C, G) :-
parent(C, P),
parent(P, G).
Meaning is:
parent(alice, harriet). parent(alice, george).
parent(bob, harriet). parent(bob, george).
parent(harriet, laura). parent(harriet, ken).
grandparent(alice, laura). grandparent(alice, ken).
grandparent(bob, laura). grandparent(bob, ken).
492
x
The Meaning of a Logic Program (3)
Meaning of a recursive predicate is also a set of clauses
E.g., what is the meaning of:
num(0).
num(s(N)) :- num(N).
num/1 holds for numbers written in successor notation, so
meaning is:
num(0).
num(s(0)).
num(s(s(0))).
num(s(s(s(0)))).
...
493
x
21.3 Finding Meaning
Meaning of program P can be found using immediate
consequence function T
P
T
P
(I) = |H [ (H : G
1
, . . . G
n
) P G
1
I . . . G
n
I
Here is any substitution that unies G
1
, . . . G
n
with
elements of I and grounds all variables in H
Take T
2
P
(I) = T
P
(T
P
(I)), T
3
P
(I) = T
P
(T
P
(T
P
(I))), etc.
Meaning of program P is T

P
()
494
x
Example
Take program P = |num(0), num(s(N)) : num(N)
T
1
P
() = |num(0)
(because body of clause is empty)
T
2
P
() = |num(0), num(s(0))
T
3
P
() = |num(0), num(s(0)), num(s(s(0)))
T

P
() =
|num(0), num(s(0)), num(s(s(0))), num(s(s(s(0)))), . . .
Meaning of most programs is innite
495
x
Exercise
Give the semantics of the following Prolog program:
p(a,b).
p(b,c).
p(c,d).
q(X,Y) :- p(X,Y).
q(X,Y) :- p(Y,X).
496
x
21.4 Why Study Semantics?
Programming (thinking about your code)
Verication (is it correct)
Debugging (the answer is wrong, but why)
Implementation
Language design
Philosophy
Hundreds of papers have been written on the semantics of
logic programs, many concerning negation
497
x
21.4.1 Verication and Debugging
Suppose each clause/predicate of a program is true
according to my intended interpretation
Then everything computed by the program (the meaning,
the set of logical consequences) is true
Correctness can be veried just by reasoning about
individual components
If the program computes something false, one of
clauses/predicates must be false
Declarative debugging systems use the intended
interpretation to nd which one
498
x
21.5 Approximating Meaning
Can also approximate meaning of a program: gives some
information about the program
Approximation can be made nite: can actually be
computed
Usual approach: replace data in program by an abstraction,
then compute meaning
Many interesting program properties are Boolean: use
propositional logic
E.g., parity (even/odd): abstract 0 by true
Abstract s(X) by x
499
x
Approximating Meaning (2)
Abstracted num predicate:
num(true)
num(x) num(x)
num(0)
num(s(X)) num(X)
T
1
P
() = |num(true)
T
2
P
() = |num(true), num(false)
T
3
P
() = |num(true), num(false)
Can stop here: further repetitions will not add anything
Result is nite
Says that both even and odd numbers satisfy num/1
500
x
Approximating Meaning (3)
Program:
plus(0, Y, Y).
plus(s(X), Y, s(Z)) :- plus(X, Y, Z).
Abstracted version:
plus(true, y, y) y can be either true or false
plus(x, y, z) plus(x, y, z)
T
1
P
() = |plus(true, true, true), plus(true, false, false)
T
2
P
() =

plus(true, true, true), plus(true, false, false),

plus(false, true, false), plus(false, false, true)

T
3
P
() =

plus(true, true, true), plus(true, false, false),

plus(false, true, false), plus(false, false, true)

501
x
Approximating Meaning (4)
This result is better shown as a table:
+ even odd
even even odd
odd odd even
Even such a simple analysis is able to discover interesting
properties of programs
502
x
Exercise
Use parity analysis to determine the possible parities of the
arguments of p/1 dened as:
p(0,s(0)).
p(s(X), s(s(Y))) :- p(X, Y).
503
x
21.6 Groundness Analysis
A more useful property for optimization of Prolog code is
groundness
Again, a Boolean property
append([], Y, Y).
append([U|X], Y, [U|Z]) :- append(X, Y, Z).
Abstracted version:
append(true, y, y)
append(u x, y, u z) append(x, y, z)
In second clause, u can be true or false, so:
append(true, y, y)
append(x, y, z) append(x, y, z)
append(false, y, false) append(x, y, z)
504
x
Groundness Analysis (2)
append(true, y, y)
append(x, y, z) append(x, y, z)
append(false, y, false) append(x, y, z)
T
1
P
() = |append(true, true, true), append(true, false, false)
T
2
P
() =

append(true, true, true), append(true, false, false),

append(false, true, false), append(false, false, false)

T
2
P
() =

append(true, true, true), append(true, false, false),

append(false, true, false), append(false, false, false)

505
x
Groundness Analysis (3)
A truth table will help us understand this:
x y z append(x, y, z) T

P
()
true true true true
true true false false
true false true false
true false false true
false true true false
false true false true
false false true false
false false false true
We see when append(x, y, z) is true, (x y) z
506
x
Groundness Analysis (4)
So after a call append(X,Y,Z), X and Y will be ground i Z is
We can use this result in analyzing predicates that call
append
rev([], []).
rev([U|X], Y) :-
rev(X, Z),
append(Z, [U], Y).
Abstracted version:
rev(true, true)
rev(u x, y) (rev(x, z) append(z, u, y))
507
x
Groundness Analysis (5)
Using what weve learned about append:
rev(true, true)
rev(u x, y) (rev(x, z) ((z u) y))
Since u can be either true or false:
rev(true, true)
rev(x, y) (rev(x, z) (z y))
rev(false, y) (rev(x, z) (false y))
Simplifying biimplications:
rev(true, true)
rev(x, y) rev(x, y)
rev(false, false) rev(x, z)
508
x
Groundness Analysis (6)
rev(true, true)
rev(x, y) rev(x, y)
rev(false, false) rev(x, z)
T
1
P
() = |rev(true, true)
T
2
P
() = |rev(true, true), rev(false, false)
T
3
P
() = |rev(true, true), rev(false, false)
509
x
Groundness Analysis (7)
So after rev(X,Y), X is ground i Y is: x y
This analysis gives quite precise results
Many other such abstractions have been proposed
This is an area of active research
510

22 Finite State Machines

What is a program? What is an algorithm? How simple
can we make them?
1. Introduction
2. Finite State Machines
3. FSMs in Prolog
4. Formally
5. NFAs
6. Power
511

22.1 Introduction
There are many programming languages, many
programming paradigms
All have a few things in common; programs:
Are nite
Take input
Produce output
Make decisions based on current input and possibly
earlier input
To facilitate recalling information about earlier inputs,
most languages allow state of computation to be changed
512

22.2 Finite State Machines

Simplest mechanism we can dene to do this always has a
current state, which is one of a nite number of discrete
states
Each input, together with current state, determines next
state and any output
The state captures what is important about the history of
the computation
This is a nite state machine (FSM) or nite automaton
513

Finite State Machines (2)

A touch light is an example of a nite state machine
1. Light is initially o;
2. when touched, the 50 watt lament is lit;
3. when touched again, the 50 watt lament is
extinguished and the 100 watt lament is lit;
4. when touched again, both laments are lit
5. when touched again, both laments are extinguished
(go back to step 1)
514

22.2.1 State Diagrams

We can depict machine as a state diagram or state
transition diagram
0 50
100 150
touch
touch
touch touch
Circles represent states; arrows represent transitions
between states in response to input
Initial state is indicated by sourceless arrow
515

22.2.2 Output
FSMs can produce output
0 50
100 150
touch/+f1
touch/f1,f2
touch/+f1
touch/f1,+f2
Here +f1 means that lament 1 should be turned on, f2
means lament 2 should be turned o, etc.
516

22.2.3 Example
This FSM copies its input of binary numbers to its output,
stripping leading 0s:
q0 q1
1/1
0 1/1
0/0
The transition from the initial state for 0 leaves it in that
state without any output
States capture the history of the computation
Think of state q0 as meaning no 1s seen yet and q1 as
some 1s seen
517

Exercise
What output does the following FSM produce with input
aabbaaabbb?
q2
q0 q1
b/b
b/b
b/b
a
a/a
a/a
More generally, describe what it does.
518

22.2.4 Accepting States

Many problems amount to simply determining if the input
is acceptable does it satisfy some criterion
Double circle around state indicates accepting state
When input runs out, if machine is in an accepting state, it
accepts that input string; otherwise it doesnt
Can have as many accepting states as needed
519

Accepting States (2)

Determine if the input is one a followed by one or more bs
followed by a single c:
a b
q2
c
q1
q3
q4
q0
b, c
a, c
a
b
a, b, c
a, b, c
No output needed here, just accept or reject
Machine can do both: have output and accept or reject
520

22.3 FSMs in Prolog

To simulate FSMs in Prolog, we can specify state
transition by a predicate delta(State0, Input, State) which
says that when in State0 we receive Input as input, we
transition into State
Also specify initial and accepting states
delta(q0, a, q1). delta(q0, b, q4). delta(q0, c, q4).
delta(q1, a, q4). delta(q1, b, q2). delta(q1, c, q4).
delta(q2, a, q4). delta(q2, b, q2). delta(q2, c, q3).
delta(q3, a, q4). delta(q3, b, q4). delta(q3, c, q4).
delta(q4, a, q4). delta(q4, b, q4). delta(q4, c, q4).
initial(q0).
accepting(q3).
521

FSMs in Prolog (2)

Code to similate an FSM is simple:
recognize(Input) :-
initial(State0),
run(Input, State0, State),
accepting(State).
run([], State, State).
run([I|Is], State0, State) :-
delta(State0, I, State1),
run(Is, State1, State).
522

Exercise
Design an FSM to recognize strings containing an even
number of as. The input can include both as and bs.
523

22.4 Formally
What does it take to dene a FSM?
Q a set of states
a set of input symbols, called the alphabet
species the state transitions
q
0
the initial state
F the set of accepting states
(assuming we do not need output).
So an FSM is a 5-tuple:
/Q, , , q
0
, F)
524

22.4.1
State transition is specied by a function
Given any state and any input, yields the state to
transition into
: (Q) Q
Can specify as a table (as we did for Prolog
implementation):
state s input i (s, i)
q0 a q1
q0 b q4
q0 c q4
q1 a q4
.
.
.
.
.
.
.
.
.
525

22.5 NFAs
What if state transition were specied by a relation rather
than a function?
Q Q
When is a function, only one next state given current
state and input
When is a relation, may be more than one next state
Such a FSM is called a Nondeterministic Finite Automaton
or NFA
If is a function: Deterministic Finite Automaton or DFA
An NFA accepts an input string if some selection of the
state transitions specied by leads to an accepting state
526

22.5.1 transitions
NFAs also often allow transitions to be specied
A transition is a spontaneous transition a transition in
response to no input at all
Specify this formally by pretending the input alphabet
contains an extra symbol , and there can be as many s
as you like between any two real symbols
Then, formally becomes a relation
Q( |) Q
527

22.5.2 Example
This NFA accepts all input that is either some as optionally
followed by some bs or some bs optionally followed by some
as:
b a
q4 q3
a b
q2 q1
q0 q5
a
b

a
b
b
a
528

Example (2)
Important result: any NFA can be converted into an
equivalent DFA
Intuition: state in new DFA corresponds to set of states in
NFA
This is an equivalent DFA to the previous NFA:
b a
q4 q3
a b
q2 q1
q0 q5
a
b
b
a
a
b
a,b
529

22.6 Power
FSMs cannot do everything real programs can do
FSMs can recognize ab or aabb or aaabbb:
q0 q1 q2
a
a a
q3
q3 q4 q5
b b b
q5
b b
b
a,b
a
a
a
a,b
This regular structure can be extended to recognize a
n
b
n
for n up to any xed limit
But its not possible to build a FSM to recognize a
n
b
n
for
any n
530
531
532
533
534

23 Turing Machines
1. Turing Machines
2. Nondeterministic Turing Machines
535

23.1 Turing Machines

Introduced by Alan Turing
Abstract machine with many features of computer
Designed before the stored program computer!
No memory limit!
An innite tape, and a tape reader, that reads one
symbol at a time.
536

Turing Machines (2)

0 1 2 3 4 5 6 ...
...
A quintuple M = (Q, , , , q0)
A nite set of states Q.
A nite set , the tape alphabet, which includes blank
B
A subset |B called the input alphabet
A partial transition function : Q Q |L, R
A start state q0 Q
537

23.1.1 Turing Machines: Initial

0 1 2 n
...
q0
c1 c2 cn B B ... ...
...
B
Computation begins with
An input string s = c
1
c
n
in

on the tape from

position 1 to n
The remaining tape blank (lled with B)
Initial state q0
538

23.1.2 Turing Machines: Transition

... ...
q
x ... ... y
q
Machine in state q reading tape symbol x
(q, x) = [q

, y, d]
Transitions have three parts:
Change the state to q

Write symbol y on square scanned by tape head

Move head left or right (depending on direction d)
539

23.1.3 Turing Machines: Final

... ...
q
x
Machine halts if in state q reading tape symbol x
there is no (q, x) = [q

, y, d]
Remember is a partial function.
Output is the result remaining on the tape.
Machine halts abnormally if the head moves o the
left end of the tape.
540

23.1.4 Turing Machines: Example

Change all as to bs and vice versa.
B a b
q0 q1, B, R
q1 q2, B, L q1, b, R q1, a, R
q2 q2, a, L q2, b, L
Represented as a state machine
B/B R
a/b R
b/a R
a/a L
b/b L
q0 q1 q2
B/B L
541

23.1.5 Turing Machines: Traces

A conguration uq
i
vB
represents the tape uvBBB. . . (v includes
rightmost non blank)
shows tape head over rst symbol in v
shows machine state q
i
notation uq
i
vB xq
j
yB indicates a transition from
conguration uq
i
vB to xq
j
yB.
uq
i
vB

xq
j
yB means result of any nite number of
steps
542

23.1.6 Turing Machines: Example Trace

q
0
BabaB
Bq
1
abaB
Bbq
1
baB
Bbaq
1
aB
Bbabq
1
B
Bbaq
2
bB
Bbq
2
abB
Bq
2
babB
q
2
BbabB
B/B R
a/b R
b/a R
a/a L
b/b L
q0 q1 q2
B/B L
543

23.1.7 Turing Machines: Another Example

Machine to add 1 to a binary number
B/B R
q0 q1 q2
B/B L
0/0 R
1/1 R
q3
0/1 R
1/0 L
B/1 R
q
0
B001B q
0
B11B
Bq
1
001B Bq
1
11B
B0q
1
01B B1q
1
1B
B00q
1
1B B11q
1
B
B001q
1
B B1q
2
1B
B00q
2
1B Bq
2
10B
B0q
2
00B q
2
B00B
B01q
3
0B 1q
3
00B
544

23.1.8 Turing Machines as Acceptors

0 1 2 3 4 5 6 ...
...
A sextuple M = (Q, , , , q0, F)
F is the set of nal states.
If M halts in a state q F then the input is accepted
If M halts in a state q , F the input is rejected.
L(M) is the set of strings accepted by M.
545

Turing Machines as Acceptors (2)

q0
0/0 R
1/1 R
q1
B/B R 0/B R
1/B R
0/0 R
1/1 R
q2
q3
q4
q5
B/B L
B/B L
0/B L
q6
0/0 L
1/1 L
1/B L
B/B R
A machine that accepts a string which is an even length
palindrome of 0s and 1s. e.g 00, 0110, 0001001000 L(M)
546

Exercise
Modify the even length palindrome machine to accept odd
length palindromes too e.g. 101
q0
0/0 R
1/1 R
q1
B/B R 0/B R
1/B R
0/0 R
1/1 R
q2
q3
q4
q5
B/B L
B/B L
0/B L
q6
0/0 L
1/1 L
1/B L
B/B R
547

23.1.9 Turing Machines in Prolog

given delta(State,Sym,NewState,NewSym,LR)
(maybe) given accepting(State) for accepting states
We can write a Turing machine simulator in Prolog
So Prolog can do anything a Turing machine can
delta(q0, B, q1, B, right).
delta(q1, B, q2, B, left).
delta(q1, a, q1, b, right).
delta(q1, b, q1, a, right).
delta(q2, a, q2, a, left).
delta(q2, b, q2, b, left).
initial(q0).
548

Main Code
run(Input, Output, State) :-
initial(State0),
tape_list_position(Tape0, Input, 0),
run(State0, Tape0, State, Tape),
tape_list_position(Tape, Output, _).
recognize(Input) :-
run(Input, _, State),
accepting(State).
549

State Transition
run(State0, Tape0, State, Tape) :-
( step(State0, Tape0, State1, Tape1) ->
run(State1, Tape1, State, Tape)
; State = State0,
Tape = Tape0
).
step(State0, Tape0, State, Tape) :-
replace_tape_symbol(Tape0, Sym0, Tape1, Sym1),
delta(State0, Sym0, State, Sym1, Direction),
move_tape(Direction, Tape1, Tape).
550

Handling the Tape

tape_list_position(tape(Left, Right), List, Pos) :-
length(Left, Pos),
reverse(Left, Left1),
append(Left1, Right, List).
replace_tape_symbol(tape(Left0,Right0), Sym0, tape(Left0,Right), Sym) :-
replace_next_of_infinite_tape(Right0, Sym0, Right, Sym).
move_tape(left, tape([Lsym|Left],Right), tape(Left,[Lsym|Right])).
move_tape(right, tape(Left,Right), tape([Rsym|Left],Right1)) :-
replace_next_of_infinite_tape(Right, Rsym, [_|Right1], Rsym).
replace_next_of_infinite_tape([Sym0|Rest], Sym0, [Sym|Rest], Sym).
replace_next_of_infinite_tape([], B, [Sym], Sym).
551

23.2 Nondeterministic Turing Machines

maps to a subset of Q |L, R rather than just
one (or zero)
Computation chooses which one to take?
A non-deterministic Turing machine M accepts input s
if some possible computation accepts s.
Important result: Any language accepted by a
non-deterministic Turing machine can be accepted by
a deterministic Turing machine
552

Example
q0 q1
B/B R c/c R
c/c L
q2
q3
q4
q5
a/a R
b/b L
b/b R
q6
a/a L
a/a R
b/b R
c/c R
A machine which accepts strings of as, bs and cs where
there is a c followed by or preceded by ab.
553

Example (2)
Trace1 Trace2 Trace3
q
0
BacabB q
0
BacabB q
0
BacabB
Bq
1
acabB Bq
1
acabB Bq
1
acabB
Baq
1
cabB Baq
1
cabB Baq
1
cabB
Bacq
1
abB Bacq
2
abB Bq
3
acabB
Bacaq
1
bB Bacaq
4
bB
Bacabq
1
B Bacabq
6
B
First and third do not accept, but second does
Thats good enough: the machine accepts
554
555
556
557
558

24 Undecidability
Are there some programs that cannot be written?
How many kinds of innity are there?
559

24.1 Church-Turing Thesis

There is an eective procedure to solve a decision problem
P if, and only if, there is a Turing machine that answers
yes on inputs p P and no for p , P.
All computation can be performed by Turing
machines?
Not a theorem since we have no formal denition of an
eective procedure!
More like the denition of eective procedure!
Extended Church-Turing thesis A decision problem P is
partially solvable if, and only if, there is a Turing machine
thats answers yes on inputs p P.
560

24.1.1 Evidence for Church-Turing Thesis

Every eective procedure in
Partial recursive functions
Lambda calculus
Predicate logic
Register machines
can be simulated by Turing machine.
All known eective procedures can be transformed to
Turing machines
561

24.2 An undecidable problem

The Halting Problem
Given an arbitrary Turing machine
M = (Q, , , , q
0
)
An input s

Does M halt on input s ?

For particular Turing machines we may be able to
determine that they halt.
But not for all possible machines
562

24.2.1 Prove the Halting Problem Undecidable

Suppose to the contrary
There is a Turing machine H which accepts
description of Turing machine M and input w and
accepts M and w if machine M halts on input w.
Assume = |0, 1 and = |0, 1, B, and states
|q
0
, . . . , q
n
and q
0
is the start state.
Representing machine M (its function)
Symbol 0 1 B q
0
q
1
q
i
L R
Encoding 1 11 111 1 11 1
i+1
1 11
(q
i
, x) = [q
j
, y, d] as string
code(q
i
)0code(x)0code(q
j
)0code(y)0code(d)
563

Prove the Halting Problem Undecidable (2)

Represent function by 00 between two individual
transitions.
Beginning and end represented by 000.
Example
(q
0
, B) = [q
1
, B, R] 101110110111011
(q
1
, 0) = [q
0
, 0, L] 1101010101
(q
1
, 1) = [q
2
, 1, R] 110110111011011
(q
2
, 1) = [q
0
, 1, L] 1110110101101
M is represented as R(M) by
00010111011011101100110101010100110110111011011001110110101101000
564

Prove the Halting Problem Undecidable (3)

Machine H takes a description of machine M, R(M)
and input s and accepts the input if M halts on s, and
otherwise halts and does not accept.
Halting
H
Machine
M halts with input s
M does not halt with input s
reject
accept
R(M)s
Make a new machine D that copies its input and then
applies H, and loops if H accepts, otherwise halts.
Halting
H
Machine
halt
loop
R(M)R(M)
COPY
R(M)
D
M does not halt with input R(M)
M halts with input R(M)
565

Prove the Halting Problem Undecidable (4)

Execute D on the input R(D)
Halting
H
Machine
halt
loop
R(D)R(D)
COPY
R(D)
D
D does not halt with input R(D)
D halts with input R(D)
Contradiction if D halts on input R(D) then D loops!
Hence The language L
H
of strings R(M)s such that
machine M halts on input s is not decidable
566

Exercise
Suppose Prolog had a builtin predicate halt(Goal) that
succeeds if Goal would eventually terminate, and fails
otherwise. Write a Prolog predicate contra/0 that calls
halt/1 in such a way that halt/1 cannot possibly work.
567

24.3 Universal Machines

We can build a Universal Turing Machine that
simulates any Turing machine:
Universal
U
Machine
M halts with input s
M does not halt with input s
loop
accept
R(M)s
The language L
H
of strings R(M)s such that machine
M halts on input s is semidecidable
568

24.3.1 A Universal Machine U (3 tape machine)

If input is not of form R(M)s move indenitely right
(loop)
write string s on tape 3
write 1 encoding state q
0
on tape 2
simulate M on tape 3:
scan tape 1 for a transition for the state encoded
on tape 2 q
i
acting on the symbol x under the head
on tape 3
if no transition, U halts
otherwise (q
i
, x) = [q
j
, y, d]
write new state code(q
j
) on tape 2
write symbol y to tape 3
move tape head on tape 3 in direction d
569

24.4 Reducability
A decision problem P is (Turing) reducible to a
problem P

if:
there is a Turing machine M which maps input p to
p

such that p P i p

Idea translate new problem P to old problem P

Example: we can reduce the problem of detemining if

a string is even length to detecting if a string is an
even length palindrome
M maps input replacing all 1s by 0s
palindrome
Even length
reject
accept
length of s in 0s
M
s
D
s is of odd length
s is if even length
570

24.4.1 Another Undecidable Problem

The problem to determine if a Turing machine halts
on blank input is undecidable
Assume contrary, machine B answers problem
create the machine H from B, that is reduce halting
problem to blank tape problem
Build machine N which takes input R(M)s and creates
output R(M

) where M

is a machine which:
takes a blank tape as input
writes s on tape
then executes machine M on tape
571

Another Undecidable Problem (2)

The machine N provides a reduction of the halting
problem to the halting on blank tape problem.
R(M)s R(M)
M halts with input s
does not halt
reject
accept
H
B
Machine
Blank
N
572

24.5 Countability
There are innitely many natural numbers |0, 1, 2, . . .
Are there more integers |. . . , 2, 1, 0, 1, 2, . . . than
natural numbers?
Two sets have the same cardinality (size) if we can
match each element of one set to a dierent element
of the other, and vice versa
A set that is either nite or has the same cardinality as
the natural numbers is countable
Are all sets countable?
573

24.5.1 Integers
The integers are countable:
0 1 2 3 4 5 6
321 0 2 3 1
Match nonnegative integers p with natural number 2p
Match negative integers n with natural number 2n 1
574

24.5.2 Rationals
Rational numbers are numbers that can be expressed
as n/d for integers n and d
The rational numbers are countable
All rationals appear in this:
0
4
3 2 1 1 2 3
4 4 4 4 4 4
0
3
3 2 1 1 2 3
3 3 3 3 3 3
0
2
3 2 1 1 2 3
2 2 2 2 2 2
0
1 1 1 1 1 1 1
3 2 1 1 2 3
Can match rationals with
naturals:
0
4
3 2 1 1 2 3
4 4 4 4 4 4
0
3
3 2 1 1 2 3
3 3 3 3 3 3
0
2
3 2 1 1 2 3
2 2 2 2 2 2
0
1 1 1 1 1 1 1
3 2 1 1 2 3
575

24.5.3 Reals
Real numbers include rationals and irrational numbers
Irrationals include e, ,

2, etc.
The real numbers are not countable
Proof by Georg Cantor (diagonal argument)
Assume reals are countable
Then reals between 0 and 1 are countable
576

24.5.4 Reals are Uncountable

Then we can arrange all reals in [0, 1] like this:
0 0.D
0
0
D
0
1
D
0
2
D
0
3

1 0.D
1
1
D
1
1
D
1
2
D
1
3

2 0.D
2
2
D
2
1
D
2
2
D
2
3

3 0.D
3
3
D
3
1
D
3
2
D
3
3

.
.
.
Each D
n
m
is the m
th
decimal digit of the n
th
real
number
Create a real number X = 0.X
0
X
1
X
2
X
3
where each
X
i
is 2 if D
i
i
is 1, or 1 otherwise
X is not in our set of real numbers (it is dierent from
each in at least one digit)
Contradiction!
577

Exercise
Is the set of integer intervals, e.g. from 1 to 10, or from 0
to 99, or from -78 to -42, countable? Why or why not?
578
579
580
581
582

25 Complexity
1. What is Complexity?
2. Rates of Growth
3. Tractable Problems
4. NP Problems
583

25.1 What is Complexity?

Performance of an algorithm = resources required for
its execution
Time
Space
Complexity of a problem = resources required for
best possible algorithm
there may be no universal best algorithm
special cases may have better algorithms
Examples
Sorting
Searching
584

What is Complexity? (2)

Require a formal denition of computation
Turing Machine
Partial recursive functions
Lambda calculus
Predicate Logic
Register Machines
Reason about programs in these formalisms
Restrict to decision problems
A decision problem asks if input p P
It decides whether p is in the set P, or
alternatively denes set P
585

What is Complexity? (3)

Time complexity of a Turing Machine M:
The (worst case) number of transitions steps
required to process input string of length n
Space complexity of a Turing Machine:
The (worst case) maximum length of the tape
required to process input string of length n
Time complexity is always greater than space
complexity (why?).
Note this is complexity of an algorithm not complexity
of a problem
586

25.1.1 Complexity Example

Recall the Turing Machine that accepts even length
palindromes
q0
0/0 R
1/1 R
q1
B/B R 0/B R
1/B R
0/0 R
1/1 R
q2
q3
q4
q5
B/B L
B/B L
0/B L
q6
0/0 L
1/1 L
1/B L
B/B R
Worst cases are: when we succeed: input s = uu
R
, or
when we fail at last step: input s = u0u
R
or u1u
R
587

Complexity Example (2)

q
0
BB q
0
B0B q
0
B00B q
0
B111B
Bq
1
B Bq
1
0B Bq
1
00B Bq
1
111B
accept BBq
2
B BBq
2
0B BBq
3
11B
Bq
5
BB BB0q
2
B BB1q
3
1B
reject BBq
4
0B BB11q
3
B
Bq
6
BBB BB1q
5
1B
BBq
1
BB BBq
6
1BB
accept Bq
6
B1BB
BBq
1
1BB
BBBq
3
BB
BBq
5
BBB
reject
588

Complexity Example (3)

Worst case steps
length of input transition steps
0 1
1 3
2 6
3 10
.
.
.
.
.
.
n
n+1
i=1
= (n + 2)(n + 1)/2
589

25.1.2 Dierent execution machines

Some forms of execution machine oer better
complexity
Random Access Machine (RAM) (closer to modern
computer)
constant time access to all memory locations by
index
for (i = 1; i <= n/2; i++)
if (s[i] != s[n+1-i]) return FALSE;
return TRUE;
This version takes n steps.
590

Dierent execution machines (2)

the complexity of a problem P is the complexity of the
best algorithm for P (for a given class of execution
machine)
(n + 2)(n + 1)/2 for Turing machine
n for RAM
591

25.2 Rates of Growth

n 0 5 10 25 50 100 1000 10000
20n + 500 500 600 700 1000 1500 2500 20500 200500
n
2
0 25 100 625 2500 10000 1000000 100000000
n
2
+ 2n + 5 5 40 125 680 2605 10205 1002005 100020005
n
2
/(n
2
+ 2n + 5) 0 .625 .800 .919 .960 .980 .998 .9999
Contribution of n
2
to n
2
+ 2n + 5 is almost all as n
increases
key: only the fastest growing term is really important
in determining rates of growth.
592

25.2.1 Big O Notation

A function f(n) is said to be order g(n) if there is a
positive constant c and positive integer n
0
such that
f(n) c g(n), n n
0
Write f = O(g) if f is of order g.
Example f(n) = n
2
+ 2n + 5, g(n) = n
2
then f = O(g)
f(n) = n
2
+ 2n + 5
n
2
+ 2n
2
+ 5n
2
for n 1
= 8n
2
= 8 g(n)
593

25.2.2 Big O Hierarchy

constant O(1) hash table lookup
logarithmic O(log(n)) binary search tree lookup
linear O(n) list lookup
n log n O(nlog(n)) sorting
quadratic O(n
2
)
cubic O(n
3
) solving linear equations
polynomial O(n
r
) for some r
exponential O(b
n
) for some b deciding propositional logic
factorial O(n!)
594

25.3 Tractable Problems

log
2
(n) n n
2
n
3
2
n
n!
5 2 5 25 125 32 120
10 3 10 100 1000 1024 3628800
20 4 20 400 8000 1048576 2.4 10
18
50 5 50 2500 125000 1.1 10
15
3.0 10
64
100 6 100 10000 1000000 1.2 10
30
> 10
157
200 7 200 40000 8000000 1.6 10
60
> 10
374
A problem is polynomial complexity if it is O(n
r
) for
some xed r
Problems which are not polynomial complexity are
intractable
Cannot be realistically solved for even medium
instances
But we really want to solve these problems!
595

25.4 Nondeterministic Polynomial Time

A problem is non-deterministic polynomial time if
there is a non-deterministic Turing machine M that
solves the problem of size n in at most a polynomial
number of transitions n
r
for some xed r.
Alternatively problem is non-deterministic polynomial
time if:
Guessing stage (non-deterministically guess an
answer)
Checking stage (in polynomial time, check the
guess)
596

25.4.1 SAT
Example: propositional satisability
Given a set of propositional clauses, guess a valuation for
all the truth values. Evaluate F under this valuation. If true
answer yes! Given a propositional formula in clausal form
Nondeterministically guess a truth assignment for each
variable
Check whether it makes the clauses true
For each clause, is there a true literal in the clause
O(n) where n is the size of the formula
597

25.4.2 P and NP
A problem is in the class P if it is (deterministic)
polynomial time
A problem is in the class NP if it is non-deterministic
polynomial time
P NP
P = NP one of the most important problems in
Computer Science. Everyone believes that P ,= NP!
598

25.4.3 A problem in P
Solution of propositional horn clauses is O(n)
Algorithm
For each clause x x
0
, . . . x
n
set count = n
place all clauses with count 0 in queue
Remove rst from queue, set lhs to true
Subtract 1 from the count of all clauses that
contain lhs
Add new clauses with count 0 to queue.
continue until queue empty
599

25.4.4 P and NP and reducibility

If p is (polynomial time) reducible to q and q P, then
p P
If p is (polynomial time) reducible to q and q NP,
then p NP
A problem p is NP-hard if every q NP can be
reduced to p.
A problem p is NP-complete if p is NP-hard and
p NP
Propositional satisability is the most famous
NP-complete problem.
600

25.4.5 Proving NP completeness

If we can reduce problem p to q and p is NP-complete,
then q is NP-hard.
3SAT.
A 3SAT problem is a SAT problem where each
clause has at most 3 literals.
We can reduce SAT to 3SAT by adding new
variables.
Long clause l
1
l
2
l
3
l
4
becomes
(l
1
l
2
y) (y l
3
l
4
)
Any solution of the conjunction satises the
original clause
Any solution of the original clause can be
extended to satisfy the conjunction (choose the
right value for y)
601

25.4.6 NP completeness
Thousands of problems have been shown to be NP
complete!
edge cover, Hamiltonian path, graph coloring
scheduling, rostering, register allocation
Constraint programming concentrates on solving just
these kind of problems
602

25.5 Summary
Church Turing thesis: eective procedures
Turing Machines
Halting problem is undecidable
Validity problem for predicate logic is semidecidable
Satisability/Validity problem for propositional logic
(SAT) is NP-complete
Tractable and Intractable problems
Solution of predicate Horn clauses is undecidable
Solution of propositional Horn clauses is O(n)
603
604
605
606

26 Review
Cannot cover the whole semester in one lecture, but well
try. . . .
1. Propositional Logic
2. Predicate Logic
3. Automata
607

26.1 Propositional Logic

A proposition is statement that can be either true or false,
e.g. interest rates are rising
Assign propositional variable to simple propositions for
convenience, e.g. R for interest rates are rising
Combine propositions using connectives:
(negation, not)
(conjunction, and)
(disjunction, or)
(material implication, if)
(biimplication, i)
608

Exercise: From English

R = Interest rates rising
S = Share prices falling
U = Unemployment rising
1. If interest rates rise, share prices fall
2. Interest rates rise if share prices fall (Careful!)
3. Interest rates are rising, but unemployment is not
4. Unemployment rises exactly when interest rates do
5. If unemployment rises, then share prices fall if interest
rates rise
609

26.1.1 Truth Tables

Truth tables have a row for each combination of values of
propositional variables, column for each formula of interest
A B A B A B A A B A B
T T T T F T T
T F F T F F F
F T F T T T F
F F F F T T T
If all truth table rows for a formula are true, formula is a
tautology; if all are false, formula is unsatisable
A model of a formula is an assignment of truth values to
variables that makes it true (truth table row)
610

26.1.2 Arguments
Argument is a sequence of propositions ending in a
conclusion, e.g.:
When interest rates rise, share prices fall.
Interest rates are rising. Therefore, share prices
will fall.
Conclusion is claimed to follow from premises
To check correctness, see if conjunction of premises imply
conclusion, e.g. ((R S) R) S
R S R S (R S) R ((R S) R) S
T T T T T
T F F F T
F T T F T
F F T F T
All rows of truth table are true, so argument is valid
611

26.1.3 Better Way

Usually faster to demonstrate argument validity by
contradiction: assume it is invalid, and show a
contradiction
Simple technique can help with the bookkeeping: write out
the formula and write T or F under each variable and
connective as you determine them, propagating variable
values
((R S) R) S
T X F T T F F
So the initial assumption (that the argument was invalid)
was wrong; the argument is valid
612

26.1.4 Axiomatic System (AL)

Axiom schemas allow any w for A, B, and C
Ax1 A (B A)
Ax2 (A (B C)) ((A B) (A C))
Ax3 (A B) (B A)
One rule of deduction, or inference rule: modus ponens:
from A and A B infer B
AL system is:
1. Consistent: A i , A
2. Sound: A implies [= A
3. Complete: [= A implies A
4. Decidable: there is an algorithm to always decide if A
613

Exercise: Complete the proof

|A B, B C A C
1 B C Hyp
2 (B C) (A (B C)) Ax1
3 (a) MP 1,2
4 (A (B C)) ((A B) (A C)) Ax2
5 (A B) (A C) (b)
6 (c) Hyp
7 A C MP 5,6
(a)
(b)
(c)
614

Exercise: Normal Forms

A literal is a basic proposition or the negation of one
Conjunctive normal form (CNF): conjunction of 1 or
more disjunctions of 1 or more literals
Disjunctive normal form (DNF): the converse
Exercise: which normal form are these?
(A B) (C D)
(A B)
(A B)
(A B) C
(A B) C
Convert to normal form: replace and using only
, , ; push in; remove double ; distribute over
and over
615

26.1.5 Resolution
Clausal form: CNF written as set of sets
Complementary literals: e.g. A and A
Resolvent of 2 clauses with complementary literals is
union of 2 clauses with complementary literals removed
E.g. resolvent of |A, B, C and |A, B, D is
|A, C, D
Horn clause has at most 1 positive literal
616

Resolution (2)
Resolution
~B
~A, B

A, B ~A, ~B A, ~B
B
Resolve any 2
clauses
Linear Resolution
~A, B
A, B
B
A
A, ~B
~A, ~B
~B B

Resolve result of
last step with any
other clause
Linear Input
Resolution
~p, ~s
~r, ~s r
~s s

p, ~r
q, ~p, ~s ~q
Resolve result of
last step with
clause from
program
All are sound. All are complete, except L.I. Resolution:
complete only for Horn clauses
617

26.2 Predicate Logic

Variables stand for anything
Predicates describe properties of individuals or
relationships among individuals parameterized
propositions
Interpretation limits domain of discourse and gives
meaning of predicates, functions, and constants
Truth value of formula usually depends on
interpretation
Formula A is valid, written [= A, if A is true in every
interpretation; satisable if true in some interpretation
618

26.2.1 Quantiers
xF means F is true for every x in the domain of
discourse
xF means F is true for some x in the domain
xyF not the same as yxF
xyF is the same as yxF
xF not the same as xF
xF is the same as xF
Quantier applies to single immediately following
formula, e.g. in xP(x) Q(x), the quantier only
applies to P(x)
619

26.2.2 From English

Translating from English to predicate logic, be careful
of order of quantiers, and negation, parentheses
Translate every P does Q to x(P(x) Q(x))
Translate some Ps do Q to x(P(x) Q(x))
Note usually use with and with
620

Exercise: To and from English

B(x) x is a book
P(x) x is a person
O(x, y) x is older than y
A(x, y) x is the author of y
R(x, y) x is a reader of y
Everyone is a book
Everyone reads books
x(yA(x, y) y(B(y) R(x, y)))
Every author is older than the books they write
621

26.2.3 Normal Forms

Prenex normal form is like conjunctive normal form
with all quantiers at the left
Convert to PNF like CNF, but xF = xF and
xF = xF
When multiple quantiers use same variable, rename
all but one to use new variables
Once and are gone and all are innermost, just
move all quantiers in order to front of formula
622

26.2.4 Clausal Form

Clausal form is PNF with no existential quantiers
Skolemisation eliminates existential quantiers
Replace existentially quantied variables by new
function of all variables universally quantied in outer
scope
Function of no variables is a constant
E.g., xyzP(x, y, z) = xyP(x, y, f(x, y)) and
xyP(x, y) = yP(c, y)
Clausal form usually written as set of sets
623

26.2.5 Resolution
Herbrand interpretation: interpretation mapping every
constant, function and predicate symbol to that
symbol (identity interpretation)
Herbrand Universe: set of all ground terms that can be
created from the function and constant symbols of the
program
Herbrand: Set of clauses is unsatisable i a nite
subset of ground instances is
Robinson: Resolution is sound and complete for
predicate logic
Resolution same as for propositional logic, except that
unication is used to match complementary literals
624

26.2.6 Unication
Substitution species terms to substitute for some
variables in a term or atom; other variables are left
unchanged
E.g., given substitution = |a/x, f(x)/y and term
T = g(x, y, z), T = g(a, f(x), z) (note new x not
replaced by a)
Simplied algorithm to unify a and b:
1. If a is a variable not appearing anywhere in b, add a
substitution b/a
2. If b is a variable not appearing anywhere in a, add a
substitution a/b
3. If both are terms with the same function and arity,
recursively unify the arguments pairwise
4. otherwise, fail
625

Exercise: Resolution Proof

Use resolution to prove the following set of clauses is
unsatisable:

|A(c, v, v), |A(f(u, x), y, f(u, z)), A(x, y, z), |A(f(a, c), f(a, c), v)

626

26.3 Automata
Finite Automata (Finite State Machine) handles a
sequence of input symbols from input alphabet set
Machines reaction to input symbol depends on current
state, an element of Q
Reaction to input specied by function : Q Q
Machine must also specify initial state q
0
Machine may act as a recognizer ; then must also
specify a set of states F; when input runs out, if state
of machine F then input is accepted by machine
Machine may produce output; then may also specify
an output symbol to produce for given state and input
Nondeterministic Finite Automaton (NFA) is FA where
is a relation rather than a function; Any NFA can be
rewritten as a DFA
627

Exercise
Often drawn as diagram with circles representing states
and arcs labeled by input symbols representing transitions
( function)
What input does this FSM accept?
b c c
q1
q3
q4
q2 q0
a
a,b
a, b, c
b c
a, b
a
c
628

26.3.1 Pushdown Automata

Pushdown automata are like FAs augmented with
unlimited stack
Each transition may consume symbol from input, push
symbol, or pop (and check) symbol
Extend FA with set of symbols allowed on stack;
maps state, input symbol, and stack top to new state
and stack top
Usually interested in nondeterministic pushdown
automata: is a relation
Cannot rewrite every NPDA to equivalent DPDA
Pushdown automata can recognize languages FAs
cannot, eg a
n
b
n
NPDAs can recognize regular languages (cf regular
expressions, as used in many Unix tools)
629

26.3.2 Turing Machines

Turing machines replace the stack with an innite tape
Input is provided on the tape, output is written there,
and tape can be used for intermediate results
Tape always allows special blank symbol B; after nite
input, tape is all Bs
is tape alphabet; |B
At each transition, tape is moved either left (L) or
right (R) one symbol
: Q Q |L, R
is a partial function; when has no value for current
state and tape symbol, machine halts
630

Exercise
Which of these inputs does the following machine accept?
More generally, what inputs will the machine accept?
a/a R
x/x R
b/b R
x/x R
a/a L
b/b L
x/x L
x/x R
q0 q1
B/B R
q2
q3
q4
q5
b/x R
B/B R
c/x L
q6
a/B R
B/B R
x/x R B/B R
abaca
abc
aabbcccc
aaabbbccc
631

26.3.3 Undecidability
Church-Turing Thesis: there is an eective procedure
to decide a problem i a Turing machine can do so
Cannot be proved, but has stood the test of time
Halting problem (will a turing machine M ever halt if
given input s) is undecidable can never be
implemented on any TM
Halting problem is semidecidable can built TM SH
that will accept when M will halt for input s; if it
wont, SH will not terminate
Problem P is reducible to Q if input for P can be
rewritten to input for Q
If P is reducible to Q and Q is decidable, so is P; if P
is undecidable, so is Q
Satisability of predicate logic formulae is undecidable
632

26.3.4 Countability
Two set are same cardinality if some function maps
every element of one to a unique element of the other
A set is countable if it has same cardinality as the
natural numbers
Integers are countable: e.g., map even naturals n to
n/2 and odd to (n + 1)/2
Rational numbers are countable
Real numbers are not: Cantor diagonal argument
633

26.3.5 Complexity
Complexity measures worst case time or space usage
of algorithm depending on size of input
Complexity of problem measures complexity of best
possible algorithm
Algorithm of order f(n) O(f(n)) means f(n)
dominates complexity of algorithm
Complexity depends on computation model: e.g.,
RAM can test palindrome in O(n), TM O(n
2
)
Problem is in NP if some Nondeterministic TM can
solve problem in polynomial time (O(n
c
) for some c)
Problem is NP-hard if every problem in NP can be
reduced to it in polynomial time; NP-complete if in
NP and NP-hard
Many problems are NP-complete, including SAT:
634
determining satisability of propositional logic formulae
635
636