Artificial Intelligence (AI):Programming with VISUAL Prolog

PROLOG (for PROgramming in LOGic) is a very important tool in programming artificial intelligence applications and in the development of expert systems. It allows the programmer to model the logical relationships among objects and processes, complex problems are inherently easier to solve, and the resulting program is easier to maintain through its lifecycle. With Visual Prolog, applications such as customized knowledge bases, expert systems, natural language interfaces, and smart information management systems are easy to develop. Prolog is a declarative language. This means that given the necessary facts and rules, Prolog will use deductive reasoning to solve problems. This is in the contrast to traditional computer languages, such as C, BASIC and Pascal, which are procedural languages. We can also use prolog as any other programming languages in a procedural manner.

Prolog can be viewed as a tool to solve problems in the field of artificial intelligence or it can be very well used a general programming language.  

Prolog enforces the different problem solving paradigm complementary to traditional programming languages so it is believed that a student of computer should learn programming in prolog.

Data types in prolog

There are mainly three data types in prolog which are:

a)      Atoms and numbers

b)      Variables

c)      Structures

a) Atoms and numbers

Atoms can be constructed in three different ways

• Strings of letters, digits, and the underscore character starting with a lower case letter.    For example: man, ram, comp_students, pc_ct_063
• Strings of special characters.                                                                                               For example: < ----- >                                                                                                      Care should be taken not to use the character combination that may some built in meaning.
• Strings of characters enclosed in quotes.                                                                               For example: ‘Hari’    ‘Bird’ etc.                                                                                         Numbers used in prolog are integers and real numbers.     

b) Variables

Variables are strings of letters digits and underscore that start with an underscore or an uppercase letter. The scope of a variable is one clause only. So the same variable used in different clauses mean different thing.             

For example: X, Y, Hari, _load etc.        

Note here that Hari is a variable unlike the earlier use ‘Hari’ where it was a constant, an atom.

An underscore ‘_’ also known as anonymous variable is used in clauses when a variable need not be inferred to more than once.      

c) Structures

 Structures are objects that have different components. The components can be atoms or yet some other structures. A function is used to construct a structure as follows:

family (father, mother, children)

Here family is a structure that has father, mother and children as its elements. The father and mother may de atoms where the children may be yet another structure or a list of atoms. List is a special built in structure in prolog.

A list is a built in structure in prolog. It can be thought of sequence of elements ordered linearly however it is internally represented as a binary tree.

For example: [ albert, john, krish, willium ]

This representation is as follows:

The list as such can be broken down into two parts, the HEAD and the TAIL. The head is the first element of the list and tail is the remaining list. The above list can be broken down as:

[H|T]

Where H = albert

And T = [ john, krish, willium ]

List is one of the most useful structure in prolog.

Writing programs in prolog

All prolog programs start from the goal. It then uses the facts and clauses to break down the goal to sub-goals and tries to prove the sub-goals. A clause is said to have succeeded if there is a combination of facts and clause(s) that holds true.

Prolog has built in backtracking (it will be more clear in next lab) mechanism i. e. whenever three are multiple paths, it chooses one tries to prove it, and comes back to the choices whether the first one succeeds or fails.

Visual Prolog Program to find the bigger of the Two Numbers.

In this program, we have defined a predicate that gives us the larger of atwo given integers. The predicate bigger is defined in the PREDICATES section and the relation is defined in the CLAUSES section. It is customary to put together the predicate definition and clause definition for each predicate but it is not necessary. However, all the clauses for a predicate have to be written together. 

PREDICATES    bigger (integer, integer, integer) CLAUSES   bigger(X,Y,Z):-      X>Y,Z=X.  bigger(X,Y,Z):-      X<Y,Z=Y. GOAL  bigger (4,9,X).

Visual Prolog Program  to find hcf of numbers.

PREDICATES hcf(integer, integer, integer) CLAUSES   hcf(X, Y, X):-        Y mod X = 0.   hcf(X,Y,Z):-        S = Y mod X,S<>0, hcf(S, X, Z). GOAL   hcf(5,10,X).

Visual Prolog program combining facts and rules

Here the predicate mother is used to assert facts. There are four facts in that section. Similarly the predicate husband is used to assert more facts. The predicates son and father are used to define rules. We could have defined rules even with mother and husband but we bet that conciseness for program clarity at this stage.

PREDICATES husband(STRING,STRING) father(STRING,STRING) mother(STRING,STRING) son(STRING,STRING) CLAUSES mother("Kushalya","Ram"). mother("Kaikai","Bharat"). mother("Sumitra","Laxman"). mother("Sumitra","Satrughan"). husband("Dasrath","Kaushalya"). husband("Dasrath","Kaikai"). husband("Dasrath","Sumitra"). son(A,C):- mother(C,A). son(A,C):-husband(C,B), mother(B,A). father(A,B):- husband(A,C), mother(C,B). GOAL son(X, "Kaikai").

Visual Prolog Program to add the contents of an integer list.

Here in this program, the add function is made that adds the contents of list. The first segment ( i.e the Domains section ) defines or declares the space dynamically for integer list. Then the predicate add is defined that takes integer list and a Integer as arguments. The next clause section provides the necessary reasoning and facts to find the solution to the problem. Here the predicate add is called recursively until it gets the last element of the list which is the empty list itself and returns 0 if empty list is encountered. The add predicate else adds the first element to the solution repeatedly to find the solution.

DOMAINS int_list=Integer* PREDICATES             add(int_list, Integer) CLAUSES             add([],0).             add([H|T],Y):- add(T,Y1),Y=Y1+H.                                                 GOAL add([3,2,1,0],X).

                                                                      

Visual Prolog Program to find length of a list.

In this program the predicate length takes integer list and output a integer which is the length of list. Here the predicate length is called repeatedly or recursively until a last empty list is encountered and the 0 value is returned which is then continuously incremented to find the length.

DOMAINS int_list=Integer* PREDICATES length(int_list,integer) CLAUSES length([],0). length([H|T],L):-             length(T,L1),L=L1+1. GOAL length([1,2,3,4,5,6],X).

Visual Prolog Program to find the factorial of a number.

To find the factorial of a number in Visual Prolog, the number is decreased and the predicate “factorial” is continuously until a Zero is encountered when it returns a value 1. Then the predicate multiplies the returned value and the decremented number continuously. Thus, the factorial of a number is found. The visual prologue code to find the factorial of a number is given below:

PREDICATES             factorial(Integer,Integer) Clauses             factorial(0,1).             factorial(X,Y):-                                               X<>0,S=X-1,factorial(S,Y1),Y=X*Y1.                                                             Goal factorial(5,X).

Visual Prolog Program to append two list.

Here the two list are taken by the predicate “append” and returns the appended list. To append two list a list is broken continuously until the last empty list is encountered and finally the other list is appended or joined at the end of first recursively. The code to append is given as follows:

DOMAINS int_list=Integer * PREDICATES append(int_list,int_list,int_list) CLAUSES append([],X,Z):-             Z=X. append([H|T],X,Y):-             append(T,X,Z),Y=[H|Z]. GOAL append([1,2,3,4,5],[6,7,8,9],X).

Visual Prolog Program to delete a given element from the list.

To delete a element from a list the position and the element list is passed to the predicate delete. Then  the delete predicate continuously breaks the list into head (H) and Tail (T) to find that the correct position is reached. On reaching the appropriate position to delete the element the predicate slices the head off the list and finally merges the remaining art with the rest. The prolog code is given as below:

DOMAINS int_list=Integer * PREDICATES delete(integer,int_list,int_list) CLAUSES delete(0,[H|T],T). delete(P,[H|T],[H|Z]):-             P1=P-1,delete(P1,T,Z). GOAL delete(0,[1,2,3,4,5,6,7,8,9],X).