FORMAL METHODS Prolog April 2 & 6, 2015. Formal Methods Programming Languages Imperative Declarative...

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];

}


Declarative Solution


• 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


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)


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


Horn Clauses

• Program Clauses

p(terms).p(terms) :- p1(terms), …, pn(terms).

• Goal Clause

?- pi(terms).

Unit clause

Conditional clause


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


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


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


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


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


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


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).


Prolog predicates as Testers and Generators


Example:

Sample Goals:?- father(mark, joe).

yes

?- father(mary, X).

X = steve

?

?- father(Who, mark). ?X = bob ;X = ann


Prolog Computation Model

• Two key ideas:• Resolution-style Proof - unification of a goal with clause-

head• Backtracking Search - for answers in resolution search

tree


Nondeterminism Backtracking



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

?- parent(mark, jane)

father(mark, jane)

fail

mother(mark, jane)

succeed


Backtracking + Answers mother(bob, mary).mother(ann, mary).mother(mark, jane).mother(mary, sue).


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



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


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


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))


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]]


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

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]


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]


Let’s compare the definition of the ‘append’ operation

in the differentprogramming

paradigms


C definition of ‘append’


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’


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.


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]


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 = []


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}


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]


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


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].


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.



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!


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

…


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.


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).


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


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).


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!


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).


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!


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).


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!


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).


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).


Constraints help prune unproductive search

Prolog: Generate-then-Test is the preferred strategy

CLP®: Test-then-Generate is a better strategy


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.


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!


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


Applications of Constraints

• Optimization (Scheduling)• Drawing Layouts• Modeling of Physical Systems

Constrained Objects



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.

FORMAL METHODS Prolog April 2 & 6, 2015. Formal Methods Programming Languages Imperative Declarative...

Documents

Transcript of FORMAL METHODS Prolog April 2 & 6, 2015. Formal Methods Programming Languages Imperative Declarative...