Syntax and Meaning of Prolog Programs

1
Syntax and Meaning of Prolog Programs

• Notes for Ch.2 of Bratko
• For CSCE 580 Sp03
• Marco Valtorta

2
Data Objects

• The typing system of Prolog is simple
• Data objects include
• simple objects
• constants
• atoms
• numbers
• variables
• structures

3
Atoms

• strings of letters, digits, and underscore,
  starting with a lower-case letter
• string of special characters (e.g., gt)
• (Some are predefined!)
• strings of characters enclosed in single quotes
  (e.g., Tim, c\Marco\foo.pl)

4
Numbers

• Integers
• limits are implementation dependent.
• ?-current_prolog_flag( X,Y) gives 2147483647 and
  2147483648 (32 bits)
• Real numbers
• Rarely used
• float Computers cripled (sic) representation of
  a real number. Represented as IEEE double
  (SWI-Prolog manual, p.234 glossary of terms)

5
Variables

• Strings of letters, digits, and underscore
  characters, starting with an upper-case (capital)
  letter or an underscore character
• The underscore by itself is the anonymous
  variable, e.g.
• has_a_child( X) - parent ( X,Y).
• is equivalent to
• has_a_child(X) - parent( X,_).

6
Scope of Variables

• Each underscore represents a new anonymous
  variable
• someone_has_child - parent( _,_).
• is equivalent to
• someone_has_child - parent( X,Y).
• and not equivalent to
• someone_has_child - parent( X,X).
• The lexical scope of all other (named) variables
  is one clause

7
Structures

• Structures are data objects that have several
  components
• The components are combined by functors
• date( 1, may, 2001)
• date( Day, may, 2001)
• segment( point( 1,1), point( 2,3))
• move( state( P1, onfloor, P1, H),
• push( P1,P2),
• state( P2,onfloor,P2,H)
• The first three denote objects, the last one
  denotes a predicate

8
Terms

• Syntactically, all Prolog data objects are terms
• A term is either
• a simple object, or
• a structure, i.e., a functor followed by (, one
  or more terms separated by commas, and )
• Structures are conveniently represented by trees
• actually, any term may be represented by a tree

9
Examples of Structures

• point( 1,1)
• T triangle( point( 4,2), point(6,4), point(
  7,1))
• There are two different functors in point( X,Y)
  and point( X,Y,Z) point/2 (a functor of arity 2)
  and point/3 (a functor of arity 3)
• ( ( a,b), -(c,5)) may represent (ab)(c-5)
• infix notation is possible and will be described
  in Ch.3
• par( r1, seq( par( r2,r3), r4)))
• resistive circuit example in Figure 2.6(d)

10
Matching

• Two terms match if
• (1) they are identical, or
• (2) the variables in both terms may be
  instantiated in such a way that after the
  substitution of variables by these objects the
  terms become identical
• E.g., date( D,M,2001) and date( D1,may,Y1) match
  with the unifier D/D1,M/may,Y1/2001
• Replace D with D1 everywhere in the two terms,
  then replace M with may, then replace Y1 with 2001

11
Most General Unifier

• ?-date( D,M,2001) date( D1,may,Y1),
• date( D,M,2001) date( 15,M,Y).
• The first goal succeeds with most general unifier
  (mgu) g1 D/D1, M/may, Y1/2001 then, we try
  to match
• date( D1,may,2001) and date( 15,may,Y)
• This succeeds with mgu g2 D1/15, Y/2001
• Composition of g1 and g2 (g1 o g2) gives D/15,
  M/may, Y1/2001, D1/15, Y/2001

12
Algorithm to Find MGU for Terms

• If S and T are constants, they match only if they
  are identical
• If S is a variable and T is anything, check
  whether T contains S if so, fail if not,
  substitute T for S and conversely
• If S and T are structures, they match only if
• they have the same principal functor
• all corresponding components match
• Example Figure 2.7

13
Computing by Matching

• ch2_1.pl
• vertical( seg( point( X,Y), point( X,Y1))).
• horizontal( seg( point( X,Y), point( X1,Y))).
• 1 ?- vertical( seg( point(1,1), point(1,2))).
• Yes
• 2 ?- !!.
• vertical( seg( point(1,1), point(1,2))).
• Yes
• 3 ?- point(1,2)point(2,Y).
• vertical( seg( point(1,1), point(2,Y))).
• No
• Imagine how more difficult this would be in Java!

14
More Matching Examples

• ?-vertical( seg( point( 2,3), P).
• P point( 2,Y)
• 2 ?- vertical( seg( point(2,3), P)).
• P point(2, _G409)
• fresh variables are used in each copy of a clause
• ?-vertical(S), horizontal(S).
• S seg( point(X,Y),point(X,Y))
• a point is the only (degenerate) segment that is
  both horizontal and vertical
• 1 ?- vertical(S), horizontal(S).
• S seg(point(_G391, _G392), point(_G391,
  _G392))

15
Declarative Meaning of Prolog Programs

• P - Q, R.
• Declarative readings
• P is true if Q and R are true
• From Q and R follows P
• Procedural readings
• To solve problem P, first solve subproblem Q,
  then solve subproblem R
• To satisfy P, first satisfy Q, and then R

16
Declarative Meaning

• An instance of a clause is the clause with each
  of its variable substituted by a term
• A goal G is true if and only if
• there is a clause C in the program such that
• there is a clause instance I of C such that
• the head of I is identical to G, and
• all the goals in the body of G are true
• A query is true if all of its goals are true for
  the same instantiation of the variables

17
Semicolon (Or)

• P - Q R. stands for
• P - Q. P - R.
• P - Q,RS,T,U. stands for
• P - (Q,R) (S,T,U). which is the same as
• P - Q,R. P - S,T,U.
• In Prolog, disjunctions may only appear in the
  body (premise) of a rule, not in its head
  (conclusion).

18
Examples

• Exercise 2.6 ch2_2.pl

19
Procedural Meaning

• Sample trace of the procedure execute
• program of Figure 2.10 (in ch2_3.pl)
• query ?-dark( X), big( X).
• Use the Prolog tracer
• non-graphical (nonguitracer/0)
• graphical (PCE-based guitracer/0)
• I find the non-graphical tracer clearer on this
  example

20
The Procedure execute
program
success/failure indicator
execute
goal list
instantiation of variables
21
execute

• English description Box on p.42
• Pseudocode Figure 2.11
• The instantiation returned is the one that leads
  to successful termination
• If a recursive call to execute fails,
  backtracking occurs, and variable instantiations
  done after the failure point are undone
• Hashing (at least on functors) is used to reduce
  scanning

22
Monkey and Banana

• A classic example of a puzzle-style problem (task
  environment is observable, deterministic,
  single-agent, static, etc.)
• The program solves the problem by search
• state has four components
• monkeys horizontal position (atdoor, middle,
  atwindow)
• monkeys vertical position (onfloor, onbox)
• horizontal position of the box (atdoor, middle,
  atwindow)
• whether the monkey has the banana (has, hasnot)

23
Moves

• There are four types of actions (moves), which
  change the state of the environment
• grasp banana
• climb box
• push box
• walk around
• These are formalized by the relation
• move( State1, Move, State2), where State1 and
  State2 are the states before and after the Move

24
Two Moves

• A simple move
• move( state( middle, onbox, middle, hasnot),pre
• grasp,
  move
• state( middle, onbox, middle, has) ).
  post
• A move schema
• move( state( Pos1, onfloor, Box, Has), state
  before
• walk( Pos1, Pos2),
  move
• state( Pos2, onfloor, Box, Has) ).
  state after

25
Can the Monkey Get the Banana?

• If the monkey has the banana, it can get it
• canget( state( _,_,_,has) ).
• If the monkey does not have the banana, it can
  get it if it can move to a state in which it can
  get the banana
• canget( State1) -
• move( State1, Move, State2),
• canget( State2).
• See Figure 2.13 (graph)

26
Monkey and Banana Program

• Figure 2.14. Try
• ?-canget( state( atdoor, onfloor,
  atwindow,hasnot) ).
• Goal tree for this goal is shown in Figure 2.15
• Prolog backtracks only once
• Why does Prolog try the moves in the order
  indicated?
• The order of clauses is crucial

27
Danger of Infinite Looping

• p - p.
• ?-p.
• If we place the walk rule before the climb and
  push rules (program fig2_14ord.pl), the monkey
  will walk aimlessly and never get the banana
• ?- canget(state(atdoor,onfloor,atwindow,hasnot)).
• ERROR Out of local stack
• Tracing indicates a repeated goal
• There are more principled ways to prevent
  infinite looping in search, as we will see in
  Ch.11

28
Variations on Predecessor

• The variations (in program ch2_16.pl, in which I
  included the parent relation) are obtained by
  reordering goals or clauses of the original
• pred1 and pred2 always work
• pred4 fails on, e.g., ?-pred4(tom,pat)
• pred3 fails on, e.g., ?-pred3(liz,jim)
• pred1 is simplest it tries the simplest
  options first

29
Combining Declarative and Procedural Views

• The order of clauses and goals matters
• Some declaratively correct Prolog programs do not
  work in practice
• Should we forget about the declarative meaning of
  Prolog programs?
• No! Declarative aspects are easier to formulate
  and understand
• First concentrate on the declarative aspects of a
  problem, then address the procedural aspects as
  needed