Prolog is a
logic programming
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applyin ...
language that has its origins in
artificial intelligence
Artificial intelligence (AI) is the capability of computer, computational systems to perform tasks typically associated with human intelligence, such as learning, reasoning, problem-solving, perception, and decision-making. It is a field of re ...
,
automated theorem proving
Automated theorem proving (also known as ATP or automated deduction) is a subfield of automated reasoning and mathematical logic dealing with proving mathematical theorems by computer programs. Automated reasoning over mathematical proof was a majo ...
, and
computational linguistics
Computational linguistics is an interdisciplinary field concerned with the computational modelling of natural language, as well as the study of appropriate computational approaches to linguistic questions. In general, computational linguistics ...
.
Prolog has its roots in
first-order logic
First-order logic, also called predicate logic, predicate calculus, or quantificational logic, is a collection of formal systems used in mathematics, philosophy, linguistics, and computer science. First-order logic uses quantified variables over ...
, a
formal logic
Logic is the study of correct reasoning. It includes both formal and informal logic. Formal logic is the study of deductively valid inferences or logical truths. It examines how conclusions follow from premises based on the structure o ...
. Unlike many other
programming language
A programming language is a system of notation for writing computer programs.
Programming languages are described in terms of their Syntax (programming languages), syntax (form) and semantics (computer science), semantics (meaning), usually def ...
s, Prolog is intended primarily as a
declarative programming
In computer science, declarative programming is a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow.
Many languages that ap ...
language: the program is a set of facts and
rules
Rule or ruling may refer to:
Human activity
* The exercise of political or personal control by someone with authority or power
* Business rule, a rule pertaining to the structure or behavior internal to a business
* School rule, a rule tha ...
, which define
relations. A
computation
A computation is any type of arithmetic or non-arithmetic calculation that is well-defined. Common examples of computation are mathematical equation solving and the execution of computer algorithms.
Mechanical or electronic devices (or, hist ...
is initiated by running a ''query'' over the program.
[
Prolog was one of the first logic programming languages and remains the most popular such language today, with several free and commercial implementations available. The language has been used for ]theorem proving
Automated theorem proving (also known as ATP or automated deduction) is a subfield of automated reasoning and mathematical logic dealing with proving mathematical theorems by computer programs. Automated reasoning over mathematical proof was a majo ...
, expert system
In artificial intelligence (AI), an expert system is a computer system emulating the decision-making ability of a human expert.
Expert systems are designed to solve complex problems by reasoning through bodies of knowledge, represented mainly as ...
s, term rewriting
In mathematics, computer science, and logic, rewriting covers a wide range of methods of replacing subterms of a formula with other terms. Such methods may be achieved by rewriting systems (also known as rewrite systems, rewrite engines, or reduc ...
, type system
In computer programming, a type system is a logical system comprising a set of rules that assigns a property called a ''type'' (for example, integer, floating point, string) to every '' term'' (a word, phrase, or other set of symbols). Usu ...
s, and automated planning
Automated planning and scheduling, sometimes denoted as simply AI planning, is a branch of artificial intelligence that concerns the realization of strategy, strategies or action sequences, typically for execution by intelligent agents, autonomou ...
, as well as its original intended field of use, natural language processing
Natural language processing (NLP) is a subfield of computer science and especially artificial intelligence. It is primarily concerned with providing computers with the ability to process data encoded in natural language and is thus closely related ...
.[ See also ]Watson (computer)
IBM Watson is a computer system capable of question answering, answering questions posed in natural language. It was developed as a part of IBM's DeepQA project by a research team, led by principal investigator David Ferrucci. Watson was named ...
.
Prolog is a Turing-complete, general-purpose programming language, which is well-suited for intelligent knowledge-processing applications.
History
The name ''Prolog'' was chosen by Philippe Roussel, at the suggestion of his wife, as an abbreviation for ' ( French for ''Programming in logic
Logic is the study of correct reasoning. It includes both formal and informal logic. Formal logic is the study of deductively valid inferences or logical truths. It examines how conclusions follow from premises based on the structure o ...
''). It was created around 1972 by Alain Colmerauer with Philippe Roussel, from the ''Artificial Intelligence Group'' of the Faculty of Sciences of Luminy of Aix-Marseille II University of France
France, officially the French Republic, is a country located primarily in Western Europe. Overseas France, Its overseas regions and territories include French Guiana in South America, Saint Pierre and Miquelon in the Atlantic Ocean#North Atlan ...
. It was based on Robert Kowalski's procedural interpretation of Horn clause
In mathematical logic and logic programming, a Horn clause is a logical formula of a particular rule-like form that gives it useful properties for use in logic programming, formal specification, universal algebra and model theory. Horn clauses are ...
s, and it was motivated in part by the desire to reconcile the use of logic as a declarative knowledge representation language with the procedural representation of knowledge that was popular in North America in the late 1960s and early 1970s. According to Robert Kowalski, the first Prolog system was developed in 1972 by Colmerauer and Phillipe Roussel. The first implementation of Prolog was an interpreter written in Fortran by Gerard Battani and Henri Meloni. David H. D. Warren took this interpreter to the University of Edinburgh
The University of Edinburgh (, ; abbreviated as ''Edin.'' in Post-nominal letters, post-nominals) is a Public university, public research university based in Edinburgh, Scotland. Founded by the City of Edinburgh Council, town council under th ...
, and there implemented an alternative front-end, which came to define the "''Edinburgh Prolog''" syntax used by most modern implementations. Warren also implemented the first compiler for Prolog, creating the influential DEC-10 Prolog in collaboration with Fernando Pereira. Warren later generalised the ideas behind DEC-10 Prolog, to create the Warren Abstract Machine
In 1983, David H. D. Warren designed an abstract machine for the execution of Prolog consisting of a memory architecture and an instruction set. This design became known as the Warren Abstract Machine (WAM) and has become the ''de facto'' standard ...
(WAM).
European AI researchers favored Prolog while Americans favored Lisp
Lisp (historically LISP, an abbreviation of "list processing") is a family of programming languages with a long history and a distinctive, fully parenthesized Polish notation#Explanation, prefix notation.
Originally specified in the late 1950s, ...
, reportedly causing many nationalistic debates on the merits of the languages. Much of the modern development of Prolog came from the impetus of the Fifth Generation Computer Systems project (FGCS), which developed a variant of Prolog named '' Kernel Language'' for its first operating system
An operating system (OS) is system software that manages computer hardware and software resources, and provides common daemon (computing), services for computer programs.
Time-sharing operating systems scheduler (computing), schedule tasks for ...
.
Pure Prolog was originally restricted to the use of a resolution theorem prover with Horn clause
In mathematical logic and logic programming, a Horn clause is a logical formula of a particular rule-like form that gives it useful properties for use in logic programming, formal specification, universal algebra and model theory. Horn clauses are ...
s of the form:
H :- B1, ..., Bn.
The application of the theorem-prover treats such clauses as procedures:
to show/solve H, show/solve B1 and ... and Bn.
Pure Prolog was soon extended, however, to include negation as failure
Negation as failure (NAF, for short) is a non-monotonic inference rule in logic programming, used to derive \mathrm~p (i.e. that p is assumed not to hold) from failure to derive p. Note that \mathrm ~p can be different from the statement \neg p o ...
, in which negative conditions of the form not(Bi) are shown by trying and failing to solve the corresponding positive conditions Bi.
Subsequent extensions of Prolog by the original team introduced constraint logic programming
Constraint logic programming is a form of constraint programming, in which logic programming is extended to include concepts from constraint satisfaction. A constraint logic program is a logic program that contains constraints in the body of claus ...
abilities into the implementations.
Impact
Although Prolog is widely used in research and education, Prolog and other logic programming languages have not had a significant impact on the computer industry in general.[Logic programming for the real world. Zoltan Somogyi, Fergus Henderson, Thomas Conway, Richard O'Keefe. Proceedings of the ILPS'95 Postconference Workshop on Visions for the Future of Logic Programming.] Most applications are small by industrial standards, with few exceeding 100,000 lines of code. Programming in the large is considered to be complex because not all Prolog compilers support modules, and there are compatibility problems between the module systems of the major Prolog compilers. Portability of Prolog code across implementations has also been a problem, but developments since 2007 have meant: "the portability within the family of Edinburgh/Quintus derived Prolog implementations is good enough to allow for maintaining portable real-world applications."
Software developed in Prolog has been criticised for having a high performance penalty compared to conventional programming languages. In particular, Prolog's non-deterministic evaluation strategy can be problematic when programming deterministic computations, or when even using "don't care non-determinism" (where a single choice is made instead of backtracking over all possibilities). Cuts and other language constructs may have to be used to achieve desirable performance, destroying one of Prolog's main attractions, the ability to run programs "backwards and forwards".
Prolog is not purely declarative: because of constructs like the cut operator, a procedural reading of a Prolog program is needed to understand it. The order of clauses in a Prolog program is significant, as the execution strategy of the language depends on it. Other logic programming languages, such as Datalog
Datalog is a declarative logic programming language. While it is syntactically a subset of Prolog, Datalog generally uses a bottom-up rather than top-down evaluation model. This difference yields significantly different behavior and properties ...
, are truly declarative but restrict the language. As a result, many practical Prolog programs are written to conform to Prolog's depth-first search
Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible al ...
order, rather than as purely declarative logic programs.
Use in industry
Prolog has been used in Watson. Watson uses IBM's DeepQA software and the Apache UIMA (Unstructured Information Management Architecture) framework. The system was written in various languages, including Java, , and Prolog, and runs on the SUSE Linux Enterprise Server
SUSE Linux Enterprise (SLE) is a Linux-based operating system developed by SUSE. It is available in two editions, suffixed with Server (SLES) for servers and mainframes, and Desktop (SLED) for workstations and desktop computers.
Its major ve ...
11 operating system using Apache Hadoop
Apache Hadoop () is a collection of open-source software utilities for reliable, scalable, distributed computing. It provides a software framework for distributed storage and processing of big data using the MapReduce programming model. Hadoop wa ...
framework to provide distributed computing. Prolog is used for pattern matching
In computer science, pattern matching is the act of checking a given sequence of tokens for the presence of the constituents of some pattern. In contrast to pattern recognition, the match usually must be exact: "either it will or will not be a ...
over natural language parse trees. The developers have stated: "We required a language in which we could conveniently express pattern matching rules over the parse trees and other annotations (such as named entity recognition results), and a technology that could execute these rules very efficiently. We found that Prolog was the ideal choice for the language due to its simplicity and expressiveness."[ Prolog is being used in the Low-Code Development Platform GeneXus, which is focused around AI. Open source ]graph database
A graph database (GDB) is a database that uses graph structures for semantic queries with nodes, edges, and properties to represent and store data. A key concept of the system is the graph (or edge or relationship). The graph relates the dat ...
TerminusDB is implemented in Prolog. TerminusDB is designed for collaboratively building and curating knowledge graph
In knowledge representation and reasoning, a knowledge graph is a knowledge base that uses a Graph (discrete mathematics), graph-structured data model or topology to represent and operate on data. Knowledge graphs are often used to store interl ...
s.
Syntax and semantics
In Prolog, program logic is expressed in terms of relations, and a computation is initiated by running a ''query'' over these relations. Relations and queries are constructed using Prolog's single data type, the ''term''. Relations are defined by ''clauses''. Given a query, the Prolog engine attempts to find a resolution refutation
In argumentation, an objection is a reason arguing against a premise, argument, or conclusion. Definitions of objection vary in whether an objection is always an argument (or counterargument) or may include other moves such as questioning.
An o ...
of the negated query. If the negated query can be refuted, i.e., an instantiation for all free variables is found that makes the union of clauses and the singleton set consisting of the negated query false, it follows that the original query, with the found instantiation applied, is a logical consequence
Logical consequence (also entailment or logical implication) is a fundamental concept in logic which describes the relationship between statement (logic), statements that hold true when one statement logically ''follows from'' one or more stat ...
of the program. This makes Prolog (and other logic programming languages) particularly useful for database, symbolic mathematics
In mathematics and computer science, computer algebra, also called symbolic computation or algebraic computation, is a scientific area that refers to the study and development of algorithms and software for manipulating mathematical expressions ...
, and language parsing applications. Because Prolog allows impure predicates, checking the truth value
In logic and mathematics, a truth value, sometimes called a logical value, is a value indicating the relation of a proposition to truth, which in classical logic has only two possible values ('' true'' or '' false''). Truth values are used in ...
of certain special predicates may have some deliberate side effect
In medicine, a side effect is an effect of the use of a medicinal drug or other treatment, usually adverse but sometimes beneficial, that is unintended. Herbal and traditional medicines also have side effects.
A drug or procedure usually use ...
, such as printing a value to the screen. Because of this, the programmer is permitted to use some amount of conventional imperative programming
In computer science, imperative programming is a programming paradigm of software that uses Statement (computer science), statements that change a program's state (computer science), state. In much the same way that the imperative mood in natural ...
when the logical paradigm is inconvenient. It has a purely logical subset, called "pure Prolog", as well as a number of extralogical features.
Data types
Prolog's single data type
In computer science and computer programming, a data type (or simply type) is a collection or grouping of data values, usually specified by a set of possible values, a set of allowed operations on these values, and/or a representation of these ...
is the ''term''. Terms are either ''atom
Atoms are the basic particles of the chemical elements. An atom consists of a atomic nucleus, nucleus of protons and generally neutrons, surrounded by an electromagnetically bound swarm of electrons. The chemical elements are distinguished fr ...
s'', ''numbers'', ''variables'' or ''compound terms''.[ The Prolog terminology differs from that of ]logic
Logic is the study of correct reasoning. It includes both formal and informal logic. Formal logic is the study of deductively valid inferences or logical truths. It examines how conclusions follow from premises based on the structure o ...
.
A term of Prolog is (depending on the context) a term or an atomic formula
In mathematical logic, an atomic formula (also known as an atom or a prime formula) is a formula with no deeper propositional structure, that is, a formula that contains no logical connectives or equivalently a formula that has no strict subformu ...
of logic.
An atom in a standard logic terminology means an atomic formula
In mathematical logic, an atomic formula (also known as an atom or a prime formula) is a formula with no deeper propositional structure, that is, a formula that contains no logical connectives or equivalently a formula that has no strict subformu ...
;
an atom of Prolog (depending on the context) is a constant, function
symbol or predicate symbol of logic.
* An atom is a symbol name starting with a lower case letter or guarded by quotes. Examples of atoms include x
, red
, 'Taco'
, 'some atom'
, and 'p(a)'
.
* Numbers can be floats or integer
An integer is the number zero (0), a positive natural number (1, 2, 3, ...), or the negation of a positive natural number (−1, −2, −3, ...). The negations or additive inverses of the positive natural numbers are referred to as negative in ...
s. Most of the major Prolog systems support arbitrary length integer numbers.
* Variables are denoted by a string consisting of letters, numbers and underscore characters, and beginning with an upper-case letter or underscore. Variables closely resemble variables in logic in that they are placeholders for arbitrary terms.
* A compound term is composed of an atom called a "functor" and a number of "arguments", which are again terms. Compound terms are ordinarily written as a functor followed by a comma-separated list of argument terms, which is contained in parentheses. The number of arguments is called the term's arity
In logic, mathematics, and computer science, arity () is the number of arguments or operands taken by a function, operation or relation. In mathematics, arity may also be called rank, but this word can have many other meanings. In logic and ...
. An atom can be regarded as a compound term with arity
In logic, mathematics, and computer science, arity () is the number of arguments or operands taken by a function, operation or relation. In mathematics, arity may also be called rank, but this word can have many other meanings. In logic and ...
zero. An example of a compound term is person_friends(zelda, om,jim
.
Special cases of compound terms:
* A ''List'' is an ordered collection of terms. It is denoted by square brackets with the terms separated by commas, or in the case of the empty list, by []
. For example, [1,2,3,4]
or [red,green,blue]
.
* ''Strings'': A sequence of characters surrounded by quotes is equivalent to either a list of (numeric) character codes, a list of characters (atoms of length 1), or an atom depending on the value of the Prolog flag double_quotes
. For example, "to be, or not to be"
.[ISO/IEC 13211-1:1995 Prolog, 6.3.7 Terms - double quoted list notation. ]International Organization for Standardization
The International Organization for Standardization (ISO ; ; ) is an independent, non-governmental, international standard development organization composed of representatives from the national standards organizations of member countries.
M ...
, Geneva.
Rules and facts
Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted to Horn clause
In mathematical logic and logic programming, a Horn clause is a logical formula of a particular rule-like form that gives it useful properties for use in logic programming, formal specification, universal algebra and model theory. Horn clauses are ...
s. Two types of Horn clauses are used to define Prolog programs: rules and facts. A rule is of the form
Head :- Body.
and is read as "Head is true if Body is true". A rule's body consists of calls to predicates, which are called the rule's goals. The built-in logical operator
In logic, a logical connective (also called a logical operator, sentential connective, or sentential operator) is a logical constant. Connectives can be used to connect logical formulas. For instance in the syntax of propositional logic, the ...
,/2
(meaning an arity 2 operator with name ,
) denotes conjunction of goals, and ;/2
denotes disjunction
In logic, disjunction (also known as logical disjunction, logical or, logical addition, or inclusive disjunction) is a logical connective typically notated as \lor and read aloud as "or". For instance, the English language sentence "it is ...
. Conjunctions and disjunctions can only appear in the body, not in the head of a rule.
Clauses with empty bodies are called facts. An example of a fact is:
human(socrates).
which is equivalent to the rule:
human(socrates) :- true.
The built-in predicate true/0
is always true.
Given the above fact, one can ask:
''is socrates a human?''
?- human(socrates).
Yes
''what things are humans?''
?- human(X).
X = socrates
Clauses with bodies are called rules. An example of a rule is:
mortal(X) :- human(X).
If we add that rule and ask ''what things are mortals?''
?- mortal(X).
X = socrates
Predicates and programs
A ''predicate'' (or ''procedure definition'') is a collection of clauses whose heads have the same name and arity. We use the notation ''name/arity'' to refer to predicates. A ''logic program'' is a set of predicates. For example, the following Prolog program, which defines some family relations, has four predicates:
mother_child(trude, sally).
father_child(tom, sally).
father_child(tom, erica).
father_child(mike, tom).
sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y), not(X = Y).
parent_child(X, Y) :- father_child(X, Y).
parent_child(X, Y) :- mother_child(X, Y).
Predicate father_child/2
has three clauses, all of which are facts, and predicate parent_child/2
has two clauses, both are rules.
Due to the relational nature of many built-in predicates, they can typically be used in several directions. For example, length/2
can be used to determine the length of a list (length(List, L)
, given a list List
), and to generate a list skeleton of a given length (length(X, 5)
), and to generate both list skeletons and their lengths together (length(X, L)
). Similarly, append/3
can be used both to append two lists (append(ListA, ListB, X)
given lists ListA
and ListB
), and to split a given list into parts (append(X, Y, List)
, given a list List
). For this reason, a comparatively small set of library predicates suffices for many Prolog programs.
As a general purpose language, Prolog also provides various built-in predicates to perform routine activities like input/output
In computing, input/output (I/O, i/o, or informally io or IO) is the communication between an information processing system, such as a computer, and the outside world, such as another computer system, peripherals, or a human operator. Inputs a ...
, using graphics and otherwise communicating with the operating system. These predicates are not given a relational meaning and are only useful for the side-effects they exhibit on the system. For example, the predicate write/1
displays a term on the screen.
Loops and recursion
Iterative algorithms can be implemented by means of recursive predicates.
Consider the parent_child/2
predicate defined in the family relation program above. The following Prolog program defines the ''ancestor'' relation:
ancestor(X, Y) :- parent_child(X, Y).
ancestor(X, Y) :- parent_child(X, Z), ancestor(Z, Y).
It expresses that X is an ancestor of Y if X is parent of Y or X is parent of an ancestor of Y. It is recursive because it is defined in terms of itself (there is a call to predicate ancestor/2
in the body of the second clause).
Execution
Execution of a Prolog program is initiated by the user's posting of a single goal, called the query. Logically, the Prolog engine tries to find a resolution refutation of the negated query. The resolution method used by Prolog is called SLD resolution
SLD resolution (''Selective Linear Definite'' clause resolution) is the basic rule of inference, inference rule used in logic programming. It is a refinement of Resolution (logic), resolution, which is both Soundness, sound and refutation Completen ...
. If the negated query can be refuted, it follows that the query, with the appropriate variable bindings in place, is a logical consequence of the program. In that case, all generated variable bindings are reported to the user, and the query is said to have succeeded. Operationally, Prolog's execution strategy can be thought of as a generalization of function calls in other languages, one difference being that multiple clause heads can match a given call. In that case, the system creates a choice-point, unifies the goal with the clause head of the first alternative, and continues with the goals of that first alternative. If any goal fails in the course of executing the program, all variable bindings that were made since the most recent choice-point was created are undone, and execution continues with the next alternative of that choice-point. This execution strategy is called chronological backtracking
Backtracking is a class of algorithms for finding solutions to some computational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons a candidate ("backtracks") as soon as it de ...
. For example, given the family relation program defined above, the following query will be evaluated to true:
?- sibling(sally, erica).
Yes
This is obtained as follows: Initially, the only matching clause-head for the query sibling(sally, erica)
is the first one, so proving the query is equivalent to proving the body of that clause with the appropriate variable bindings in place, i.e., the conjunction (parent_child(Z,sally), parent_child(Z,erica))
. The next goal to be proved is the leftmost one of this conjunction, i.e., parent_child(Z, sally)
. Two clause heads match this goal. The system creates a choice-point and tries the first alternative, whose body is father_child(Z, sally)
. This goal can be proved using the fact father_child(tom, sally)
, so the binding Z = tom
is generated, and the next goal to be proved is the second part of the above conjunction: parent_child(tom, erica)
. Again, this can be proved by the corresponding fact. Since all goals could be proved, the query succeeds. Since the query contained no variables, no bindings are reported to the user. A query with variables, like:
?- father_child(Father, Child).
enumerates all valid answers on backtracking.
Notice that with the code as stated above, the query ?- sibling(sally, sally).
also succeeds. One would insert additional goals to describe the relevant restrictions, if desired.
Negation
The built-in Prolog predicate \+/1
provides negation as failure
Negation as failure (NAF, for short) is a non-monotonic inference rule in logic programming, used to derive \mathrm~p (i.e. that p is assumed not to hold) from failure to derive p. Note that \mathrm ~p can be different from the statement \neg p o ...
, which allows for non-monotonic reasoning. The goal \+ illegal(X)
in the rule
legal(X) :- \+ illegal(X).
is evaluated as follows: Prolog attempts to prove illegal(X)
. If a proof for that goal can be found, the original goal (i.e., \+ illegal(X)
) fails. If no proof can be found, the original goal succeeds. Therefore, the \+/1
prefix operator is called the "not provable" operator, since the query ?- \+ Goal.
succeeds if Goal is not provable. This kind of negation is sound
In physics, sound is a vibration that propagates as an acoustic wave through a transmission medium such as a gas, liquid or solid.
In human physiology and psychology, sound is the ''reception'' of such waves and their ''perception'' by the br ...
if its argument is "ground" (i.e. contains no variables). Soundness is lost if the argument contains variables and the proof procedure is complete. In particular, the query ?- legal(X).
now cannot be used to enumerate all things that are legal.
Programming in Prolog
In Prolog, loading code is referred to as ''consulting''. Prolog can be used interactively by entering queries at the Prolog prompt ?-
. If there is no solution, Prolog writes no
. If a solution exists then it is printed. If there are multiple solutions to the query, then these can be requested by entering a semi-colon ;
. There are guidelines on good programming practice to improve code efficiency, readability and maintainability.
Here follow some example programs written in Prolog.
Hello World
Example of a basic query in a couple of popular Prolog dialects:
This comparison shows the prompt ("?-" vs ", ?-") and resolution status ("true". vs "yes", "false". vs "no") can differ from one Prolog implementation to another.
Compiler optimization
Any computation can be expressed declaratively as a sequence of state transitions. As an example, an optimizing compiler
An optimizing compiler is a compiler designed to generate code that is optimized in aspects such as minimizing program execution time, memory usage, storage size, and power consumption. Optimization is generally implemented as a sequence of op ...
with three optimization passes could be implemented as a relation between an initial program and its optimized form:
program_optimized(Prog0, Prog) :-
optimization_pass_1(Prog0, Prog1),
optimization_pass_2(Prog1, Prog2),
optimization_pass_3(Prog2, Prog).
or equivalently using DCG notation:
program_optimized --> optimization_pass_1, optimization_pass_2, optimization_pass_3.
Quicksort
The quicksort
Quicksort is an efficient, general-purpose sorting algorithm. Quicksort was developed by British computer scientist Tony Hoare in 1959 and published in 1961. It is still a commonly used algorithm for sorting. Overall, it is slightly faster than ...
sorting algorithm, relating a list to its sorted version:
partition([], _, [], []).
partition([X, Xs], Pivot, Smalls, Bigs) :-
( X @< Pivot ->
Smalls = [X, Rest],
partition(Xs, Pivot, Rest, Bigs)
; Bigs = [X, Rest],
partition(Xs, Pivot, Smalls, Rest)
).
quicksort([]) --> [].
quicksort([X, Xs]) -->
,
quicksort(Smaller), [X], quicksort(Bigger).
Design patterns of Prolog
A design pattern (computer science), design pattern is a general reusable solution to a commonly occurring problem in software design
Software design is the process of conceptualizing how a software system will work before it is implemented or modified.
Software design also refers to the direct result of the design process the concepts of how the software will work which co ...
. Some design patterns in Prolog are skeletons, techniques, cliches, program schemata,[
] logic description schemata,[
] and higher-order programming.[
]
Higher-order programming
A higher-order predicate is a predicate that takes one or more other predicates as arguments. Although support for higher-order programming takes Prolog outside the domain of first-order logic, which does not allow quantification over predicates, ISO Prolog now has some built-in higher-order predicates such as call/1
, call/2
, call/3
, findall/3
, setof/3
, and bagof/3
. Furthermore, since arbitrary Prolog goals can be constructed and evaluated at run-time, it is easy to write higher-order predicates like maplist/2
, which applies an arbitrary predicate to each member of a given list, and sublist/3
, which filters elements that satisfy a given predicate, also allowing for currying
In mathematics and computer science, currying is the technique of translating a function that takes multiple arguments into a sequence of families of functions, each taking a single argument.
In the prototypical example, one begins with a functi ...
.
To convert solutions from temporal representation (answer substitutions on backtracking) to spatial representation (terms), Prolog has various all-solutions predicates that collect all answer substitutions of a given query in a list. This can be used for list comprehension
A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical '' set-builder notation'' (''set comprehension'') as distinct from the use o ...
. For example, perfect numbers
In number theory, a perfect number is a positive integer that is equal to the sum of its positive proper divisors, that is, divisors excluding the number itself. For instance, 6 has proper divisors 1, 2 and 3, and 1 + 2 + 3 = 6, so 6 is a perfec ...
equal the sum of their proper divisors:
perfect(N) :-
between(1, inf, N), U is N // 2,
findall(D, (between(1,U,D), N mod D =:= 0), Ds),
sumlist(Ds, N).
This can be used to enumerate perfect numbers, and to check if a number is perfect.
As another example, the predicate maplist
applies a predicate P
to all corresponding positions in a pair of lists:
maplist(_, [], []).
maplist(P, [X, Xs], [Y, Ys]) :-
call(P, X, Y),
maplist(P, Xs, Ys).
When P
is a predicate that for all X
, P(X,Y)
unifies Y
with a single unique value, maplist(P, Xs, Ys)
is equivalent to applying the map
A map is a symbolic depiction of interrelationships, commonly spatial, between things within a space. A map may be annotated with text and graphics. Like any graphic, a map may be fixed to paper or other durable media, or may be displayed on ...
function in functional programming
In computer science, functional programming is a programming paradigm where programs are constructed by Function application, applying and Function composition (computer science), composing Function (computer science), functions. It is a declarat ...
as Ys = map(Function, Xs)
.
Higher-order programming style in Prolog was pioneered in HiLog HiLog is a programming logic with higher-order syntax, which allows arbitrary terms to appear in predicate and function positions. However, the model theory of HiLog is first-order. Although syntactically HiLog strictly extends first order logic, Hi ...
and λProlog
λProlog, also written lambda Prolog, is a logic programming language featuring polymorphic typing, modular programming, and higher-order programming. These extensions to Prolog are derived from the higher-order hereditary Harrop formulas used ...
.
Modules
For programming in the large, Prolog provides a module system, which is in the ISO Standard.
However, while most Prolog systems support structuring the code into modules, virtually no implementation adheres to the modules part of the ISO standard. Instead, most Prolog systems have decided to support as ''de-facto'' module standard the Quintus
Quintus is a male given name derived from ''Quintus (praenomen), Quintus'', a common Latin language, Latin forename (''praenomen'') found in the culture of ancient Rome. Quintus derives from Latin word ''quintus'', meaning "fifth".
Quintus is ...
/SICStus
SICStus Prolog is a Proprietary software, proprietary, ISO Prolog, ISO-conforming implementation of the logic programming language Prolog. It is developed by the Swedish Institute of Computer Science since 1985 and puts a strong focus on perform ...
module system. However, further convenience predicates concerning modules are provided by some implementations only and often have subtle differences in their semantics.
Some systems chose to implement module concepts as source-to-source compilation into base ISO Prolog, as is the case of Logtalk
Logtalk is an object-oriented logic programming language that extends and leverages the Prolog language with a feature set suitable for programming in the large.Paulo Moura (2003). Logtalk: Design of an Object-Oriented Logic Programming Language. ...
. GNU Prolog initially diverted from ISO modules, opting instead for Contextual Logic Programming
Contextual may refer to:
* Contextual advertising, advertisements based on other content displayed
* Contextual deep linking, links that bring users to content in mobile apps regardless of whether or not they had the app previously installed
* Cont ...
, in which unit (module) loading and unloading can be made dynamically. Ciao
( , ) is an informal salutation in the Italian language that is used for both " hello" and "goodbye".
Originally from the Venetian language, it has entered the vocabulary of English and of many other languages around the world. Its dual mea ...
designed a strict module system that, while being basically compatible with the ''de-facto'' standard used by other Prolog systems, is amenable to precise static analysis, supports term hiding, and facilitates programming in the large. XSB takes a different approach and offers an ''atom-based'' module system. The latter two Prolog systems allow controlling the ''visibility of terms'' in addition to that of predicates.
Parsing
There is a special notation called definite clause grammar A definite clause grammar (DCG) is a way of expressing grammar, either for natural or formal languages, in a logic programming language such as Prolog. It is closely related to the concept of attribute grammars / affix grammars.
DCGs are usually as ...
s (DCGs). A rule defined via -->/2
instead of :-/2
is expanded by the preprocessor (expand_term/2
, a facility analogous to macros in other languages) according to a few straightforward rewriting rules, resulting in ordinary Prolog clauses. Most notably, the rewriting equips the predicate with two additional arguments, which can be used to implicitly thread state around, analogous to monads in other languages. DCGs are often used to write parsers or list generators, as they also provide a convenient interface to difference lists.
Meta-interpreters and reflection
Prolog is a homoiconic
In computer programming, homoiconicity (from the Greek words ''homo-'' meaning "the same" and ''icon'' meaning "representation") is an informal property of some programming languages. A language is homoiconic if a program written in it can be manip ...
language and provides many facilities for reflective programming
In computer science, reflective programming or reflection is the ability of a process to examine, introspect, and modify its own structure and behavior.
Historical background
The earliest computers were programmed in their native assembly lang ...
(reflection). Its implicit execution strategy makes it possible to write a concise meta-circular evaluator (also called ''meta-interpreter'') for pure Prolog code:
solve(true).
solve((Subgoal1,Subgoal2)) :-
solve(Subgoal1),
solve(Subgoal2).
solve(Head) :-
clause(Head, Body),
solve(Body).
where true
represents an empty conjunction, and clause(Head, Body)
unifies with clauses in the database of the form Head :- Body
.
Since Prolog programs are themselves sequences of Prolog terms (:-/2
is an infix operator) that are easily read and inspected using built-in mechanisms (like read/1
), it is possible to write customized interpreters that augment Prolog with domain-specific features. For example, Sterling and Shapiro present a meta-interpreter that performs reasoning with uncertainty, reproduced here with slight modifications:
solve(true, 1) :- !.
solve((Subgoal1,Subgoal2), Certainty) :-
!,
solve(Subgoal1, Certainty1),
solve(Subgoal2, Certainty2),
Certainty is min(Certainty1, Certainty2).
solve(Goal, 1) :-
builtin(Goal), !,
Goal.
solve(Head, Certainty) :-
clause_cf(Head, Body, Certainty1),
solve(Body, Certainty2),
Certainty is Certainty1 * Certainty2.
This interpreter uses a table of built-in Prolog predicates of the form
builtin(A is B).
builtin(read(X)).
% etc.
and clauses represented as clause_cf(Head, Body, Certainty)
. Given those, it can be called as solve(Goal, Certainty)
to execute Goal
and obtain a measure of certainty about the result.
Turing completeness
Pure Prolog is based on a subset of first-order predicate logic, Horn clause
In mathematical logic and logic programming, a Horn clause is a logical formula of a particular rule-like form that gives it useful properties for use in logic programming, formal specification, universal algebra and model theory. Horn clauses are ...
s, which is Turing completeness, Turing-complete. Turing completeness of Prolog can be shown by using it to simulate a Turing machine:
turing(Tape0, Tape) :-
perform(q0, [], Ls, Tape0, Rs),
reverse(Ls, Ls1),
append(Ls1, Rs, Tape).
perform(qf, Ls, Ls, Rs, Rs) :- !.
perform(Q0, Ls0, Ls, Rs0, Rs) :-
symbol(Rs0, Sym, RsRest),
once(rule(Q0, Sym, Q1, NewSym, Action)),
action(Action, Ls0, Ls1, [NewSym, RsRest], Rs1),
perform(Q1, Ls1, Ls, Rs1, Rs).
symbol([], b, []).
symbol([Sym, Rs], Sym, Rs).
action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
action(stay, Ls, Ls, Rs, Rs).
action(right, Ls0, [Sym, Ls0], [Sym, Rs], Rs).
left([], [], Rs0, [b, Rs0]).
left([L, Ls], Ls, Rs, [L, Rs]).
A simple example Turing machine is specified by the facts:
rule(q0, 1, q0, 1, right).
rule(q0, b, qf, 1, stay).
This machine performs incrementation by one of a number in unary encoding: It loops over any number of "1" cells and appends an additional "1" at the end. Example query and result:
?- turing([1,1,1], Ts).
Ts = [1, 1, 1, 1] ;
This illustrates how any computation can be expressed declaratively as a sequence of state transitions, implemented in Prolog as a relation between successive states of interest.
Implementation

ISO Prolog
The International Organization for Standardization
The International Organization for Standardization (ISO ; ; ) is an independent, non-governmental, international standard development organization composed of representatives from the national standards organizations of member countries.
M ...
(ISO) Prolog technical standard consists of two parts. ISO/IEC 13211-1,[ISO/IEC 13211: Information technology – Programming languages – Prolog. ]International Organization for Standardization
The International Organization for Standardization (ISO ; ; ) is an independent, non-governmental, international standard development organization composed of representatives from the national standards organizations of member countries.
M ...
, Geneva. published in 1995, aims to standardize the existing practices of the many implementations of the core elements of Prolog. It has clarified aspects of the language that were previously ambiguous and leads to portable programs. There are three corrigenda: Cor.1:2007, Cor.2:2012, and Cor.3:2017. ISO/IEC 13211-2, published in 2000, adds support for modules to the standard. The standard is maintained by the JTC1, ISO/IEC JTC1/SC22/WG17 working group. ANSI X3J17 is the US Technical Advisory Group for the standard.
Compilation
For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-based Warren Abstract Machine
In 1983, David H. D. Warren designed an abstract machine for the execution of Prolog consisting of a memory architecture and an instruction set. This design became known as the Warren Abstract Machine (WAM) and has become the ''de facto'' standard ...
(WAM) instruction set. Some implementations employ abstract interpretation to derive type and mode information of predicates at compile time, or compile to real machine code for high performance. Devising efficient implementation methods for Prolog code is a field of active research in the logic programming community, and various other execution methods are employed in some implementations. These include clause binarization and stack machines, stack-based virtual machines.
Tail recursion
Prolog systems typically implement a well-known optimization method called tail call#Tail call optimization, tail call optimization (TCO) for deterministic predicates exhibiting tail recursion or, more generally, tail calls: A clause's stack frame is discarded before performing a call in a tail position. Therefore, deterministic tail-recursive predicates are executed with constant stack space, like loops in other languages.
Term indexing
Finding clauses that are unifiable with a term in a query is linear in the number of clauses. Term indexing uses a data structure that enables Sublinear time, sub-linear-time lookups. Indexing only affects program performance, it does not affect semantics. Most Prologs only use indexing on the first term, as indexing on all terms is expensive, but techniques based on ''field-encoded words'' or ''Superimposed code, superimposed codewords'' provide fast indexing across the full query and head.
Hashing
Some Prolog systems, such as Logic Programming Associates, WIN-PROLOG and SWI-Prolog, now implement hashing to help handle large datasets more efficiently. This tends to yield very large performance gains when working with large corpora such as WordNet.
Tabling
Some Prolog systems, (B-Prolog, XSB, SWI-Prolog, YAP (Prolog), YAP, and Ciao
( , ) is an informal salutation in the Italian language that is used for both " hello" and "goodbye".
Originally from the Venetian language, it has entered the vocabulary of English and of many other languages around the world. Its dual mea ...
), implement a memoization method called ''tabling'', which frees the user from manually storing intermediate results. Tabling is a space–time tradeoff; execution time can be reduced by using more memory to store intermediate results:
Subgoals encountered in a query evaluation are maintained in a table, along with answers to these subgoals. If a subgoal is re-encountered, the evaluation reuses information from the table rather than re-performing resolution against program clauses.
Tabling can be extended in various directions. It can support recursive predicates through SLG resolution or linear tabling. In a multi-threaded Prolog system tabling results could be kept private to a thread or shared among all threads. And in incremental tabling, tabling might react to changes.
Implementation in hardware
During the Fifth Generation Computer Systems project, there were attempts to implement Prolog in hardware with the aim of achieving faster execution with dedicated architectures. Furthermore, Prolog has a number of properties that may allow speed-up through parallel execution. A more recent approach has been to compile restricted Prolog programs to a field-programmable gate array (FPGA). However, rapid progress in general-purpose hardware has consistently overtaken more specialised architectures.
In 1982, computers operated at around 10,000 to 100,000 LIPS [logical inferences per second]. The FGCS planned to produce computers operating at 0.1 to 1 GLIPS. The Institute for New Generation Computer Technology documents estimated that 1 LIP took about 100 operations on a conventional computer. The plan was to produce at the end of the project (in 1992) a machine with 1000 processors achieving 1 GLIPS, implying at least 1 MLIPS per processor.
Sega implemented Prolog for use with the Sega AI Computer , released for the Japanese market in 1986. Prolog was used for reading natural language inputs, in the Japanese language, via a touch pad.
Extensions
Various implementations have been developed from Prolog to extend logic programming abilities in many directions. These include type system, types, modes, constraint logic programming
Constraint logic programming is a form of constraint programming, in which logic programming is extended to include concepts from constraint satisfaction. A constraint logic program is a logic program that contains constraints in the body of claus ...
(CLP), Object-oriented programming, object-oriented logic programming (OOLP), concurrency, linear logic (LLP), functional and higher-order logic programming abilities, plus interoperability with knowledge bases:
Types
Prolog is an untyped language. Attempts to introduce and extend Prolog with types began in the 1980s, and continue . Type information is useful not only for type safety but also for reasoning about Prolog programs.
Modes
The syntax of Prolog does not specify which arguments of a predicate are inputs and which are outputs. However, this information is significant and it is recommended that it be included in the comments. Modes provide valuable information when reasoning about Prolog programs and can also be used to accelerate execution.
Constraints
Constraint logic programming extends Prolog to include concepts from constraint satisfaction. A constraint logic program allows constraints in the body of clauses, such as: A(X,Y) :- X+Y>0.
It is suited to large-scale combinatorial optimisation problems and is thus useful for applications in industrial settings, such as automated time-tabling and production scheduling. Most Prolog systems ship with at least one constraint solver for finite domains, and often also with solvers for other domains like rational numbers.
Object-orientation
Flora-2 is an object-oriented knowledge representation and reasoning system based on F-logic and incorporates HiLog HiLog is a programming logic with higher-order syntax, which allows arbitrary terms to appear in predicate and function positions. However, the model theory of HiLog is first-order. Although syntactically HiLog strictly extends first order logic, Hi ...
, Transaction logic, and defeasible reasoning.
Logtalk
Logtalk is an object-oriented logic programming language that extends and leverages the Prolog language with a feature set suitable for programming in the large.Paulo Moura (2003). Logtalk: Design of an Object-Oriented Logic Programming Language. ...
is an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler. As a multi-paradigm language, it includes support for both prototypes and classes.
Oblog is a small, portable, object-oriented extension to Prolog by Margaret McDougall of EdCAAD, University of Edinburgh.
Objlog was a frame-based language combining objects and Prolog II from CNRS, Marseille, France.
Prolog++ was developed by Logic Programming Associates and first released in 1989 for MS-DOS PCs. Support for other platforms was added, and a second version was released in 1995. A book about Prolog++ by Chris Moss was published by Addison-Wesley in 1994.
Visual Prolog is a multi-paradigm language with interfaces, classes, implementations and object expressions.
Graphics
Prolog systems that provide a graphics library are SWI-Prolog, Visual Prolog, Logic Programming Associates, WIN-PROLOG, and B-Prolog.
Concurrency
Prolog-MPI is an open-source SWI-Prolog extension for distributed computing over the Message Passing Interface. Also there are various concurrent Prolog programming languages.
Web programming
Some Prolog implementations, notably Visual Prolog, SWI-Prolog and Ciao
( , ) is an informal salutation in the Italian language that is used for both " hello" and "goodbye".
Originally from the Venetian language, it has entered the vocabulary of English and of many other languages around the world. Its dual mea ...
, support server-side web programming with support for web protocols, HTML and XML. There are also extensions to support semantic web formats such as Resource Description Framework (RDF) and Web Ontology Language (OWL). Prolog has also been suggested as a client-side language. In addition, Visual Prolog supports JSON-RPC and Websockets.
Adobe Flash
Cedar
is a free and basic Prolog interpreter. From version 4 and above Cedar has a FCA (Flash Cedar App) support. This provides a new platform to programming in Prolog through ActionScript.
Other
* F-logic extends Prolog with frames/objects for knowledge representation.
* Transaction logic extends Prolog with a logical theory of state-changing update operators. It has both a model-theoretic and procedural semantics.
* OW Prolog has been created in order to answer Prolog's lack of graphics and interface.
Interfaces to other languages
Frameworks exist which can bridge between Prolog and other languages:
* Th
LPA Intelligence Server
allows embeddin
in other programming languages, including: C (programming language), C, , C Sharp (programming language), C#, Java (programming language), Java, Visual Basic (classic), Visual Basic (VB), Delphi (software), Delphi, .NET, Lua (programming language), Lua, Python (programming language), Python, and others. It exploits the dedicated string data type which LPA Prolog provides
* Th
Logic Server
Application Programming Interface (API) allows both the extension and embedding of Prolog in C (programming language), C, , Java (programming language), Java, Visual Basic (classic), Visual Basic (VB), Delphi (software), Delphi, .NET, and any language or environment which can call a .dll or .so. It is implemented fo
Amzi! Prolog + Logic Server
but the API specification can be made available for any implementation.
JPL
is a bi-directional Java Prolog bridge which ships with SWI-Prolog by default, allowing Java and Prolog to call each other (recursively). It is known to have good concurrency support and is under active development.
InterProlog
a programming Library (computing), library bridge between Java platform, Java and Prolog, implementing bi-directional predicate/method calling between both languages. Java objects can be mapped into Prolog terms and vice versa. Allows the development of graphical user interfaces (GUIs) and other functions in Java while leaving logic processing in the Prolog layer. Supports XSB and SWI-Prolog.
* Prova provides native syntax integration with Java, agent messaging and reaction rules. Prova positions itself as a rule-based scripting (RBS) system for middleware. The language breaks new ground in combining imperative programming, imperative and declarative programming
In computer science, declarative programming is a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow.
Many languages that ap ...
.
PROL
An embeddable Prolog engine for Java. It includes a small IDE and a few libraries.
GNU Prolog for Java
is an implementation of ISO Prolog as a Java library (gnu.prolog)
* Ciao
( , ) is an informal salutation in the Italian language that is used for both " hello" and "goodbye".
Originally from the Venetian language, it has entered the vocabulary of English and of many other languages around the world. Its dual mea ...
provides interfaces to C, , Java, and relational databases.
C#-Prolog
is a Prolog interpreter written in (managed) C#. Can easily be integrated in C# programs. Characteristics: reliable and fairly fast interpreter, command line interface, Windows-interface, builtin DCG, XML-predicates, SQL-predicates, extendible. The complete source code is available, including a parser generator that can be used for adding special purpose extensions.
A Warren Abstract Machine for PHP
A Prolog compiler and interpreter in PHP 5.3. A library that can be used standalone or within Symfony2.1 framework which was translated fro
Stephan Buettcher's
work in Java which can be found [here ]
tuProlog
is a lightweight Prolog system for distributed applications and infrastructures, intentionally designed around a minimal core, to be either statically or dynamically configured by loading/unloading libraries of predicates. tuProlog natively supports multi-paradigm programming, providing a clean, seamless integration model between Prolog and mainstream object-oriented languages, namely Java, for tuProlog Java version, and any .NET-based language (C#, F#..), for tuProlog .NET version.
is a bi-directional interface between Prolog and Python using portable low-level primitives. It was initially developed for XSB by Anderson and Swift,[Andersen, C. and Swift, T., 2023. The Janus System: a bridge to new prolog applications. In Prolog: The Next 50 Years (pp. 93-104). Cham: Springer Nature Switzerland.] but has been adopted as a joint initiative by the XSB, Ciao and SWI-Prolog teams.
See also
* Comparison of Prolog implementations
* Logico-linguistic modeling. A method for building knowledge-based system that uses Prolog.
* Answer set programming. A fully declarative approach to logic programming.
* Association for Logic Programming
Related languages
* The Gödel (programming language), Gödel language is a strongly typed implementation of concurrent constraint logic programming. It is built on SICStus Prolog.
* Visual Prolog, formerly named PDC Prolog and Turbo Prolog, is a data type, strongly typed Object-oriented programming, object-oriented dialect of Prolog, which is very different from standard Prolog. As Turbo Prolog, it was marketed by Borland, but is now developed and marketed by the Danish firm Prolog Development Center (PDC) that originally produced it.
* Datalog
Datalog is a declarative logic programming language. While it is syntactically a subset of Prolog, Datalog generally uses a bottom-up rather than top-down evaluation model. This difference yields significantly different behavior and properties ...
is a subset of Prolog. It is limited to relationships that may be stratified and does not allow compound terms. In contrast to Prolog, Datalog is not Turing-complete.
* Mercury (programming language), Mercury is an offshoot of Prolog geared toward software engineering in the large with a static, polymorphic type system, as well as a mode and determinism system.
* GraphTalk is a proprietary implementation of Warren's Abstract Machine, with additional object-oriented properties.
* In some ways Prolog is a subset of Planner (programming language), Planner. The ideas in Planner were later further developed in the Scientific Community Metaphor.
* AgentSpeak is a variant of Prolog for programming agent behavior in multi-agent systems.
* Erlang (programming language), Erlang began life with a Prolog-based implementation and maintains much of Prolog's unification-based syntax.
Pilog
is a declarative language built on top of PicoLisp, that has the semantics of Prolog, but uses the syntax of Lisp.
* λProlog
λProlog, also written lambda Prolog, is a logic programming language featuring polymorphic typing, modular programming, and higher-order programming. These extensions to Prolog are derived from the higher-order hereditary Harrop formulas used ...
is an extension of core Prolog that features polymorphic typing, modular programming, and higher-order programming, including direct support for terms with variable-binding operators through so-called λ-tree syntax and higher-order pattern unification.
Notes
References
Further reading
*
* Ivan Bratko (computer scientist), Ivan Bratko, ''Prolog Programming for Artificial Intelligence'', 4th ed., 2012,
Book supplements and source code
* William F. Clocksin, Christopher S. Mellish: ''Programming in Prolog: Using the ISO Standard''. Springer, 5th ed., 2003, . ''(This edition is updated for ISO Prolog. Prior editions described Edinburgh Prolog.)''
* William F. Clocksin: ''Clause and Effect. Prolog Programming for the Working Programmer''. Springer, 2003, .
* Michael A. Covington, Donald Nute, Andre Vellino, ''Prolog Programming in Depth'', 1996, .
* Michael A. Covington, ''Natural Language Processing for Prolog Programmers'', 1994,
* M. S. Dawe and C.M.Dawe, ''Prolog for Computer Sciences'', Springer Verlag 1992.
* ''ISO/IEC 13211: Information technology – Programming languages – Prolog''. International Organization for Standardization
The International Organization for Standardization (ISO ; ; ) is an independent, non-governmental, international standard development organization composed of representatives from the national standards organizations of member countries.
M ...
, Geneva.
* Feliks Kluźniak and Stanisław Szpakowicz (with a contribution by Janusz S. Bień). ''Prolog for Programmers''. Academic Press Inc. (London), 1985, 1987 (available under a Creative Commons license at ). .
* Richard O'Keefe, ''The Craft of Prolog'', .
* Robert Smith, John Gibson, Aaron Sloman: 'POPLOG's two-level virtual machine support for interactive languages', in ''Research Directions in Cognitive Science Volume 5: Artificial Intelligence'', Eds Derek H. Sleeman, D. Sleeman and N. Bernsen, Lawrence Erlbaum Associates, pp 203–231, 1992.
* Leon Sterling and Ehud Shapiro, ''The Art of Prolog: Advanced Programming Techniques'', 1994, .
* David H D Warren, Luis M. Pereira and Fernando Pereira, Prolog - the language and its implementation compared with Lisp. ACM SIGART Bulletin archive, Issue 64. Proceedings of the 1977 symposium on Artificial intelligence and programming languages, pp 109–115.
External links
*
{{Authority control
Dynamically typed programming languages
French inventions
Homoiconic programming languages
Logic programming languages
Pattern matching programming languages
Programming languages created in 1972
Programming languages with an ISO standard
Prolog programming language family