0% found this document useful (0 votes)

92 views

Prolog Tutorial

The document discusses the declarative programming language Prolog including its origins and capabilities for logic and constraint programming. Prolog uses clauses and rules to represent relationships between variables and can find solutions to queries by attempting to satisfy the bodies of rules and constraints.

Uploaded by

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

92 views

Prolog Tutorial

Uploaded by

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

You are on page 1/ 162

Prolog:

Programming in Logic
with some mention of Datalog and
Constraint Logic Programming

600.325/425 Declarative Methods

- J. Eisner

The original declarative

programming
language

Courses in programming languages

Prolog is always the declarative language they teach.
(imperative, functional, object-oriented, declarative)

Alain Colmeraeur & Philippe Roussel, 1971-1973

With help from theorem proving folks such as Robert Kowalski

Original project: Type in French statements & questions
Computer needed NLP and deductive reasoning
Efficiency by David Warren, 1977 (compiler, virtual machine)
Colmerauer & Roussel wrote 20 years later:
Prolog is so simple that one has the sense that sooner or
later someone had to discover it that period of our lives
remains one of the happiest in our memories.
We have had the pleasure of recalling it for this paper over
almonds accompanied by a dry martini.
600.325/425 Declarative Methods
- J. Eisner

Prolog vs. ECLiPSe

Most common free Prolog implementation is SWI Prolog.

Very nice, though faster ones are for sale (e.g., SICSTUS Prolog).

To run Prolog, you can just run ECLiPSe!

ECLiPSe is a perfectly good Prolog implementation,

although so far weve concentrated only on its extra features.

600.325/425 Declarative Methods

- J. Eisner

Prolog vs. ECLiPSe

Constraint
programming

Logic programming
(e.g., Prolog)

Constraint logic
programming
(e.g., ECLiPSe)

Efficient:
Variable ordering
Value ordering
Constraint joining and
propagation

Expressive:
Subroutines
Recursion
Variable domains are
terms (including lists
and trees)
But:
Simple, standard
solver: backtracking
and unification

Combo:
Tries to combine best
of both worlds
Later on well see how

But:
Encoding is annoying
Variables limited to
finite sets, ints, reals

600.325/425 Declarative Methods

- J. Eisner

Prolog as constraint
programming
(Person, Food)

Food

sam

dal

sam

curry

josie

samosas

josie

curry

rajiv

burgers

The above shows an ordinary constraintrajiv

between two
dal variables:
Person and Food
Prolog makes you name this constraint.
Heres a program that defines it:

Person

eats(sam, dal).
eats(sam, curry).
eats(rajiv, burgers).

eats(josie, samosas).
eats(josie, curry).
eats(rajiv, dal).

Now it acts like a subroutine! At the Prolog prompt you can type

eats(Person1, Food1). % constraint over two variables

eats(Person2, Food2). % constraint over two other variables
600.325/425 Declarative Methods
- J. Eisner

Simple constraints in Prolog

Heres a program defining the eats constraint:

eats(sam, dal).
eats(josie, samosas).
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
Now at the Prolog prompt you can type

eats(Person1, Food1). % constraint over two variables

eats(Person2, Food2). % constraint over two other variables

To say that Person1 and Person2 must eat a common

food, conjoin two constraints with a comma:
Actually, it will

eats(Person1, Food), eats(Person2, Food).

Prolog gives you possible solutions:

Person1=sam, Person2=josie, Food=curry

Person1=josie, Person2=sam, Food=curry
600.325/425 Declarative Methods
- J. Eisner

start with
solutions where
Person1=sam,
Person2=sam.
How to fix?
6

eats(sam, dal).
eats(sam, curry).
eats(rajiv, burgers).

eats(josie, samosas).
eats(josie, curry).
eats(rajiv, dal).

Your program file (compiled)

Sometimes called the database

Query that you type interactively

eats(Person1, Food), eats(Person2, Food).

Person1=sam, Person2=josie, Food=curry Prologs

Person1=josie, Person2=sam, Food=curry
600.325/425 Declarative Methods
- J. Eisner

answer
7

Simple constraints in Prolog

Heres a program defining the eats constraint:

eats(sam, dal).
eats(josie, samosas).
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
Now at the Prolog prompt you can type

eats(Person1, Food1). % constraint over two variables

eats(Person2, Food2). % constraint over two other variables

To say that Person1 and Person2 must eat a common

food, conjoin two constraints with a comma:
Actually, it will

eats(Person1, Food), eats(Person2, Food).

Prolog gives you possible solutions:

Person1=sam, Person2=josie, Food=curry

Person1=josie, Person2=sam, Food=curry
600.325/425 Declarative Methods
- J. Eisner

start with
solutions where
Person1=sam,
Person2=sam.
How to fix?
8

Queries in Prolog
These things you type at the prompt are called queries.
Prolog answers a query as Yes or No
according to whether it can find a satisfying assignment.
If it finds an assignment, it prints the first one before printing Yes.
You can press Enter to accept it, in which case youre done,
or ; to reject it, causing Prolog to backtrack and look for another.

eats(Person1, Food1). % constraint over two variables

eats(Person2, Food2). % constraint over two other variables

eats(Person1, Food), eats(Person2, Food).

Prolog gives you possible solutions:

[ press ; ]
Person1=sam, Person2=josie, Food=curry
Person1=josie, Person2=sam, Food=curry
600.325/425 Declarative Methods
- J. Eisner

Constants vs. Variables

Heres a program defining the eats constraint:

eats(sam, dal).
eats(josie, samosas).
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).

Now at the Prolog prompt you can type

eats(Person1, Food1). % constraint over two variables

eats(Person2, Food2). % constraint over two other variables

Nothing stops you from putting constants into constraints:

eats(josie, Food).
% what Food does Josie eat? (2 answers)
eats(Person, curry).
% what Person eats curry? (2 answers)
eats(josie, Food), eats(Person, Food). % wholl share what with Josie?

Food=curry, Person=sam
600.325/425 Declarative Methods
- J. Eisner

Constants vs. Variables

Variables start with A,B,Z or underscore:

Food, Person, Person2, _G123
Constant atoms start with a,b,z or appear in single quotes:
josie, curry, CS325
Other kinds of constants besides atoms:
Integers -7, real numbers 3.14159, the empty list []
eats(josie,curry) is technically a constant structure

Nothing stops you from putting constants into constraints:

eats(josie, Food).
% what Food does Josie eat? (2 answers)
eats(Person, curry).
% what Person eats curry? (2 answers)
eats(josie, Food), eats(Person, Food). % wholl share what with Josie?

Food=curry, Person=sam
600.325/425 Declarative Methods
- J. Eisner

Rules in Prolog
Lets augment our program with a new constraint:
eats(sam, dal).
eats(josie, samosas).
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
compatible(Person1, Person2) :- eats(Person1, Food),
eats(Person2, Food).
head

body

means if its supposed to look like

Person1 and Person2 are compatible if there exists some Food

that they both eat.
One way to satisfy the head of this rule is to satisfy the body.
You type the query: compatible(rajiv, X). Prolog answers: X=sam.

Prolog doesnt report that Person1=rajiv, Person2=sam, Food=dal.

These act like local variables in the rule. It already forgot about them.
600.325/425 Declarative Methods
- J. Eisner

Rules in Prolog

Lets augment our program with a new constraint:

eats(sam, dal).
eats(josie, samosas).
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
compatible(Person1, Person2) :- eats(Person1, Food),
eats(Person2, Food).
compatible(Person1, Person2) :- watches(Person1, Movie),
watches(Person2, Movie).
compatible(hal, Person2) :- female(Person2), rich(Person2).

One way to satisfy the head of this rule is to satisfy the body.
why only one way? Why not if and only if?
allusion to movie Shallow Hal;
600.325/425
Declarative
Methods
shows
that constants
can appear in rules
- J. Eisner

The Prolog solver

Prologs solver is incredibly simple.

eats(sam,X).

Iterates in order through the programs eats clauses.

First one to match is eats(sam,dal).
so it returns with X=dal.
If you hit semicolon, it backtracks and continues:
Next match is eats(sam,curry).
so it returns with X=curry.

600.325/425 Declarative Methods

- J. Eisner

The Prolog solver

Prologs solver is incredibly simple.

eats(sam,X).
eats(sam,X), eats(josie,X).

It satisfies 1st constraint with X=dal. Now X is assigned.

Now to satisfy 2nd constraint, it must prove eats(josie,dal). No!
So it backs up to 1st constraint & tries X=curry (sams other food).
Now it has to prove eats(josie,curry). Yes!
So it is able to return X=curry. What if you now hit semicolon?

eats(sam,X), eats(Companion, X).

What happens here?

What variable ordering is being used? Where did it come from?
What value ordering is being used? Where did it come from?

600.325/425 Declarative Methods

- J. Eisner

The Prolog solver

Prologs solver is incredibly simple.

eats(sam,X).
eats(sam,X), eats(josie,X).
eats(sam,X), eats(Companion, X).
compatible(sam,Companion).
This time, first clause that matches is

compatible(Person1, Person2) :- eats(Person1, Food),

eats(Person2, Food).
Head of clause matches with Person1=sam, Person2=Companion.
So now we need to satisfy body of clause:

eats(sam,Food), eats(Companion,Food).

Look familiar?
We get Companion=rajiv.

600.325/425 Declarative Methods

- J. Eisner

The Prolog solver

Prologs solver is incredibly simple.

eats(sam,X).
eats(sam,X), eats(josie,X).
eats(sam,X), eats(Companion, X).
compatible(sam,Companion).
compatible(sam,Companion), female(Companion).

compatible(Person1, Person2) :- eats(Person1, Food),

eats(Person2, Food).
Our first try at satisfying 1st constraint is Companion=rajiv (as before).
But then 2nd constraint is female(rajiv). which is presumably false.
So we backtrack and look for a different satisfying assignment of the
first constraint: Companion=josie.
Now 2nd constraint is female(josie). which is presumably true.
We backtracked into this compatible clause (food) & retried it.
No need yet to move on to the next compatible clause (movies).
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

Each constraint has four ports: call, exit, redo, fail

600.325/425 Declarative Methods

- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
exit

call

exit

call

Each constraint has four ports: call, exit, redo, fail

exit ports feed forward into call ports

600.325/425 Declarative Methods

- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:

redo fail

Each constraint has four ports: call, exit, redo, fail

exit ports feed forward into call ports
fail ports feed back into redo ports
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
backtracking at work

call
fail

exit
redo

Each constraint has four ports: call, exit, redo, fail

exit ports feed forward into call ports
fail ports feed back into redo ports
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

no way to satisfy this constraint given

the assignments so far so first call fails
How disappointing. Lets try a happier outcome.
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

call

we satisfy this constraint, making additional

assignments, and move on

600.325/425 Declarative Methods

- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

we satisfy this constraint, making additional

assignments, and move on
but if our assignments cause later constraints to
fail, Prolog may come back and redo this one
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

we satisfy this constraint, making additional

assignments, and move on
but if our assignments cause later constraints to
fail, Prolog may come back and redo this one
lets say we do find a new way to satisfy it.
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

If the new way still causes later constraints to

fail, Prolog comes back through the redo port to
try yet again.

600.325/425 Declarative Methods

- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
fail

exit
redo

If the new way still causes later constraints to

fail, Prolog comes back through the redo port to
try yet again.
If were now out of solutions, we fail too
600.325/425 Declarative Methods
- J. Eisner

Backtracking and Beads

Each Prolog constraint is like a bead in a string

of beads:
call
redo fail

exit
redo

If the new way still causes later constraints to

fail, Prolog comes back through the redo port to
try yet again.
If were now out of solutions, we fail too
sending Prolog back to redo previous constraint.
600.325/425 Declarative Methods
- J. Eisner

Rules as nested beads

loves(hal, X) :- female(X), rich(X).

loves(hal, X)
call
fail

female(X)

rich(X)

exit
redo

this is why you can backtrack into loves(hal,X)

600.325/425 Declarative Methods

- J. Eisner

Alternative rules
loves(hal, X) :- female(X), rich(X).
loves(Child, X) :- parent(X, Child).
loves(hal, X)
call

fail

female(X)

rich(X)

parent(X, hal)

exit
redo
exit
redo

after running out of rich women, hal tries his parents

600.325/425 Declarative Methods
- J. Eisner

Alternative rules
female(parvati).
female(josie).
female(martha).

female(X)
female(parvati)
female(josie)
female(martha)

loves(hal, X)
call

fail

female(X)

rich(X)

parent(X, hal)

600.325/425 Declarative Methods

- J. Eisner

exit
redo
exit
redo

Prolog as a database
language
The various eats(, ) facts can be regarded as rows in a

database (2-column database in this case).

Standard relational database operations:
eats(X,dal). % select
edible(Object) :- eats(Someone, Object). % project
parent(X,Y) :- mother(X,Y).
% union
parent(X,Y) :- father(X,Y).
sister_in_law(X,Z) :- sister(X,Y), married(Y,Z).
% join
Why the heck does anyone still use SQL? Beats me.
Warning: Prologs backtracking strategy can be inefficient.

But we can keep the little language illustrated above (Datalog)

and instead compile into optimized query plans, just as for SQL.
600.325/425 Declarative Methods
- J. Eisner

Recursive queries

Prolog allows recursive queries (SQL doesnt).

Whos married to their boss?

Whos married to their bosss boss?

boss(X,Y), boss(Y,Z), married(X,Z).

Whos married to their bosss bosss boss?

boss(X,Y), married(X,Y).

Okay, this is getting silly. Lets do the general case.

Whos married to someone above them?

above(X,X).
above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y), married(X,Y).

Base case. For simplicity, it says that any X is above herself.

If you dont like that, replace base case with above(X,Y) :- boss(X,Y).
600.325/425 Declarative Methods
- J. Eisner

Recursive queries

above(X,X).
above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(c,h). % should return Yes
matches above(X,X)? no

boss(a,b). boss(a,c).
boss(b,d). boss(c,f).
boss(b,e).
a
b
d

c
e

f
g

600.325/425 Declarative Methods

- J. Eisner

Recursive queries

above(X,X).
above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(c,h). % should return Yes
matches above(X,Y) with X=c, Y=h
boss(c,Underling),
matches boss(c,f) with Underling=f
above(f, h).
matches above(X,X)? no

boss(a,b). boss(a,c).
boss(b,d). boss(c,f).
boss(b,e).
a
b
d

c
e

f
g

600.325/425 Declarative Methods

- J. Eisner

Recursive queries

above(X,X).
above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(c,h). % should return Yes
boss(a,b). boss(a,c).
matches above(X,Y) with X=c, Y=h
boss(b,d). boss(c,f).
boss(c,Underling),
boss(b,e).
a
matches boss(c,f) with Underling=f
above(f, h).
b
c
matches above(X,Y) with X=f, Y=h
(local copies of X,Y distinct from previous call) d e f
boss(f,Underling),
g h

matches boss(f,g) with Underling=g

above(g, h).

ultimately fails because g has no underlings

600.325/425 Declarative Methods
- J. Eisner

Recursive queries

matches boss(f,h) with Underling=h

above(h, h).

matches above(X,X) with X=h

600.325/425 Declarative Methods
- J. Eisner

Ordering constraints for

b
above(X,X).
speed
d e
above(X,Y) :- boss(X,Underling), above(Underling,Y).

Which is more efficient?

above(c,h), friends(c,h).
friends(c,h), above(c,h).

Probably quicker to check

first whether theyre friends.
If theyre not, can skip the
whole long above(c,h)
computation, which must
iterate through descendants
of c.

Which is more efficient?

above(X,Y), friends(X,Y).
friends(X,Y), above(X,Y).
For each boss X, iterate
through all Y below her and
check if each Y is her friend.
(Worse to start by iterating
through all friendships: if X has
5 friends Y, we scan all the
people below her 5 times,
looking for each friend in turn.)

600.325/425 Declarative Methods

- J. Eisner

Ordering constraints for

above(X,X).
speed

query
modes 2.

+,+

+,-,+
-,-

a
b
d

c
e

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- boss(Overling,Y), above(X,Overling).
If the query is above(c,e)?

f
g

1. iterates over descendants of c, looking for e

2. iterates over ancestors of e, looking for c.
2. is better: no node has very many ancestors, but some
have a lot of descendants.

If the query is above(c,Y)?

If the query is above(X,e)?
If the query is above(X,Y)?

1. is better. Why?
2. is better. Why?
Doesnt matter much. Why?

600.325/425 Declarative Methods

- J. Eisner

Ordering constraints for

above(X,X).
speed

query
modes 2.

+,+

+,-,+
-,-

a
b
d

c
e

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- boss(Overling,Y), above(X,Overling).
If the queryWarning:
is above(c,e)?
Actually, 1. has a significant

f
g

advantage in Prolog implementations that

1. iteratesdoover
descendants of c, looking for e
1st-argument indexing.
2. iterates over ancestors of e, looking for c.
That makes
it much
to find
2. is better:
no node
has faster
very many
ancestors, but some
a given
children (boss(x,Y))
have a
lot ofxs
descendants.

than a given ys parents (boss(X,y)).

Sois
it above(c,Y)?
is much faster to find
1. is descendants
better. Why?
query
than ancestors.

If the
2. is better. Why?
If the query is above(X,e)?
If you dont like that, figure
outmatter
how to much. Why?
Doesnt
If the query is
above(X,Y)?
tell your Prolog to do 2nd-argument
indexing.
Or just
use subordinate(Y,X)
600.325/425
Declarative
Methods
- J. of
Eisner
instead
boss(X,Y)!

Ordering constraints for

above(X,X).
speed

1.
2.

a
b
d

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- above(Underling,Y), boss(X,Underling).

c
e

f
g

2. takes forever literally!! Infinite recursion.

above(c,h). % should return Yes
matches above(X,Y) with X=c, Y=h
above(Underling, h)
matches above(X,Y) with X=Underling, Y=h
above(Underling, h)

600.325/425 Declarative Methods

- J. Eisner

Ordering constraints for

above(X,X).
speed

1.
2.

a
b
d

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- above(Underling,Y), boss(X,Underling).

c
e

f
g

2. takes forever literally!! Infinite recursion.

Heres how:
above(c,h). % should return Yes
matches above(X,X)? no

600.325/425 Declarative Methods

- J. Eisner

Ordering constraints for

above(X,X).
speed

1.
2.

a
b
d

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- above(Underling,Y), boss(X,Underling).

c
e

f
g

2. takes forever literally!! Infinite recursion.

Heres how:
above(c,h). % should return Yes
matches above(X,Y) with X=c, Y=h
above(Underling, h)
matches above(X,X) with local X = Underling = h
boss(c, h) (our current instantiation of boss(X, Underling))
no match
600.325/425 Declarative Methods
- J. Eisner

Ordering constraints for

above(X,X).
speed

1.
2.

a
b
d

Which is more efficient?

above(X,Y) :- boss(X,Underling), above(Underling,Y).
above(X,Y) :- above(Underling,Y), boss(X,Underling).

c
e

f
g

2. takes forever literally!! Infinite recursion.

Heres how:
above(c,h). % should return Yes
matches above(X,Y) with X=c, Y=h
above(Underling, h)
matches above(X,Y) with X=Underling, Y=h
above(Underling, h),

600.325/425 Declarative Methods

- J. Eisner

Prolog also allows complex

terms

What weve seen so far is called Datalog:

databases in logic.

Prolog is programming in logic. It goes a

little bit further by allowing complex terms,
including records, lists and trees.

These complex terms are the source of the

only hard thing about Prolog, unification.
600.325/425 Declarative Methods
- J. Eisner

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B, date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).

Several essentially identical ways to find older students:

at_jhu(student(IDNum, Name, date(Day,Month,Year))),

Year < 1983.
at_jhu(student(_, Name, date(_,_,Year))),
Year < 1983.
usually no need to use =
at_jhu(Person),
but sometimes its nice
Person=student(_,_,Birthday),
to introduce a temporary name
Birthday=date(_,_,Year),
especially if youll use it twice
Year < 1983.
This query binds Person and Birthday to
complex structured values, and Year to an int. Prolog prints them all.
600.325/425 Declarative Methods
- J. Eisner

homepage(html(head(title("Peter A. Flach")),
body([img([align=right,src="logo.jpg"]),One big term
img([align=left,src="peter.jpg"]),representing
h1("Peter Flach's homepage"), an HTML web page.
The style on
h2("Research interests"),
the previous
ul([li("Learning from structured data"),
slide could get
...,
unmanageable.
li(a([href="CV.pdf"],"Full CV"))]),
h2("Current activities"),
...,
You have to
h2("Past activities"),
remember that
...,
birthday is
h2("Archives"),
argument #3
...,
pagetype(Webpage,researcher):of person, etc.
hr,address()
page_get_head(Webpage,Head),
])
head_get_title(Head, Title),
)).
This nondeterministic query asks
person(Title),

whether the page title is a person

and Research appears in some
heading on the page.

slide thanks to Peter A. Flach (modified)

page_get_body(Webpage,Body),
body_get_heading(Body,Heading),
substring("Research",Heading).

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday( Stu , Bday) :- Stu=student(_, _, Bday).
date_get_year(Date,Year) :- Date=date(_, _, Year). bad style

So you could write accessors in object-oriented style:

student_get_bday(Student,Birthday),
date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
Answer:
Student=student(456591, Fuzzy W, date(23, aug, 1966)),
Birthday=date(23, aug, 1966),
Year=1966.
600.325/425 Declarative Methods
- J. Eisner

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday),
date_get_year(date(_, _, Year), Year).

Bday)

.
good style

So you could write accessors in object-oriented style:

student_get_bday(Student,Birthday),
whoa, what are the
date_get_year(Birthday,Year),
variable bindings at
at_jhu(Student), Year < 1983.
this point??
Answer:
Student&Birthday
Student=student(456591, Fuzzy W, date(23,
aug, 1966)),
werent
forced to
Birthday=date(23, aug, 1966),
particular values
Year=1966.
by the constraint.
600.325/425 Declarative Methods
But were forced
49
- J. Eisner
into a relation

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday),
date_get_year(date(_, _, Year), Year).

Bday)

.
good style

So you could write accessors in object-oriented style:

student_get_bday(Student,Birthday),
student Student
date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
? ?
?
Birthday
Answer:
Student=student(456591, Fuzzy W, date(23, aug, 1966)),
Birthday=date(23, aug, 1966),
Year=1966.
600.325/425 Declarative Methods
- J. Eisner

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday),
date_get_year(date(_, _, Year), Year).

Bday)

.
good style

So you could write accessors in object-oriented style:

student_get_bday(Student,Birthday),
student Student
date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
? ? date
Birthday
Answer:
? 1966)),
?
?
Year
Student=student(456591, Fuzzy W, date(23, aug,
Birthday=date(23, aug, 1966),
Year=1966.
600.325/425 Declarative Methods
- J. Eisner

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday),
date_get_year(date(_, _, Year), Year).

Bday)

.
good style

So you could write accessors in object-oriented style:

student_get_bday(Student,Birthday),
student Student
date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
128327 SK date
Birthday
Answer:
2 may
1986 Year
Student=student(456591, Fuzzy W, date(23, aug,
1966)),
Birthday=date(23, aug, 1966),
Year=1966.
600.325/425 Declarative Methods
- J. Eisner

Complex terms
at_jhu(student(128327, Spammy K', date(2, may, 1986))).
at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday),
date_get_year(date(_, _, Year), Year).

Bday)

.
good style

So you could write accessors in object-oriented style:

Fail

student_get_bday(Student,Birthday),
date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
(and backtrack)
Answer:
Student=student(456591, Fuzzy W, date(23, aug, 1966)),
Birthday=date(23, aug, 1966),
Year=1966.
600.325/425 Declarative Methods
- J. Eisner

How does matching happen?

eats(sam, dal).
eats(josie, sundae(vanilla, caramel)).
eats(rajiv, sundae(mintchip, fudge)).
eats(robot(C-3PO), Anything). % variable in a fact
Query: eats(A, sundae(B,fudge)).
Answer: A=rajiv, B=mintchip

600.325/425 Declarative Methods

- J. Eisner

How does matching happen?

sundae
B

A=sam

fudge

eats
sam

dal

No match

sundaedal
(more precisely, sundae/2 dal/0)

600.325/425 Declarative Methods

- J. Eisner

How does matching happen?

sundae
B

A=josie

fudge
B=vanilla

eats
josie sundae

No match

vanilla caramel
fudgecaramel

600.325/425 Declarative Methods

- J. Eisner

How does matching happen?

sundae
B

A=rajiv

eats
rajiv

sundae

Match!

fudge
B=mintchip

mintchip fudge

600.325/425 Declarative Methods

- J. Eisner

How does matching happen?

eats
(B still unknown)
A=robot(C-3PO)
A

sundae

fudge

robot

Anything
Anything =
sundae(B,fudge)
C-3PO

600.325/425 Declarative Methods

- J. Eisner

How does matching happen?

eats(sam, dal).
eats(josie, sundae(vanilla, caramel)).
eats(rajiv, sundae(mintchip, fudge)).
eats(robot(C-3PO), Something) :- food(Something).
food(dal).
icecream(vanilla).
food(fudge).
icecream(chocolate).
food(sundae(Base, Topping)) :- icecream(Base),
food(Topping).
Query: eats(robot(A), sundae(B,fudge)).
Answer: A=C-3PO, B can be any kind of ice cream
600.325/425 Declarative Methods
- J. Eisner

How does matching happen?

Lets use a = constraint to invoke unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).
Answer: A=blah(blah), B=2, E=f(D)
foo
A

foo
bar

blah
f

blah

bar
2

D
This is like unit propagation in DPLL SAT solvers.

Unifying 2 nodes propagates: it forces their children to be unified too.

(As in DPLL, propagation could happen in any order. Options?)
This may bind some unassigned variables to particular nodes.
(Like assigning A=0600.325/425
or A=1 inDeclarative
DPLL.) Methods
In case of a conflict, backtrack
to prev. decision, undoing all propagation.
60
- J. Eisner

Two obvious recursive

definitions
Term (the central data structure in Prolog programs)

Any variable is a term (e.g., X).

2.
Any atom (e.g., foo) or other simple constant (e.g., 7) is a term.
3.
If f is an atom and t1, t2, tn are terms,
then f(t1, t2, tn) is a term.
This lets us build up terms of any finite depth.
1.

Unification (matching of two terms =)

1.
If or is a variable, = succeeds and returns immediately:
side effect is to bind that variable.
2.
If is f(t1, t2, tn) and is f(t1, t2, tn), then recurse:
= succeeds iff we can unify children t1=t1, t2=t2, tn=tn.

n=0 is the case where , are atoms or simple constants.

In all other cases, = fails (i.e., conflict).
600.325/425 Declarative Methods
- J. Eisner

Two obvious recursive

More properly, if its still unknown (?), given bindings so far.
definitions
Consider foo(X,X)=foo(3,7). Recurse:

First we unify X=3. Now X is no longer unknown.

Then try to unify X=7, but since X already bound to 3,
this tries to unify 3=7 and fails. X cant be both 3 and 7.

(Like the conflict from assigning X=0 and

then X=1 during DPLL propagation.)
How about: foo(X1,X2)=foo(3,7), X1=X2? Or X1=X2, foo(X1,X2)=foo(3,7)?

Unification (matching of two terms =)

n=0 is the case where , are atoms or simple constants.

In all other cases, = fails (i.e., conflict).
600.325/425 Declarative Methods
- J. Eisner

Variable bindings resulting from

unification
Lets use the = constraint to invoke unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo

foo
bar

?
B

blah
blah 2

f
?

bar
?

foo
A

blah
blah 2

600.325/425 Declarative Methods

- J. Eisner

bar
f
?

Variable bindings resulting from

unification
The = constraint invokes unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo
?

bar
?
B

foo
blah
blah 2

f
?

bar
?

foo
A

blah
blah 2

Further constraints cant unify E=7. Why not?

600.325/425 Declarative Methods

- J. Eisner

bar

f
?

Variable bindings resulting from

unification
The = constraint invokes unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo
?

bar
?
B

foo
blah
blah 2

f
?

bar
?

foo
A

blah
blah 2

Further constraints cant unify E=7. Why not?

B
They can unify E=f(7). Then D=7 automatically.

600.325/425 Declarative Methods

- J. Eisner

bar
f
?

Variable bindings resulting from

unification
The = constraint invokes unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo
?

bar
?
B

Note: All unification is

undone upon backtracking!

foo
blah
blah 2

f
?

bar
?

foo
A

blah
blah 2

Further constraints cant unify E=7. Why not?

B
They can unify E=f(7). Then D=7 automatically.
Or if they unify D=7, then E=f(7) automatically.
600.325/425 Declarative Methods
- J. Eisner

bar
f
?

Two obvious recursive

definitions
Even X=f(X) succeeds, with X=the weird circular term f(f(f())).
Our definitions of terms and unification dont allow circularity.
So arguably X=f(X) should just fail. Unsatisfiable constraint!
But this occurs check would be slow, so Prolog skips it.

Unification (matching of two terms =)

n=0 is the case where , are atoms or simple constants.

In all other cases, = fails (i.e., conflict).
600.325/425 Declarative Methods
- J. Eisner

When does Prolog do

To satisfy an = constraint.
unification?
To satisfy any other constraint . Prolog tries to unify it with some that
1.
2.

is the head of a clause in your program:

.
% a fact
:- , , .
% a rule
1
2
3

Prologs decisions = which clause from your program to pick.

Like decision variables in DPLL, this is the nondeterministic choice part.

A decision propagates in two ways:

Unifying nodes forces their children to unify, as we just saw.

After unifying = where is a rule head, we are forced to satisfy

constraints 1, 2, 3 from the rules body (requiring more unification).

Like unit propagation in DPLL. Can fail, forcing backtracking.

How to satisfy them may involve further decisions, unlike DPLL.

Variable bindings that arise during a unification may affect Prologs ability
to complete the unification, or to do subsequent unifications that are
needed to satisfy additional constraints (e.g., those from clause body).

Bindings are undone600.325/425

upon backtracking,
up to the last decision for which
Declarative Methods
other options are available. - J. Eisner
68

Note: The = constraint isnt

really special
To process an = constraint.

Actually, this is not really special. You could implement = if

it werent built in. Just put this fact in your program:

equal(X,X).

Now you can write the constraint

equal(foo(A,3), foo(2,B)).

How would Prolog try to satisfy the constraint?

It would try to unify equal(X,X) with equal(foo(A,3), foo(2,B)).

This means unifying X with foo(A,3) and X with foo(2,B).
So foo(A,3) would indirectly get unified with foo(2,B),
yielding A=2, B=3.
600.325/425 Declarative Methods
- J. Eisner

Note: The = constraint isnt

really
special
Query: equal(foo(A,3), foo(2,B)).

Unify against program fact: equal(X,X).

equal
foo
A

equal
foo

3 2

The unification wouldnt have

succeeded if there hadnt
been a way to instantiate A,B
to make the foo terms equal.
equal

foo

If we wanted to call it = instead of equal,

we could write =(X,X) as our program
fact. Prolog even lets you declare = as
infix, making X=X a synonym for =(X,X).
600.325/425 Declarative Methods
- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday),

student_get_bday
Student
Birthday
?
?

student_get_bday
student
?

600.325/425 Declarative Methods

- J. Eisner

Bday

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday),

student_get_bday
Student
student
Birthday
? ? ?
600.325/425 Declarative Methods
- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),

student_get_bday date_get_year
Student
Year
student
?
Birthday
? ? ?
600.325/425 Declarative Methods
- J. Eisner

date_get_year
date
?

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),

student_get_bday date_get_year
Student
student
Birthday
? ? date
Year
? ? ?
600.325/425 Declarative Methods
- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
Note: We dont really care

student_get_bday date_get_year
about the black pieces anymore.
Student
They are just left-over junk
student
that helped us satisfy previous
Birthday
constraints. We could even
? ? date
garbage-collect them now, since
Year
no variables point to them.
? ? ?
Declarative
The rest of the structure600.325/425
is exactly
what Methods
we hoped for (earlier slide).
- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
at_jhu(Student),
at_jhu
at_jhu
student_get_bday date_get_year
Student
student
student
Birthday
? ? date
128327 SK date
Year
2 may 1986
? ? ?

600.325/425 Declarative Methods

- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
at_jhu(Student),
at_jhu
student_get_bday date_get_year
Student
student
Birthday
128327 SK date
Year
2 may 1986

600.325/425 Declarative Methods

- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
at_jhu(Student), Year < 1983.
at_jhu
student_get_bday date_get_year
Student
fail! 1986 < 1983
student
Birthday
doesnt match anything
128327 SK date
<
in database. (Well, okay,
Year
actually < is built-in.)
1983
2 may 1986

600.325/425 Declarative Methods

- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B,
date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
at_jhu(Student),
at_jhu
at_jhu
student_get_bday date_get_year
backtrack!
Student
student
student
Birthday
? ? date
128327 SK date
Year
2 may 1986
? ? ?

600.325/425 Declarative Methods

- J. Eisner

Now we should really get the

birthday example

at_jhu(student(128327, Spammy K', date(2, may, 1986))).

at_jhu(student(126547, Blobby B, date(15, dec, 1985))).
at_jhu(student(456591, Fuzzy W',
date(23, aug, 1966))).
student_get_bday(student(_, _, Bday), Bday).
date_get_year(date(_, _, Yr), Yr).

student_get_bday(Student,Birthday), date_get_year(Birthday,Year),
at_jhu(Student),
at_jhu
at_jhu
student_get_bday date_get_year
try another
Student
student
student
Birthday
? ? date
126547 BB date
Year
15 dec 1985
? ? ?

600.325/425 Declarative Methods

- J. Eisner

Variable bindings resulting from

unification
Lets use the = constraint to invoke unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo

foo
bar

?
B

blah
blah 2

f
?

bar
?

foo
A

blah
blah 2

600.325/425 Declarative Methods

- J. Eisner

bar
f
?

Variable bindings resulting from

unification
The = constraint invokes unification directly

Query: foo(A,bar(B,f(D))) = foo(blah(blah), bar(2,E)).

Answer: A=blah(blah), B=2, f(D)=E
foo

foo
bar

?
B

blah
blah 2

f
?

bar

Each variable name stores a pointer too

(initially to a new ?).
So, what happens if we now unify A=D?

foo
A

blah
blah 2

In memory, its not animated. What happens really?

bar

?
Each ? stores a pointer.
D
Initially its the null pointer, but when ? is first unified with another term,
change it to point to that term. (This is whats undone upon backtracking.)
Future accesses to the ? dont see the ?; they transparently follow its pointer.
(If two ?s with null pointers 600.325/425
are unified,
pick one
and make it point to the other
Declarative
Methods
J. Eisner
(just as in the Union-Find algorithm). -This
may lead to chains of pointers.) 82

Time to try some

programming!

Now you know how the Prolog solver works.

(It helps to know in advance.)

Lets try some programming!

Well try recursion again, but this time with

complex terms.

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

here)
female(sarah).
female(rebekah).
female(hagar_concubine).
female(milcah).
female(bashemath).
female(mahalath).
female(first_daughter).
female(second_daughter).
female(terahs_first_wife).
female(terahs_second_wife).
female(harans_wife).
female(lots_first_wife).
female(ismaels_wife).
female(leah).
female(kemuels_wife).
female(rachel).
female(labans_wife).

male(terah).
male(abraham). male(nahor).
male(haran).
male(isaac).
male(ismael).
male(uz).
male(kemuel). male(bethuel).
male(lot).
male(iscah).
male(esau).
male(jacob).
male(massa).
male(hadad). male(laban).
male(reuel).
male(levi3rd).
male(judah4th).
male(aliah). male(elak).
male(moab). male(benammi).

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

here)
father(terah, sarah).
father(terah, abraham).
father(terah, nahor).
father(terah, haran).
father(abraham, isaac).
father(abraham, ismael).
father(nahor, uz).
father(nahor, kemuel).
father(nahor, bethuel).
father(haran, milcah).
father(haran, lot).
father(haran, iscah).
father(isaac, esau).
father(isaac, jacob).
father(ismael, massa).
father(ismael, mahalath).
father(ismael, hadad).
father(ismael, bashemath).
father(esau, reuel).
father(jacob, levi3rd).
father(jacob, judah4th).
father(esau, aliah).
father(esau, elak).
father(kemuel, aram).
father(bethuel, laban).
father(bethuel, rebekah).
father(lot, first_daughter).
father(lot, second_daughter).
father(lot, moab).
father(lot, ben_ammi).
father(laban, rachel).
father(laban, leah).

mother(terahs_second_wife, sarah).
mother(terahs_first_wife, abraham).
mother(terahs_first_wife, nahor).
mother(terahs_first_wife, haran).
mother(sarah, isaac).
mother(hagar_concubine, ismael).
mother(milcah, uz).
mother(milcah, kemuel).
mother(milcah, bethuel).
mother(harans_wife, milcha).
mother(harans_wife, lot).
mother(harans_wife, iscah).
mother(rebekah, esau).
mother(rebekah, jacob).
mother(ismaels_wife, massa).
mother(ismaels_wife, mahalath).
mother(ismaels_wife, hadad).
mother(ismaels_wife, bashemath).
mother(bethuels_wife, laban).
mother(bethuels_wife, rebekah).
mother(lots_first_wife, first_daughter).
mother(lots_first_wife, second_daughter).
mother(first_daughter, moab).
mother(second_daughter, ben_ammi).
mother(bashemath, reuel).
mother(leah, levi3rd).
mother(leah, judas4th).
mother(mahalath, aliah).
mother(mahalath, elak).
mother(lebans_wife,
rachel).
600.325/425 Declarative
Methods
mother(lebans_wife, leah).
- J. Eisner

Family trees (just Datalog

here)

wife(X, Y):- husband(Y, X).

husband(terah, terahs_first_wife).
husband(terah, terahs_second_wife).
married(X, Y):- wife(X, Y).
husband(abraham, sarah).
husband(abraham, hagar_concubine).
married(X, Y):- husband(X, Y).
husband(nahor, milcah).
husband(haran, harans_wife).
husband(isaac, rebekah).
husband(ismael, ismaels_wife).
husband(kemuel, kemuels_wife).
husband(bethuel, bethuels_wife).
husband(lot, lots_first_wife).
convention in
husband(lot, first_daughter).
these slides
husband(lot, second_daughter).
Does husband(X,Y) mean
husband(esau, bashemath).
husband(jacob, leah).
X is the husband of Y
husband(jacob, rachel).
or
husband(esau, mahalath).
husband(laban, labans_wife).
The husband of X is Y?

Conventions vary pick one and stick to it!

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

% database
here)

mother(sarah,isaac).

father(abraham,isaac).

parent(X, Y):- mother(X, Y).

parent(X, Y):- father(X, Y).

grandmother(X, Y):- mother(X, Z), parent(Z, Y).

grandfather(X, Y):- father(X, Z), parent(Z, Y).
grandparent(X, Y):- grandfather(X, Y).
grandparent(X, Y):- grandmother(X, Y).
Can we refactor this code on blackboard to avoid duplication?

better handling of male/female

currently grandmother and grandfather repeat the same XZY pattern

better handling of generations

currently great_grandmother and great_grandfather would repeat it again

600.325/425 Declarative Methods
- J. Eisner

Family trees (just Datalog

here)
Refactored
database (now specifies parent, not mother/father):

female(sarah).
male(abraham).

Refactored ancestry (recursive, gender-neutral):

parent(sarah, isaac).
parent(abraham, isaac).

anc(0,X,X).
anc(N,X,Y) :- parent(X,Z), anc(N-1,Z,Y).

Now just need one clause to define each English word:

parent(X,Y)
:- anc(1,X,Y).
mother(X,Y)
:- parent(X,Y), female(X).
father(X,Y)
:- parent(X,Y), male(X).
grandparent(X,Y) :- anc(2,X,Y).
grandmother(X,Y) :- grandparent(X,Y), female(X).
grandfather(X,Y) :- grandparent(X,Y), male(X).
great_grandparent(X,Y) :- anc(3,X,Y).
etc.
600.325/425 Declarative Methods
- J. Eisner

Family trees (just Datalog

here)
ancestry (recursive, gender-neutral):
Refactored

anc(0,X,X).
anc(N,X,Y) :- parent(X,Z), anc(N-1,Z,Y).

Wait a minute! What does anc(2,abraham,Y) do?

Recurses on anc(2-1, isaac, Y).

Which recurses on anc((2-1)-1, jacob,Y).
Which recurses on anc(((2-1)-1)-1, joseph, Y).

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

here)
ancestry (recursive, gender-neutral):
Refactored

anc(0,X,X).
anc(N,X,Y) :- parent(X,Z), anc(N-1,Z,Y).

Wait a minute! What does anc(2,abraham,Y) do?

Recurses on anc(2-1, isaac, Y).

Which recurses on anc((2-1)-1, jacob,Y).

Oops! (2-1)-1 isnt zero. Its -(-(2,1),1)), a compound term.

anc
anc
doesnt
jacob
Y
unify
0
X
X
with
1
2

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

here)
ancestry (recursive, gender-neutral):
Refactored

anc(0,X,X).
anc(N,X,Y) :- parent(X,Z), anc(N-1,Z,Y).
N > 0, M is N-1, parent(X,Z), anc(M,Z,Y).
is does arithmetic for you:
is(0,1-1).
0 is 1-1.
is(4,2+2).
4 is 2+2.
is(24, 7*7-5*5)
24 is 7*7-5*5.

cuts off the search for

grandchildren at 2 levels
(once N <= 0, its legal but wasteful
to continue to recurse in hopes that
well run into 0 again if we keep
subtracting 1!)

600.325/425 Declarative Methods

- J. Eisner

Family trees (just Datalog

here)
Refactored
ancestry (recursive, gender-neutral):

anc(0,X,X).
anc(N,X,Y) :- M is N-1, parent(X,Z), anc(M,Z,Y).

Now, the above works well for queries like

anc(2,abraham,Y). % query mode: anc(+,+,-)
anc(2,X,jacob).
% query mode: anc(+,-,+)
anc(2,X,Y). % query mode: anc(+,-,-)
But what happens if N is unassigned at query time?
anc(N,abraham,jacob).
% query mode: anc(-,+,+)
Instantiation fault on constraint M is N-1.
The is built-in predicate doesnt permit queries in the mode is(-,-)!
So cant compute N-1.
At least not without using an ECLiPSe delayed constraint: M #= N-1.
A delayed constraint doesnt have to be satisfied yet, but well hang onto it for later.
Anything we learn later about the domains of M and N will be propagated.

Same problem if we have the constraint N > 0, which only allows >(+,+).
Here the ECLiPSe delayed constraint would be N #> 0.
600.325/425 Declarative Methods
- J. Eisner

Family trees (just Datalog

here)
Refactored
ancestry (recursive, gender-neutral):

Now, the above works well for queries like

anc(0,X,X).
anc(N,X,Y) :- M is N-1, M >= 0, parent(X,Z), anc(M,Z,Y).

anc(0,X,X).
anc(N,X,Y) :- parent(X,Z), anc(M,Z,Y), N is M+1.
Here we query parent(+,-), which binds Z,
and then recursively query anc(-,+,+) again, which binds M,
and then query is(-,+), which is a permitted mode for is. That works.

What a shame that we have to write different programs to handle different

query modes! Not very
declarative.
600.325/425
Declarative Methods
- J. Eisner

A few more examples of family

relations

(only the gender-neutral

versions
half_sibling(X,Y)
:- parent(Z,X), parent(Z,Y),
X \= Y.

are

shown):- mother(Z,X), mother(Z,Y), father(W,X), father(W,Y), X \=Y.

sibling(X,Y)

Warning: This inequality constraint X \= Y only works right in mode +,+.

(It asks whether unification would fail. So the answer to A \= 4 is no,

since A=4 would succeed! There is no way for Prolog to represent that A can
be anything but 4 there is no anything but 4 term. However, ECLiPSe
can use domains or delayed constraints to represent this property of A: use a
delayed constraint A #\= 4.)

aunt_or_uncle(X,Y) :- sibling(X,Z), parent(Z,Y).

cousin(X,Y):- parent(Z,X), sibling(Z,W), parent(W,Y).

deepcousin(X,Y):- sibling(X,Y).

deepcousin(X,Y):- parent(Z,X), deepcousin(Z,W), parent(W,Y).

% siblings are 0 th cousins

% we are Nth cousins if we have parents who are (N-1)st cousins

600.325/425 Declarative Methods
- J. Eisner

Ancestry

deepcousin(X,Y):- sibling(X,Y).

% siblings are 0th cousins

deepcousin(X,Y):- parent(Z,X), deepcousin(Z,W), parent(W,Y).

% we are Nth cousins if we have parents who are (N-1)st cousins

Suppose we want to count the cousin levels.

nth_cousin(N,X,Y) :- ?
Should remind you of a previous problem: work it out!
What is the base case?
query mode +,+, Who are my 3rd cousins?
For what N are we Nth cousins? query mode -,+,+
Did you ever wonder what 3rd cousin twice removed means?
answer(X,Y) :- nth_cousin(3,X,Z), anc(2,Z,Y).
600.325/425 Declarative Methods
- J. Eisner

Lists

How do you represent the list 1,2,3,4?

Use a structured term:
cons(1, cons(2, cons(3, cons(4, nil))))
Prolog lets you write this more prettily as [1,2,3,4]
cons(1, cons(2, cons(3, cons(4, nil))))

if X=[3,4], then [1,2|X]=[1,2,3,4]

cons(3,cons(4,nil)) cons(1,cons(2,X))

600.325/425 Declarative Methods

- J. Eisner

Lists

How do you represent the list 1,2,3,4?

Use a structured term:
cons(1, cons(2, cons(3, cons(4, nil))))
Prolog lets you write this more prettily as [1,2,3,4]

cons(1, cons(2, cons(3, cons(4, nil))))

[1,2,3,4]=[1,2|X] X=[3,4]
cons(1,cons(2,X))

by unification

cons(3,cons(4,nil))

600.325/425 Declarative Methods

- J. Eisner

Lists

How do you represent the list 1,2,3,4?

Use a structured term:
cons(1, cons(2, cons(3, cons(4, nil))))
Prolog lets you write this more prettily as [1,2,3,4]

cons(1, cons(2, nil))

[1,2]

=[1,2|X]

cons(1,cons(2,X))

X=[]
nil

600.325/425 Declarative Methods

- J. Eisner

Decomposing lists

first(X,List) :- ?

first(X,List) :- List=[X|Xs].

first(X, [X|Xs]).

Traditional variable name:

X followed by some more Xs.
Nicer: eliminates the single-use variable List.

first(X, [X|_]).

Also eliminate the single-use variable Xs.

600.325/425 Declarative Methods
- J. Eisner

Decomposing lists

first(X, [X|_]).
rest(Xs, [_|Xs]).

Query: first(8, [7,8,9]).

Query: first(X, [7,8,9]).

Answer: no
Answer: X=7

Query: first(7, List).

Answer: List=[7|Xs]
(will probably print an internal var name like _G123 instead of Xs)

Query: first(7, List), rest([8,9], List).

Answer: List=[7,8,9].
Can you draw the structures that get unified to do this?
600.325/425 Declarative Methods
- J. Eisner

100

Decomposing lists

In practice, no one ever actually defines

rules for first and rest.
Just do the same thing by pattern
matching: write things like [X|Xs] directly
in your other rules.

600.325/425 Declarative Methods

- J. Eisner

101

List processing: member

member(X,Y) should be true if X is any object, Y is a list,

and X is a member of the list Y.

member(X, [X|_]). % same as first

member(X, [Y|Ys]) :- member(X,Ys).
Query: member(giraffe, [beaver, ant, steak(giraffe), fish]).
Answer: no
(why?)
Its recursive, but where is the base case???

if (list.empty()) then return no

% missing in Prolog??
else if (x==list.first()) then return yes
% like 1st Prolog
rule
else return member(x, list.rest())
% like 2nd Prolog rule
600.325/425 Declarative Methods
- J. Eisner

102

List processing: member

Query: member(X, [7,8,7]).

Answer:
X=8 ;
X=7

X=7 ;

Query: member(7, List).

Answer: List=[7 | Xs] ;

List=[X1, 7| Xs] ;
List=[X1, X2, 7 | Xs] ;
(willing to backtrack forever)
600.325/425 Declarative Methods
- J. Eisner

103

List processing: length

Query: member(7, List), member(8,List), length(List, 3).

Answer: List=[7,8,X] ;
List=[7,X,8] ;
(now searches forever for next answer
see prev. slide!)
Query: length(List, 3), member(7, List), member(8,List).
Answer: List=[7, 8, X] ;
How do we define length?
List=[7, X, 8] ;
length([], 0).
List=[8, 7, X] ;
length([_|Xs],N) :List=[X, 7, 8] ;
length(Xs,M), N is M+1.
List=[8, X, 7] ;
But this will cause infinite
List=[X, 8, 7]
recursion for length(List,3).
(why in this order?)

600.325/425 Declarative Methods

- J. Eisner

104

List processing: length

Query: member(7, List), member(8,List), length(List, 3).

Answer: doesnt terminate (see previous slide!)

How do
Query:
length(List,
3), member(7, List), member(8,List).
we define length?

length([], List=[7,
0).
Answer:
8, X] ;
length([_|Xs],N) :- N > 0,

List=[7, X, 8] ;
length(Xs,M),
N is

List=[X, 7, 8]
; M+1.
But this will cause an
List=[8, 7, X] ;
instantiation fault when we
List=[8, X, 7] ;
recurse. Well try to test
MList=[X,
> 0, but 8,
M 7]
is still unbound.

How do we define length?

length([], 0).
length([_|Xs],N) :length(Xs,M), N is M+1.
But this will cause infinite
recursion for length(List,3).

600.325/425 Declarative Methods

- J. Eisner

105

Prolog does have hacky

How do we define length?

ways to tell which case
length([], 0).
were in. So we can have
both definitions built-in
length([_|Xs],N) :- N > 0,
version of length does.
M is N-1, length(Xs,M).
Works great for length(List,3).
Query:
member(7, List), member(8,List), length(List, 3).
Unfortunately, instantiation fault for
Answer:
doesnt terminate (see previous slide!)
length([a,b,c],N).
Query:
How For
that
caselength?
we
use ourList),
first member(8,List).
version!
length(List,
3),should
member(7,
do
we
define
Answer:
How do we define length?
length([], List=[7,
0).
8, X] ;
length([_|Xs],N) :- N > 0,
length([], 0).
List=[7, X, 8] ;
length(Xs,M),
N is
length([_|Xs],N) :List=[X, 7, 8]
; M+1.
But this will cause an
length(Xs,M), N is M+1.
List=[8, 7, X] ;
instantiation fault when we But this will cause infinite
List=[8, X, 7] ;
recurse. Well try to test
recursion for length(List,3).
List=[X,
8,
7]
M > 0, but M is still unbound.

List processing: length

600.325/425 Declarative Methods

- J. Eisner

106

Prolog does have hacky

How do we define length?

ways to tell which case
length([], 0).
were in. So we can have
both definitions built-in
length([_|Xs],N) :- N > 0,
version of length does.
M is N-1, length(Xs,M).
Works great for length(List,3).
Query:
member(7, List), member(8,List), length(List, 3).
Unfortunately, instantiation fault for
Answer:
doesnt terminate (see previous slide!)
length([a,b,c],N).
Query:
How For
that
caselength?
we
use ourList),
first member(8,List).
version!
length(List,
3),should
member(7,
do
we
define
Answer:
How do we define length?
length([], List=[7,
0).
8, X] ;
Toto, I dont think were in
.
length([_|Xs],N) :- N > 0,
List=[7,
X, 8] ;programminglength([],
0).
declarative
anymore

.
length(Xs,M),
M
is
N+1.
length([_|Xs],N) :List=[X, 7, 8] ;
The problem:
But this will cause an
length(Xs,M), N is M+1.
List=[8, 7, X] ;
instantiation
fault
when we But this will cause infinite
N is M+1
is not pure
List=[8,
X, 7]
; Prolog.
and
try to test M >
Neitherrecurse
is
N
>
0.
recursion for length(List,3).
List=[X,
8,
7]
M is still unbound.
These 0.
constraints cant be processed by unification

List processing: length

as you encounter them. Theyre handled by some outside

mechanism that requires certain variables to be already assigned.
600.325/425 Declarative Methods
107
- J. Eisner
Is there a pure Prolog alternative
(maybe slower, but always works)?

Arithmetic in pure Prolog

Lets rethink arithmetic as term unification!

I promised wed divide 6 by 2
by making Prolog prove that x 2*x = 6.
Query: times(2,X,6). So how do we program times?
Represent 0 by z (for zero)
Represent 1 by s(z) (for successor).
Represent 2 by s(s(z))
Represent 3 by s(s(s(z)))
Peano integers
So actually our query times(2,X,6) will be written
times(s(s(z)), X, s(s(s(s(s(s(z))))))).
600.325/425 Declarative Methods
- J. Eisner

108

A pure Prolog definition of

length

length([ ],z).
length([_|Xs], s(N)) :- length(Xs,N).
This is pure Prolog and will work perfectly everywhere.
Yeah, its a bit annoying to use Peano integers for input/output:

Query: length([[a,b],[c,d],[e,f]], N).

Answer: N=s(s(s(z)))
Query: length(List, s(s(s(z)))).
Answer: List=[A,B,C]

yuck?

But you could use impure Prolog to convert them to ordinary

numbers just at input and output time
600.325/425 Declarative Methods
- J. Eisner

109

A pure Prolog definition of

length

length([ ],z).
length([_|Xs], s(N)) :- length(Xs,N).
This is pure Prolog and will work perfectly everywhere.
Converting between Peano integers and ordinary numbers:

Query: length([[a,b],[c,d],[e,f]], N), decode(N,D).

Answer: N=s(s(s(z))), D=3
Query: encode(3,N), length(List, N).
Answer: N=s(s(s(z))), List=[A,B,C]

decode(z,0). decode(s(N),D) :- decode(N,E), D is E+1.

encode(0,z). encode(D,s(N)) :- D > 0, E is D-1, encode(E,N).
600.325/425 Declarative Methods
- J. Eisner

110

2+2 in pure Prolog

First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S
A+(B+1)=S.

The above should make sense declaratively.

Dont worry yet about how the solver works.

Just worry about what the program says.

It inductively defines addition of natural

numbers! The first line is the base case.
600.325/425 Declarative Methods
- J. Eisner

111

2+2 in pure Prolog

First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S
A+(B+1)=S.

add(s(s(z)),s(s(z)),Sum ) original query

600.325/425 Declarative Methods

- J. Eisner

112

2+2 in pure Prolog

First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S
A+(B+1)=S.

add(

original query

600.325/425 Declarative Methods

- J. Eisner

113

2+2 in pure Prolog

First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S
A+(B+1)=S.

add
note the
unification
of variables
between
different calls

original query
matches head of rule

1st recursive call

matches head of rule
z
z
?
2nd recursive call
matches base case
Removed outer skins from 1st argument (outside-in),
wrapping them
around
2nd argument
(inside-out).
600.325/425
Declarative
Methods
- J. Eisner

114

2+2 in pure Prolog

First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S
A+(B+1)=S.

Query: add(s(s(z)), s(s(z)), Sum ). % 2+2=?

Matches head of second clause: A=s(z), B=s(s(z)).
So now we have to satisfy body: add(s(z), s(s(s(z))), Sum).
Matches head of second clause: A=z, B=s(s(s(z))).
So now we have to satisfy body: add(z, s(s(s(s(z)))), Sum).
Matches head of first clause: B=s(s(s(s(z)))), B=Sum.
So Sum=s(s(s(s(z))))! Unification has given us our answer.

600.325/425 Declarative Methods

- J. Eisner

115

More 2+2: An interesting

variant
First, lets define a predicate add/3.

add(z,B,B).

add(s(A),B,s(Sum)) :- add(A,B,Sum). % (A+1)+B=(S+1)

% 0+B=B.
A+B=S.

add
z

original query
matches head of rule

1st recursive call

matches head of rule
z
z
?
2nd recursive call
matches base case
Removed outer skins from 1st argument (outside-in),
nested them
to form
the result
600.325/425
Declarative
Methods (outside-in),
116
- J. Eisner
dropped 2nd argument
into the core.

More 2+2: An interesting

variant
First, lets define a predicate add/3.

add(z,B,B).
% 0+B=B.
add(s(A),B,s(Sum)) :- add(A,B,Sum). % (A+1)+B=(S+1)
A+B=S.

Query: add(s(s(z)), s(s(z)), Total ). % 2+2=?

Matches head of second clause: A=s(z), B=s(s(z)), Total=s(Sum).
So now we have to satisfy body: add(s(z), s(s(z)), Sum).
Matches head of 2nd clause: A=z, B=s(s(z)), Total=s(s(Sum)).
So now we have to satisfy body: add(z, s(s(z)))), Sum).
Matches head of first clause: B=s(s(z)).
So we have built up Total=s(s(Sum))=s(s(s(z))).

600.325/425 Declarative Methods

- J. Eisner

117

An amusing query

Query: add(z, N, s(N)). % 0+N = 1+N

Answer: you would expect no
But actually: N = s(s(s(s(s(s()))))

Looks good: 0+ = 1+ since both are !

Only get this circular term since Prolog skips

the occurs check while unifying the query with
add(z,B,B)

600.325/425 Declarative Methods

- J. Eisner

118

List processing continued:

append

You probably already know how to write a non-destructive

append(Xs,Ys) function in a conventional language, using
recursion.

append(Xs,Ys):
if (Xs.empty())
return Ys
else
subproblem = Xs.rest(); // all but the 1st element
subsolution = append(subproblem, Ys)
return cons(Xs.first(), subsolution)
600.325/425 Declarative Methods
- J. Eisner

119

List processing continued:

append

You probably already know how to write a non-destructive

append(Xs,Ys) function in a conventional language, using
recursion.
In more Prologgy notation:

append([],Ys): return Ys
append([X|Xs],Ys): return [X | append(Xs,Ys)]

600.325/425 Declarative Methods

- J. Eisner

120

List processing continued:

append

You probably already know how to write a non-destructive

append(Xs,Ys) function in a conventional language, using
recursion.

In actual Prolog, the function looks much the same, but once
youve written it, you can also run it backwards!
In Prolog there are no return values. Rather, the return value
is a third argument: append(Xs,Ys,Result).
This is a constraint saying that Result must be the append of
the other lists.
Any of the three arguments may be known (or partly known)
at runtime. We look for satisfying assignments to the others.

600.325/425 Declarative Methods

- J. Eisner

121

List processing continued:

append
append(Xs,Ys,Result) should be true if Xs and Ys are

lists and Result is their concatenation (another list).

Query: append([1,2],[3,4],Result)
Answer: Result=[1,2,3,4]

Try this:

append([],Ys,Ys).

append([X|Xs],Ys,Result) :- ?

600.325/425 Declarative Methods

- J. Eisner

122

List processing continued:

append
append(Xs,Ys,Result) should be true if Xs and Ys are

lists and Result is their concatenation (another list).

Query: append([1,2],[3,4],Result)
Answer: Result=[1,2,3,4]

Try this:

append([],Ys,Ys).
append([X|Xs],Ys,Result) :- append(Xs,[X|Ys],Result).

But wait: what order are the onion skins being

wrapped in?
This is like the first version of 2+2
600.325/425 Declarative Methods
- J. Eisner

123

List processing continued:

append
append(Xs,Ys,Result) should be true if Xs and Ys are

lists and Result is their concatenation (another list).

Query: appendrev([1,2],[3,4],Result)
Answer: Result=[2,1,3,4]

Rename this to appendrev!

appendrev([],Ys,Ys).
appendrev([X|Xs],Ys,Result) :- appendrev(Xs,[X|Ys],Result).

But wait: what order are the onion skins being

wrapped in?
This is like the first version of 2+2
600.325/425 Declarative Methods
- J. Eisner

124

List processing continued:

append
Lets wrap the onion skins like the other 2+2

Query: append([1,2],[3,4],Result)
Answer: Result=[1,2,3,4]

Heres the correct version of append:

append([],Ys,Ys).
append([X|Xs],Ys,[X|Result]) :- append(Xs,Ys,Result).
1. our
inputs

4. construct
our output

2. inputs to
recursive call

3. output of
recursive call

A procedural (non-declarative) way to read this rule

600.325/425 Declarative Methods
- J. Eisner

125

List processing continued:

append
Lets wrap the onion skins like the other 2+2

Query: append([1,2],[3,4],Result)
Answer: Result=[1,2,3,4]

Heres the correct version of append:

append([],Ys,Ys).
append([X|Xs],Ys,[X|Result]) :- append(Xs,Ys,Result).
This version also makes perfect sense declaratively.
And we still have a use for the other version, appendrev:

appendrev(Xs,[],Ys).
reverse(Xs,Ys) :- ?
600.325/425 Declarative Methods
- J. Eisner

126

Arithmetic continued:
Subtraction
add(z,B,B).
% 0+B=B.

add(s(A),B,Sum) :- add(A,s(B),Sum). % (A+1)+B=S

A+(B+1)=S.

add(z,B,B).
% 0+B=B.
add(s(A),B,s(Sum)) :- add(A,B,Sum). % (A+1)+B=(S+1)
A+B=S.

add(s(s(z)), X, s(s(s(s(s(z)))))).
add(s(s(s(s(s(z))))), X, s(s(z))).

Pure Prolog gives you subtraction for free!

600.325/425 Declarative Methods

- J. Eisner

127

Multiplication and division

How do you define multiplication?

(Then division will come for free.)

600.325/425 Declarative Methods

- J. Eisner

128

Square roots

mult(X, X, s(s(s(s(s(s(s(s(s(z)))))))))).

600.325/425 Declarative Methods

- J. Eisner

129

More list processing: Sorting

sort(Xs, Ys)

You can write recursive selection sort, insertion sort, merge

sort, quick sort where the list Xs is completely known so
that you can compare its elements using <.
This is basically like writing these procedures in any functional
language (LISP, OCaml, ). Its no more declarative than
those languages.
But how about this more declarative version?

sort(Xs, Ys) :- permutation(Xs,Ys), ordered(Ys).

How do we write these?

ordered is the easy one

600.325/425 Declarative Methods
- J. Eisner

130

More list processing: Sorting

ordered([]).
ordered([X]).
ordered([X,Y|Ys]) :- ?

600.325/425 Declarative Methods

- J. Eisner

131

More list processing: Sorting

ordered([]).
ordered([X]).
ordered([X,Y|Ys]) :- X =< Y, ordered([Y|Ys]).

600.325/425 Declarative Methods

- J. Eisner

132

More list processing: Sorting

Query: deleteone(b, [a,b,c,b], Xs).

Answer: Xs=[a,c,b] ;
Xs=[a,b,c]
deleteone(X,[X|Xs],Xs).
deleteone(Z,[X|Xs],[X|Ys]) :deleteone(Z,Xs,Ys).

600.325/425 Declarative Methods

- J. Eisner

133

More list processing: Sorting

Can we use deleteone(X,List,Rest) to write

permutation(Xs,Ys)?
permutation([], []).
permutation(Xs, [Y|PYs]) :deleteone(Y,Xs,Ys),
permutation(Ys,PYs).
Starting with Xs, delete any Y to leave Ys. Permute
the Ys to get PYs. Then glue Y back on the front.
To repeat, sorting by checking all permutations is
horribly inefficient. You can also write the usual fast
sorting algorithms in Prolog.

Hmm, but we dont have random-access arrays and its hard

to graft those on if you want the ability to modify them
Can use lists rather than arrays if your algorithm is selection
sort, insertion sort, mergesort try these yourself in Prolog!
600.325/425 Declarative Methods
- J. Eisner

134

Mergesort

Query: mergesort([4,3,6,5,9,1,7],S).
Answer: S=[1,3,4,5,6,7,9]
mergesort([],[]).
mergesort([A],[A]).
mergesort([A,B|R],S) :split([A,B|R],L1,L2),
mergesort(L1,S1), mergesort(L2,S2),
merge(S1,S2,S).
split([],[],[]).
split([A],[A],[]).
split([A,B|R],[A|Ra],[B|Rb]) :- split(R,Ra,Rb).
merge(A,[],A).
merge([],B,B).
merge([A|Ra],[B|Rb],[A|M]) :- A =< B, merge(Ra,[B|Rb],M).
merge([A|Ra],[B|Rb],[B|M]) :- A > B, merge([A|Ra],Rb,M).
600.325/425 Declarative Methods
- J. Eisner

135

A bad SAT solver

(no short-circuit evaluation or
propagation)
// Suppose formula uses 5 variables: A, B, C, D, E

for A {0, 1}
for B {0, 1}
for C {0, 1}
for D {0, 1}
for E {0, 1}
if formula is true
immediately return (A,B,C,D,E)
return UNSAT

600.325/425 Declarative Methods

- J. Eisner

136

A bad SAT solver in Prolog

Query (what variable & value ordering are used here?)

bool(A),bool(B),bool(C),bool(D),bool(E),formula(A,B,C,D,E).

Program

% values available for backtracking search

bool(false). bool(true).
% formula (A v ~C v D) ^ (~B v C v E) ^ (A xor E) ^
formula(A,B,C,D,E) :clause1(A,C,D), clause2(B,C,E), xor(A,E),
% clauses in that formula
clause1(true,_,_). clause1(_,false,_). clause1(_,_,true).
clause2(false,_,). clause2(_,true,_). clause2(_,_,true).
xor(true,false). xor(false,true).
600.325/425 Declarative Methods
- J. Eisner

137

A bad SAT solver in Prolog

Query (what variable & value ordering are used here?)

bool(A),bool(B),bool(C),bool(D),bool(E),formula(A,B,C,D,E).

Program

% values available for backtracking search

bool(false). bool(true).

A
B
C
D
E

false
false
false

true

true
false

true
false
true false

true

600.325/425 Declarative Methods

- J. Eisner

true
false

true

138

The Prolog cut operator, !

Query

bool(A),bool(B), , bool(C),bool(D),bool(E),formula(A,B,C,D,E).

Program

Cuts off part of the search space.

Once we have
managed to satisfy
% values available for backtracking
search
bool(A),bool(B) and gotten past !,
bool(false). bool(true). we are committed to our choices so far

and wont backtrack to revisit them.

A
B
C
D
E

false
false
false

true

We still backtrack to find other ways

of satisfying the subsequent
constraints bool(C),bool(D),
600.325/425 Declarative Methods
- J. Eisner

139

The Prolog cut operator, !

Query

bool(A),bool(B),bool(C),bool(D),bool(E),formula(A,B,C,D,E), .

Program

Cuts off part of the search space.

Once we have
managed to satisfy the
% values available for backtracking
search
bool(false). bool(true). constraints before ! (all constraints in
this case), we dont backtrack. So we

return only first satisfying assignment.

A
B
C
D
E

false
false
false

true

true
false

true
false
true false

First satisfying assignment

600.325/425 Declarative Methods
- J. Eisner

140

The Prolog cut operator, !

Query

bool(A),bool(B),bool(C), ,bool(D),bool(E),formula(A,B,C,D,E).

Program

% values available for backtracking search

bool(false). bool(true).

A
B
C
D
E

false
false
false

600.325/425 Declarative Methods

- J. Eisner

141

The Prolog cut operator, !

Query

bool(A), bool2(B,C),

!,bool(D),bool(E),formula(A,B,C,D,E).

Program

Same effect, using a subroutine.

% values available for backtracking search

bool(false). bool(true).
bool2(X,Y) :- bool(X), bool(Y).
A
B
C
D
E

false
false
false

600.325/425 Declarative Methods

- J. Eisner

142

The Prolog cut operator, !

Query

bool(A), bool2(B,C),

,bool(D),bool(E),formula(A,B,C,D,E).

Program

Now effect of !
% values available for backtracking searchis local to bool2.
bool2 will commit to
bool(false). bool(true).
its first solution,
bool2(X,Y) :- bool(X), bool(Y), .
namely (false,false),
% equivalent to: bool2(false,false).
not backtracking to
get other solutions.
false
true
A
But thats just how
false
false
B
bool2 works inside.
false
false
C
Red query doesnt
D
know bool2 contains a
E
cut; it backtracks to
try different A,
600.325/425 Declarative Methods
calling bool2 for143each.
- J. Eisner

call
fail

exit
redo

How cuts affect

backtracking
main routine

subroutine
for
clause #2
Can try other
options here
before failing
and returning
to caller

Normal backtracking
if we fail
within clause #2

But fail immediately

(return to caller) if we
backtrack past a cut.
Caller can still go back & change
something & call us again.

600.325/425 Declarative Methods

- J. Eisner

144

A bad SAT solver in Prolog

Query

bool(A),bool(B),bool(C),bool(D),bool(E),formula(A,B,C,D,E).

Program

% values available for backtracking search

bool(false). bool(true).
% formula (A v ~C v D) ^ (~B v C v E) ^ (A xor E) ^
formula(A,B,C,D,E) :clause1(A,C,D), clause2(B,C,E), xor(A,E),
clause1(true,_,_).
Truly inefficient!
Even checking whether the formula is
clause1(_,false,_).
satisfied may take exponential time,
clause1(_,_,true).
because we backtrack through all the
ways to justify that its satisfied!

600.325/425 Declarative Methods

- J. Eisner

145

A bad SAT solver in Prolog

Query

bool(A),bool(B),bool(C),bool(D),bool(E),formula(A,B,C,D,E).

Program

% values available for backtracking search

bool(false). bool(true).
% formula (A v ~C v D) ^ (~B v C v E) ^ (A xor E) ^
formula(A,B,C,D,E) :clause1(A,C,D), clause2(B,C,E), xor(A,E),
clause1(true,_,_) :- !.
Much better. Now once we know that
clause1 is satisfied, we can move on;
clause1(_,false,_) :- !.
we dont have to backtrack through all
clause1(_,_,true).

the reasons its satisfied.

Are these green cuts that dont change the output of the program?
Yes, in this case, if we600.325/425
only callDeclarative
clause1 Methods
in mode clause1(+,+,+).
146
Eisner
Except that they will eliminate- J.duplicate
solutions, too.

Another pedagogical
eats(sam, dal).
eats(josie, samosas).
example
of
cut
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
compatible(Person1, Person2) :- eats(Person1, Food),
eats(Person2, Food).
compatible(Person1, Person2) :- watches(Person1, Movie),
watches(Person2, Movie).
To whom should we advertise curry?
eats(X,curry), compatible(X,Y).

eats(X,curry), !, compatible(X,Y).

X=sam, Y=sam; X=sam, Y=josie; X=josie, X=sam; X=josie, Y=josie

X=sam, Y=sam; X=sam, Y=josie

eats(X,curry), compatible(X,Y), !.

X=sam, Y=sam
600.325/425 Declarative Methods
- J. Eisner

147

Using cut to force

determinism

Query: deleteone(b, [a,b,c,b], Xs).

Answer: Xs=[a,c,b] ;
Xs=[a,b,c]
deleteone(X,[X|Xs],Xs).
deleteone(Z,[X|Xs],[X|Ys]) :- deleteone(Z,Xs,Ys).

600.325/425 Declarative Methods

- J. Eisner

148

Using cut to force

determinism
deletefirst

Query: deleteone(b, [a,b,c,b], Xs).

Answer: Xs=[a,c,b] ;
Xs=[a,b,c]
deletefirst(X,[X|Xs],Xs).:- ! .
deletefirst(Z,[X|Xs],[X|Ys]) :- deletefirst(Z,Xs,Ys).

600.325/425 Declarative Methods

- J. Eisner

149

Using cut to override default

rules
permissions(superuser,
[read,write]) :- !.
with
specificFile,cases

permissions(guest, File, [read]) :- public(File), !. % exception to exception

permissions(guest, File, []) :- !. % if this matches, prevent lookup
permissions(User, File, PermissionsList) :- lookup().
% unsafe? what if looked-up permissions were set wrong?
can_fly(X) :- penguin(X), !, fail.
can_fly(X) :- bird(X).
progenitor(god, adam) :- !. % cut is unnecessary but efficient
progenitor(god, eve) :- !.
% cut is unnecessary but efficient.
progenitor(X,Y) :- parent(X,Y).
600.325/425 Declarative Methods
- J. Eisner

150

Using cut to get negation,

eats(sam, dal).
eats(josie, samosas).
sort
of
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).

\+ eats(sam,dal). % \+ means not provable

Yes

\+ eats(sam,X).

\+ eats(sam,rutabaga).

eats(rajiv, dal).

% since we can prove that sam does eat some X

\+ eats(robot,X).

Yes

% since we cant currently prove that robot eats anything

600.325/425 Declarative Methods
- J. Eisner

151

Using cut to get negation,

eats(sam, dal).
eats(josie, samosas).
sort
of
eats(sam, curry).
eats(josie, curry).
eats(rajiv, burgers).
eats(rajiv, dal).
avoids(Person,Food) :- eats(Person,Food), !, fail.
avoids(Person,Food).

avoids(sam,dal). % avoids is implemented in the same way as \+

avoids(sam,rutabaga).

Yes

If we can prove eats, we commit with !

to not being able to prove avoid
Otherwise we can prove avoid!

avoids(sam,X).

% since we can prove that sam does eat some X

avoids(robot,X).

Yes

% since we cant currently prove that robot eats anything

600.325/425 Declarative Methods
- J. Eisner

152

More list processing:

Query: deleteall(2, [1,2,3,1,2], Ys).
deleteall

Answer: Ys=[1,3,1]

deleteall(X,[X|Xs],Ys) :- deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- Z\=X, deleteall(Z,Xs,Ys).
Works fine for ground terms :
deleteall(Z,[],[]).
2 \= 1, so we dont delete 1.

But how about deleteall(Z, [1,2,3,1,2], Ys)?

Wed like \= to mean constrained not to unify.

So Z \= 1 should mean Z can be any term at all except for 1.

But how do we represent that in memory??
Not like unification, which just specializes a variable to refer to a
more specific term than before. Anything but 1 is not a term.

So instead, it means these dont unify right now

Z \= 1 is just short for \+ (Z=1)

600.325/425 Declarative Methods
- J. Eisner

153

More list processing:

Query: deleteall(A, [1,2,3,1,2], Ys).
deleteall

Answer: A=1, Ys=[2,3,2] since only first clause succeeds

(and then A is ground in recursive call)

deleteall(X,[X|Xs],Ys) :- deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- Z\=X, deleteall(Z,Xs,Ys).
deleteall(Z,[],[]).
Wed like \= to mean constrained not to unify.

So Z \= 1 should mean Z can be any term at all except for 1.

But how do we represent that in memory??
Not like unification, which just specializes a variable to refer to a
more specific term than before. Anything but 1 is not a term.

So instead, it means these dont unify right now

Z \= 1 is just short for \+ (Z=1)

600.325/425 Declarative Methods
- J. Eisner

154

More list processing:

Query: deleteall(A, [1,2,3,1,2], Ys).
deleteall

Answer: A=1, Ys=[2,3,2] Equivalent way to make only 1st clause

deleteall(X,[X|Xs],Ys) :- ! , deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- deleteall(Z,Xs,Ys).
deleteall(Z,[],[]).

succeed (but faster: never tries 2 )

Wed like \= to mean constrained not to unify.

So Z \= 1 should mean Z can be any term at all except for 1.

But how do we represent that in memory??
Not like unification, which just specializes a variable to refer to a
more specific term than before. Anything but 1 is not a term.

So instead, it means these dont unify right now

Z \= 1 is just short for \+ (Z=1)

600.325/425 Declarative Methods
- J. Eisner

155

More list processing:

Query: deleteall(A, [1,2,3,1,2], Ys).
deleteall

Answer: A=1, Ys=[2,3,2] ;

Instantiation fault since =\= only allowed in mode +,+
deleteall(X,[X|Xs],Ys) :- deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- Z=\=X, deleteall(Z,Xs,Ys).
deleteall(Z,[],[]).
Wed like \= to mean constrained not to unify.

So Z \= 1 should mean Z can be any term at all except for 1.

But how do we represent that in memory??
Not like unification, which just specializes a variable to refer to a
more specific term than before. Anything but 1 is not a term.

So instead, it means these dont unify right now

Z \= 1 is just short for \+ (Z=1)

600.325/425 Declarative Methods
- J. Eisner

156

More list processing:

Query: member(A,[1,2,3,1,2]), deleteall(A, [1,2,3,1,2], Ys).
deleteall

Ensure that A is ground

Answer: A=1, Ys=[2,3,2] ;
A=2, Ys=[1,3,1] ; etc. before we try calling deleteall
(5 answers)
deleteall(X,[X|Xs],Ys) :- deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- Z\=X, deleteall(Z,Xs,Ys).
deleteall(Z,[],[]).

Wed like \= to mean constrained not to unify.

So Z \= 1 should mean Z can be any term at all except for 1.

But how do we represent that in memory??
Not like unification, which just specializes a variable to refer to a more
specific term than before. Anything but 1 is not a term.

So instead, it means these dont unify right now

Z \= 1 is just short for \+ (Z=1)

600.325/425 Declarative Methods
- J. Eisner

157

More list processing:

Query: deleteall(A, [1,2,3,1,2], Ys).
deleteall

ECLiPSe delayed constraint!

Answer: A=1, Ys=[2,3,2] ;
A=2, Ys=[1,3,1] ; etc. Will be handled once Z is known.
deleteall(X,[X|Xs],Ys) :- deleteall(X,Xs,Ys).
deleteall(Z,[X|Xs],[X|Ys]) :- Z#\=X, deleteall(Z,Xs,Ys).
deleteall(Z,[],[]).

This is the right approach (fully declarative). Beyond Prolog. :-lib(ic).

How many answers? Still 5 answers?
Nope! 4 answers:
A=1, Ys=[2,3,2] ; match 1st clause (so A=1)
A=2, Ys=[1,3,1] ; match 2nd clause (so A#\=1), then 1st (so A=2)
A=3, Ys=[1,2,1,2] ; match 2nd (so A#\=1), then 2nd (A#\=2), then 1st (A=3)
If we match 2nd clause once more, then well have to keep matching it
for the rest of the list, since we will have constraints A {1,2,3} that
prevent us from taking the 1st clause again
A=A, Ys=[1,2,3,1,2], plus 600.325/425
delayed goals
saying
A {1,2,3}
Declarative
Methods
158
- J. Eisner
match 2nd clause
5 times

More list processing:

Query: deleteall(A, [1,2,3,1,2], Ys).
deleteall

ECLiPSe delayed constraint!

This is the right approach (fully declarative). Beyond Prolog. :-lib(ic).

Well, still not perfect. What happens with query
deleteall(1, List, [2,3,2])?
Unfortunately we get infinite recursion on the first clause.

600.325/425 Declarative Methods

- J. Eisner

159

Constraint logic
programming
In constraint logic programming,
you can include constraints on integers
like N #= M+1 (rather than N is M+1) and X#\=Z (rather than X \=Z)

without having to worry about which variables are already instantiated.

If a constraint cant be processed yet, it will be handled later, as soon as

its variables are sufficiently instantiated. Example: N #= M+1, N #= 5.
In fact, do bounds propagation. Example: N #= M+1, N #> 5.
But what happens if vars are never sufficiently instantiated?
The labeling(Vars) constraint does backtracking search:
tries all assignments of Vars consistent with constraints so far
finds these assignments using backtracking search interleaved with
constraint propagation (e.g., bounds consistency)
you can control the variable and value ordering
only sensible for variables whose values are constrained to a finite
set, or the integers, etc., since we cant easily backtrack through all
the infinitely many terms that might be assigned to a variable.
600.325/425 Declarative Methods
- J. Eisner

160

Constraint logic
programming

We explored at the ECLiPSe prompt or on the

blackboard:

various small examples of CLP, e.g.,

X #= 2*Y, X=10.
X #> 2*Y, X=10.
member(X,[1,2,3,4,2]), X #= 2*Y.
X #= 2*Y, member(X,[1,2,3,4,2]).

uniqmember
simplified version of Golomb ruler (from Eclipse website)
600.325/425 Declarative Methods
- J. Eisner

161

Constraint logic programming:

alldifferent

Wrong answer:

alldiff([]).
alldiff([X|Xs]) :- member(Y,Xs), X #\= Y, alldiff(Xs).

Right answer (although it lacks the strong propagator

from ECLiPSes standard alldifferent):

alldiff([]).
? (see homework)
600.325/425 Declarative Methods
- J. Eisner

162

AMC Report - CCTV
100% (2)
AMC Report - CCTV
1 page
TS4F01 1 EN Col17 ExerciseHandbook A4 109
No ratings yet
TS4F01 1 EN Col17 ExerciseHandbook A4 109
1 page
Solving Dog Behavior Problems Like A Professional
From Everand
Solving Dog Behavior Problems Like A Professional
James O'Heare
No ratings yet
Prolog: Programming in Logic: With Some Mention of Datalog and Constraint Logic Programming
No ratings yet
Prolog: Programming in Logic: With Some Mention of Datalog and Constraint Logic Programming
162 pages
Prolog: Programming in Logic: With Some Mention of Datalog and Constraint Logic Programming
No ratings yet
Prolog: Programming in Logic: With Some Mention of Datalog and Constraint Logic Programming
140 pages
Introduction To PROLOG: Manish Khare M.Sc. (CS), M.Tech. (CSE)
100% (1)
Introduction To PROLOG: Manish Khare M.Sc. (CS), M.Tech. (CSE)
27 pages
AI File
No ratings yet
AI File
29 pages
Lecture 2 - Syntax and Meaning of Prolog Programs
No ratings yet
Lecture 2 - Syntax and Meaning of Prolog Programs
33 pages
chaps-1-3-ai-prolog
No ratings yet
chaps-1-3-ai-prolog
33 pages
BATCH 2 AIML RECORD 1 Vignesh
No ratings yet
BATCH 2 AIML RECORD 1 Vignesh
50 pages
PROLOG
No ratings yet
PROLOG
54 pages
Module 4 Notes
No ratings yet
Module 4 Notes
61 pages
2011.017.AI Prolog Tutorial
No ratings yet
2011.017.AI Prolog Tutorial
122 pages
Tutorial Prolog
100% (3)
Tutorial Prolog
46 pages
PROLOG Assigement
No ratings yet
PROLOG Assigement
19 pages
Chapter Five
No ratings yet
Chapter Five
63 pages
Lecture Notes An Introduction To Prolog Programming: Ulle Endriss
No ratings yet
Lecture Notes An Introduction To Prolog Programming: Ulle Endriss
80 pages
Lecture # 11 PDF
No ratings yet
Lecture # 11 PDF
7 pages
Lecture Notes An Introduction To Prolog Programming: Ulle Endriss
No ratings yet
Lecture Notes An Introduction To Prolog Programming: Ulle Endriss
80 pages
ذكاء إصطناعي عملي
No ratings yet
ذكاء إصطناعي عملي
18 pages
A Unit of S.V.S.U: Chhatrapati Shahuji Subharti Institute of Technology & Engineering
No ratings yet
A Unit of S.V.S.U: Chhatrapati Shahuji Subharti Institute of Technology & Engineering
40 pages
CSBS-AI LAB MANUAL (1)
No ratings yet
CSBS-AI LAB MANUAL (1)
15 pages
Lab 2
No ratings yet
Lab 2
12 pages
List of Laboratory Experiments
No ratings yet
List of Laboratory Experiments
38 pages
Lecture1 LP
No ratings yet
Lecture1 LP
116 pages
Intelligent and Expert Sys Lab File
No ratings yet
Intelligent and Expert Sys Lab File
21 pages
AI L21 Prolog PDF
No ratings yet
AI L21 Prolog PDF
59 pages
Prolog Programming
100% (2)
Prolog Programming
66 pages
Introduction To Prolog
No ratings yet
Introduction To Prolog
21 pages
Logic Using Prolog
No ratings yet
Logic Using Prolog
14 pages
Prolog - : Programming in Logic
No ratings yet
Prolog - : Programming in Logic
52 pages
Intro To Prolog Programing
100% (1)
Intro To Prolog Programing
66 pages
1 Prolog
No ratings yet
1 Prolog
89 pages
Prolog Basics and Installation
No ratings yet
Prolog Basics and Installation
20 pages
Ch1_2 CS3032
No ratings yet
Ch1_2 CS3032
22 pages
Prologintro1 2 4up
No ratings yet
Prologintro1 2 4up
6 pages
Prolog As AI Programming Language - 1
No ratings yet
Prolog As AI Programming Language - 1
38 pages
Lecture 22-26 Prolog
No ratings yet
Lecture 22-26 Prolog
57 pages
Lecture 8
No ratings yet
Lecture 8
5 pages
History of Prolog
No ratings yet
History of Prolog
20 pages
AI Practical File
No ratings yet
AI Practical File
30 pages
CS344: Introduction To Artificial Intelligence: Pushpak Bhattacharyya
No ratings yet
CS344: Introduction To Artificial Intelligence: Pushpak Bhattacharyya
37 pages
5 Prolog Intro
No ratings yet
5 Prolog Intro
25 pages
Csa2001-Fundamentals in Ai and ML: Submitted by
No ratings yet
Csa2001-Fundamentals in Ai and ML: Submitted by
21 pages
Logic Chapter05 Logic Programming
No ratings yet
Logic Chapter05 Logic Programming
20 pages
COMP313A Programming Languages
No ratings yet
COMP313A Programming Languages
92 pages
l7
No ratings yet
l7
39 pages
BuiNguyenHoang Lab W02
No ratings yet
BuiNguyenHoang Lab W02
6 pages
Logic Programming Tutorial 1: Prolog Warm-Up
No ratings yet
Logic Programming Tutorial 1: Prolog Warm-Up
2 pages
Section 2 Ai303
No ratings yet
Section 2 Ai303
29 pages
Excel Simulations
From Everand
Excel Simulations
Gerard M. Verschuuren
3.5/5 (2)
Genetic Algorithms
From Everand
Genetic Algorithms
Isuru Abeysinghe
4.5/5 (3)
Rola Italian: Level 3
From Everand
Rola Italian: Level 3
Edward Lee Rocha
No ratings yet
50 Python Concepts Every Developer Should Know
From Everand
50 Python Concepts Every Developer Should Know
Hernando Abella
No ratings yet
How to Find Inter-Groups Differences Using Spss/Excel/Web Tools in Common Experimental Designs: Book 1
From Everand
How to Find Inter-Groups Differences Using Spss/Excel/Web Tools in Common Experimental Designs: Book 1
P.Y. Cheng
No ratings yet
Grammar Rules Made Funny (2): How to Improve Your Spoken and Written American Business English
From Everand
Grammar Rules Made Funny (2): How to Improve Your Spoken and Written American Business English
Yury Lee
No ratings yet
Exercises in Speaking English
From Everand
Exercises in Speaking English
A. G. Schopf A.A. B.A.
No ratings yet
The Little Prover
From Everand
The Little Prover
Daniel P. Friedman
4/5 (3)
8 Weeks to 200 Consecutive Lunges: Build Stronger Legs by Working Your Glutes, Quads, Lower Back, and Hamstrings | at Home Workouts | No Gym Required |
From Everand
8 Weeks to 200 Consecutive Lunges: Build Stronger Legs by Working Your Glutes, Quads, Lower Back, and Hamstrings | at Home Workouts | No Gym Required |
Cody Smith
No ratings yet
Grammar Rules Made Funny (1): How to Improve Your Spoken and Written American Business English
From Everand
Grammar Rules Made Funny (1): How to Improve Your Spoken and Written American Business English
Yury Lee
No ratings yet
Attacking Problems in Logarithms and Exponential Functions
From Everand
Attacking Problems in Logarithms and Exponential Functions
David S. Kahn
5/5 (1)
8 Weeks to 200 Consecutive Sit-ups: Build a Strong Core by Working Your Abs, Obliques, and Lower Back | at Home Workouts | No Gym Required |
From Everand
8 Weeks to 200 Consecutive Sit-ups: Build a Strong Core by Working Your Abs, Obliques, and Lower Back | at Home Workouts | No Gym Required |
Cody Smith
No ratings yet
Computer Arithmetic (5 Hours)
No ratings yet
Computer Arithmetic (5 Hours)
27 pages
Ejemplo de Ensayo Editorial
100% (1)
Ejemplo de Ensayo Editorial
4 pages
FIELD STUDY 1 E7 Utilizing Teaching Learning Resources and ICT
No ratings yet
FIELD STUDY 1 E7 Utilizing Teaching Learning Resources and ICT
15 pages
Creating Facebook Pages With Impact
No ratings yet
Creating Facebook Pages With Impact
68 pages
Favour
No ratings yet
Favour
19 pages
Time
No ratings yet
Time
4 pages
(R18A0588) Python Programming Lab Manual
100% (1)
(R18A0588) Python Programming Lab Manual
63 pages
Sony DSX-S310BTX
No ratings yet
Sony DSX-S310BTX
108 pages
Computer Architecture Homework Solutions
No ratings yet
Computer Architecture Homework Solutions
6 pages
CCN Lab1 Manual Doc File NEW
No ratings yet
CCN Lab1 Manual Doc File NEW
75 pages
InputDirector LOG
No ratings yet
InputDirector LOG
3 pages
SGS MIN 1317 Laboratory Quality Control Summary SLIM en
No ratings yet
SGS MIN 1317 Laboratory Quality Control Summary SLIM en
2 pages
ch09 Memory and Virtual Memory
No ratings yet
ch09 Memory and Virtual Memory
55 pages
Features NEW 2017 Vostro Desktop (3668/3669/3667/3660) Specifications
No ratings yet
Features NEW 2017 Vostro Desktop (3668/3669/3667/3660) Specifications
1 page
CompTIA Security Sy0-701 Exam Objectives (6 0)
No ratings yet
CompTIA Security Sy0-701 Exam Objectives (6 0)
21 pages
Mobile Communication
No ratings yet
Mobile Communication
57 pages
Prepare Satellite Server
No ratings yet
Prepare Satellite Server
4 pages
POWER9 IC922 Level 2
No ratings yet
POWER9 IC922 Level 2
7 pages
Answer Definition: ADO Is A Rich Set of Classes, Interfaces, Structures and Enumerated Types That Manage Data Access From Various Types of Data Stores
No ratings yet
Answer Definition: ADO Is A Rich Set of Classes, Interfaces, Structures and Enumerated Types That Manage Data Access From Various Types of Data Stores
34 pages
Resume
No ratings yet
Resume
4 pages
PowerProtect Data Manager
No ratings yet
PowerProtect Data Manager
250 pages
Bazzaz Software Manual V123
No ratings yet
Bazzaz Software Manual V123
10 pages
Cursos_en_Torrent_Última_Actualización_27_10_2024_Hoja_1
100% (2)
Cursos_en_Torrent_Última_Actualización_27_10_2024_Hoja_1
8 pages
PRIME Quick Guide-2015
No ratings yet
PRIME Quick Guide-2015
6 pages
SIMEAS PXXX Com Modbus A3 en
No ratings yet
SIMEAS PXXX Com Modbus A3 en
48 pages
364 Ais - Database.model - file.PertemuanFileContent LOGMAT 7
No ratings yet
364 Ais - Database.model - file.PertemuanFileContent LOGMAT 7
6 pages
Unit 5 SAP SuccessFactors HXM - Metadata Framework
No ratings yet
Unit 5 SAP SuccessFactors HXM - Metadata Framework
49 pages
DBMS Concepts & Programming in FoxPro
No ratings yet
DBMS Concepts & Programming in FoxPro
3 pages