ASSIGNMENT – 01

TOPIC: STUDY OF PROLOG.

1. DEFINATION: "Prolog" is a programming language that used primarily for logic-
based tasks. It’s short for "Programming in Logic." Prolog is particularly known for
its use in artificial intelligence and computational linguistics.

Prolog is logical programming language. It has important role in artificial intelligence.

Unlike many other programming languages, Prolog logic is expressed as relations
(called as Facts and Rules).

Prolog is a high-level programming language that is primarily used for solving

problems related to artificial intelligence, computational linguistics, and symbolic
reasoning. It is based on formal logic and allows programmers to express knowledge
in terms of facts, rules, and queries.

Prolog was invented by Alain Colmerauer, a French computer scientist, along with
his collaborator Philippe Roussel. They developed the language in the early 1970s at
the University of Marseille, France.

In Prolog, a program is essentially a set of facts and rules about relationships between
objects, and queries are posed to infer new facts based on those rules.
Key features of Prolog include:
1. Facts: Statements that are unconditionally true.
2. Rules: Conditional statements that define relationships or how facts can be derived.
3. Queries: Requests to find information or prove certain facts based on the knowledge
base.

SWI-Prolog version 9.2(for Microsoft Window)

Applications :
Prolog is highly used in artificial intelligence(AI). Prolog is also used for pattern
matching over natural language parse trees.
2. HISTORY:
The history of Prolog dates back to the late 1960s and early 1970s, when it was
developed as part of research into artificial intelligence and computational logic.

1. Origins (Late 1960s)

• Early Influences: Prolog’s roots lie in logic programming and formal logic systems,
specifically predicate logic, which was developed by the logician Alfred Tarski.
• Researchers Involved: Prolog was primarily developed by two researchers, Alain
Colmerauer and Philippe Roussel, in France. They were working at the University
of Marseille.

2. Development of Prolog (1972)

• In 1972, Alain Colmerauer and his team created the first version of Prolog at the
University of Marseille. It was designed to be a tool for natural language processing
and was based on the resolution principle, a method of logical inference.
• Prolog was initially developed to handle specific problems, such as parsing natural
language and performing symbolic reasoning.

3. Expansion and Refinement (1970s–1980s)

• Prolog was quickly adopted by researchers in AI because it allowed for powerful
symbolic reasoning and problem-solving capabilities..
• In 1977, a team of researchers at Edinburgh University (including Robert Kowalski)
worked on extending Prolog’s capabilities and created the first practical
implementation of the language, which helped spread Prolog's use beyond France.

4. Standardization and Adoption (1990s–2000s)

• In 1995, the International Organization for Standardization (ISO) released the
first official standard for Prolog, which helped unify the language’s many variations
and implementations.

5. Modern Use (2000s–Present)

• Today, Prolog is still widely used in fields like artificial intelligence, computational
linguistics, and knowledge representation.
• While it’s not as popular as general-purpose programming languages (like Python or
Java), Prolog remains a key tool for research and certain AI applications, especially
those involving symbolic reasoning and logic-based tasks.
Prolog’s influence can be seen in many areas of AI and logic programming, and it
continues to be used for specific applications like natural language processing, expert
systems, and even some machine learning models.
3. USES OF PROLOG:

Prolog has a number of applications in artificial intelligence (AI) and machine

learning (ML), particularly due to its focus on symbolic reasoning, logic-based
problem solving, and knowledge representation. Prolog still plays a crucial role in
certain domains of AI. Here are some of its uses:

1. Expert Systems
• Knowledge Representation: Prolog is particularly well-suited for expert systems,
which require encoding knowledge about a specific domain.
• Inference Engines: The language’s inference mechanism, based on logical reasoning,
can be used to draw conclusions from a set of rules and facts. This makes Prolog a
good fit for systems that mimic the decision-making abilities of human experts.

2. Natural Language Processing (NLP)

• Prolog has been historically used in natural language processing (NLP) tasks, such as
parsing sentences and understanding syntax and semantics. The structure of Prolog
allows it to easily model the relationships between words and phrases.
• Grammatical Inference: Prolog can be used for tasks like parsing context-free
grammars and generating possible sentence structures from a given set of rules.

3. Automated Theorem Proving

• Prolog can be used in automated theorem proving, where it attempts to prove
mathematical theorems or verify logical statements. The backtracking and search
capabilities of Prolog allow it to systematically explore all possibilities in proving a
theorem.

4. Knowledge-Based Systems
• In AI, knowledge-based Prolog’s rule-based approach makes it ideal for creating
systems that manage large knowledge bases and reason over them effectively.
• Semantic Networks: Prolog can be used to represent and work with semantic
networks or ontologies, which are graphical representations of relationships between
concepts in a domain of knowledge.

5. Problem Solving and Planning

• Prolog can be used for tasks like problem-solving, planning, and scheduling. Its
logical inference engine can explore different actions and their consequences to come
up with a plan to achieve a goal.

6. Machine Learning (ML)

• While Prolog is not widely used for traditional ML tasks (like training neural
networks or deep learning), it can still be applied to symbolic reasoning tasks within
AI.
• Inductive Logic Programming (ILP): ILP is a form of machine learning that uses
logic programming as a framework to learn from examples.

7. Robotics
• Prolog used in robotic systems, particularly for tasks like pathfinding, decision-
making, and reasoning about the robot’s environment. Prolog’s ability to represent
and reason about spatial relationships, actions, and goals makes it a useful tool in
some robotics applications.

8. Constraint Logic Programming (CLP)

• constraint logic programming (CLP), which allows the integration of constraints
(such as numerical or relational conditions) into the problem-solving process. This is
useful in fields like optimization, scheduling, and resource allocation, where
constraints must be satisfied during decision-making.

9. Game AI
• Prolog can be used to implement simple game AI, especially in logic-based games or
puzzle-solving games, where reasoning and decision-making are central. It can help
design AI.

4. SYNTAX:
1. Facts
• Facts are the most basic kind of knowledge in Prolog. They represent unconditionally
true statements.
• A fact is written as a predicate followed by its arguments.

• The predicate is usually a noun (or a descriptive name), and the arguments are the values
it relates to.
Example:

likes(john, pizza).

likes(mary, apple).

Here, likes(john, pizza) and likes(mary, apple) are facts. They mean "John likes pizza" and

"Mary likes apple."

2. Rules
• Rules define relationships between facts and allow Prolog to infer new facts.
 • A rule has a head (a conclusion) and a body (a set of conditions that must be true for
the head to be true).

• The syntax for a rule is:

head :- body.

• The body is typically a conjunction (AND) of conditions, written with commas.

Example:

likes_food(Person, Food) :- likes(Person, Food), edible(Food).

This rule says: "A person likes food if the person likes that food and the food is edible."

3. Queries

• Queries are used to ask Prolog to find facts or prove something based on the facts and
rules defined.

• A query is written as a goal (predicate) and ends with a ?.

• Prolog will try to find solutions to the query by looking through the facts and rules.

Example:

?- likes(john, pizza).
This query asks, "Does John like pizza?" If there is a fact likes(john, pizza). in the

knowledge base, Prolog will respond with true. If not, it will return false.

4. Variables

• Variables in Prolog begin with an uppercase letter or an underscore (_). They represent
placeholders for any value.

• Variables allow Prolog to generalize facts and rules.

Example:

likes(X, pizza). % This means "X likes pizza", where X can be any person.

• Prolog will try to match X with any value that satisfies the rule or fact.

5. Negation

• Prolog allows negation in queries, but negation is handled using the \+ operator.
Example:
 ?- \+ likes(john, pizza).

This query asks, "Does John not like pizza?" Prolog will return true if likes(john, pizza) is
false.

6. Lists

• Lists in Prolog are written with square brackets [], and elements are separated by
commas.

• A list can be an empty list [] or a non-empty list [Head | Tail], where Head is the first
element and Tail is the rest of the list.

Example:

my_list([1, 2, 3, 4]).

• You can pattern-match lists in rules or queries.

Example:

first_element([Head | _], Head).

This rule says, "The first element of a list is the head of the list."

7. Comments

• Comments in Prolog are written with a percent sign (%). Anything after the % on the
same line is treated as a comment.

Example:

% This is a comment
likes(john, pizza). % John likes pizza

8. Arity

• The arity of a predicate is the number of arguments it takes.

• For example, likes(john, pizza) has arity 2 because it takes two arguments.

Example:

Here’s a simple Prolog program that includes facts, rules, and a query:

% Facts
likes(john, pizza).
 likes(mary, apple).

edible(pizza).

edible(apple).

% Rule

likes_food(Person, Food) :- likes(Person, Food), edible(Food).

% Query

?- likes_food(john, pizza). % Will return true

?- likes_food(mary, pizza). % Will return false

In this example:
• likes(john, pizza) and likes(mary, apple) are facts.
• The rule likes_food(Person, Food) checks if a person likes a food and if it is edible.

• The queries ask Prolog to check if john likes pizza and if mary likes pizza.

5. ADVANTAGE AND DISADVANTAGE OD PROLOG:

Advantages of Prolog:
1. Declarative Nature:

o This high-level, declarative style is especially helpful for problems where the
logic and relationships are more important than the step-by-step procedural
approach. You define facts, rules, and relationships, and Prolog handles the
process of reasoning and finding solutions.

2. Built-in Inference and Backtracking:

o Prolog has a powerful backtracking mechanism that automatically tries

different possibilities to find solutions to queries. This makes it particularly
useful for search problems, puzzles, and tasks requiring exhaustive exploration
of possibilities.

3. Symbolic Reasoning:

o Prolog is well-suited for symbolic reasoning, which involves working with

concepts and abstract representations (e.g., reasoning about relationships,
facts, or categories).
4. Rule-Based Programming:

o Prolog’s rule-based approach allows for easy expression of complex

relationships and decision-making logic.

5. Efficient Handling of Complex Queries:

o Prolog can handle complex queries and reasoning tasks efficiently, especially
when the relationships between entities are intricate.

6. Compact and Concise Code:

o Prolog programs can often be much shorter and more compact than equivalent
programs written in imperative languages.

7. Suitable for AI Applications:

o Prolog is ideal for certain AI applications, such as expert systems, natural

language processing, automated theorem proving, planning, and constraint
satisfaction problems.

Disadvantages of Prolog:

1. Performance Issues:
o Prolog is generally slower than imperative programming languages like C,
Java, or Python, especially for tasks that involve heavy computation or large
amounts of data. Prolog performs backtracking and searches exhaustively for
solutions, it can become inefficient for problems that require searching large
solution spaces.
2. Limited Use Cases:

o Prolog is not a general-purpose programming language and is not suited for

tasks like system programming, low-level optimization, or developing high-
performance applications (e.g., graphics, games, or large-scale data
processing).
3. Steep Learning Curve:

o For developers accustomed to imperative languages, Prolog can have a steep

learning curve due to its different paradigm (logic programming vs. procedural
programming).

o The declarative nature and reliance on reasoning might be difficult to grasp at

first, particularly when dealing with complex queries or non-trivial
backtracking.
4. Debugging and Tracing:
 o Debugging in Prolog can be challenging. Since the program’s behavior
depends on logical inference, it’s not always clear how control flow works,
especially when backtracking occurs.

5. Lack of Libraries and Ecosystem:

o Compared to more popular languages like Python, Java, or C++, Prolog has a
smaller ecosystem and fewer pre-built libraries or frameworks, especially in
newer fields like web development, mobile apps, or cloud computing.
o While Prolog is well-suited for AI applications, the limited library support can
make it harder to integrate with other technologies or modern development
environments.

6. Memory Management:

o Prolog's automatic memory management and backtracking can sometimes lead

to memory inefficiencies. When exploring large search spaces, the language
may use more memory than desired, particularly if there is no efficient
pruning of the search space.

o In certain complex queries, Prolog may not be able to handle the memory
requirements or time constraints.

7. Lack of Support for State Changes:

o Prolog is not ideal for programming tasks that involve state changes, such as
interactive systems or systems with side effects (e.g., GUI development or
handling user input in real-time).

Advantages and Disadvantages:

Advantages Disadvantages

Declarative, easy-to-understand Performance can be slower compared to

syntax imperative languages

Built-in backtracking and Limited use cases for general-purpose

automatic inference programming

Strong in symbolic reasoning and Steep learning curve for those unfamiliar
logical inference with logic programming

Ideal for AI-related applications Debugging can be challenging

(expert systems, NLP)
Smaller ecosystem, fewer libraries and
Compact and concise code tools available
Advantages Disadvantages