Full Logic Programming

1. Full Logic Programming

2. Data structures • Pure LP allows only to represent relations (=predicates) • To obtain full LP we will add functors (=function symbols) • This will allow us to represent data structures

3. Data structures • Pure LP allows only to represent relations (=predicates) • To obtain full LP we will add functors (=function symbols) • This will allow us to represent data structures • In particular, functors can be nested

4. Data structures • Pure LP allows only to represent relations (=predicates) • To obtain full LP we will add functors (=function symbols) • This will allow us to represent data structures • In particular, functors can be nested

5. Functor examples cons(a,[ ]) describes the list [a]. [ ] is an individual constant, standing for the empty list . The cons functor has a syntactic sugar notation as an inx operator |: • cons(a,[ ]) is written: [a|[ ]]. • cons(b,cons(a,[ ])) the list [b,a], or [b|[a|[ ]]]. The syntax [b,a] uses the • printed form of lists in Prolog. • tree(Element,Left,Right) a binary tree, with Element as the root, and Left and Right as its sub-trees. • tree(5,tree(8,void,void),tree(9,void,tree(3,void,void)))

6. Capturing natural number arithmetics • 1. Definition of natural numbers: • % Signature: natural_number(N)/1 • % Purpose: N is a natural number. • natural_number(0). • natural_number(s(X)) :- natural_number(X).

7. Addition and substraction • % Signature: Plus(X,Y,Z)/3 • % Purpose: Z is the sum of X and Y. • plus(X, 0, X) :- natural_number(X). • plus(X, s(Y), s(Z)) :- plus(X, Y, Z). • ?- plus(s(0), 0, s(0)). /* checks 1+0=1 • Yes. • ?- plus(X, s(0), s(s(0)). /* checks X+1=2, e.g., minus • X=s(0). • ?- plus(X, Y, s(s(0))). /* checks X+Y=2, e.g., all pairs of natural • numbers, whose sum equals 2 • X=0, Y=s(s(0)); • X=s(0), Y=s(0); • X=s(s(0)), Y=0.

8. Less or Equal • % Signature: le(X,Y)/2 • % Purpose: X is less or equal Y. • le(0, X) :- natural_number(X). • le(s(X), s(Z)) :- le(X, Z).

9. Multiplication • % Signature: Times(X,Y,Z)/2 • % Purpose: Z = X*Y • times(0, X, 0) :- natural_number(X). • times(s(X), Y, Z) :- times(X, Y, XY), plus(XY, Y, Z).

10. Implications • Pure LP can’t capture unbounded arithmetics. • It follows that full LP is strictly more expressible than pure LP • In facts full LP is as expressible as Turing Machines • Full LP is undecidable • In RE: if there is a proof we will find it, but if not we may fail to terminate • Proofs may be of unbounded size since unification may generate new symbols through repeated substitutions of variables x with f(y).

11. Data Structures % Signature: binary_tree(T)/1 % Purpose: T is a binary tree. binary_tree(void). binary_tree(tree(Element,Left,Right)) :- binary_tree(Left),binary_tree(Right). % Signature: tree_member(X, T)/2 % Purpose: X is a member of T. tree_member(X, tree(X, _, _)). tree_member(X, tree(Y,Left, _)):- tree_member(X,Left). tree_member(X, tree(Y, _, Right)):- tree_member(X,Right).

12. Lists • Syntax: • [ ] is the empty list . • [Head|Tail] is a syntactic sugar for cons(Head, Tail), where Tail is a list term. • Simple syntax for bounded length lists: • [a|[ ]] = [a] • [a|[ b|[ ]]] = [a,b] • [rina] • [sister_of(rina),moshe|[yossi,reuven]] = [sister_of(rina),moshe,yossi,reuven] • Defining a list: • list([]). /* defines the basis • list([X|Xs]) :- list(Xs). /* defines the recursion

13. Lists • Syntax: • [ ] is the empty list . • [Head|Tail] is a syntactic sugar for cons(Head, Tail), where Tail is a list term. • Simple syntax for bounded length lists: • [a|[ ]] = [a] • [a|[ b|[ ]]] = [a,b] • [rina] • [sister_of(rina),moshe|[yossi,reuven]] = [sister_of(rina),moshe,yossi,reuven] • Defining a list: • list([]). /* defines the basis • list([X|Xs]) :- list(Xs). /* defines the recursion

14. List membership: • % Signature: member(X, List)/2 • % Purpose: X is a member of List. • member(X, [X|Xs]). • member(X, [Y|Ys]) :- member(X, Ys)

15. List membership: • % Signature: member(X, List)/2 • % Purpose: X is a member of List. • member(X, [X|Xs]). • member(X, [Y|Ys]) :- member(X, Ys)

16. Append • append([], Xs, Xs). • append([X|Xs], Ys, [X|Zs] ) :- • append(Xs, Ys, Zs). • ?- append([a,b], [c], X). • ?- append(Xs, [a,d], [b,c,a,d]). • ?- append(Xs, Ys, [a,b,c,d]).

17. Append • append([], Xs, Xs). • append([X|Xs], Y, [X|Zs] ) :- append(Xs, Y, Zs). • ?- append([a,b], [c], X). • ?- append(Xs, [a,d], [b,c,a,d]). • ?- append(Xs, Ys, [a,b,c,d]).

18. Reverse reverse([], []). reverse([H|T], R) :- reverse(T, S), append(S, [H], R). OR reverse(Xs, Ys):- reverse_help(Xs,[],Ys). reverse_help([X|Xs], Acc, Ys ) :- reverse_help(Xs,[X|Acc],Ys). reverse_help([ ],Ys,Ys ).