Prolog 23485 224018709 2008-07-06T23:23:31Z 82.58.25.177 Exchanged name/page for tuProlog {{two other uses|the programming language|the sense of an introduction|prologue|the company|Cyan Worlds}} {{ infobox programming language | paradigm = [[Logic programming]] | year = 1972 | designer = [[Alain Colmerauer]] | implementations = [[BProlog]], [[ECLiPSe]], [[Ciao Prolog]], [[GNU Prolog]], Quintus, SICStus, [[Strawberry Prolog|Strawberry]], [[SWI-Prolog]], [[YAP-Prolog]], [[TuProlog|tuProlog]] | dialects = ISO Prolog, Edinburgh Prolog | influenced = [[Visual Prolog]], [[Mercury programming language|Mercury]], [[Oz programming language|Oz]], [[Erlang programming language|Erlang]], [[Strand (programming language)|Strand]], [[KL0]], [[KL1]] }} '''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. Having its roots in [[formal logic]], and unlike many other programming languages, Prolog is [[declarative programming|declarative]]: The program logic is expressed in terms of relations, and execution is triggered by running ''queries'' 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 (logic)|resolution]] [[refutation]] 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 of the program. This makes Prolog (and other logic programming languages) particularly useful for database, symbolic mathematics, and language parsing applications. Because Prolog allows impure [[predicates]], checking the truth value of certain special predicates may have some deliberate side effect, such as printing a value to the screen. This permits the programmer to use some amount of conventional [[imperative programming]] when the logical paradigm is inconvenient. The language was first conceived by a group around [[Alain Colmerauer]] in [[Marseille]], [[France]], in the early [[1970s]], while the first compiler was written by [[David H. D. Warren]] in [[Edinburgh, Scotland]]. Prolog was one of the first logic programming languages, and remains among the most popular such languages today, with many free and commercial implementations available. While initially aimed at natural language processing, the language has since then stretched far into other areas like theorem proving, [[expert systems]], games, automated answering systems, ontologies and sophisticated control systems, and modern Prolog environments support the creation of graphical user interfaces, as well as administrative and networked applications. ==History== The name ''Prolog'' was chosen by [[Philippe Roussel]] as an abbreviation for ''{{lang|fr|programmation en logique}}'' ([[French language|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 clause]]s. 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. 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 ''[[KL1|Kernel Language]]'' for its first [[operating system]]. Pure Prolog was originally restricted to the use of a [[resolution (logic)|resolution]] theorem prover with [[Horn clause]]s of the form: <tt>H :- B<sub>1</sub>, …, B<sub>n</sub>.</tt>. The application of the theorem-prover treats such clauses as procedures: to show/solve <tt>H</tt>, show/solve <tt>B<sub>1</sub></tt> and … and <tt>B<sub>n</sub></tt>. Pure Prolog was soon extended, however, to include [[negation as failure]], in which negative conditions of the form not(B<sub>i</sub>) are shown by trying and failing to solve the corresponding positive conditions B<sub>i</sub>. == Data types == Prolog's single data type is the ''term''. Terms are either ''atoms'', ''numbers'', ''variables'' or ''compound terms''. An '''atom''' is a general-purpose name with no inherent meaning. It is composed of a sequence of characters that is parsed by the Prolog reader as a single unit. Atoms are usually bare words in Prolog code, written with no special syntax. However, atoms containing spaces or certain other special characters must be surrounded by single quotes. Atoms beginning with a capital letter must also be quoted, to distinguish them from variables. The empty list, written <code>[]</code>, is also an atom. Other examples of atoms include <code>x</code>, <code>blue</code>, <code>'Taco'</code>, and <code>'some atom'</code>. '''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 (bound to equal a specific term) via [[unification]]. A single underscore (<code>_</code>) denotes an anonymous variable and means "any term". Unlike other variables, the underscore does not represent the same value everywhere it occurs within a predicate definition. 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]]. An atom can be regarded as a compound term with [[arity]] zero. Examples of compound terms are <code>truck_year('Mazda', 1986)</code> and <code>'Person_Friends'(zelda,[tom,jim])</code>. Compound terms with functors that are declared as operators can be written in prefix or infix notation. For example, the terms <code>-(z)</code>, <code>+(a,b</code>) and <code>=(X,Y)</code> can also be written as <code>-z</code>, <code>a+b</code> and <code>X=Y</code>, respectively. Users can declare arbitrary functors as operators with different precedences 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 <code>[]</code> is a list. A compound term with functor <code>.</code> (dot) and arity 2, whose second argument is a list, is itself a list. There exists special syntax for denoting lists: <code>.(A, B)</code> is equivalent to <code>[A|B]</code>. For example, the list <code>.(1, .(2, .(3, [])))</code> can also be written as <code>[1 | [2 | [3 | []]]]</code>, or even more compactly as <code>[1,2,3]</code>. * ''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. == Programming in Prolog == Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted to [[Horn clauses]], a [[Turing completeness|Turing-complete]] subset of first-order [[predicate logic]]. There are two types of clauses: Facts and rules. 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 [[Predicate (mathematics)|predicate]] <code>,/2</code> (meaning a 2-arity operator with name <code>,</code>) denotes [[Logical conjunction|conjunction]] of goals, and <code>;/2</code> denotes [[Logical disjunction|disjunction]]. 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 <code>true/0</code> is always true. Given above fact, one can ask: ''is tom a cat?'' ?- cat(tom). Yes ''what things are cats?'' ?- cat(X). X = tom Due to the relational nature of many built-in predicates, they can typically be used in several directions. For example, <code>length/2</code> can be used to determine the length of a list (<tt>length(List, L)</tt>, given a list <tt>List</tt>) as well as to generate a list skeleton of a given length (<tt>length(X, 5)</tt>), and also to generate both list skeletons and their lengths together (<tt>length(X, L)</tt>). Similarly, <code>append/3</code> can be used both to append two lists (<tt>append(ListA, ListB, X)</tt> given lists <tt>ListA</tt> and <tt>ListB</tt>) as well as to split a given list into parts (<tt>append(X, Y, List)</tt>, given a list <tt>List</tt>). 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. 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 <tt>write/1</tt> 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 (logic)|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: 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. 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|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. == Negation == The built-in Prolog predicate \+/1 provides [[negation as failure]], which allows for [[non-monotonic logic|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 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 ([[Definite_clause_grammar|DCG]]s). 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_functional_programming|monads]] in other languages. DCGs are often used to write parsers or list generators, as they also provide a convenient interface to list differences. ===Parser example=== A larger example will show the potential of using Prolog in parsing. Given the sentence expressed in [[Backus-Naur form|BNF]]: <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, corresponding to a predictive parser with one token look-ahead: 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]. This code defines a relation between a sentence (given as a list of tokens) and its [[abstract syntax tree]] (AST). Example query: ?- phrase(sentence(AST), [a,=,1,+,3,*,b,;,b,=,0,;]). AST = 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(Tokens, _), phrase(sentence(AST), Tokens). Tokens = [a, =, a, (;)], AST = assign(a, id(a)) ; Tokens = [a, =, b, (;)], AST = 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]]. 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: 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 (computer science)|reflection]]. Its implicit execution strategy makes it possible to write a concise [[meta-circular evaluator]] (also called ''meta-interpreter'') 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. ==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. Some Prolog systems, like [[BProlog]] and [[XSB]], implement an extension called ''tabling'', which frees the user from manually storing intermediate results. == Examples == Here follow some example programs written in Prolog. === QuickSort === The [[QuickSort]] 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]) --> { 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: 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 === The following Prolog program uses [[dynamic programming]] to find the [[longest common subsequence]] of two lists in polynomial time. The clause database is used for [[memoization]]: :- 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. * [http://apps.lumii.lv/prolog-mpi/ Prolog-MPI] is an open-source [[SWI-Prolog]] extension for distributed computing over the [[Message Passing Interface]]. * [[Oblog]] is a small, portable, Object-oriented extension to Prolog by Margaret McDougall of EdCAAD, University of Edinburgh. == 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 programming language|Planner]]. 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]]: * [http://www.declarativa.com/interprolog/ InterProlog], a programming 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 interface|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 programming|imperative]] and [[declarative programming]]. == See also == * [[Comparison of Prolog implementations]] * [[Prolog standards compliance]] == References == {{refbegin|2}} * Michael A. Covington, Donald Nute, Andre Vellino, ''Prolog Programming in Depth'', 1996, ISBN 0-13-138645-X. * Michael A. Covington, ''Natural Language Processing for Prolog Programmers'', 1994, ISBN 0-13-629213-5. * Leon Sterling and Ehud Shapiro, ''The Art of Prolog: Advanced Programming Techniques'', 1994, ISBN 0-262-19338-8. * [[Ivan Bratko]], ''PROLOG Programming for Artificial Intelligence'', 2000, ISBN 0-201-40375-7. * Robert Kowalski, [http://www.doc.ic.ac.uk/~rak/papers/the%20early%20years.pdf ''The Early Years of Logic Programming''], CACM January 1988. * ''ISO/IEC 13211: Information technology &mdash; Programming languages &mdash; Prolog''. [[International Organization for Standardization]], Geneva. * Alain Colmerauer and Philippe Roussel, [http://www.lim.univ-mrs.fr/~colmer/ArchivesPublications/HistoireProlog/19november92.pdf ''The birth of Prolog''], in ''The second ACM SIGPLAN conference on History of programming languages'', p. 37-52, 1992. * [[Richard O'Keefe]], ''The Craft of Prolog'', ISBN 0-262-15039-5. * Patrick Blackburn, Johan Bos, Kristina Striegnitz, ''Learn Prolog Now!'', 2006, ISBN 1-904987-17-6. {{refend}} == External links == {{wikibooks}} * [http://www.cs.kuleuven.ac.be/~remko/prolog/faq/files/faq.html comp.lang.prolog FAQ] * [http://pauillac.inria.fr/~deransar/prolog/docs.html Prolog: The ISO standard] * [http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/contents.html Prolog Tutorial] by J.R.Fisher * [http://www.allisons.org/ll/Logic/Prolog/Examples/ Runnable examples] by Lloyd Allison * [http://kti.ms.mff.cuni.cz/~bartak/prolog/index.html On-line guide to Prolog Programming] by Roman Bartak * [http://www.coli.uni-saarland.de/~kris/learn-prolog-now/ Learn Prolog Now!] by Patrick Blackburn, Johan Bos and Kristina Striegnitz * [http://www.cs.bham.ac.uk/~pjh/prolog_course/se207.html Prolog and Logic Programming] by Dr Peter Hancox * [http://www.amzi.com/ExpertSystemsInProlog/index.htm Building Expert Systems in Prolog], online book by Amzi! Inc. * [http://en.literateprograms.org/Category:Programming_language:Prolog Literate programming in Prolog] [[Category:Prolog programming language family]] [[Category:Computer and telecommunication standards]] [[Category:Declarative programming languages]] [[ar:برولوغ]] [[an:Prolog]] [[ast:Prolog]] [[bg:Пролог]] [[ca:Prolog]] [[cs:Prolog (programovací jazyk)]] [[da:Prolog (programmeringssprog)]] [[de:Prolog (Programmiersprache)]] [[es:Prolog]] [[eo:Prolog]] [[fr:Prolog]] [[gl:Prolog]] [[ko:프롤로그]] [[io:Prolog]] [[id:Prolog]] [[is:Prolog (forritunarmál)]] [[it:Prolog]] [[he:פרולוג (שפת תכנות)]] [[lt:Prolog]] [[jbo:prolog]] [[hu:Prolog programozási nyelv]] [[nl:Prolog]] [[ja:Prolog]] [[no:Prolog (programmeringsspråk)]] [[pl:Prolog (język programowania)]] [[pt:Prolog]] [[ro:Prolog]] [[ru:Пролог (язык программирования)]] [[sk:Prolog]] [[sl:Prolog]] [[fi:Prolog]] [[sv:Prolog]] [[th:ภาษาโปรล็อก]] [[tr:Prolog]] [[uk:Пролог (мова програмування)]] [[bat-smg:Prolog]] [[zh:Prolog]]