Program 1: THE FAMILY PROGRAM.CODE:

parent(pam,bob).parent(tom,bob).parent(tom,liz).parent(bob,ann).parent(bob,pat).parent(pat,jim).

female(pam).male(tom).male(bob).female(liz).female(ann).female(pat).male(jim).

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

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

grandparent(X,Z):- parent(X,Y), parent(Y,Z).

sister(X,Y):- parent(Z,X), parent(Z,Y). female(X), different(X,Y).

predecessor(X,Z):- parent(X,Z).

predecessor(X,Z):- parent(X,Y), predecessor(Y,Z).

OUTPUT:1 ?- predecessor(pam,jim).true .

2 ?- predecessor(pam,X).X = bob ;X = ann ;X = pat ;X = jim ;false.

Program 2: CODE:

big(bear).big(elephant).small(cat).

brown(bear).black(cat).gray(elephant).

dark(Z):- black(Z).

dark(Z):- brown(Z).

OUTPUT:1 ?- dark(X),big(X).X = bear.

Program 3: Different VERSION of FAMILY program.CODE:

parent(pam,bob).parent(tom,bob).parent(tom,liz).parent(bob,ann).parent(bob,pat).parent(pat,jim).

pred1(X,Z):- parent(X,Z).pred1(X,Z):- parent(X,Y),

pred1(Y,Z).

pred2(X,Z):- parent(X,Y), pred2(Y,Z).

pred2(X,Z):- parent(X,Z).

pred3(X,Z):- parent(X,Z).pred3(X,Z):- pred3(X,Y), parent(Y,Z).

pred4(X,Z):- pred4(X,Y), parent(Y,Z).pred4(X,Z):- parent(X,Z).

OUTPUT:1 ?- pred1(tom,pat).true .

2 ?- pred2(tom,pat).true .

3 ?- pred3(tom,pat).true .

4 ?- pred4(tom,pat). ERROR: Out of local stack Exception: (1,675,218) pred4(tom, _G367) ? creep

Program 4: Define two predicates Evenlength(List) and oddlength(List) so that they are true if their argument is a list of even or odd length respectively.CODE:

evenlength(X):- length(X,N),N mod 2=:=0.

oddlength(X):- length(X,N),N mod 2=:=1.

OUTPUT:1 ?- evenlength([a,b,c,d]).true.

2 ?- oddlength([a,b,c,d]).false.

Program 5: Define the relation reverse(List,ReversedList) that reverses the list.CODE:

reverse([],[]).reverse([First|Rest],Reversed):- reverse(Rest,ReversedRest),

conc(RevesredRest,[First],Reversed).

conc([],L,L).conc([X|L1],L2,[X|L3]):-conc(L1,L2,L3).

OUTPUT:1 ?- reverse([n,e,h,a],R).R = [a, h, e, n].

Program 6: Define the predicate that palindrome(List). A list is a palindrome if it reads the same in the forward and in the backward direction.CODE:

palindrome(List):- reverse(List,List).

reverse([],[]).reverse([First|Rest],Reversed):- reverse(Rest,ReversedRest),

conc(RevesredRest,[First],Reversed).conc([],L,L).conc([X|L1],L2,[X|L3]):-conc(L1,L2,L3).

OUTPUT:1 ?- palindrome([m,a,d,a,m]).true.

2 ?- palindrome([n,e,h,a]).false.

Program 7: Define the relation shift(List1,List2) so that List2 is List1 ‘shifted rotationally’ by one element to the left.CODE:

shift([First|Rest],Shifted):- conc(Rest,[First],Shifted).

conc([],L,L).conc([X|L1],L2,[X|L3]):-conc(L1,L2,L3).

OUTPUT:1 ?- shift([1,2,3,4,5],L1),shift(L1,L2).L1 = [2, 3, 4, 5, 1],L2 = [3, 4, 5, 1, 2].

Program 8: Define relation dividelist(List,List1,List2) so that the elements of the List are partitioned between List1 and List2, and List1 and List2 are approximately the same length. CODE:

dividelist([],[],[]).dividelist([X],[X],[]).dividelist([X,Y|List],[X|List1],[Y|List2]):-dividelist(List,List1,List2).

OUTPUT:1 ?- dividelist([a,b,c,d,e],List1,List2).List1 = [a, c, e],List2 = [b, d].

Program 9: Define the relation flatten(List,FlatList) where List can be a list of lists, and FlatList is List ‘flattened’ so that the elements of List’s sublists are reorganized as one plain list.CODE:

flatten([Head|Tail],FlatList):- flatten(Head,FlatHead),flatten(Tail,FlatTail),conc(FlatHead,FlatTail,FlatList).

conc([],L,L).conc([X|L1],L2,[X|L3]):-conc(L1,L2,L3).

OUTPUT:1 ?- flatten([a,b,[c,d],[],[[[e]]],f],L).L = [a, b, c, d, e, f].

Program 10: Define the relation max(X,Y,Max) so that Max is greater of the two X and Y.CODE:

max(X,Y,X):- X>=Y.max(X,Y,Y):- X<Y.

OUTPUT:1 ?- max(2,5,Max).Max = 5.

Program 11: Define the predicate maxlist(List,Max)

so that Max is the greatest number in the list of numbers List.CODE:

maxlist([X],X).maxlist([X,Y|Tail],Max):- maxlist([Y|Tail],Max1),

max(X,Max1,Max).

max(X,Y,X):- X>=Y.max(X,Y,Y):- X<Y.

OUTPUT:1 ?- maxlist([3,9,4,5,12],Max).Max = 12.

Program 12: Define the predicate sumlist(List,Sum) so that the Sum is the sum of the given list of numbers List.

CODE:sumlist([],0).sumlist([Head|Tail],Sum):- sumlist(Tal,Sum1),

Sum is Head + Sum1.

OUTPUT:1 ?- sumlist([1,2,6,4,21],Sum).Sum = 34.

Program 13: Define the predicate ordered(List) which is true if List is an ordered list of numbers.

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

OUTPUT:1 ?- ordered([1,5,6,6,9,12]).true .

2 ?- ordered([1,7,3,8,5]).false.

Program 14: Define the predicate subsum(Set,Sum,SubSet)

so that Set is a list of numbers, SubSet is a subset of these numbers,a nd the sum of the numbers im SubSet is Sum.

CODE:subsum([],0,[]).subsum([N|List],Sum,[N|Sub]):- Sum1 is Sum-N,

subsum(List,Sum1,Sub). % N is in subsetsubsum([N|List],Sum,Sub):- subsum(List,Sum,Sub). % N is notin subset

OUTPUT:1 ?- subsum([1,2,5,3,2],5,Sub).Sub = [1, 2, 2] ;Sub = [2, 3] ;Sub = [5] ;Sub = [3, 2] ;false.

Program 15: Define the procedure between(N1,N2,X) which, for two given integers N1 and N2, generates through backtracking all the inetegers X that satisfy the constraint N1<= X<=N2.CODE:

between(N1,N2,N1):- N1=< N2.between(N1,N2,X):- N1<N2,

NewN1 is N1+1, between(NewN1,N2,X).

OUTPUT:30 ?- between(4,9,X).X = 4 ;X = 5 ;X = 6 ;X = 7 ;X = 8 ;X = 9 ;false.

Program 16: Define the predicate length(List,N) where N is the length of the given list.

CODE:length([],0).

length([_|Tail],N):- length(Tail,N1), N is 1+N1.

OUTPUT:1 ?- length([a,b,[c,d],e],N).N = 4.

Program 17: Define the predicate gcd(X,Y,D) so that D is the greatest common divisor of two numbers X and Y.

CODE:gcd(X,X,X).

gcd(X,Y,D):- X<Y, Y1 is Y-X, gcd(X,Y1,D).

gcd(X,Y,D):- Y<X, gcd(Y,X,D).

OUTPUT:

1 ?- gcd(20,25,D).D = 5 .

2 ?- gcd(3,6,D).D = 3 .

Program 18: Define the predicate Permutation(List,P) so that P generates all the permutations of the given list.

CODE: a)

permutation([],[]).permutation([X|L],P):- permutation(L,L1),

insert(X,L1,P).

insert(X,L1,P):- del(X,P,L1).

del(X,[X|Tail],Tail).del(X,[Y|Tail],[Y|Tail1]):- del(X,Tail,Tail1).

OUTPUT:1 ?- permutation([a,b,c],P).P = [a, b, c] ;P = [b, a, c] ;P = [b, c, a] ;P = [a, c, b] ;P = [c, a, b] ;P = [c, b, a] ;false.

b)permutation([],[]).permutation(L,[X|P]):- del(X,L,L1),

permutation(L1,P).

del(X,[X|Tail],Tail).del(X,[Y|Tail],[Y|Tail1]):- del(X,Tail,Tail1).

OUTPUT:1 ?- permutation([a,b,c],P).P = [a, b, c] ;P = [a, c, b] ;P = [b, a, c] ;P = [b, c, a] ;P = [c, a, b] ;P = [c, b, a] ;false.

Program 19: Define the predicate sublist(S,L) so that S occurs within L as its sublist.CODE:

sublist(S,L):- conc(L1,L2,L), conc(S,L3,L2).

conc([],L,L).conc([X|L1],L2,[X|L3]):- conc(L1,L2,L3).

OUTPUT:1 ?- sublist(S,[a,b,c]).S = [] ;S = [a] ;S = [a, b] ;S = [a, b, c] ;S = [] ;S = [b] ;S = [b, c] ;S = [] ;S = [c] ;S = [] ;false.

Program 20: Define the predicate member(X,L) so that it return true if X occurs in list L.CODE:

member(X,[X|Tail]).

member(X,[Head|Tail]):- member(X,Tail).

OUTPUT:Ȉ1 ?- member(b,[a,b,c]).true .

2 ?- member(b,[a,[b,c]]).false.

Program 21: Define the predicate Del(X,L,L1) so that L1 is the list returned after deleting element X from list L.CODE:

del(X,[X|Tail],Tail).

del(X,[Y|Tail],[Y|Tail1]):- del(X,Tail,Tail1).

OUTPUT:1 ?- del(a,[a,b,a,a],L).L = [b, a, a] .

Program 22: Let the program be :p(1).p(2):-!.p(3).

Write all Prolog’s answers to the following questions:CODE:

1 ?- p(X).

X = 1 ;X = 2.

2 ?- p(X),p(Y).

X = Y, Y = 1 ;X = 1,Y = 2 ;X = 2,Y = 1 ;X = Y, Y = 2.

3 ?- p(X),!,p(Y).

X = Y, Y = 1 ;X = 1,Y = 2.

Program 23: The following relation classifies numbers into three classes: positive, zero and negative : class(Number,positive):- Number > 0. class(0,zero). class(Number,negative):- Number < 0.

Define this procedure using cuts.CODE:

class(Number,positive):- Number > 0,!.

class(0,zero):-!.

class(Number,negative).

OUTPUT:1 ?- class(2,P).P = positive.

2 ?- class(-6,P).P = negative.

3 ?- class(0,P).P = zero.

Program 24: Define the procedure Split(Numbers,Positives,Negatives) Which splits a list of numbers into two lists: positive ones(including zero) and negatives ones.

a) Without using cut. CODE:

split([],[],[]). split([X|L],[X|L1],L2):- X>=0,

split(L,L1,L2). split([X|L],L1,[X|L2]):- split(L,L1,L2).

OUTPUT: 1 ?- split([3,-1,0,5,-2],P,N). P = [3, 0, 5], N = [-1, -2].

b) Using cut.CODE:

split([],[],[]). split([X|L],[X|L1],L2):- X>=0,!,

split(L,L1,L2). split([X|L],L1,[X|L2]):- split(L,L1,L2).

OUTPUT: 1 ?- split([3,-1,0,5,-2],P,N). P = [3, 0, 5], N = [-1, -2].

Program 25: Example demonstrating the CUT.CODE:

beat(tom,jim).beat(ann,tom).beat(pam,jim).

class(X,fighter):- beat(X,_), beat(_,X),!.

class(X,winner):- beat(X,_),!.

class(X,sportsman):- beat(_,X).

OUTPUT:1 ?- class(tom,C).C = fighter.

2 ?- class(tom,sportsman).true.

Program 26: Example demonstrating the NEGATION.CODE:

beat(tom,jim).beat(ann,tom).beat(pam,jim).

class(X,fighter):- beat(X,_), beat(_,X).

class(X,winner):- beat(X,_), not beat(_,X).

class(X,fighter):- beat(X,_), not beat(_,X).

OUTPUT:1 ?- class(tom,sportsman).false.

2 ?- class(tom,C).C = fighter.

Program 27: Define the procedure count(A,L,N) where A is atom, L is the list and N is the number of occurrences.CODE:

count(_,[],0).

count(A,[B|L],N):- atom(B),A=B,!, count(A,L,N1),

N is N1+1 ; count(A,L,N).

OUTPUT:1 ?- count(a,[a,b,a,a],N).N = 3.

Program 28: Define the predicate conc(L1,L2,L3) that append two list into a third list L3.CODE:

conc([],L,L).conc([X|L1],L2,[X|L3]):- conc(L1,L2,L3).

OUTPUT:1 ?- conc([1,2,3],[a,b,c,d],L3).L3 = [1, 2, 3, a, b, c, d].

Program 29: Define the predicate fib(N,R) that returns the nth term of a Fibonacci series. CODE:

fib(1,1).fib(2,1).fib(N,R):- N>=3,

N1 is N-1, N2 is N-2, fib(N1,R1), fib(N2,R2), R is R1+R2.

OUTPUT:1 ?- fib(8,R).R = 21.

Program 30: Define the predicate bagof(X,P,L) that produce the list L of all the object X such that a goal P is satisfied.CODE:

age(peter,7).age(ann,5).age(pat,8).age(tom,5).

OUTPUT:1 ?- bagof(Child,age(Child,Age),List).Age = 5,List = [ann, tom] ;Age = 7,List = [peter] ;Age = 8,List = [pat].

Program 31: Define the predicate setof(X,P,L) that produce the list L of object X such that a goal P is satisfied.

CODE:age(peter,7).age(ann,5).age(pat,8).age(tom,5).

OUTPUT:1 ?- setof(Child,Age^age(Child,Age),ChildList),| setof(Age,Child^age(Child,Age),AgeList).ChildList = [ann, pat, peter, tom],AgeList = [5, 7, 8].

Program 32: Define the predicate findall(X,P,L) that produce the list L objects that goal P is satisfied.CODE:

age(peter,7).age(ann,5).age(pat,8).age(tom,5).

OUTPUT:1 ?- findall(Child,age(Child,Age),List).List = [peter, ann, pat, tom].

Program 33: Define the predicate assert(X) such that a clause X is always added to the database.CODE:

fast(ann).slow(tom).slow(pat).

OUTPUT:1 ?- assert(| (faster(X,Y):- fast(X),slow(Y))).true.

2 ?- faster(A,B).A = ann,B = tom ;A = ann,B = pat ;A = ann,B = tom ;A = ann,B = pat ;A = ann,B = tom ;A = ann,B = pat.

3 ?- retract(slow(X)).X = tom ;X = pat.

4 ?- faster(ann,_).false.

Program 34: Define the predicate nth(N,L,R)) such that R is the nth element of the list L. CODE:

nth(0,[X|_],X).nth(N,[_|T],R):- N1 is N-1,

nth(N1,T,R).

OUTPUT:1 ?- nth(4,[1,4,7,2,9,8],R).R = 9 .

Program 35: Define the predicate pow(N,K,R) such that R is the kth power of a number N. CODE:

power(N,0,1).power(N,K,R):- K1 is K-1,

power(N,K1,R1), R is R1*N.

OUTPUT:1 ?- power(3,2,R).R = 9 .

Program 36: Define the predicate to solve problem of tower of HanoiCODE:

hanoi(N):- move(N,left,centre,right).

move(1,A,_,C):- inform(A,C),!.move(1,A,B,_):- inform(A,B),!.move(N,A,B,C):- N1 is N-1,

move(N1,A,C,B),inform(A,C),move(N1,B,A,C).

inform(Location1,Location2):- write('\n move a disk from '), write(Location1), write(' to '), write(Location2).

OUTPUT:1 ?- hanoi(3).

move a disk from left to right move a disk from left to centre move a disk from right to centre move a disk from left to right move a disk from centre to left move a disk from centre to right move a disk from left to righttrue.

Program 37: Define the predicate fact(X,Y) such that Y is the factorial of X. CODE:

start(1):-!.start(0):- write('\n Enter any no. : '),

read(X), fact(X,Y), write('Factorial of '), write(X), write(' is '), write(Y), write('\nContinue?? 0 for YES, 1 for NO : '), read(Choice), start(Choice).

fact(0,1):- !.fact(X,Y):- X1 is X-1,

fact(X1,Y1), Y is X*Y1.

OUTPUT:1 ?- start(0).

Enter any no. : 6|: .Factorial of 6 is 720Continue?? 0 for YES, 1 for NO : 0|: .

Enter any no. : 4|: .Factorial of 4 is 24Continue?? 0 for YES, 1 for NO : 1|: .true.

Program 38: Given a graph, define a predicate to find path between two node of the graph.

CODE:edge(a,b).edge(b,c).edge(c,d).edge(d,e).edge(e,f).edge(a,f).edge(b,e).edge(c,f).edge(b,f).edge(c,e).

path(X,Y):- edge(X,Y).path(X,Y):- edge(X,Z),edge(Z,Y).

OUTPUT:1 ?- path(a,b).true .

2 ?- path(a,f).true .

Program 39: Define the predicate mul(X,N,M) to multiply the given no. X with no N. CODE:

mul(X,1,X).mul(X,Y,Z):- Y>0,

Y1 is Y-1, mul(X,Y1,Z1), Z is X+Z1.

OUTPUT:1 ?- mul(2,8,M).M = 16 .

Program 40: Define the predicate to sort a list using insertion sort.CODE:

insertsort([],[]).insertsort([X|T],Sorted):- insertsort(T,SortT),

insert(X,SortT,Sorted).

insert(X,[Y|Sorted],[Y|Sorted1]):- gt(X,Y),!, insert(X,Sorted,Sorted1).

insert(X,Sorted,[X|Sorted]).

gt(X,Y):- X>Y.

OUTPUT:1 ?- insertsort([1,4,6,2,3],X).X = [1, 2, 3, 4, 6].

Program 45: Define the predicate merge(L1,L2,L3) that merges two list into a third list L3.CODE:

merge([],List,List) :-!.

merge(List,[],List).

merge([X|Rest1],[Y|Rest2],[X|Rest3]) :-X<Y,!,merge(Rest1,[Y|Rest2],Rest3).

merge(List1,[Y|Rest2],[Y|Rest3]) :-merge(List1,Rest2,Rest3).

OUTPUT:

1 ?- merge([a,b,c],[x,y,z],L).L = [a, b, c, x, y, z]. 2 ?- merge([4,5,6],[1,2,3],L).L = [1, 2, 3, 4, 5, 6].