Principles of Programming Languages

Transcription

1 Principles of Programming Languages Lesson Collaboration 22 An Introduction and Management to Logic Programming Dana Fisman Logic Programming ( Pure Prolog ) 1

2 Review of Last Lecture How does it look like? What is the meaning? What is the execution alg? Relational Logic Programming Logic Programming Prolog

3 Operational Semantics for LP Interpreter of LP uses two main procedures: o Answer-query(P,Q) Builds a proof tree for Q wrt. P aka ProofTree(P,Q) returns a substitution s to the variables of Q showing Q holds (or true if there are no variables) or fail if no substitution will make the formula true (or false if there are no variables) o Unify(A,B) returns a substitution s such that s = mgu(a,b) or Fail if A and B cannot be unified

4 Unify Goal of Unify(A,B): find the most general unifier. Example: Unify( p(x,3,x,w), p(y,z,4,w) ) ==> {X=4, Y=4, Z=3} Indeed: p(x, 3, X, W) {X=4, Y=4, Z=3} = p(4, 3, 4, W) p(y, Z, 4, W) {X=4, Y=4, Z=3} = p(4, 3, 4, W)

5 Disagreement Set The disagreement set of two atomic formulas A and B is the set of left most symbols on which the formulas disagree. Examples: d-s(p(x,3,x,w), p(y,z,4,w)) = {X,Y}. d-s(p(5,3,x,w), p(5,3,4,w)) = {X,4}.

6 Unify - A unification algorithm Signature: unify(a, B) Type: [atomic-formula * atomic-formula -> a substitution or FAIL] Postcondition: result = mgu(a, B) if A and B are unifiable or FAIL, otherwise unify(a, B) return unify_h(a, B, {}) unify_h(a, B, s) if A s top pred is different than A s top pred (in name or arity) return FAIL Let A = A s Let B = B s if A = B return s else let D = disagreement-set(a, B ) if D = {X, t} /* X is a variable; t is a term */ let s = s {X = t} unify_h(a, B, s ) else return FAIL

7 Unify - example unify[ p(x, 3, X, W), p(y, Y, Z, Z) ] ==> unify_h[p(x, 3, X, W), p(y, Y, Z, Z), {} ] ==> D = {X, Y} unify_h[p(y, 3, Y, W), p(y, Y, Z, Z), {X = Y} ] ==> D = {Y, 3} unify_h[p(3, 3, 3, W), p(3, 3, Z, Z), {X = 3, Y= 3} ] ==> D = {Z, 3} unify_h[p(3, 3, 3, W), p(3, 3, 3, 3), {X = 3, Y= 3, Z = 3} ] ==> D = {W, 3} unify_h[p(3, 3, 3, 3), p(3, 3, 3, 3), {X = 3, Y= 3, Z:= 3, W = 3} ] ==> {X = 3, Y = 3, Z = 3, W = 3}

8 answer-query: an interpretation algorithm for LP Input: A query Q?- Q 1,..., Q n. Each component is called goal A program P, with numbered rules A goal selection policy G sel A rule selection policy R sel Output: A set of (possibly partial) substitutions for variables of Q.

9 Operational Semantics for LP Method: Build a node N for the given query Q From current node N: If it is a success leaf (N = true), o extract answer and return it o Backtrack to obtain more answers Input: a program P and a query Q Output: partial subs to query variables (or true/false) If it is a failure leaf (N =false) o Backtrack If it is not a leaf node and N = (G1,,Gn) o o select a goal Gi and select a rule H :- B1,, Bk If H can be unified with Gi unifier Subs then create a new node N = (G1, Gi-1, B1,, Bk, Gi+1, Gn) Subs Otherwise, create a new node N = false. o Make N the current node.

10 Applying Answer-Query parent(abraham, isaac). %p1 parent(isaac, jacob). %p2 parent(sarah, isaac). %p3 parent(jacob, joseph). %p4 male(abraham). %m1 male(isaac). %m2 male(jacob). %m3 male(joseph). %m4 ancestor(a,d) :- parent(a,d). %a1 ancestor(a,d) :- parent(a,p), %a2 ancestor(p,d).?- ancestor(isaac,d). %a1 {A1=isaac,D1=D} D=joseph par(isaac, D1) %p2 {D1=jacob} par(jacob, D2) %p4 {D2=joseph} true anc(isaac,d) %a2 {A1=isaac,D1=D} par(isaac, P1), anc(p1,d1) %p2 {P1=jacob} true anc(jacob,d1) D=jacob %a1 {A2=jacob, D2=D1} %a2 {A2=jacob, D2=D1} %a1 {A3=joseph, D3=D2} par(jacob, P2), anc(p2,d2) %p4 {P2=joseph} anc(joseph,d2) %a2 {A3=joseph,D3=D2} par(joseph, D3) false par(joseph, P3), anc(p3,d3) false

11 Applying Answer-Query parent(abraham, isaac). %p1 parent(isaac, jacob). %p2 parent(sarah, isaac). %p3 parent(jacob, joseph). %p4 male(abraham). %m1 male(isaac). %m2 male(jacob). %m3 male(joseph). %m4 %a1 anc(isaac,d) %a1 {A2=P1,D2=D} %a2 {A1=isaac,D1=D} anc(p1,d), par(isaac, P1) %a2 {A2=P2,D2=D} ancestor(a,d) :- parent(a,d). %a1 ancestor(a,d) :- parent(a,p), %a2 ancestor(p,d).?- ancestor(isaac,d). par(p1,d), par(isaac, P1) anc(p2,d), par(p2, P1), par(isaac, P1) %a2 {A3=P3,D3=D} par(isaac, abraham) par(isaac, issac) par(isaac, sarah) par(isaac, jacob) anc(p3,d), par(p3, P2), par(p2, P1), par(isaac, P1) %a1 %a2 fail fail fail true

12 Significant kinds of proof trees Finite success proof tree: A finite tree with a successful path. Finite failure proof tree: A finite tree with no successful path. Infinite success proof tree: An infinite tree with a successful path. Infinite failure proof tree: An infinite tree with no successful path.

13 Decidability of Relational LP Proof: Claim: Given a program P and a query Q in RLP, the problem "Is Q provable from P ", denoted P ` Q is decidable. The number of terms (constants/variables) and predicates appearing in P and Q is finite. Thus, the number of possible atomic formula (i.e. goals appearing in a node of the proof tree) is finite (except for renaming). Let N(P,Q) be that number. Then, any path that is longer than N(P,Q) is infinite. QED

14 Prolog and subsets of interest Relational Logic Programming Datalog Logic Programming Prolog

15 Modeling SQL in RLP o RLP naturally represents structured databases (tables with static columns). o A procedure consisting of facts can represent a table in the database. o Often databases are access via elementary SQL operations such as: select, project, union, Cartesian product and join.

16 Modeling SQL in RLP Select (rows from table r, fitting some criteria): r1(x1, X2, X3) :- r(x1, X2, X3), X2 \= X3. Project (some columns from table r): r1(x1, X3) :- r(x1, X2, X3). Union (unite tables r and s, with identical columns): r_union_s(x1,..., Xn) :- r(x1,..., Xn). r_union_s(x1,..., Xn) :- s(x1,..., Xn).

17 Modeling SQL in RLP Cartesian product (all combinations of rows from r and s): r_x_s(x1,..., Xn, Y1,..., Ym) :- r(x1,..., Xn ), s(y1,..., Ym). Natural Join (join tables r and s, with mutual column X): r_join_s(x1,..., Xn, X, Y1,..., Ym) :- r(x1,..., Xn, X ), s(x, Y1,..., Ym).

18 Prolog and its subsets Relational Logic Programming Logic Programming Prolog

19 Logic Programming The only difference between RLP and LP is that a functor symbol is added to the syntax Functors are used to represent composite data structures. course(ppl, Sun, 14, 16, 35, 310). course(ppl, Mon, 14, 16, 32, 307). course(ppl, time(sun,14,16), location(35,310)). course(ppl, time(mon,14,16), location(32,307)).

20 Logic Programming This addition of functors has significant implication: the resulting logic is Turing Complete (recursively enumerable). and thus partially decidable. Implementation requires a more complex unification algorithm.

21 Logic Programming Terms Syntax Terms are now define inductively: Base A constant is a term A variables is a term Inductive step If t 1,..., t n are terms and f is a functor symbol then f(t 1,..., t n ) is a term.

22 Atomic formula in FLP - examples parent(juliet, Child) Constants: ppl, Mon, 14, 16, 32, 307 Functors: time, location, course course(ppl, time(mon,14,16), location(32,307)). member(cube(red(x)), Lst) Functors: cube, red, member Variables: X, Lst ancestor(mary, sister_of(john)) Constants: john, mary Functors: sister_of, ancestor p(f(f(f(g(a,g(b,c)))))) Constants: a, b, c Functors: f,g,p

23 LP Concrete Syntax Extension <term> ==> <constant> <variable> <composite-term> <composite-term> ==> <functor> ( (<term>, )* <term> ) <functor> ==> <constant>

24 LP Abstract Syntax Extension <term>: Kinds: <constant>, <variable>, <composite-term> <composite-term>: Components: Functor: <constant> Term: <term>. Amount: >=1. Ordered.

25 Example power of functors To show the power of functors, we will write a small program in pure Prolog that o defines what are formulas in conjunctive normal form (CNF) o provides a procedure to transform a formula not in CNF to an equivalent formula in CNF Credit for the example: Marcin Judinski

26 PL CNF Example o: OR a: AND n: NEG

27 Example: Defining CNF monomial(x) :- atom(x). monomial(neg(x)) :- atom(x). disjunction(x) :- monomial(x). disjunction(or(x,y)) :- disjunction(x), disjunction(y). cnf(x) :- disjunction(x). cnf(and(x,y)) :- disjunction(x), disjunction(y). cnf(and(x,y)) :- cnf(x), cnf(y).?- atom(foo). true?- monomial(bar). true?- monomial(neg(bar)). true?- monomial(and(bar)). false

28 Example: Defining CNF monomial(x) :- atom(x). monomial(neg(x)) :- atom(x). disjunction(x) :- monomial(x). disjunction(or(x,y)) :- disjunction(x), disjunction(y). cnf(x) :- disjunction(x). cnf(and(x,y)) :- disjunction(x), disjunction(y). cnf(and(x,y)) :- cnf(x), cnf(y).?- disjunction(foo). true?- disjunction(neg(foo)). true?- disjunction(or(neg(foo),bar)). true?- disjunction(and(neg(foo),bar)). false

29 Example: Defining CNF monomial(x) :- atom(x). monomial(neg(x)) :- atom(x). disjunction(x) :- monomial(x). disjunction(or(x,y)) :- disjunction(x), disjunction(y). cnf(x) :- disjunction(x). cnf(and(x,y)) :- disjunction(x), disjunction(y). cnf(and(x,y)) :- cnf(x), cnf(y).?- cnf(and(neg(foo),bar)). true?- cnf(or(neg(foo),bar)). true?- cnf(or(neg(foo),and(bar,moo))). false?- cnf(and(neg(foo),or(bar,moo))). true

30 PL CNF Example Now we would like to define a procedure with input: a boolean formula (using and,or,neg) output: an equivalent formula in CNF % Signature: givecnfequiv(boolform)/1 % Purpose: Prints a formula cnf that is equivalent % to boolform is in CNF This procedure will invoke % Signature: cnfequiv(boolform, cnf)/2 % Purpose: Transforms a boolean formula to an equivalent % one in CNF % Postcondition: cnf is equivalent to boolform in CNF % Precondition: boolform is a boolean formula % and cnf is a variable

31 Ex. Defining givecnfequiv givecnfequiv(x) :- cnfequiv(x,y), write(y). cnfequiv(x,y) :- transform(x,z), cnfequiv(z,y). cnfequiv(x,x).?- cnfequiv(or(neg(foo),and(bar,moo)), X). X = and(or(neg(foo), bar), or(neg(foo), moo))?- givecnfequiv(or(neg(foo),and(bar,moo))). and(or(neg(foo), bar), or(neg(foo), moo)) true

32 Ex. Defining transform transform(neg(neg(x)),x). % eliminate double negation transform(neg(and(x,y)), or(neg(x),neg(y))). % De Morgan transform(neg(or(x,y)), and(neg(x),neg(y))). % De Morgan % distribution transform(or(x,and(y,z)), and(or(x,y),or(x,z))). transform(or(and(x,y),z), and(or(x,z),or(y,z))). % recursion to transform sub terms transform(or(x1,y), or(x2,y)) :- transform(x1,x2). transform(or(x,y1), or(x,y2)) :- transform(y1,y2). transform(and(x1,y), and(x2,y)) :- transform(x1,x2). transform(and(x,y1), and(x,y2)) :- transform(y1,y2). transform(neg(x1),neg(x2)) :- transform(x1,x2).

33 Ex. Defining transform transform(neg(neg(x)),x). % eliminate double negation transform(neg(and(x,y)), or(neg(x),neg(y))). % De Morgan transform(neg(or(x,y)), and(neg(x),neg(y))). % De Morgan % distribution transform(or(x,and(y,z)), and(or(x,y),or(x,z))). transform(or(and(x,y),z), and(or(x,z),or(y,z))). % recursion to transform sub terms transform(or(x1,y), or(x2,y)) :- transform(x1,x2). transform(or(x,y1), or(x,y2)) :- transform(y1,y2). transform(and(x1,y), and(x2,y)) :- transform(x1,x2). transform(and(x,y1), and(x,y2)) :- transform(y1,y2). transform(neg(x1),neg(x2)) :- transform(x1,x2).

34 PL Operational Semantics The abstract interpreter AnswerQuery(P,Q) for RLP applies to LP as well. The only difference is that the unification algorithm has to be extended to handle the richer term structure, which now includes functors that can be nested within other functors.

35 LP - Unification - unify(member(x,tree(x,left,right)), member(y,tree(9,void,tree(3,void,void)))) ==> {Y=9, X=9, Left=void, Right=tree(3,void,void)} unify(t(x, f(a), X), t(g(u), U, W)) ==> {X=g(f(a)), U=f(a), W=g(f(a))} unify(t(x, f(x), X), t(g(u), U, W)) ==> fails

36 Unify in LP Signature: unify(a, B) Type: [atomic-formula * atomic-formula -> a substitution or FAIL] Postcondition: result = mgu(a, B) if A and B are unifiable or FAIL, otherwise unify(a, B) return unify_h(a, B, {}) unify_h(a, B, s) if A s top pred is different than A s top pred (in name or arity) return FAIL Let A = A s Let B = B s if A = B The occur check return s constraint else let D = disagreement-set(a, B ) if D = {X, t} and X does not occur in t let s = s {X = t} unify_h(a, B, s ) else return FAIL

37 LP as Programming Language? Can we call Pure Prolog a programming language? o It has the required 3: Syntax, Semantics, Operational semantics To be called a general purpose programming logic it also has to be Turing Complete. o We should be able to implement any RE function in it.

38 Expressivity and Decidability LP Claim: LP is Turing-Complete. How can this be proven? One can write a short LP program that implements a Turing Machine. Claim: LP is only partially decidable. The finiteness algorithm we used for RLP does no longer hold. In the presence of functors that can be nested within each other, the number of different atomic formulas is unbounded.

39 Expressivity of Prolog and its subsets Not Turing Complete Turing Complete Turing Complete Relational Logic Programming Logic Programming Prolog

40 What about our Scheme Subsets? Which is the smallest one which is Turing Complete? Scheme L4 define L1 only primitive ops and types L2 L3 cond lambda cons car cdr '() list letrec Turing Complete L5

41 Expressivity of Prolog and its subsets Not Turing Complete Turing Complete Turing Complete Relational Logic Programming Logic Programming Prolog So, why do we need to extend Pure Prolog? Before we go into Full Prolog, let s try to implement some of these ourselves.