Prolog is a logic programming language. It is a general purpose language often associated with artificial intelligence and computational linguistics. It has a purely logical subset, called "pure Prolog", as well as a number of extralogical features. A programming paradigm is a paradigmatic style of programming (compare with a methodology, which is a paradigmatic style of doing software engineering). ... Logic programming (which might better be called logical programming by analogy with mathematical programming and linear programming) is, in its broadest sense, the use of mathematical logic for computer programming. ... Year 1972 (MCMLXXII) was a leap year starting on Saturday (link will display full calendar) of the Gregorian calendar. ... Professor Alain Colmerauer is the creator of the logic programming language Prolog for computers. ... Look up Implementation in Wiktionary, the free dictionary. ... B-Prolog is a high-performance, high-quality, and award-wining implementation of the standard Prolog language with several useful extended features including action rules for event handling, finite-domain constraint solving, and tabling. ... GNU Prolog A Native Prolog Compiler with Constraint Solving over Finite Domains GNU Prolog is a free Prolog compiler with constraint solving over finite domains developed by Daniel Diaz. ... Strawberry Prolog is very close to ISO-Prolog syntax but it has many extensions which are not part from the standard. ... SWI-Prolog is an open source implementation of the programming language Prolog, commonly used for teaching. ... The introduction to this article provides insufficient context for those unfamiliar with the subject matter. ... A dialect of a programming language is a (relatively small) variation or extension of the language that does not change its intrinsic nature. ... Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. ... Mercury is a functional logic programming language based on Prolog, but more geared towards practical applications. ... Oz is a multi-paradigm programming language. ... Erlang is a general-purpose concurrent programming language and runtime system. ... Strand is a high-level symbolic language for parallel computing, similar in syntax to Prolog. ... Logic programming (which might better be called logical programming by analogy with mathematical programming and linear programming) is, in its broadest sense, the use of mathematical logic for computer programming. ... Garry Kasparov playing against Deep Blue, the first machine to win a chess game against a reigning world champion. ... Computational linguistics is an interdisciplinary field dealing with the statistical and logical modeling of natural language from a computational perspective. ...

History

The name Prolog was chosen by Philippe Roussel as an abbreviation for "PROgrammation en LOGique” (French for programming in logic). It was created around 1972 by Alain Colmerauer with Philippe Roussel, based on Robert Kowalski's procedural interpretation of Horn clauses. 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. Professor Alain Colmerauer is the creator of the logic programming language Prolog for computers. ... Robert Anthony Kowalski (Bob Kowalski, born May 15, 1941 in Bridgeport, Connecticut, USA) is an American logician and computer scientist, who has spent much of his career in the UK. He was educated at the University of Chicago, University of Bridgeport (BA in mathematics, 1963), Stanford University (MSc in mathematics... In logic, and in particular in propositional calculus, a Horn clause is a proposition of the general type (p and q and . ...

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. The PIM/m-1 machine, one of the few fifth generation computers ever produced The Fifth Generation Computer Systems project (FGCS) was an initiative by Japans Ministry of International Trade and Industry, begun in 1982, to create a fifth generation computer (see history of computing hardware) which was supposed... // An operating system (OS) is a set of computer programs that manage the hardware and software resources of a computer. ...

Pure Prolog was originally restricted to the use of a resolution theorem prover with Horn clauses of the form In mathematical logic and automated theorem proving, resolution is a rule of inference leading to a refutation theorem-proving technique for sentences in propositional logic and first-order logic. ... In logic, and in particular in propositional calculus, a Horn clause is a proposition of the general type (p and q and . ...

H :- B₁, …, B_n..

The application of the theorem-prover treats such clauses as procedures

to show/solve H, show/solve B₁ and … and B_n.

Pure Prolog was soon extended, however, to include negation as failure, in which negative conditions of the form not(B_i) are shown by trying and failing to solve the corresponding positive conditions B_i. A common default assumption is that what is not known to be true is believed to be false. ...

Data types

Prolog's single data type is the term. Terms are either atoms, numbers, variables or compound terms.

Example atoms are: x, blue, 'Some atom', and [].

Numbers can be floats or integers. Many Prolog implementations also provide unbounded integers and rational 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 variable can become instantiated via unification. A single underscore (_) denotes an anonymous variable and means "any term". For the idea of global unification, see globalization. ...

A compound term has a functor and a number of arguments, which are again terms. The number of arguments is called the term's arity. (Atoms can be regarded as a special case of compound terms of arity zero.) The mathematical term arity sprang from words like unary, binary, ternary, etc. ... The mathematical term arity sprang from words like unary, binary, ternary, etc. ...

Examples for terms are f(a,b) and p(x,y,z). Some operators can be used in infix notation. For example, the terms +(a,b) and =(X,Y) can also be written as a+b and X=Y, respectively. Users can also declare arbitrary sequences of symbols as new infix or postfix operators to allow for domain-specific notations. The notation f/n is commonly used to denote a term with functor f and arity n.

Special cases of compound terms:

• Lists are defined inductively: The atom [] is a list. A compound term with functor . (dot) and arity 2, whose second argument is a list, is itself a list. There exists special syntax for denoting lists: .(A, B) is equivalent to [A|B]. For example, the list .(1, .(2, .(3, []))) can also be written as [1,2,3].
• Strings: A sequence of characters surrounded by quotes is equivalent to a list of (numeric) character codes, generally in the local character encoding or Unicode if the system supports Unicode.

A character encoding or character set (sometimes referred to as code page) consists of a code that pairs a sequence of characters from a given set with something else, such as a sequence of natural numbers, octets or electrical pulses, in order to facilitate the storage of text in computers... Unicode is an industry standard designed to allow text and symbols from all of the writing systems of the world to be consistently represented and manipulated by computers. ...

Programming in Prolog

Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted to Horn clauses, a Turing-complete subset of first-order predicate logic. There are two types of clauses: Facts and rules. A rule is of the form In logic, a Horn clause is a clause (a disjunction of literals) with at most one positive literal. ...

 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 predicate ,/2 denotes conjunction of goals, and ;/2 denotes disjunction. Due to the restriction to Horn clauses, 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:

 cat(tom). 

which is equivalent to the rule:

 cat(tom) :- true. 

The built-in predicate true/0 is always true.

Given above fact, one can ask:

is tom a cat?

 ?- cat(tom). Yes 

what things are cats?

 ?- cat(X). X = tom 

Functional programming can be regarded as a proper subset of logic programming since functions are a special case of relations. 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 as well as to generate a list skeleton of a given length, and also to generate both list skeletons and their lengths together. Similarly, append/3 can be used both to append two lists as well as to split a given list into parts. For this reason, a comparatively small set of library predicates suffices for many Prolog programs. All predicates can also be used to perform unit tests: Queries can be embedded in programs and allow for automatic compile-time regression testing. In computer programming, a unit test is a method of testing the correctness of a particular module of source code. ...

As a general purpose language, Prolog also provides various built-in predicates to perform routine activities like input/output, 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.

Evaluation

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. 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. For example: In mathematical logic and automated theorem proving, resolution is a rule of inference leading to a refutation theorem-proving technique for sentences in propositional logic and first-order logic. ... In logic programming, SLD resolution is an algorithm for mechanically proving statements of first-order logic from a set of Horn clauses; particularly, linear resolution with a selection function for definite sentences. ... Backtracking is a type of algorithm that is a refinement of brute force search. ...

 sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y). parent_child(X, Y) :- father_child(X, Y). parent_child(X, Y) :- mother_child(X, Y). mother_child(trude, sally). father_child(tom, sally). father_child(tom, erica). father_child(mike, tom). 

This results in the following query being evaluated as 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 (X = Y). One would insert additional goals to describe the relevant restrictions, if desired.

Loops and recursion

Iterative algorithms can be implemented by means of recursive predicates. Prolog systems typically implement a well-known optimization technique called 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. In computer science, tail recursion is a special case of recursion that can be easily transformed into an iteration. ...

Negation

The built-in Prolog predicate +/1 provides negation as failure, which allows for non-monotonic reasoning. The goal "+ illegal(X)" in the rule A common default assumption is that what is not known to be true is believed to be false. ... A non-monotonic logic is a formal logic whose consequence relation is not monotonic. ...

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

is evaluated is 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 if its argument is ground. Soundness is lost if the argument contains variables. In particular, the query "?- legal(X)." can now not be used to enumerate all things that are legal.

Operational considerations

Under a declarative reading, the order of rules, and of goals within rules, is irrelevant since logical disjunction and conjunction are commutative. Procedurally, however, it is often important to take into account Prolog's execution strategy, either for efficiency reasons, or due to the semantics of impure built-in predicates for which the order of evaluation matters.

DCGs and parsing

There is a special notation called definite clause grammars (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 straight-forward 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 list differences. Wikibooks Haskell has a page on the topic of Understanding monads Some functional programming languages make use of monads[1] [2] to structure programs which include operations that must be executed in a specific order. ...

Parser example

A larger example will show the potential of using Prolog in parsing.

Given the sentence expressed in BNF: The Backus-Naur form (BNF) (also known as Backus normal form) is a metasyntax used to express context-free grammars: that is, a formal way to describe formal languages. ...

 <sentence> ::= <stat_part> <stat_part> ::= <statement> | <stat_part> <statement> <statement> ::= <id> = <expression> ; <expression> ::= <operand> | <expression> <operator> <operand> <operand> ::= <id> | <digit> <id> ::= a | b <digit> ::= 0..9 <operator> ::= + | - | * 

This can be written in Prolog using DCGs (assuming the input like [a, =, 3, *, b, ;, b, =, 0, ;] etc.):

 sentence --> statement, sentence_r. sentence_r --> []. sentence_r --> statement, sentence_r. statement --> id, [=], expression, [;]. expression --> term, expression_r. expression_r --> []. expression_r --> [+], term, expression_r. expression_r --> [-], term, expression_r. term --> factor, term_r. term_r --> []. term_r --> [*], factor, term_r. factor --> id. factor --> [D], { (number(D) ; var(D)), between(0, 9, D) }. id --> [a]. id --> [b]. 

This corresponds to a predictive parser with one token look-ahead. The program can be used to test whether a given list is in the language generated by the grammar:

 ?- phrase(sentence, [a,=,1,+,3,*,b,;,b,=,0,;]). Yes 

By augmenting the predicates with additional arguments to keep track of the parsed elements, an abstract syntax tree (AST) of the parsed sentence can be created in parallel to parsing it: In computer science, an abstract syntax tree (AST) is a finite, labeled, directed tree, where the internal nodes are labeled by operators, and the leaf nodes represent the operands of the node operators. ...

 sentence(S) --> statement(S0), sentence_r(S0, S). sentence_r(S, S) --> []. sentence_r(S0, seq(S0, S)) --> statement(S1), sentence_r(S1, S). statement(assign(Id,E)) --> id(Id), [=], expression(E), [;]. expression(E) --> term(T), expression_r(T, E). expression_r(E, E) --> []. expression_r(E0, E) --> [+], term(T), expression_r(plus(E0,T), E). expression_r(E0, E) --> [-], term(T), expression_r(minus(E0, T), E). term(T) --> factor(F), term_r(F, T). term_r(T, T) --> []. term_r(T0, T) --> [*], factor(F), term_r(times(T0, F), T). factor(id(ID)) --> id(ID). factor(digit(D)) --> [D], { (number(D) ; var(D)), between(0, 9, D)}. id(a) --> [a]. id(b) --> [b]. 

Example query:

 ?- phrase(sentence(S), [a,=,1,+,3,*,b,;,b,=,0,;]). S = seq(assign(a, plus(digit(1), times(digit(3), id(b)))), assign(b, digit(0))) ; 

The AST is represented using Prolog terms and can be used to apply optimizations, to compile such expressions to machine-code, or to directly interpret such statements. As is typical for the relational nature of predicates, these definitions can be used both to parse and generate sentences, and also to check whether a given tree corresponds to a given list of tokens. Using iterative deepening for fair enumeration, each arbitrary but fixed sentence and its corresponding AST will be generated eventually:

 ?- length(Ts, _), phrase(sentence(S), Ts). Ts = [a, =, a, (;)], S = assign(a, id(a)) ; Ts = [a, =, b, (;)], S = assign(a, id(b)) etc. 

Higher-order programming

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, computer science and linguistics (semantics), currying or Schönfinkelisation[1] is the technique of transforming a function that takes multiple arguments into a function that takes a single argument (the other arguments having been specified by the curry). ...

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. For example, perfect numbers equal the sum of their proper divisors: In some programming languages, list comprehension is a syntactic construct for creating a list based on existing lists, analogous to the set-builder notation (set comprehension), that is, the mathematical notation such as the following: For an example, in Haskells list comprehension syntax, the example set-builder construct above... In mathematics, a perfect number is an integer which is the sum of its proper positive divisors, excluding itself. ...

 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 also to check whether a number is perfect.

Meta-interpreters and reflection

Prolog is a homoiconic language and provides many facilities for reflection. Its implicit execution strategy makes it possible to write a concise meta-circular evaluator for pure Prolog code. 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 easy to write customized interpreters that augment Prolog with domain-specific features. In computer programming, homoiconicity is a property of some programming languages, in which the primary representation of the program source code is also a data structure in a primitive type of the language itself. ... In computer science, reflection is the process by which a computer program of the appropriate type can be modified in the process of being executed, in a manner that depends on abstract features of its code and its runtime behavior. ... A meta-circular evaluator is a special case of a self-interpreter in which the existing facilities of the parent interpreter are directly applied to the source code being interpreted, without any need for additional parsing. ...

Implementation techniques

For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-based Warren Abstract Machine (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 techniques for Prolog code is a field of active research in the logic programming community, and various other execution techniques are employed in some implementations. These include clause binarization and stack-based virtual machines. In 1983, David H. D. Warren designed an abstract machine for the execution of Prolog consisting of a memory architecture and an instruction set [War83]. This design became known as the Warren Abstract Machine (WAM) and has become the de facto standard target for Prolog compilers. ... In computer science, abstract interpretation is a theory of sound approximation of the semantics of computer programs, based on monotonic functions over ordered sets, especially lattices. ...

Examples

Here follow some example programs written in Prolog.

QuickSort

The QuickSort sorting algorithm, relating a list to its sorted version: Quicksort in action on a list of random numbers. ...

 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]) --> { partition(Xs, X, Smaller, Bigger) }, quicksort(Smaller), [X], quicksort(Bigger). 

Turing machine

Turing completeness of Prolog can be shown by using it to simulate a Turing machine: In computability theory, an abstract machine or programming language is called Turing complete, Turing equivalent, or (computationally) universal if it has a computational power equivalent to a universal Turing machine (a simplified model of a programmable computer). ...

 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 example 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. As another example for this, an optimizing compiler 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. 

Dynamic programming

A Prolog program can modify its own clause database at run time. This can make programs harder to understand and also slower than purely logical versions. In some cases though, dynamic updates of the database are very useful and can improve efficiency considerably, in particular for dynamic programming problems. As an example, consider the task of finding the longest common subsequence of two lists. A naive solution is: In mathematics and computer science, dynamic programming is a method of solving problems exhibiting the properties of overlapping subproblems and optimal substructure (described below) that takes much less time than naive methods. ... The longest common subsequence problem (LCS) is finding a longest sequence which is a subsequence of all sequences in a set of sequences (often just two). ...

 lcs([], _, []) :- !. lcs(_, [], []) :- !. lcs([X|Xs], [X|Ys], [X|Ls]) :- !, lcs(Xs, Ys, Ls). lcs([X|Xs], [Y|Ys], Ls) :- lcs([X|Xs], Ys, Ls1), lcs(Xs, [Y|Ys], Ls2), length(Ls1, L1), length(Ls2, L2), ( L1 >= L2 -> Ls = Ls1 ; Ls = Ls2 ). 

In Prolog systems that support tabling, such as BProlog and XSB, this exponential-time program can be turned into a solution with polynomial runtime by just adding a declaration like: B-Prolog is a high-performance, high-quality, and award-wining implementation of the standard Prolog language with several useful extended features including action rules for event handling, finite-domain constraint solving, and tabling. ... The XSB (Xtreme Student Body) is a fantasy football league founded in 2002 at the University of Mississippi by then-student Will Bardwell. ...

 :- table lcs/3. 

This advises the system to store intermediate results for this predicate. The same effect can be achieved manually in other Prolog systems by using the clause database for memoization. This requires only very few and purely mechanical changes to the original program: Memoization is a technique used to speed up computer programs by storing the results of functions for later reuse, rather than recomputing them. ...

 :- dynamic stored/1. memo(Goal) :- ( stored(Goal) -> true ; Goal, assertz(stored(Goal)) ). lcs([], _, []) :- !. lcs(_, [], []) :- !. lcs([X|Xs], [X|Ys], [X|Ls]) :- !, memo(lcs(Xs, Ys, Ls)). lcs([X|Xs], [Y|Ys], Ls) :- memo(lcs([X|Xs], Ys, Ls1)), memo(lcs(Xs, [Y|Ys], Ls2)), length(Ls1, L1), length(Ls2, L2), ( L1 >= L2 -> Ls = Ls1 ; Ls = Ls2 ). 

Example query:

 ?- lcs([x,m,j,y,a,u,z], [m,z,j,a,w,x,u], Ls). Ls = [m, j, a, u] 

Extensions

• Constraint logic programming is important for many Prolog applications in industrial settings, like time tabling and other scheduling tasks. Most Prolog systems ship with at least one constraint solver for finite domains, and often also with solvers for other domains like rational numbers.
• HiLog and λProlog extend Prolog with higher-order programming features.
• F-logic extends Prolog with frames/objects for knowledge representation.
• OW Prolog has been created in order to answer Prolog's lack of graphics and interface.
• Logtalk is an open source object-oriented extension to the Prolog programming language. Integrating logic programming with object-oriented and event-driven programming, it is compatible with most Prolog compilers. It supports both prototypes and classes. In addition, it supports component-based programming through category-based composition.
• Prolog-MPI is an open-source SWI-Prolog extension for distributed computing over the Message Passing Interface.

Bold textConstraint logic programming is a form of constraint programming, in which logic programming is extended to include concepts from constraint satisfaction. ... λProlog, also written lambda Prolog, is a strongly-typed functional logic programming language. ... Higher-order programming is programming that exploits the ability to use functions as values; it is usually borrowed from models of computation like the lambda calculus which make heavy use of higher-order functions. ... F-logic (frame logic) is a knowledge representation- and ontology language. ... Knowledge representation is an issue that arises in both cognitive science and artificial intelligence. ... Logtalk is an open source object-oriented extension to Prolog. ... SWI-Prolog is an open source implementation of the programming language Prolog, commonly used for teaching. ... The Message Passing Interface (MPI) is a computer communications protocol. ...

Related languages

• Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog. Visual Prolog is a strongly-typed object-oriented dialect of Prolog, which is considerably different from standard Prolog. As Turbo Prolog it was marketed by Borland, but it is now developed and marketed by the Danish firm PDC (Prolog Development Center) that originally produced it.
• Datalog is actually 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.
• In some ways Prolog is a subset of Planner, e.g., see Kowalski's early history of logic programming. The ideas in Planner were later further developed in the Scientific Community Metaphor.

Frameworks also exist which can provide a bridge between Prolog and the Java programming language: Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. ... Datalog is a query and rule language for deductive databases that syntactically is a subset of Prolog. ... Planner (often seen in publications as PLANNER) is a programming language designed by Carl Hewitt at MIT, and first published in 1969. ... The Scientific Community Metaphor is an approach in computer science to understanding and performing scientific communities. ... Java is an object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s. ...

• InterProlog, a programming library bridge between 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 GUIs and other functionality in Java while leaving logic processing in the Prolog layer. Supports XSB, SWI-Prolog and YAP.
• 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 and declarative programming.

The Java platform is the name for a computing environment, or platform, from Sun Microsystems which can run applications developed using the Java programming language and set of development tools. ... A graphical user interface (GUI) is a type of user interface which allows people to interact with a computer and computer-controlled devices which employ graphical icons, visual indicators or special graphical elements called widgets, along with text labels or text navigation to represent the information and actions available to... The XSB (Xtreme Student Body) is a fantasy football league founded in 2002 at the University of Mississippi by then-student Will Bardwell. ... SWI-Prolog is an open source implementation of the programming language Prolog, commonly used for teaching. ... Prova is a software language which combines Prolog with Java. ... In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ... Declarative programming is a term with two distinct meanings, both of which are in current use. ...

See also

• Alice
• Oz
• Mercury
• PDC Prolog
• LISP
• Poplog
• Constraint satisfaction
• Robert Kowalski
• Alain Colmerauer
• Comparison of Prolog implementations
• Prolog standards compliance

Alice is a functional programming language designed by the Programming Systems Lab at Saarland University. ... Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Saarland University. ... Mercury is a functional/logical programming language based on Prolog, but designed to be more useful for real-world programming problems. ... Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. ... Lisp is a family of computer programming languages with a long history and a distinctive fully-parenthesized syntax. ... Poplog is a powerful multi-language reflective programming environment, originally created in the UK for use at the Universities of Birmingham and Sussex. ... In artificial intelligence and operations research, constraint satisfaction is the process finding a solution to a set of constraints. ... Robert Anthony Kowalski (Bob Kowalski, born May 15, 1941 in Bridgeport, Connecticut, USA) is an American logician and computer scientist, who has spent much of his career in the UK. He was educated at the University of Chicago, University of Bridgeport (BA in mathematics, 1963), Stanford University (MSc in mathematics... Professor Alain Colmerauer is the creator of the logic programming language Prolog for computers. ... The following Comparison of Prolog implementations provides a reference for the relative feature sets of different implementations of the Prolog computer programming language. ... Prolog is a logic programming language. ...

References

• Richard O'Keefe, The Craft of Prolog, ISBN 0-262-15039-5.

Ivan Bratko, Slovenian computer scientist, * 10 June 1946, Ljubljana. ... This article does not cite any references or sources. ... Dr Richard A. OKeefe is computer scientist, currently working in Department of Computer Science, University of Otago, Dunedin, New Zealand. ...

External links

• Literate programming in Prolog
• Prolog Tutorial by J.R.Fisher
• Visual Prolog Tutorial
• Runnable examples by Lloyd Allison
• Prolog Programming A First Course by Paul Brna
• Adventure in Prolog, online book by Amzi! Inc.
• On-line guide to Prolog Programming by Roman Bartak
• Prolog minibook by Faiz ul haque Zeya
• Learn Prolog Now! by Patrick Blackburn, Johan Bos and Kristina Striegnitz
• Prolog and Logic Programming by Dr Peter Hancox
• Strawberry Prolog Help, online help
• Building Expert Systems in Prolog, online book by Amzi! Inc.
• comp.lang.prolog FAQ
• Prolog: The ISO standard
• Prolog Development Center