1.6 Strings

Strings are usually written as a sequence of characters surrounded by quotes. They are often internally represented as lists of ASCII codes.

2 Facts

Programming in Prolog is very different from programming in a procedural language. In Prolog you supply a database of facts and rules; you can then perform queries on the database. The basic unit of Prolog is the predicate, which is defined to be true. A predicate consists of a head and a number of arguments. For example:

cat(tom).

Stores the Prolog fact that 'tom' is a 'cat'. More formally, 'cat' is the head, and 'tom' is the argument. Here are some sample queries you could ask a Prolog interpreter basing on this fact:

is tom a cat?

?- cat(tom). yes.

what things are cats?

?- cat(X). X = tom; no.

Predicates are usually defined to express some fact the program knows about the world. In most of the cases, the usage of predicates requires a certain convention. Thus, which version of the two below would signify that Pat is the father of Sally?

father(sally,pat). father(pat,sally).

In both cases 'father' is the head and 'sally' and 'pat' are arguments. However in the first case, Sally comes first in the argument list, and in the second, Pat comes first (the order in the argument list matters). The first case is an example of a definition in Verb Subject ObjectVerb Subject Object commonly used in its abbreviated form VSO is a term in linguistic typology. It represents one type of languages when classifying languages according to the sequence of these constitutents in neutral expressions: Ate Sam oranges''. order, and the second of Verb Object SubjectVerb Object Subject commonly used in its abbreviated form VOS is a term in Linguistic typology. It represents one type of languages when classifying languages according to the sequence of these constitutents in neutral expressions: Ate oranges Sam''. order. Since Prolog does not understand English, both versions are fine so far as it is concerned; however it is good programming style to stick to either convention during the writing of a single program, in order to avoid writing something like

father(pat,sally). father(jessica,james).

Some predicates are built in into the language, and allow a Prolog program to perform routine activities (such as input/output, using graphics and otherwise communicating with the operating system). For example, the predicate write can be used for output to the screen. Thus,

write('Hello')

will display the word 'Hello' on the screen.

3 Rules

The second type of statements in Prolog is rules. An example of a rule is

light(on) :- switch(on).

The ":-" means "if"; this rule means light(on) is true if switch(on) is true. Rules can also make use of variableIn computer science and mathematics, a variable is a symbol denoting a quantity or symbolic representation. In mathematics, a variable often represents an unknown quantity; in computer science, it represents a place where a quantity can be stored. Variabls; variables begin with capital letters while constants begin with lower case letters. For example,

father(X,Y) :- parent(X,Y),male(X).

This means "if someone is a parent of someone and he's male, he is a father". The ancedent and consequent are in reverse order to that normally found in logic. It is possible to place multiple predicates in a consequent, joined with conjunction, for example:

a,b,c :- d.

which is simply equivalent to three separate rules:

a :- d. b :- d. c :- d.

What is not allowed are rules like:

a;b :- c.

that is "if c then a or b". This is because of the restriction to Horn clauses.

4 Evaluation

When the interpreter is given a query, it tries to find facts that match the query. If no outright facts are available, it attempts to satisfy all rules that have the fact as a conclusion. For example given the prolog code

sibling(X,Y) :- parent(Z,X), parent(Z,Y). father(X,Y) :- parent(X,Y), male(X). mother(X,Y) :- parent(X,Y), female(X). parent(X,Y) :- father(X,Y). parent(X,Y) :- mother(X,Y). mother(trude, sally). father(tom, sally). father(tom, erica). father(mike, tom). male(tom). female(trude). male(mike).

This results in the following query being evaluated as true:

?- sibling(sally, erica) yes.

The interpreter arrives at this result at matching the rule sibling(X, Y) by binding (colloquially; substituting) sally to X and erica to Y. This means the query can be expanded to parent(Z,sally), parent(Z,erica). Matching this conjunction is done by looking at all possible parents of sally. However, parent(trude,sally) doesn't lead to a viable solution, because if 'trude' is substituted for Z, parent(trude,erica) would have to be true, and no such fact (or any rule that can satisfy this) is present. So instead, tom is substituted for Z, and erica and sally turn out to be siblings none the less.

The code

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

Might seem suspicious. After all, not every parent is a father. But it is true that any father is a parent. On the other hand, someone is only someone's mother if she is both that person's parent and female.

To infer that all fathers are male, you'd need to code

male(X) :- father(X,_).

which simply doesn't care whoever the child is (the underscore is an anonymous variable).

4.1 Negation

Typically, a query is evaluated to false by merit of not finding any positive rules or facts that support the statement. This is called the Closed World Assumption ; it is assumed that everything worth knowing is in the database, so there is no outside world that might contain heretofore unknown evidence. In other words; if a fact is not known to be true (or false), it is assumed to be false.

A rule such as

legal(X) :- NOT illegal(X).

can only be evaluated by exhaustively searching for all things illegal, comparing them to X, and if no illegal fact can be found to be the same as X, X is legal. This is called Negation By Failure .

5 Execution

Prolog is a logical language, so in theory you shouldn't care about how it executes. However, sometimes it is prudent to take into account how the inference algorithm works, to prevent a prolog program from running unnecessarily long.

For example, we can write code to count the number of elements in a list.

elems([],0). elems([H|T], X) :- elems(T, Y), X is Y + 1.

This simply says; if the list is empty, the number of elements is zero. If the list is non-empty, then X is one higher than Y, which is the number of elements in the remainder of the list without the first element.

In this case, there is a clear distinction between the cases in the rules' antecedent. But consider the case where you need to decide whether to keep gambling in a Casino;

gamble(X) :- gotmoney(X). gamble(X) :- gotcredit(X), NOT gotmoney(X).

If you have money, you keep gambling. If you've lost it all, you'll need to borrow money, or else, no more gambling. Gotmoney(X) might be a very costly function, for example, it might access your internet banking account to check your balance, which takes time. But the same goes for gotcredit.

In theory, prolog implementations might evaluate these rules out of order, so you might as well have written;

gamble(X) :- gotcredit(X), NOT gotmoney(X). gamble(X) :- gotmoney(X).

Which is fine, because the two options exclude each other. However, checking whether you can get a loan is not necessary if you know you have money. So in practice, prolog implementations will check the rule you wrote first. You can use the cut operator to tell the interpreter to skip the second option if the first suffices. For example;

gamble(X) :- gotmoney(X),!. gamble(X) :- gotcredit(X), NOT gotmoney(X).

This is called a green cut operator. The ! simply tells the interpreter to stop looking for alternatives. But you'll notice that if you need money it will need to check the second rule, and it will. Checking for gotmoney in the second rule is pretty useless since you already know you don't have any, otherwise the second rule wouldn't be evaluated in the first place. So you can change the code to

gamble(X) :- gotmoney(X),!. gamble(X) :- gotcredit(X).

This is called a red cut operator, because it is dangerous to do this. You now depend on the proper placement of the cut operator and the order of the rules to determine their logical meaning. Cut-and-paste accidents lurk in dark corners. If the rules got mixed up, you might now max out your credit card before spending your cash.

6 Hello World

hello:- write('Hello world!' ), nl.

7 Implementations

• LPA Prolog (http://www.lpa.co.uk/)
• Turbo Prolog by BorlandBorland Software Corporation (formerly Borland International, Inc. is a software company (NASDAQ NM: BORL), located in Scotts Valley, California, best known for its Turbo Pascal programming tool that has evolved into today's Delphi programming language., now unsupported
• Open Prolog (http://www.cs.tcd.ie/open-prolog/)
• Ciao Prolog (http://www.clip.dia.fi.upm.es/Software/Ciao)
• GNU Prolog (http://gnu-prolog.inria.fr)
• YAP Prolog (http://www.ncc.up.pt/~vsc/Yap)
• SWI Prolog (http://www.swi-prolog.org)
• SICStus Prolog (http://www.sics.se/sicstus/)
• Amzi! Prolog (http://www.amzi.com/)
• B-Prolog (http://www.probp.com/)
• TuProlog (http://tuprolog.sourceforge.net/)
• XSB (http://xsb.sourceforge.net/)
• Trinc Prolog (http://www.trinc-prolog.com)
• Strawberry Prolog (http://www.dobrev.com/)
• hProlog ( http://www.cs.kuleuven.ac.be/~bmd/hProlog/ )
• ilProlog ( http://www.pharmadm.com/dmax.asp ), a component of the DMax software stack
• CxProlog ( http://ctp.di.fct.unl.pt/~amd/cxprolog/ )
• NanoProlog ( http://ctp.di.fct.unl.pt/~amd/cxprolog/ ), a WAM based minimal Prolog system

8 Extensions

• OW Prolog Created in order to answer Prolog's lack of graphics and interface.

9 References

• Runnable examples
• A prolog interpreter that runs in the browser
• Prolog: The ISO standard
• Visual Prolog: An evolution of Turbo Prolog developed by Prolog Development Center at Denmark.
• Prolog Tutorial

Major programming languages ( more)

Ada | ALGOL | APL | AWK | BASIC | C | C++ | C# | COBOL | Delphi | Eiffel | Fortran | Haskell | IDL | Java | JavaScript | Lisp | LOGO | ML | Objective-C | Pascal | Perl | PHP | PL/I | Prolog | Python | Ruby | SAS | Scheme | sh | Simula | Smalltalk | SQL | Visual Basic

Programming languages Declarative programming languages Logic programming languages Major programming languages

<Hide>