Exploring Logic Programming: Concepts, History, and Execution

This report provides a comprehensive introduction to logic programming, a paradigm used in artificial intelligence. It begins by defining logic programming and its characteristics, including the use of logical sentences and clauses, differentiating between logic programming languages such as Prolog, ASP, and Datalog. The report delves into the historical context of logic programming, tracing its origins back to the 1930s and the contributions of key figures like Alonzo Church and Cordell Green. It then explores various techniques, including semantic frameworks for languages like PROLOG and TEMPLOG, along with the concepts of logic and control, and knowledge representation. The report also discusses the execution of logic programs, explaining the interpretation and compilation processes and highlighting key concepts like truth and deduction. The report covers important concepts like Horn clauses, goal reduction, and the use of negation as failure, which allows for non-monotonic logic. The report also explores the techniques used in PROLOG and TEMPLOG, providing a good overview of the field.

Introduction to Logic Programming

2
The topic in context here is the introduction to Logic Programming. It is a vast concept with
diverse sets of information regarding the programming language. It would not be possible to
delve deep into every aspect of the topic and discuss extensively every topic that pertains to the
issue. Hence a quick overview of Logic Programming would be made and almost every aspect
related to it would be introduced allowing framework for further studies and a current basic
understanding.
The first question that arises is what is logic Programming? Before that is answered the
discussion of anything related to it would not hold any real value. Logic Programming is a kind
of programming paradigm. A number of computer programs are formulated in terms of logic
programming. It is to be noted that any program which is written in terms of logic
programming consists of a group of sentences in a logical format. These sentences express a set
of facts or rules about some domain of a problem. Besides this, there are a number of logic
programming families that exist. The mentionable ones are Prolog, Answer Set Programming
abbreviated as ASP or Datalog. However, what is common in all these languages is that the rules
in the program are expressed in the form of clauses which is explained in point 1 and are inferred
as logical explanations which are explained in point 2.
1. H: B1, B2, B3, B4,.......Bn
2. H if B1, B2, B3….and Bn
In logic programming, H is taken to be the head of the rule. In addition to this, B is known as
the body of the rule. If we look back, the concept of facts has also been raised. Facts, in reality,
are the rules which have no bodies. It is demonstrated with just H.

3
Logic programming does not always necessary pertain to the simple cases of programming. A
simple case can be considered where the head and body of the rule expressed as H and B1, B2, et
cetera are the atomic formulae. In this case, the clauses are named as Horn clauses or Definite
clauses. Besides this, there can be a few other extensions beyond this simple case too. One of the
most important of these extensions is that when the clauses are in absolute negation to the atomic
formula as discussed above. Consequently, the languages in logic programming which work in
accordance with these extensions have the capability of representing knowledge in the form of
non-monotonic logic.
A brief detail should also be made about the other logic programming languages in addition to
Prolog which includes ASP and Datalog. These programs include a kind of reading which is just
declarative. In terms of its execution, the process involved is model generator and proof
procedure. However, these processes of execution are not generally under the voluntary control
of the programmer. But if we take into account the Paralog language, it is seen that it has a
system of interpretation which is procedural. It is primarily done as a process of goal reduction.
For example, in order to solve the head of the rule which is H, the body of the rule too, including
B1, B2 to Bn, everything has to be solved.
History of Logic Programming
The first appearance of logic programming goes back to the 1930s, developed by Alonzo
Church, as a feature of the lambda calculus. This was the first use of mathematical logic in
computers sciences. Apart from the developer, Cordell Green was the first one to propose the use
of the clausal form of Logic as the representation of computer programs. In 1960-1970, a debate
arises about the declarative versus the procedural representation of knowledge about artificial

4
intelligence. This is where the current form of logic programming can be traced. The advocates
of each procedure were working in different places. In Stanford, alongside Cordell Green, there
was John McCarthy, Bertram Raphael and in Edinburgh, Alan Robinson, Pat Hayes and Robert
Kowalski. While the advocates of the procedural representations were in MIT(Massachusetts
Institution of Technology), with Marvin Minsky and Seymour Papert as the head of the study.
Techniques
In widespread discussions about logic programming, a number of aspects have been discussed,
including its pros and cons. Consequently, throughout all of these discussions, it has been
established that the adoption of a compact and precise as well as formal semantics framework for
a programming language in logic programming is extremely helpful in terms of understanding
that language. This idea specifically holds good for those languages in logic programming
where the underlying logic puts forward a semantic framework which is well defined but even
then it is insufficient. In addition to the semantic models supported by models and theories,
proof-theoretic deduction plays a paramount role in the inference of logic programs. Therefore,
apart from the general implementation, if the specific context of logic programming, for
example with specific languages, the provision of the strategy of deduction proves to be more
useful than the others.
As a technical approach to the concept of logic programming, the semantic framework for two
specific kinds of logic programming languages has been taken up at the earnest. After
determining the semantic framework, the applications of these semantic are also discussed. The
two languages discussed here are PROLOG and TEMPLOG. The semantics for PROLOG
programs are issued which are most importantly used for forming the basis of the proof-method

5
for the properties of termination of the same language. When TEMPLOG is considered, it is to
be noted that it is a logic programming language which is temporal in nature. The aim is to
develop a semantics framework and then that technique is used to deliver completeness in result
for a rather fragmented or divided section of the temporal logic in the logic programming.
In the techniques used in the PROLOG language in logic programming, besides the general
frameworks, some specific frameworks are also put to use. For PROLOG, a program is most
importantly viewed as a function which is supposed to map a goal to a finite as well as infinite
sequence of the substitution process in terms of the answer. After this is done, the inference of
the program in context is then given by a solution which is the least in the system of equations
putting forward functionality. In addition to this, these equations are used in a theory in which
the varied properties of the program, specifically the properties related to termination and non-
termination are proved. The method discussed here also pertains to other PROLOG logic
programs which have added logical features.
Now, the programming language of TEMPLOG is considered. For this language, the technical
framework is a bit different. For this language, two equivalent formulations are provided. They
work in terms of semantics which are declarative in nature. The two equivalent frameworks are
first put forward on the basis of a temporal Herbrand model which is minimal. In addition to this,
the second basis is the least fixpoint. Therefore, these technicalities can be used to prove that the
language of TEMPLOG in logic programming is a part of the temporal logic. It also takes into
consideration that the temporal logic is a part of a system which is considered to be full-proof.
This framework also helps to get an insight into the expressive parameter of logic programming
on the basis of this language. For this framework to function effectively, it is important that the

6
TEMPLOG in terms of the provided propositions has the expressive parameter of not only finite
automata but also a regular language.
Concepts
One important concept associated with logic programming is the concept of logic and control.
Logic Programming is basically a means of deduction language which is controlled. One of the
most important concepts is the demarcation of the concept of logic with the concept of control in
a program. That is one of the most important things that help in the effective functioning of logic
programming. In the languages that confide in pure logic, the component of logic solely
determines the solution which is produced. The component of control, in that case, is put to
alternative lines of execution in the logic program. This can be defined by the simple formula
that an algorithm is the summation of logic and control. Here, the logic is described as the logic
program and the control is defined as a strategy which helps in proving a theorem.
In a case of propositions which is simple, the logical program, as well as the atomic goal,
contains no variables whatsoever, and there is no chance of choosing backward variables, the
context of search space comes into view for solving the goal in context. It is considered that the
top level of the goal is the root of the tree. In addition to that, there are also a number of child
nodes in the tree naturally which personify the subordinate goals in the program. These child
nodes or the subordinate goals are put under the same roof by an “and”. The alternative nodes
that are present are considered as the alternative sets of goals and they are put under the roof of
“or”. IN reality, any kind of search strategy can be used to conduct a search in this space.
PROLOG as a language in logic programming uses a strategy which is characterized by
backtracking. In addition to that, it also uses the Last in First Out method. The method used by

7
PROLOG is sequential in nature. In this method, one alternative goal in addition to one
subordinating goal is in context. Other strategies of search can also be discussed here. These are
intelligence backtracking, parallel search, and many others. These are adopted to find an optimal
solution. Another case can also be considered where the subordinate goals share the variable
which is present in the program. In this case, alternative strategies can be put to use. These are
the kinds of strategies which are to be found in the concurrent logic programming.
Another concept associated with logic programming is the representation of knowledge. It is
established that the Horn clause is subject to interpretation in terms of procedure and vice versa.
It is also established that Procedures related to goal-reduction can also be identified as Horn
clauses. In addition to this, backward reasoning also means that the programs combine the two
different ways of procedural as well as declarative knowledge representation ideas. Besides this,
the process of including the concept of negation as a failure actually means that logical
programming runs more effectively on non-monotonic logic.
No matter how many comparisons have been drawn with classical logic in terms of the lucidity
of the present framework, it is seen that the concept of negation as a failure as well that of the
Horn clause has proved to be expressive beyond repair. For instance, these current concepts
helped in establishing a natural representation of the cause and effect relationship. It takes into
account the ideas of common sense. Most importantly, this cause and effect relationship has been
effectively formulated by not only the situation calculus but also the event calculus. Besides this,
it is also compatible with the language of legislation which is relatively semi-formal in nature.
Execution of Logic Programming

8
The implementation of a programming language is a process used to execute computer programs.
A program consists of many instructions. Every instruction of the program is to be executed for a
specific task. System run here is mainly two types of methods for the execution of programming
language interpretation and compilation. A contemporary Programming language such as JAVA
provides many enhanced concepts including memory management automatic, an effective real-
time compilation. Programming languages use different approaches to carry out the process. In
this programming, rules are to be written in the figure of clauses. This programming language
uses mathematical logic to solve problems. It can be interpreted utilizing the main two concepts:
truth as well as a deduction. Truth derives the computation in the program is either true or false.
Logical deduction examines that the logical clause is whether the outcome of the program or not.
Most importantly, all the logic programming languages are of the same operational meaning.
The programs are themselves instructions to be executed. The instruction should be interpreted
as a logical statement as well as a clause. The outcome of this execution is the logical result of
the computation.
In the case of ASP and Datalog, these programs have a single declarative reading. Their
implementation is completed by a model generator or proof procedure. The programmers use this
method to examine the correctness of the program. In the case of Datalog programming, it gives
accessibility to the deductive database in either batch or imperative mode. In the case of batch
mode, a program reads through the Datalog program as well as prints the result to the query and
afterward exists. Besides this, in the situation of interactive mode, the program handles all lines
of text. It reads and prints the outcome to query after that without delay takes more inputs. On
the other hand, in the case of Prolog programs, logic language consists of procedural
interpretation like the goal reduction process. In Prolog programming, execution is initiated with

9
a single goal known as query created by users. It tries to get a resolution for the negated query.
The resolution approach used by Prolog is known as SLD resolution. If the case of a negated
query is not resolute, it follows that particular query with proper changeable binding in position.
This is the logical outcome of the program. Every generated changeable binding is reported to
the user. Afterward, the query is considered as successful. If some goals fail during the
implementation of the program, every changeable binding is undone. With the alternative choice,
the implementation process continues. However, logic programming based techniques could be
used to convert a logical program into more efficient and logically comparable programs.
Advantages of Logic Programming
The programming language is the formally formed language that is designed to converse the
instruction into the system. Logic programming can be utilized in creating the program for
controlling the actions of machines as well as express algorithms. There are main languages
including Prolog, answer set programming and data log. Using logical language provides
advantages in various ways.
This type of programming is very reliable. This is best for problem-solving tasks. It can develop
rapidly since it uses right and wrong statements, not objects. In logic programming language,
the data can be represented both intentionally as well as extensionally. Intentional representation
could produce associated representation such as adjacency directory. This is a trouble-free
acquiring of the data elements. These could be consequent energetically from pattern rules. Most
importantly, these types of languages are considered as high-level languages. They implement
the logic of computation instead of mechanics. Logic programming follows a sound outline of
mechanism and well management of memory. Besides, this type of programming language is
ideal to express algorithms as well as complex ideas.

10
This programming is made up of simple codes that are easy to read as well as debug. It is utilized
to express information simply. They are not dependent on the execution of the program for
making it more compressed or flexible or understandable. It makes information separated from
use. The architecture of the machine can be changed without any change in the program as well
as their fundamental codes. It could be changed as well as extended for supporting special forms
of information such as high order information. In addition to this, Logic programming is used
in the non-computational process depending on reasoning and exact way of expression. This is
easier to manage because it has fewer mistakes compared to another traditional language. This is
a good method to write programs which starts very quickly. Since the whole thing is to tie up in
dependencies, the exact necessary code runs when it is required.
Limitations of Logic Programming
Logic programming is limited to particular types of problems for solving. The execution of this
program can be slow and with an unconventional method such as using true-false statement, all
the problems cannot be solved. The predicates are of rigid nature as well as not readable quickly.
This is used by a fewer application. There is not any proper way available to represent
computational concepts. The poor facilities to support arithmetic have a negative effect on
programmers. Programmers always prefer the visible operational behavior of machines and
dynamic control on moving parts.
The datalog programming does not allow complicated terms such as the argument of predicates.
It imposes firm limitations on the usage of recursions as well as negation. It requires each
variable appeared at top of the clause must appear in non-arithmetic literal. In addition to this, it
also requires a clause that appeared in negative literal must appear in a positive literal of the
clause. In the case of Prolog programming, it tempts to write a clause that appears rationally

11
correct but they would not run. Input, as well as output, is not easy. In this programming, the part
of data structure cannot be re-assigned making it impossible to execute array. The exact manner
to write the predicates is expected to be effective you must know when to optimize the
predicates. Because of the lack of functional documents, predicates may become burdensome.