Prolog

This article is about the programming language. For the narrative device, seePrologue.For other uses, seePrologue (disambiguation).

Prologis alogic programminglanguage that has its origins inartificial intelligence,automated theorem provingandcomputational linguistics.

Prolog

Paradigm	Logic
Designed by	Alain Colmerauer
First appeared	1972(1972)
Stable release	Part 1: General core-Edition 1 (June 1995(1995-06)) Part 2: Modules-Edition 1 (June 2000(2000-06))
Typing discipline	Untyped (its single data type is "term" )
Filename extensions	.pl,.pro,.P
Website	Part 1:www.iso.org/standard/21413.html Part 2:www.iso.org/standard/20775.html
Majorimplementations
Amzi! Prolog,B-Prolog,Ciao,ECLiPSe,GNU Prolog,LPA Prolog,Poplog,P#,Quintus Prolog,Scryer Prolog,SICStus,Strawberry,SWI-Prolog,Tau Prolog,tuProlog,WIN-PROLOGXSB,YAP.
Dialects
ISO Prolog,Edinburgh Prolog
Influenced by
Planner
Influenced
CHR,Clojure,Datalog,Erlang,Epilog,KL0,KL1,Logtalk,Mercury,Oz,Strand,Visual Prolog
Prologat Wikibooks

Prolog has its roots infirst-order logic,aformal logic,and unlike many otherprogramming languages,Prolog is intended primarily as adeclarative programminglanguage: the program is a set of facts andrules,which definerelations.Acomputationis initiated by running aqueryover the program.

Prolog was one of the first logic programming languagesand remains the most popular such language today, with several free and commercial implementations available. The language has been used fortheorem proving,expert systems,term rewriting,type systems,andautomated planning,as well as its original intended field of use,natural language processing.

Prolog is a Turing-complete, general-purpose programming language, which is well-suited for intelligent knowledge-processing applications.

Syntax and semantics

Main article:Prolog syntax and semantics

In Prolog, program logic is expressed in terms of relations, and a computation is initiated by running aqueryover these relations. Relations and queries are constructed using Prolog's single data type, theterm.Relations are defined byclauses.Given a query, the Prolog engine attempts to find aresolutionrefutationof 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 alogical consequenceof the program. This makes Prolog (and other logic programming languages) particularly useful for database,symbolic mathematics,and language parsing applications. Because Prolog allows impurepredicates,checking thetruth valueof certain special predicates may have some deliberateside effect,such as printing a value to the screen. Because of this, the programmer is permitted to use some amount of conventionalimperative programmingwhen 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 singledata typeis theterm.Terms are eitheratoms,numbers,variablesorcompound terms.

• Anatomis a symbol name starting with a lower case letter or guarded by quotes. Examples of atoms includex,red,'Taco','some atom',and'p(a)'.
• Numberscan befloatsorintegers.Most of the major Prolog systems support arbitrary length integer numbers.
• Variablesare 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.
• Acompound termis 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'sarity.An atom can be regarded as a compound term witharityzero. An example of a compound term isperson_friends(zelda,[tom,jim]).

Special cases of compound terms:

• AListis 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 flagdouble_quotes.For example,"to be, or not to be".

Rules and facts

Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted toHorn clauses.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'sgoals.The built-inlogical operator,/2(meaning an arity 2operatorwith name,) denotesconjunctionof goals, and;/2denotesdisjunction.Conjunctions and disjunctions can only appear in the body, not in the head of a rule.

Clauses with empty bodies are calledfacts.An example of a fact is:

human(socrates).

which is equivalent to the rule:

human(socrates):-true.

The built-in predicatetrue/0is 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 calledrules.An example of a rule is:

mortal(X):-human(X).

If we add that rule and askwhat things are mortals?

?-mortal(X).
X=socrates

Predicates and programs

Apredicate(orprocedure definition) is a collection of clauses whose heads have the same name and arity. We use the notationname/arityto refer to predicates. Alogic programis 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).

parent_child(X,Y):-father_child(X,Y).
parent_child(X,Y):-mother_child(X,Y).

Predicatefather_child/2has three clauses, all of which are facts, and predicateparent_child/2has 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/2can be used to determine the length of a list (length(List, L),given a listList), 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/3can be used both to append two lists (append(ListA, ListB, X)given listsListAandListB), and to split a given list into parts (append(X, Y, List),given a listList). 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 likeinput/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 predicatewrite/1displays a term on the screen.

Loops and recursion

Iterative algorithms can be implemented by means of recursive predicates.

Consider theparent_child/2predicate defined in the family relation program above. The following Prolog program defines theancestorrelation:

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 predicateancestor/2in 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 aresolutionrefutation of the negated query. The resolution method used by Prolog is calledSLD 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,unifiesthe 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 chronologicalbacktracking.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 querysibling(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 isfather_child(Z, sally).This goal can be proved using the factfather_child(tom, sally),so the bindingZ = tomis 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\+/1providesnegation as failure,which allows fornon-monotonicreasoning. The goal\+ illegal(X)in the rule

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

is evaluated as follows: Prolog attempts to proveillegal(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\+/1prefix operator is called the "not provable" operator, since the query?- \+ Goal.succeeds if Goal is not provable. This kind of negation issoundif 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 asconsulting.Prolog can be used interactively by entering queries at the Prolog prompt?-.If there is no solution, Prolog writesno.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:

SWI-Prolog	GNU Prolog
?-write('Hello World!'),nl. HelloWorld! true. ?-	|?-write('Hello World!'),nl. HelloWorld! yes |?-

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, anoptimizing compilerwith 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 usingDCGnotation:

program_optimized-->optimization_pass_1,optimization_pass_2,optimization_pass_3.

Quicksort

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

Design patterns of Prolog

Adesign patternis a general reusable solution to a commonly occurring problem insoftware design.Some design patterns in Prolog are skeletons, techniques,cliches,program schemata,logic description schemata,andhigher-order programming.

Higher-order programming

Main articles:Higher-order logicandHigher-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 ascall/1,call/2,call/3,findall/3,setof/3,andbagof/3.Furthermore, since arbitrary Prolog goals can be constructed and evaluated at run-time, it is easy to write higher-order predicates likemaplist/2,which applies an arbitrary predicate to each member of a given list, andsublist/3,which filters elements that satisfy a given predicate, also allowing forcurrying.

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 forlist comprehension.For example,perfect numbersequal the sum of their proper divisors:

perfect(N):-
between(1,inf,N),UisN//2,
findall(D,(between(1,U,D),NmodD=:=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 predicatemaplistapplies a predicatePto all corresponding positions in a pair of lists:

maplist(_,[],[]).
maplist(P,[X|Xs],[Y|Ys]):-
call(P,X,Y),
maplist(P,Xs,Ys).

WhenPis a predicate that for allX,P(X,Y)unifiesYwith a single unique value,maplist(P, Xs, Ys)is equivalent to applying themapfunction infunctional programmingasYs = map(Function, Xs).

Higher-order programming style in Prolog was pioneered inHiLogandλProlog.

Modules

Forprogramming in the large,Prolog provides amodule 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, mostProlog systemshave decided to support asde-factomodule standard theQuintus/SICStusmodule 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 ofLogtalk.GNU Prolog initially diverted from ISO modules, opting instead forContextual Logic Programming,in which unit (module) loading and unloading can be made dynamically.Ciaodesigned a strict module system that, while being basically compatible with thede-factostandard used by other Prolog systems, is amenable to precise static analysis, supports term hiding, and facilitates programming in the large.XSBtakes a different approach and offers anatom-basedmodule system.The latter two Prolog systems allow controlling thevisibility of termsin addition to that of predicates.

Parsing

Main articles:Prolog syntax and semantics § Definite clause grammars,andDefinite clause grammar

There is a special notation calleddefinite clause grammars(DCGs). A rule defined via-->/2instead of:-/2is 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 tomonadsin 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 ahomoiconiclanguage and provides many facilities forreflective programming(reflection). Its implicit execution strategy makes it possible to write a concisemeta-circular evaluator(also calledmeta-interpreter) for pure Prolog code:

solve(true).
solve((Subgoal1,Subgoal2)):-
solve(Subgoal1),
solve(Subgoal2).
solve(Head):-
clause(Head,Body),
solve(Body).

wheretruerepresents an empty conjunction, andclause(Head, Body)unifies with clauses in the database of the formHead:- Body.

Since Prolog programs are themselves sequences of Prolog terms (:-/2is an infixoperator) that are easily read and inspected using built-in mechanisms (likeread/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),
Certaintyismin(Certainty1,Certainty2).
solve(Goal,1):-
builtin(Goal),!,
Goal.
solve(Head,Certainty):-
clause_cf(Head,Body,Certainty1),
solve(Body,Certainty2),
CertaintyisCertainty1*Certainty2.

This interpreter uses a table of built-in Prolog predicates of the form

builtin(AisB).
builtin(read(X)).
% etc.

and clauses represented asclause_cf(Head, Body, Certainty).Given those, it can be called assolve(Goal, Certainty)to executeGoaland obtain a measure of certainty about the result.

Turing completeness

Pure Prolog is based on a subset of first-orderpredicate logic,Horn clauses,which isTuring-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

Further information:Comparison of Prolog implementations

ISO Prolog

TheInternational Organization for Standardization(ISO) Prologtechnical standardconsists of two parts. ISO/IEC 13211-1,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 theISO/IEC JTC1/SC22/WG17working 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-basedWarren Abstract Machine(WAM) instruction set.Some implementations employabstract interpretationto 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 includeclause binarizationandstack-based virtual machines.

Tail recursion

Prolog systems typically implement a well-known optimization method calledtail call optimization(TCO) for deterministic predicates exhibitingtail recursionor, 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

Main article:Term indexing

Finding clauses that are unifiable with a term in a query is linear in the number of clauses.Term indexinguses adata structurethat enablessub-linear-timelookups.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 onfield-encoded wordsorsuperimposedcodewordsprovide fast indexing across the full query and head.

Hashing

Some Prolog systems, such asWIN-PROLOGand 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 asWordNet.

Tabling

Main article:Tabled logic programming

Some Prolog systems, (B-Prolog,XSB,SWI-Prolog,YAP,andCiao), implement amemoizationmethod calledtabling,which frees the user from manually storing intermediate results. Tabling is aspace–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 throughSLG resolutionor 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 theFifth 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 afield programmable gate array.However, rapid progress in general-purpose hardware has consistently overtaken more specialised architectures.

Segaimplemented Prolog for use with the Sega AI Computer, released for the Japanese market in 1986. Prolog was used for readingnatural languageinputs, in theJapanese language,via atouch pad.

Limits

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.Most applications are small by industrial standards, with few exceeding 100,000 lines of code.Programming in the largeis 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 thecut 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 asDatalog,are truly declarative but restrict the language. As a result, many practical Prolog programs are written to conform to Prolog'sdepth-first searchorder, rather than as purely declarative logic programs.

Extensions

Various implementations have been developed from Prolog to extend logic programming abilities in many directions. These includetypes,modes,constraint logic programming(CLP),object-orientedlogic programming (OOLP), concurrency,linear logic(LLP), functional andhigher-order logicprogramming abilities, plus interoperability withknowledge bases:

Types

Prolog is an untyped language. Attempts to introduce and extend Prolog with types began in the 1980s,and continue as of 2008.Type information is useful not only fortype safetybut also for reasoning about Prolog programs.

Modes

Mode specifier	Interpretation
+	nonvaron entry
-	varon entry
?	Not specified

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 programsand can also be used to accelerate execution.

Constraints

Constraint logic programmingextends Prolog to include concepts fromconstraint 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-scalecombinatorial optimisationproblemsand is thus useful for applications in industrial settings, such as automated time-tabling andproduction scheduling.Most Prolog systems ship with at least one constraint solver for finite domains, and often also with solvers for other domains likerational numbers.

Object-orientation

Flora-2is an object-oriented knowledge representation and reasoning system based onF-logicand incorporatesHiLog,Transaction logic,anddefeasible reasoning.

Logtalkis 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.

Oblogis a small, portable, object-oriented extension to Prolog by Margaret McDougall of EdCAAD, University of Edinburgh.

Objlogwas a frame-based language combining objects and Prolog II from CNRS, Marseille, France.

Prolog++was developed byLogic Programming Associatesand 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 Prologis a multi-paradigm language with interfaces, classes, implementations and object expressions.

Graphics

Prolog systems that provide agraphics libraryareSWI-Prolog,Visual Prolog,WIN-PROLOG,andB-Prolog.

Concurrency

Prolog-MPI is an open-sourceSWI-Prologextension fordistributed computingover theMessage Passing Interface.Also there are various concurrent Prolog programming languages.

Web programming

Some Prolog implementations, notablyVisual Prolog,SWI-PrologandCiao,supportserver-sideweb programmingwith support for web protocols,HTMLandXML.There are also extensions to supportsemantic webformats such asResource Description Framework(RDF) andWeb Ontology Language(OWL).Prolog has also been suggested as aclient-sidelanguage.In addition, Visual Prolog supportsJSON-RPCandWebsockets.

Adobe Flash

CedarArchived2010-10-19 at theWayback Machineis 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 throughActionScript.

Other

• F-logicextends Prolog with frames/objects forknowledge representation.
• Transaction logicextends Prolog with a logical theory of state-changing update operators. It has both a model-theoretic and procedural semantics.
• OW Prologhas 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:

• TheLPA Intelligence Serverallows embeddingLPA Prolog for Windowsin other programming languages, including:C,C++,C#,Java,Visual Basic(VB),Delphi,.NET,Lua,Python,and others. It exploits the dedicated string data type which LPA Prolog provides
• TheLogic ServerApplication Programming Interface (API) allows both the extension and embedding of Prolog inC,C++,Java,Visual Basic(VB),Delphi,.NET,and any language or environment which can call a.dll or.so. It is implemented forAmzi! Prolog + Logic Serverbut the API specification can be made available for any implementation.
• JPLis 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 programminglibrarybridge betweenJavaand Prolog, implementing bi-directional predicate/method calling between both languages. Java objects can be mapped into Prolog terms and vice versa. Allows the development ofgraphical user interfaces(GUIs) and other functions in Java while leaving logic processing in the Prolog layer. SupportsXSBandSWI-Prolog.
• Provaprovides 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 combiningimperativeanddeclarative programming.
• PROLAn embeddable Prolog engine for Java. It includes a small IDE and a few libraries.
• GNU Prolog for Javais an implementation of ISO Prolog as a Java library (gnu.prolog)
• Ciaoprovides interfaces to C, C++, Java, and relational databases.
• C#-Prologis 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 PHPA Prolog compiler and interpreter in PHP 5.3. A library that can be used standalone or within Symfony2.1 framework which was translated fromStephan Buettcher'swork in Java which can be found [herestefan.buettcher.org/cs/wam/]
• tuPrologis 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.
• Janusis a bi-directional interface between Prolog and Python using portable low-level primitives. It was initially developed for XSB by Anderson and Swift,but has been adopted as a joint initiative by the XSB, Ciao and SWI-Prolog teams.

History

Timeline of early developments in Prolog

The namePrologwas chosen by Philippe Roussel, at the suggestion of his wife, as an abbreviation forprogrammation en logique(Frenchforprogramming inlogic).It was created around 1972 byAlain Colmerauerwith Philippe Roussel, based onRobert Kowalski's procedural interpretation ofHorn 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. According toRobert Kowalski,the first Prolog system was developed in 1972 by Colmerauer and Phillipe Roussel.The first implementation of Prolog was an interpreter written inFortranby Gerard Battani and Henri Meloni.David H. D. Warrentook this interpreter to theUniversity of Edinburgh,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 theWarren Abstract Machine.

European AI researchers favored Prolog while Americans favoredLisp,reportedly causing many nationalistic debates on the merits of the languages.Much of the modern development of Prolog came from the impetus of theFifth Generation Computer Systems project(FGCS), which developed a variant of Prolog namedKernel Languagefor its firstoperating system.

Pure Prolog was originally restricted to the use of aresolutiontheorem prover withHorn clausesof the form:

H:- B1,..., Bn.

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

to show/solve H, show/solve B1and... and Bn.

Pure Prolog was soon extended, however, to includenegation 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.

Subsequent extensions of Prolog by the original team introducedconstraint logic programmingabilities into the implementations.

Use in industry

Prolog has been used inWatson.Watson uses IBM's DeepQA software and the ApacheUIMA(Unstructured Information Management Architecture) framework. The system was written in various languages, including Java, C++, and Prolog, and runs on theSUSE Linux Enterprise Server11 operating system usingApache Hadoopframework to provide distributed computing. Prolog is used forpattern matchingover 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 andexpressiveness."Prolog is being used in the Low-Code Development PlatformGeneXus,which is focused around AI.Open sourcegraph databaseTerminusDBis implemented in Prolog.TerminusDB is designed for collaboratively building and curatingknowledge graphs.

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

• TheGödellanguage is a strongly typed implementation ofconcurrent constraint logic programming.It is built onSICStus Prolog.
• Visual Prolog,formerly named PDC Prolog and Turbo Prolog, is astrongly typedobject-orienteddialect 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.
• Datalogis 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 notTuring-complete.
• Mercuryis 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 waysProlog is a subset ofPlanner.The ideas in Planner were later further developed in theScientific Community Metaphor.
• AgentSpeakis a variant of Prolog for programming agent behavior inmulti-agent systems.
• Erlangbegan life with a Prolog-based implementation and maintains much of Prolog's unification-based syntax.
• Pilogis a declarative language built on top ofPicoLisp,that has the semantics of Prolog, but uses the syntax of Lisp.
• λPrologis 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.

Further reading

• Blackburn, Patrick; Bos, Johan; Striegnitz, Kristina (2006).Learn Prolog Now!.College Publications.ISBN978-1-904987-17-8.Archived fromthe originalon 2007-08-26.Retrieved2008-12-02.
• Ivan Bratko,Prolog Programming for Artificial Intelligence,4th ed., 2012,ISBN978-0-321-41746-6.Book supplements and source code
• William F. Clocksin, Christopher S. Mellish:Programming in Prolog: Using the ISO Standard.Springer, 5th ed., 2003,ISBN978-3-540-00678-7.(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,ISBN978-3-540-62971-9.
• Michael A. Covington,Donald Nute, Andre Vellino,Prolog Programming in Depth,1996,ISBN0-13-138645-X.
• Michael A. Covington,Natural Language Processing for Prolog Programmers,1994,ISBN978-0-13-629213-5
• 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,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 aCreative Commonslicense atsites.google.com/site/prologforprogrammers/).ISBN0-12-416521-4.
• Richard O'Keefe,The Craft of Prolog,ISBN0-262-15039-5.
• Robert Smith, John Gibson,Aaron Sloman:'POPLOG's two-level virtual machine support for interactive languages', inResearch Directions in Cognitive Science Volume 5: Artificial Intelligence,EdsD. Sleemanand N. Bernsen, Lawrence Erlbaum Associates, pp 203–231, 1992.
• Leon SterlingandEhud Shapiro,The Art of Prolog: Advanced Programming Techniques,1994,ISBN0-262-19338-8.
• 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.