formal methods prolog april 2 & 6, 2015. formal methods programming languages imperative...
TRANSCRIPT
FORMAL METHODSProlog
April 2 & 6, 2015
Formal Methods
Programming Languages
Imperative Declarative
Procedural Data Abstraction
C … ObjectsModules
Ada … Java …
Relational Functional
Constraints Logic ML …
CLP … Prolog …
… …ML
Jayaraman
Declarative vs Imperative Programming
• Focus on ‘what’ rather than ‘how’• Declarative Programs resemble
Specifications• Specifications are Executable• Program reasoning is easier• Greater Code Reuse• More amenable to Parallel Execution
Formal Methods Jayaraman
Simple Illustration• Directions for a party for 25 people at
41 Prestonwood Lane, East Amherst
• Imperative Solution:for i = 1 to 25 do {
tell person[i] how to go from house[i] to party; tell person[i] how to go from party to house[i];
}
Formal Methods Jayaraman
Declarative Solution
Formal Methods Jayaraman
• A map is a declarative specification of a set of relationships, i.e., which roads are connected to another.
• Every person needs to know the logic underlying maps:
path(X,Y) road(X,Y).path(X,Y) road(X,Z),
path(Z,Y).• A map has no explicit control and
facilitates greater “code re-use”.Formal Methods Jayaraman
Algorithm = Logic + Control
• Famous paper by Robert Kowalski, Communications of the ACM, 1979
• Imperative Programs explicit Control, implicit Logic
• Declarative Programs explicit Logic, implicit Control
Formal Methods Jayaraman
Prolog• Programming in Logic• Programs are logical assertions
(for the most part).• The logic is a restriction of first-order
predicate calculus called Horn clauses.• Horn clauses have a rule-like format,
and have a natural execution model.• Prolog was invented in 1972, and has
efficient implementations today.• Download SWI-Prolog (free, good Prolog)
Formal Methods Jayaraman
Applications of PrologTraditional:
- symbolic computing- database querying- language processing
Novel uses: - configuring mobile phones for
Nokia- engineering/marketing db in Boeing- network mangement in Lucent- network configuration in
Windows/NTFormal Methods Jayaraman
Prolog Personalities
Robert A. Kowalski, introducedthe concept of ‘logic programming’
Alain Colmerauer, with colleaguePhillipe Roussel, invented Prologat the University of Marseilles
Formal Methods Jayaraman
Horn Clauses
• Program Clauses
p(terms).p(terms) :- p1(terms), …, pn(terms).
• Goal Clause
?- pi(terms).
Unit clause
Conditional clause
Formal Methods Jayaraman
if
Syntactic Conventions• Variables begin with uppercase letter:
X, Y, From, To, City, State, …
• Constants and predicates begin with lowercase letter
• Special syntax for lists:• [ ], • [1,2,3], • [[10, apple], [20, banana]]• …
• Prolog is dynamically typed• variables are not typed, run-time type checking
Formal Methods Jayaraman
Horn Clauses as Procedures
p(terms).p(terms) :- p1(terms), …, pn(terms).
path(X,Y) :- edge(X,Y).path(X,Y) :- edge(X,Z), path(Z,Y).
Example:
procedurehead
procedurebody
nondeterministicprocedure
Formal Methods Jayaraman
Datalog is a subset of Prolog
• The family database example• Some relations of interest:
father, mother, parent,grandparent, ancestor
• Illustrates Horn clauses and the basic execution model for Prolog
Formal Methods Jayaraman
Family Database Program
mother(bob, mary).mother(ann, mary).mother(mark, jane).mother(mary, sue).
father(bob,mark).father(ann,mark).father(mark, joe).father(mary,steve).
bob ann
mark mary
joe jane steve sue
Formal Methods Jayaraman
Use quotes for constants starting with upper-case
mother(‘Bob’, ‘Mary’).mother(‘Ann’, ‘mary’).…
father(‘Bob’, ‘Mark’).father(‘Ann’, ‘Mark’).…
Bob Ann
Mark Mary
Joe Jane Steve Sue
Formal Methods Jayaraman
Representing a Graph
c
a
b d
e f
edge(a,b).edge(a,c).edge(c,e).edge(b,d).edge(d,e).edge(e,f).
Prolog systemsperform indexingon such facts for efficientretrieval
Formal Methods Jayaraman
Conditional Clauses
ancestor(X,Y) :- parent(X, Y).ancenstor(X,Y) :-
parent(X, Y) :- father(X, Y).parent(X, Y) :- mother(X, Y).grandparent(X, Y) :- parent(X, Z),
parent(Z, Y).
Formal Methods Jayaraman
Prolog predicates as Testers and Generators
father(bob,mark).father(ann,mark).father(mark, joe).father(mary,steve).
Example:
Sample Goals:?- father(mark, joe).
yes
?- father(mary, X).
X = steve
?
?- father(Who, mark). ?X = bob ;X = ann
Formal Methods Jayaraman
Prolog Computation Model
• Two key ideas:• Resolution-style Proof - unification of a goal with clause-
head• Backtracking Search - for answers in resolution search
tree
Formal Methods Jayaraman
Nondeterminism Backtracking
mother(bob, mary).mother(ann, mary).mother(mark, jane).mother(mary, sue).
father(bob,mark).father(ann,mark).father(mark, joe).father(mary,steve).
parent(X, Y) :- father(X, Y).parent(X, Y) :- mother(X, Y).Goal:
?- parent(mark, jane)
father(mark, jane)
fail
mother(mark, jane)
succeed
Formal Methods Jayaraman
Backtracking + Answers mother(bob, mary).mother(ann, mary).mother(mark, jane).mother(mary, sue).
father(bob,mark).father(ann,mark).father(mark, joe).father(mary,steve).
parent(X, Y) :- father(X, Y).parent(X, Y) :- mother(X, Y).Goal:
?- parent(mark, Who)
father(mark, Who)
Who = joe
mother(mark, Who)
Who = jane;Formal Methods Jayaraman
Backtracking + Answers
mother(bob, mary).mother(ann, mary).mother(mark, jane).mother(mary, sue).
father(bob,mark).father(ann,mark).father(mark, joe).father(mary,steve).
parent(X, Y) :- father(X, Y).parent(X, Y) :- mother(X, Y).gp(X,Y) :- parent(X,Z), parent (Z,Y)
?-gp(bob, sue)
p(bob, Z), p(Z, sue)
f(bob, Z), p(Z, sue)
p(mark, sue)Z = mark
m(bob, Z), p(Z, sue)
p(mary, sue)Z = mary
f(mary, sue)
fail succeed
m(mary, sue)
fail
f(mark, sue) m(mark, sue)
fail
Formal Methods
Jayaraman
Flexible Parameter Passing
• A predicate can be invoked in any “mode” of instantiation, e.g.,
… p(bob, sue) … p(bob, Y) … p(X, sue) … p(X, Y) …
valueresult
value-valuevalue-resultresult-valueresult-result
Formal Methods Jayaraman
Unification of T1 and T2
T2T1
const (c2)
var(V2)
f(terms2)
const (c1) var(V1)
g(terms1)
c1 = c2 V2 ← c1
V1 ← c2 V1 ← V2
fail
fail
Formal Methods Jayaraman
More General Terms
• Data Terms:term ::= constant | variable |
f(terms)terms ::= term1 , … , termn
• Examples constructor terms:leaf(10)node(node(leaf(1), leaf(2)), leaf(3)))name(arthur, conan, doyle)cons(1, cons(2, nil))
Formal Methods Jayaraman
List Processing in Prolog
Lists are made an infix constructor ‘.’:
.(1, .(2, .(3, [])))Special syntax:
[1, 2, 3]
Nested lists are fine: [[10, 20], [30], [50]]
Lists can be heterogeneous: [[10, banana], [20, orange], [30, grape]]
Formal Methods Jayaraman
List Patterns
The list pattern [H|T] unifies with a list such that H is the head of the list and T is the tail.
Examples: ?- [H|T] = [1,2,3]. H = 1, T = [2,3]
?- [[N,F] | T] = [[1,fig], [5, pear],[25,grape]]
N = 1, F = fig, T = [[5, pear], [25,grape]]
Formal Methods Jayaraman
Formal Methods
Member: Code Re-use• Consider the member predicate:
member(X, [X|_]).member(X, [_|T]) :- member(X,T).
• Can be used as a tester:
|?- member(2, [1,2,3]). yes
• Can also be used as a generator:
|?- member(E, [1,2,3]). E = 1 ; E = 2 ; E = 3 ;
no
_ is a “don’t care” variable, as in ML
Jayaraman
Formal Methods
How ‘member’ works
?- member(E,[1,2,3]).
member(E, [2,3]).
member(E, [3])
member(X, [X | _]).member(X, [_ | T]) :- member(X,T).
member(E, [ ])
fail fail
succeedE = 1
succeed
E = 2succeed
E = 3
Jayaraman
More Unification Examples
?- ([H|T], L2, [H|L3]) = ([1,2], [4,5], Ans)
H = 1T = [2]L2 = [4, 5]Ans = [1 | L3]
?- ([], L2, L2) = ([], [4,5], Ans)
L2 = [4, 5]Ans = [4, 5]
Formal Methods Jayaraman
The ‘append’ definition
app([], L2, L2).app([H|T], L2, [H|L3]) :- app(T,L2,L3).
?- app([1,2], [4,5], Ans).
failapp([2], [4,5], L3).
Ans = [1|L3]
app([], [4,5], L3’).L3 = [2|L3’]fail
succeed L3’ = [4,5] Ans = [1,2,4,5]
Formal Methods Jayaraman
Let’s compare the definition of the ‘append’ operation
in the differentprogramming
paradigms
Formal Methods Jayaraman
C definition of ‘append’
Formal Methods Jayaraman
typedef struct list { int data; struct list *next; } LIST;
LIST* append(LIST *l1, LIST *l2) { LIST *n; if (l1 == NULL) return l2 else { n = (LIST*) malloc(sizeof(LIST)); n->data = l1->data; n->next = append(l1->next, l2); return n; } }
Java definition of ‘append’
Formal Methods Jayaraman
class List { int data; List next;}List append(List l2) {
List n = new List();n.data = data;
if (next != null) n.next = next.append(l2); else n.next = l2; return n; }…}
Jayaraman
Lisp definition of ‘append’
(defun append (l1 l2)(if (null l1) l2 (cons (first l1)
(append (rest l1) l2))))
Formal Methods
Lisp definition is more abstract: 1. No explicit pointer variables. 2. No explicit storage allocation. 3. ‘Cons’ causes storage to be allocated.
ML and Prolog Definitions
fun append([ ], l2) = l2 | append (h::t, l2) =
h :: append(t, l2)
append([ ], L2, L2).append ([H|T], L2, [H|L3]) :-
append(T, L2, L3).
• ML supports definitions of functions, whereas Prolog supports definitions of relations.• ML and Prolog patterns are more declarative than Lisp’s explicit selection operations (first and rest).• ML uses pattern matching, whereas Prolog uses unification (a form of “two-way matching”).• ML is statically typed, but Prolog is dynamically typed.• ML execution is deterministic, while Prolog execution is nondeterministic, i.e., depth-first search + backtracking.
Formal Methods Jayaraman
From ML to Prolog
fun append([ ], l2) = l2 | append (h::t, l2) = h :: append(t, l2)
Formal Methods
fun append([ ], l2) = l2 | append (h::t, l2) = h :: l3 :-
append(t, l2) = l3
fun append([ ], L2) = L2 | append ([H|T], l2) = [H|L3] :-
append(T, L2) = L3
append([ ], L2, L2).append ([H|T], L2, [H|L3]) :- append(T, L2, L3).
flatten
change syntax
make relation
Jayaraman
Code Reuse in Prolog ‘append’
app([ ], L2, L2).app([H|T], L2, [H|L3]) :- app(T, L2, L3).
?- app([1,2], [4,5], [1,2,4,5]).yes
?- app([1,2], [4,5], Ans).Ans = [1,2,4,5]
?- app([1,2], Ans, [1,2,4,5]).Ans = [4,5]
Formal Methods Jayaraman
Code Reuse in ‘append’ (contd)
app([], L2, L2).app([H|T], L2, [H|L3]) :- app(T,L2,L3).
?- app(L, [4,5], [1,2,4,5]). L = [1,2]
?- app(X,Y, [1,2,4,5]).
X = [], Y = [1,2,4,5]X = [1], Y = [2,4,5]X = [1,2], Y = [4,5]X = [1,2,4], Y =[5]X = [1,2,4,5], Y = []
Formal Methods Jayaraman
Unification: Prolog parameter passing
Given a pair of terms, t1 and t2, a unifier of t1 and t2 is substitution θ for the variables occurring in t1 and t2 such that t1 θ = t2 θ.
Example: t1 = p(bob, Y) t2 = p(X, sue)
Unifier θ = {X = bob, Y = sue}
Formal Methods Jayaraman
Most General Unifier Given a pair of terms, t1 and t2,
the most general unifier (mgu) μ of t1 and t2 is related to an ordinary unifier θ by the relation θ = μ ρ.
Example: t1 = p(X, Y) t2 = p(Z, sue)
Unifiers: θ1 = {X = a, Z = a, Y = sue} θ2 = {X = b, Z = b, Y = sue}
….
MGU μ = {X = T, Z = T, Y = sue}Formal Methods Jayaraman
Unification of General Terms
?- node(T1, T2) = node(leaf(10), leaf(20))
T1 = leaf(10)T2 = leaf(20)
?- app([H|T], L2, [H|L3]) = app([1,2], [4,5], Ans)
H = 1T = [2]L2 = [4, 5]Ans = [1 | L3]
Formal Methods Jayaraman
Unification of T1 and T2
T2T1
const (c2)
var(V2)
f(terms2)
const (c1) var(V1)
g(terms1)
c1 = c2 V2 ← c1
V1 ← c2 V1 ← V2
fail
fail
V1 ← f(terms2)
if occurs-check
V2 ← g(terms1)
if occurs-check
Unify terms1 and terms2 if f = g
Formal Methods Jayaraman
Occurs Check
Consider the unification ofL = [1 | L]
This equation does not have a solution, unless the infinite list [1,1,1,…] is permitted. First-order logic does not support such infinite structures, hence unification fails. “Occurs check” => check whether a variable, such as L, occurs in a term, such as [1 | L].
Formal Methods Jayaraman
Most General Unifier is Unique
Given a pair of terms, t1 and t2, the most general unifier (mgu) μ of t1 and t2 is unique – the possible exception being that two mgu’s might differ by the names of unbound variables.
Formal Methods Jayaraman
Formal Methods Jayaraman
CLP(R):Constraint Logic
Programming
• Generalizes Prolog by extending unification to more general form of constraint solving.
• Constraints are of different kinds:- Finite Domain: boolean, finite sets, …- Infinite Domain: integers, reals, …
• Constraints bring up new issues in the computational strategy.
Formal Methods Jayaraman48
Prolog’s Behavior
|?- 1 + 2 = 3.
no
|?- X = 3 * 2.
X = 3*2
Prolog’s unification operation treats +, *, etc.syntactically as a infix binary constructors.
|?- 1 + 2 = 1 + 2.
yes
|?- 1 + 2 = 2 + 1.
no
Formal Methods Jayaraman49
SICStus Prolog Constraints
| ?- use_module(library(clpr)).
| ? - {X = 2 * 3}.
X = 6.0
clp = constraintlogic programming
r = reals
| ? – {X + Y = 6, X – Y = 2}.
X = 4.0, Y = 2.0
| ? – {X * X = 64}.
64 – X*X = 0
No support forNonlinear equations!
Formal Methods Jayaraman
Constraint OperationsWhat are constraint operations?
They are builtin functions (+, *, … ) and relations (>, <, …) whose properties are known
to the underlying system, e.g.,X+Y = Y+X,X+0 = X,
X*0 = 0, X>Y ۸ Y>X false
…
Formal Methods Jayaraman
Definite Clauses + Constraints
p(terms).p(terms) :- p1(terms), … c(terms), … pn(terms)
In addition to ordinary goals, there could be constraint goals, c(terms), in the body.
Unification replaced by Constraint Solving.
Backtracking is used as before.
Formal Methods Jayaraman
Compound Interest
Compute the amount A that a principal P would grow to at monthly interest I in time T, compounded monthly.
We can define money1(P, T, I, A) as follows.
money1(P, 0, I, P).money1(P, T, I, A) :-
T > 0,money1(P*(I+1), T-1, I, A).
Formal Methods Jayaraman
money1(100, 5, 0.1, A)• money1(100, 5, 0.1, A)
• money1(100*1.1, 4, 0.1, A)
• money1(110*1.1, 3, 0.1, A)
• money1(121*1.1, 2, 0.1, A)
• money1(133.1*1.1, 1, 0.1, A)
• money1(146.41, 0, 0.1, A)
Answer: A = 146.41
Formal Methods Jayaraman
Constraints are Bi-directional
Compute the principal P that would grow to amount A at monthly interest I in time T, compounded monthly.
We can define money1(P, T, I, A) as follows.
money1(P, 0, I, P).money1(P, T, I, A) :-
T > 0,money1(P*(I+1), T-1, I, A).
Formal Methods Jayaraman
money1(P, 5, 0.1, 200)• money1(P, 5, 0.1, 200)
• money1(P*1.1, 4, 0.1, 200)
• money1(P*1.21, 3, 0.1, 200)
• money1(P*1.331, 2, 0.1, 200)
• money1(P*.14641, 1, 0.1, 200)
• money1(P*1.6105, 0, 0.1, 200)
Solve: P*1.6105 = 200
LINEAR!
Formal Methods Jayaraman
Constraint solving is limited
What is the interest rate I needed to grow principalP to amount A in time T?
Can we use the previous definition for this query?
money1(P, 0, _, P).money1(P, T, I, A) :- T > 0, money1(P*(1+I), T-1, I, A).
Formal Methods Jayaraman
money1(100, 5, I, 200)• money1(100, 5, I, 200)
• money1(100*(I+1), 4, I, 200)
• money1(100*(I+1)*(I+1), 3, I, 200)
• money1(100*(I+1)*(I+1)*(I+1), 2, I, 200)
• money1(100*(I+1)*(I+1)*(I+1)*(I+1), 1, I, 200)
• money1(100*(I+1)*(I+1)*(I+1)*(I+1)*(I+1), 0, I, 200)
Solve: 100*(I+1)*(I+1)*(I+1)*(I+1)*(I+1) = 200
NONLINEAR!
Formal Methods Jayaraman
Carrying along constraints
Compute the least time T that it takes to grow a principal P to amount A at monthly interest I, compounded monthly.
Will the previous definition work?
money1(P, 0, _, P).money1(P, T, I, A) :- T > 0, money1(P*(1+I), T-1, I, A).
Formal Methods Jayaraman
money1(100, 5, 0.1, 125)• money1(100, T, 0.1, 125)
• money1(100*1.1, T-1, 0.1, 125), T>0
• money1(110*1.1, T-2, 0.1, 125), T>0, T>1,
• money1(121*1.1, T-3, 0.1, 125), T>0, T>1, T>2
• money1(133.1*1.1, T-4, 0.1, 125), T>0, T>1, T>2,
T>3
• …NONTERMINATION!
Formal Methods Jayaraman
Definite Clauses + Constraints
Compute the least time T that it takes to grow a principal P to amount A at monthly interest I, compounded monthly.
money2(P, 0, _, A) :- P >= A.money2(P, T, I, A) :- T > 0, money2(P*(1+I), T-1, I, A).
Formal Methods Jayaraman
Combining money1 and money2
money(P, T ,I, A) :- (var(T)
-> money2(P, T, I, A). ; money1(P, T, I, A)
).
The money predicate can work in differentmodes of instantiation of its arguments,except that it cannot solve nonlinearequations, a limitation of CLP(R).
Formal Methods Jayaraman
Constraints help prune unproductive search
Prolog: Generate-then-Test is the preferred strategy
CLP®: Test-then-Generate is a better strategy
Formal Methods Jayaraman
Generate-then-Test (Prolog)
gen(0). gen(1). gen(2). ... gen(10).
Prolog: |?- generate(X, Y), test(X, Y)
Lots of unnecessary backtracking!
generate(X, Y) :- gen(X), gen(Y).
test(X, Y) :- X > 6, Y > 6.
Formal Methods Jayaraman
Test-then-Generate (CLP®)
generate(X, Y) :- gen(X), gen(Y).
test(X, Y) :- X > 6, Y > 6.
CLP(R) |?- test(X, Y), generate(X, Y)
Efficient generation of values!
Formal Methods Jayaraman
CLP(R) Computation
|?- test(X, Y), generate(X, Y)
|?- X > 6, Y > 6, generate(X, Y)
|?- gen(X), gen(Y) X > 6, Y > 6
Constraint Store
gen(1)gen(0) …. gen(7)F F F S
X=0 X=7
CLP(R) Computation
|?- test(X, Y), generate(X, Y)
|?- X > 6, Y > 6, generate(X, Y)
|?- gen(X), gen(Y) X > 6, Y > 6 X = 7
|?- gen(Y) Y > 6
gen(1)gen(0) …. gen(7)F F F S
Y=0 Y=7 { X 7, Y 7 } computed answer substitution
Formal Methods Jayaraman
Applications of Constraints
• Optimization (Scheduling)• Drawing Layouts• Modeling of Physical Systems
Constrained Objects
Formal Methods Jayaraman
Formal Methods Jayaraman
Multi Paradigm Languages
• Over the last two decades, there have been several efforts to combine language paradigms:– Functional + Logic– Functional/Logic + Concurrent– Objects + Concurrency– etc.