Introduction to Prolog: A Programming Language for AI

Prolog is a logic programming language that’s well-suited for developing logic-based artificial intelligence (AI) applications.

Prolog is also a declarative programming language, meaning that it allows the programmer to specify the rules and facts about a problem domain, and then the Prolog interpreter will use these rules and facts to automatically infer solutions to problems.

Prolog Program Basics to Know

In Prolog, programs are made up of two main components: facts and rules. Facts are statements that are assumed to be true, such as “John is a man” or “the capital of France is Paris.” Rules are logical statements that describe the relationships between different facts, such as “If John is a man and Mary is a woman, then John is not Mary.”

Prolog programs are written using a syntax that is similar to natural language. For example, a simple Prolog program might look like this:

man(john).
woman(mary).
capital_of(france, paris).

not_same(X,Y) :- man(X), woman(Y).

In this example, the first three lines are facts, while the fourth line is a rule. The rule uses the not_same/2 predicate to state that if X is a man and Y is a woman, then X is not the same as Y.

How Is Prolog Different From Other Programming Languages?

Prolog is a declarative programming language, while common programming languages like Python or JavaScript are imperative. A declarative language tells a computer what it should do, and focuses on the goal itself without providing steps to get to the goal. In contrast, an imperative language tells a computer how to reach a goal step-by-step.

One of the key features of Prolog is its ability to handle uncertain or incomplete information. In Prolog, a programmer can specify a set of rules and facts that are known to be true, but they can also specify rules and facts that might be true or false.

The Prolog interpreter will then use those rules and facts to automatically reason about the problem domain and find solutions that are most likely to be correct, given the available information.

More on AI3 Reasons AI Should Be Open Source

How to Use Prolog

One way to use Prolog is to define a set of rules that describe the relationships between different objects or concepts in your problem domain. For example, you might define rules that specify that certain objects are bigger than others, or that some objects are the same color. Then, you can use Prolog to ask questions about these objects and their relationships, and the interpreter will use your rules to deduce the answers.

To use Prolog, you will need to have a Prolog interpreter installed on your computer. There are several different Prolog interpreters available, including SWI-Prolog, GNU Prolog and B-Prolog. Once you’ve installed an interpreter, you can start writing Prolog programs using a text editor and then run them using the interpreter.

How Prolog Syntax Works

There is no single “syntax” for Prolog, as the language allows for a wide range of different programming styles and approaches. However, here are some basic elements of Prolog syntax that are commonly used:

• Facts are statements that are assumed to be true. In Prolog, facts are written using a predicate name followed by a list of arguments enclosed in parentheses. For example: man(john).
• Rules are logical statements that describe the relationships between different facts. In Prolog, rules are written using the predicate name followed by a list of arguments enclosed in parentheses, followed by a colon and a hyphen (:-) and the body of the rule. For example: happy(X) :- likes(X, pizza).
• Variables are used to represent values that can change or be determined by the interpreter. In Prolog, variables are written using a name that begins with an uppercase letter. For example: X.
• Queries are used to ask the interpreter to find solutions to problems based on the rules and facts in the program. In Prolog, queries are written by using a question mark and a hyphen (?-), then the same syntax as facts. For example: ?- not_same(john, mary).

Facts in Prolog

In Prolog, facts are statements that are assumed to be true. They are used to provide the interpreter with information about the problem domain, and the interpreter will use this information to automatically infer solutions to problems.

Facts are written using a predicate name followed by a list of arguments enclosed in parentheses. For example:

man(john).
woman(mary).
capital_of(france, paris).

In this example, the first line states that john is a man, the second line states that mary is a woman, and the third line states that paris is the capital of france.

Prolog facts can have any number of arguments, and the arguments can be variables or constants. One example of this is:

parent(john, mary).

In this case, the fact states that john is a parent of mary.

Rules in Prolog

In Prolog, rules are logical statements that describe the relationships between different facts. They are used to specify the conditions that must be met in order for a certain fact to be true.

Rules are written using the predicate name followed by a list of arguments enclosed in parentheses followed by a colon and a hyphen (:-) and the body of the rule. For example:

happy(X) :- likes(X, pizza).

In this rule, the happy/1 predicate states that X is happy if X likes pizza. 

Prolog rules can have any number of arguments, and the arguments can be variables or constants. 

As another example, the following rule has two arguments:

different(X, Y) :- cat(X), dog(Y).

In this example, the rule uses the different/2 predicate to state that if X is a cat and Y is a dog, then X is different from Y. The body of the rule is made up of two facts: cat(X) and dog(Y).

In the rule example below, it has three arguments, two of which are variables:

bigger_than(X, Y, Z) :- size(X,Xsize), size(Y,Ysize), Xsize > Ysize.

In this case, the rule states that if X and Y are objects with sizes Xsize and Ysize, respectively, and Xsize is greater than Ysize, then X is bigger than Y.

Variables in Prolog

In Prolog, variables are used to represent values that can change or be determined by the interpreter. Variables always start with an uppercase letter (such as X or Y), while atoms (constants) always start with a lowercase letter (such as x or y).

Variables can be used in both facts and rules to represent values that are not known at the time the program is written. For example, the following fact uses a variable to represent the capital of a country:

capital_of(Country, Capital).

In this case, the fact states that the Capital of a given Country is unknown, and the interpreter will use other facts and rules to determine the value of Capital when a query is made.

Queries in Prolog

Queries are used to ask the interpreter to find solutions to problems based on the rules and facts defined in the program. 

In Prolog, queries are written by using a question mark and a hyphen (?-) , followed by the same syntax as facts. For example:

?- capital_of(france, X).

In this query, the interpreter will use the capital_of/2 fact that was defined earlier to determine that the capital of France is Paris, and it will return the value paris for the variable X as the solution.

You could also ask the interpreter to find out which object is bigger than another object by using the following query:

?- bigger_than(X, Y, Z).

In this query, the interpreter will use the bigger_than/3 rule that you defined earlier to determine which object is bigger than the other, and it will return the appropriate value for Z as the solution.

More on AIHow to Develop A Large Language Model (LLM) Application

Prolog Program Example

Here is a simple Prolog program that defines a set of rules and facts about a problem domain, and then uses those rules and facts to answer a few queries:

% Facts
man(john).
woman(mary).
capital_of(france, paris).

% Rule
not_same(X, Y) :- man(X), woman(Y), X \= Y.

% Query 1
?- not_same(john, mary).
% Query 2
?- capital_of(france, X).

In this example, the program defines three facts: man(john), woman(mary), and capital_of(france, paris). These facts state that John is a man, Mary is a woman and Paris is the capital of France.

The program also defines a rule using the not_same/2 predicate. This rule states that if X is a man and Y is a woman, then X is not the same as Y.

Finally, the program includes two queries. The first query — ?- not_same(john, mary). — asks the interpreter to determine if John is not the same as Mary, based on the not_same/2 rule and the man/1 and woman/1 facts. The interpreter will use these rules and facts to deduce that John is not Mary, and it will return true as the solution to the query.

The second query — ?- capital_of(france, X). — asks the interpreter to determine the capital of France. The interpreter will use the capital_of/2 fact to determine that the capital of France is Paris, and it will return the value paris for the variable X as the solution.

Overall, this Prolog program demonstrates how to define rules and facts about a problem domain, and how to use those rules and facts to automatically infer solutions to problems.

Example AI Application of Prolog

One possible example of an AI application in Prolog is a simple diagnostic tool for medical conditions. In this application, the Prolog program would define a set of rules and facts about different medical conditions and their symptoms, and then use those rules and facts to diagnose a patient’s condition based on their reported symptoms.

Here is a simple example of a Prolog program that could be used for this purpose:

% Facts
has_symptom(flu, fever).
has_symptom(flu, headache).
has_symptom(flu, body_aches).
has_symptom(flu, cough).
has_symptom(flu, sore_throat).
has_symptom(flu, runny_nose).
has_symptom(allergy, sneezing).
has_symptom(allergy, watery_eyes).
has_symptom(allergy, runny_nose).
has_symptom(allergy, itchy_eyes).
has_symptom(cold, sneezing).
has_symptom(cold, watery_eyes).
has_symptom(cold, runny_nose).
has_symptom(cold, cough).
has_symptom(cold, sore_throat).

% Rule
has_condition(X, C) :- has_symptom(C, X).

% Query
?- has_condition(sneezing, X).

In this example, the program defines a set of facts that describe the symptoms of three different medical conditions: the flu, allergies and the common cold. The program also defines a rule using the has_condition/2 predicate, which states that if a patient has a certain symptom, then they have the medical condition that is associated with that symptom.

Finally, the program includes a query that asks the interpreter to determine which medical condition a patient has based on their reported symptoms. In this case, the query specifies that the patient has the symptom of sneezing, and it asks the interpreter to determine which medical condition the patient has. The interpreter will use the has_condition/2 rule and the has_symptom/2 facts to deduce that the patient has either the flu, allergies or the common cold, and it will return one of these conditions as the solution to the query.

This simple Prolog program demonstrates how the language can be used to develop an AI application that can diagnose medical conditions based on symptoms. Of course, in a real-world application, the program would need to be much more comprehensive and sophisticated, with a larger set of rules and facts and the ability to handle a wider range of symptoms and conditions.

More on AIWhat Is Neuromorphic Computing?

Advantages of Prolog

Prolog is a powerful and flexible language for developing AI applications, using syntax that aims to mirror natural human language. It works to provide insights and solutions that can be automatically inferred from a set of simple rules and facts. 

In conclusion, if you are interested in exploring the capabilities of Prolog for yourself, consider downloading a Prolog interpreter and experimenting with writing your own programs to see what it can do for you.

Frequently Asked Questions