Prolog
Paradigm | Logic |
---|---|
Designed by | Alain Colmerauer |
First appeared | 1972 |
Stable release | Part 1: General core-Edition 1 (June 1995 )Part 2: Modules-Edition 1 (June 2000 ) |
Typing discipline | Untyped (its single data type is "term") |
Filename extensions | .pl , .pro , .P |
Website | Part 1: www Part 2: www |
Major implementations | |
Amzi! Prolog, B-Prolog, Ciao, ECLiPSe, GNU Prolog, LPA Prolog, Poplog, P#, Quintus Prolog, Scryer Prolog, SICStus, Strawberry, SWI-Prolog, Tau Prolog, tuProlog, WIN-PROLOG XSB, YAP. | |
Dialects | |
ISO Prolog, Edinburgh Prolog | |
Influenced by | |
Planner | |
Influenced | |
CHR, Clojure, Datalog, Erlang, Epilog, KL0, KL1, Logtalk, Mercury, Oz, Strand, Visual Prolog | |
|
Prolog is a logic programming language that has its origins in artificial intelligence, automated theorem proving and computational linguistics.[1][2][3]
Prolog has its roots in
Prolog was one of the first logic programming languages
Prolog is a Turing-complete, general-purpose programming language, which is well-suited for intelligent knowledge-processing applications.
Syntax and semantics
In Prolog, program logic is expressed in terms of relations, and a computation is initiated by running a query over these relations. Relations and queries are constructed using Prolog's single data type, the term.
Data types
Prolog's single data type is the term. Terms are either atoms, numbers, variables or compound terms.[note 1]
- An atom is a symbol name starting with a lower case letter or guarded by quotes. Examples of atoms include
x
,red
,'Taco'
,'some atom'
, and'p(a)'
. - Numbers can be floats or integers. Most of the major Prolog systems support arbitrary length integer numbers.
- Variables are denoted by a string consisting of letters, numbers and underscore characters, and beginning with an upper-case letter or underscore. Variables closely resemble variables in logic in that they are placeholders for arbitrary terms.
- A compound term is composed of an atom called a "functor" and a number of "arguments", which are again terms. Compound terms are ordinarily written as a functor followed by a comma-separated list of argument terms, which is contained in parentheses. The number of arguments is called the term's arity. An atom can be regarded as a compound term with arity zero. An example of a compound term is
person_friends(zelda,[tom,jim])
.
Special cases of compound terms:
- A List is an ordered collection of terms. It is denoted by square brackets with the terms separated by commas, or in the case of the empty list, by
[]
. For example,[1,2,3,4]
or[red,green,blue]
. - Strings: A sequence of characters surrounded by quotes is equivalent to either a list of (numeric) character codes, a list of characters (atoms of length 1), or an atom depending on the value of the Prolog flag
double_quotes
. For example,"to be, or not to be"
.[13]
Rules and facts
Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted to Horn clauses. Two types of Horn clauses are used to define Prolog programs: 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
. Conjunctions and disjunctions can only appear in the body, not in the head of a rule.Clauses with empty bodies are called facts. An example of a fact is:
human(socrates).
which is equivalent to the rule:
human(socrates) :- true.
The built-in predicate true/0
is always true.
Given the above fact, one can ask:
is socrates a human?
?- human(socrates).
Yes
what things are humans?
?- human(X).
X = socrates
Clauses with bodies are called rules. An example of a rule is:
mortal(X) :- human(X).
If we add that rule and ask what things are mortals?
?- mortal(X).
X = socrates
Predicates and programs
A predicate (or procedure definition) is a collection of clauses whose heads have the same name and arity. We use the notation name/arity to refer to predicates. A logic program is a set of predicates. For example, the following Prolog program, which defines some family relations, has four predicates:
mother_child(trude, sally).
father_child(tom, sally).
father_child(tom, erica).
father_child(mike, tom).
sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y).
parent_child(X, Y) :- father_child(X, Y).
parent_child(X, Y) :- mother_child(X, Y).
Predicate father_child/2
has three clauses, all of which are facts, and predicate parent_child/2
has two clauses, both are rules.
Due to the relational nature of many built-in predicates, they can typically be used in several directions. For example, length/2
can be used to determine the length of a list (length(List, L)
, given a list List
), and to generate a list skeleton of a given length (length(X, 5)
), and to generate both list skeletons and their lengths together (length(X, L)
). Similarly, append/3
can be used both to append two lists (append(ListA, ListB, X)
given lists ListA
and ListB
), and to split a given list into parts (append(X, Y, List)
, given a list List
). For this reason, a comparatively small set of library predicates suffices for many Prolog programs.
As a general purpose language, Prolog also provides various built-in predicates to perform routine activities like input/output, using graphics and otherwise communicating with the operating system. These predicates are not given a relational meaning and are only useful for the side-effects they exhibit on the system. For example, the predicate write/1
displays a term on the screen.
Loops and recursion
Iterative algorithms can be implemented by means of recursive predicates.[14]
Consider the parent_child/2
predicate defined in the family relation program above. The following Prolog program defines the ancestor relation:
ancestor(X, Y) :- parent_child(X, Y).
ancestor(X, Y) :- parent_child(X, Z), ancestor(Z, Y).
It expresses that X is an ancestor of Y if X is parent of Y or X is parent of an ancestor of Y. It is recursive because it is defined in terms of itself (there is a call to predicate ancestor/2
in the body of the second clause).
Execution
Execution of a Prolog program is initiated by the user's posting of a single goal, called the query. Logically, the Prolog engine tries to find a resolution refutation of the negated query. The resolution method used by Prolog is called SLD resolution. 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, given the family relation program defined above, the following query will be evaluated to true:
?- sibling(sally, erica).
Yes
This is obtained as follows: Initially, the only matching clause-head for the query sibling(sally, erica)
is the first one, so proving the query is equivalent to proving the body of that clause with the appropriate variable bindings in place, i.e., the conjunction (parent_child(Z,sally), parent_child(Z,erica))
. The next goal to be proved is the leftmost one of this conjunction, i.e., parent_child(Z, sally)
. Two clause heads match this goal. The system creates a choice-point and tries the first alternative, whose body is father_child(Z, sally)
. This goal can be proved using the fact father_child(tom, sally)
, so the binding Z = tom
is generated, and the next goal to be proved is the second part of the above conjunction: parent_child(tom, erica)
. Again, this can be proved by the corresponding fact. Since all goals could be proved, the query succeeds. Since the query contained no variables, no bindings are reported to the user. A query with variables, like:
?- father_child(Father, Child).
enumerates all valid answers on backtracking.
Notice that with the code as stated above, the query ?- sibling(sally, sally).
also succeeds. One would insert additional goals to describe the relevant restrictions, if desired.
Negation
The built-in Prolog predicate \+/1
provides negation as failure, which allows for non-monotonic reasoning. The goal \+ illegal(X)
in the rule
legal(X) :- \+ illegal(X).
is evaluated as follows: Prolog attempts to prove illegal(X)
. If a proof for that goal can be found, the original goal (i.e., \+ illegal(X)
) fails. If no proof can be found, the original goal succeeds. Therefore, the \+/1
prefix operator is called the "not provable" operator, since the query ?- \+ Goal.
succeeds if Goal is not provable. This kind of negation is sound if its argument is "ground" (i.e. contains no variables). Soundness is lost if the argument contains variables and the proof procedure is complete. In particular, the query ?- legal(X).
now cannot be used to enumerate all things that are legal.
Programming in Prolog
In Prolog, loading code is referred to as consulting. Prolog can be used interactively by entering queries at the Prolog prompt ?-
. If there is no solution, Prolog writes no
. If a solution exists then it is printed. If there are multiple solutions to the query, then these can be requested by entering a semi-colon ;
. There are guidelines on good programming practice to improve code efficiency, readability and maintainability.[15]
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.
Hello World!
true.
?-
|
| ?- write('Hello World!'), nl.
Hello World!
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, 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.
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).
Design patterns of Prolog
A
Higher-order programming
A higher-order predicate is a predicate that takes one or more other predicates as arguments. Although support for higher-order programming takes Prolog outside the domain of first-order logic, which does not allow quantification over predicates,[22] ISO Prolog now has some built-in higher-order predicates such as call/1
, call/2
, call/3
, findall/3
, setof/3
, and bagof/3
.[23] Furthermore, since arbitrary Prolog goals can be constructed and evaluated at run-time, it is easy to write higher-order predicates like maplist/2
, which applies an arbitrary predicate to each member of a given list, and sublist/3
, which filters elements that satisfy a given predicate, also allowing for currying.[21]
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
perfect(N) :-
between(1, inf, N), U is N // 2,
findall(D, (between(1,U,D), N mod D =:= 0), Ds),
sumlist(Ds, N).
This can be used to enumerate perfect numbers, and to check if a number is perfect.
As another example, the predicate maplist
applies a predicate P
to all corresponding positions in a pair of lists:
maplist(_, [], []).
maplist(P, [X|Xs], [Y|Ys]) :-
call(P, X, Y),
maplist(P, Xs, Ys).
When P
is a predicate that for all X
, P(X,Y)
unifies Y
with a single unique value, maplist(P, Xs, Ys)
is equivalent to applying the map function in functional programming as Ys = map(Function, Xs)
.
Higher-order programming style in Prolog was pioneered in HiLog and λProlog.
Modules
For programming in the large, Prolog provides a module system, which is in the ISO Standard.[24] However, while most Prolog systems support structuring the code into modules, virtually no implementation adheres to the modules part of the ISO standard. Instead, most
Some systems chose to implement module concepts as source-to-source compilation into base ISO Prolog, as is the case of Logtalk.[26] GNU Prolog initially diverted from ISO modules, opting instead for Contextual Logic Programming, in which unit (module) loading and unloading can be made dynamically.[27] Ciao designed a strict module system that, while being basically compatible with the de-facto standard used by other Prolog systems, is amenable to precise static analysis, supports term hiding, and facilitates programming in the large.[28] XSB takes a different approach and offers an atom-based module system.[29] The latter two Prolog systems allow controlling the visibility of terms in addition to that of predicates.[30]
Parsing
There is a special notation called
Meta-interpreters and reflection
Prolog is a
solve(true).
solve((Subgoal1,Subgoal2)) :-
solve(Subgoal1),
solve(Subgoal2).
solve(Head) :-
clause(Head, Body),
solve(Body).
where true
represents an empty conjunction, and clause(Head, Body)
unifies with clauses in the database of the form Head :- Body
.
Since Prolog programs are themselves sequences of Prolog terms (:-/2
is an infix
read/1
), it is possible to write customized interpreters that augment Prolog with domain-specific features. For example, Sterling and Shapiro present a meta-interpreter that performs reasoning with uncertainty, reproduced here with slight modifications:[31]solve(true, 1) :- !.
solve((Subgoal1,Subgoal2), Certainty) :-
!,
solve(Subgoal1, Certainty1),
solve(Subgoal2, Certainty2),
Certainty is min(Certainty1, Certainty2).
solve(Goal, 1) :-
builtin(Goal), !,
Goal.
solve(Head, Certainty) :-
clause_cf(Head, Body, Certainty1),
solve(Body, Certainty2),
Certainty is Certainty1 * Certainty2.
This interpreter uses a table of built-in Prolog predicates of the form[31]: 327
builtin(A is B).
builtin(read(X)).
% etc.
and clauses represented as clause_cf(Head, Body, Certainty)
. Given those, it can be called as solve(Goal, Certainty)
to execute Goal
and obtain a measure of certainty about the result.
Turing completeness
Pure Prolog is based on a subset of first-order
turing(Tape0, Tape) :-
perform(q0, [], Ls, Tape0, Rs),
reverse(Ls, Ls1),
append(Ls1, Rs, Tape).
perform(qf, Ls, Ls, Rs, Rs) :- !.
perform(Q0, Ls0, Ls, Rs0, Rs) :-
symbol(Rs0, Sym, RsRest),
once(rule(Q0, Sym, Q1, NewSym, Action)),
action(Action, Ls0, Ls1, [NewSym|RsRest], Rs1),
perform(Q1, Ls1, Ls, Rs1, Rs).
symbol([], b, []).
symbol([Sym|Rs], Sym, Rs).
action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
action(stay, Ls, Ls, Rs, Rs).
action(right, Ls0, [Sym|Ls0], [Sym|Rs], Rs).
left([], [], Rs0, [b|Rs0]).
left([L|Ls], Ls, Rs, [L|Rs]).
A simple example Turing machine is specified by the facts:
rule(q0, 1, q0, 1, right).
rule(q0, b, qf, 1, stay).
This machine performs incrementation by one of a number in unary encoding: It loops over any number of "1" cells and appends an additional "1" at the end. Example query and result:
?- turing([1,1,1], Ts).
Ts = [1, 1, 1, 1] ;
This illustrates how any computation can be expressed declaratively as a sequence of state transitions, implemented in Prolog as a relation between successive states of interest.
Implementation
ISO Prolog
The
Compilation
For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-based
Tail recursion
Prolog systems typically implement a well-known optimization method called
Term indexing
Finding clauses that are unifiable with a term in a query is linear in the number of clauses.
Hashing
Some Prolog systems, such as WIN-PROLOG and SWI-Prolog, now implement hashing to help handle large datasets more efficiently. This tends to yield very large performance gains when working with large corpora such as WordNet.
Tabling
Some Prolog systems, (B-Prolog, XSB, SWI-Prolog, YAP, and Ciao), implement a memoization method called tabling, which frees the user from manually storing intermediate results. Tabling is a space–time tradeoff; execution time can be reduced by using more memory to store intermediate results:[43][44]
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.[45]
Tabling can be extended in various directions. It can support recursive predicates through SLG resolution or linear tabling. In a multi-threaded Prolog system tabling results could be kept private to a thread or shared among all threads. And in incremental tabling, tabling might react to changes.
Implementation in hardware
During the
Limits
Although Prolog is widely used in research and education,
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".[56]
Prolog is not purely declarative: because of constructs like the cut operator, a procedural reading of a Prolog program is needed to understand it.[57] The order of clauses in a Prolog program is significant, as the execution strategy of the language depends on it.[58] Other logic programming languages, such as Datalog, are truly declarative but restrict the language. As a result, many practical Prolog programs are written to conform to Prolog's depth-first search order, rather than as purely declarative logic programs.[56]
Extensions
Various implementations have been developed from Prolog to extend logic programming abilities in many directions. These include types, modes, constraint logic programming (CLP), object-oriented logic programming (OOLP), concurrency, linear logic (LLP), functional and higher-order logic programming abilities, plus interoperability with knowledge bases:
Types
Prolog is an untyped language. Attempts to introduce and extend Prolog with types began in the 1980s,[59][60] and continue as of 2008[update].[61] Type information is useful not only for type safety but also for reasoning about Prolog programs.[62]
Modes
Mode specifier | Interpretation |
---|---|
+
|
nonvar on entry
|
-
|
var on entry
|
?
|
Not specified |
The syntax of Prolog does not specify which arguments of a predicate are inputs and which are outputs.[63] However, this information is significant and it is recommended that it be included in the comments.[64] Modes provide valuable information when reasoning about Prolog programs[62] and can also be used to accelerate execution.[65]
Constraints
Object-orientation
Flora-2 is an object-oriented knowledge representation and reasoning system based on F-logic and incorporates HiLog, Transaction logic, and defeasible reasoning.
Logtalk is an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler. As a multi-paradigm language, it includes support for both prototypes and classes.
Oblog is a small, portable, object-oriented extension to Prolog by Margaret McDougall of EdCAAD, University of Edinburgh.
Objlog was a frame-based language combining objects and Prolog II from CNRS, Marseille, France.
Prolog++ was developed by Logic Programming Associates and first released in 1989 for MS-DOS PCs. Support for other platforms was added, and a second version was released in 1995. A book about Prolog++ by Chris Moss was published by Addison-Wesley in 1994.
Visual Prolog is a multi-paradigm language with interfaces, classes, implementations and object expressions.
Graphics
Prolog systems that provide a graphics library are SWI-Prolog,[69] Visual Prolog, WIN-PROLOG, and B-Prolog.
Concurrency
Prolog-MPI is an open-source SWI-Prolog extension for distributed computing over the Message Passing Interface.[70] Also there are various concurrent Prolog programming languages.[71]
Web programming
Some Prolog implementations, notably
Adobe Flash
Cedar Archived 2010-10-19 at the Wayback Machine is a free and basic Prolog interpreter. From version 4 and above Cedar has a FCA (Flash Cedar App) support. This provides a new platform to programming in Prolog through ActionScript.
Other
- knowledge representation.
- Transaction logic extends Prolog with a logical theory of state-changing update operators. It has both a model-theoretic and procedural semantics.
- OW Prolog has been created in order to answer Prolog's lack of graphics and interface.
Interfaces to other languages
Frameworks exist which can bridge between Prolog and other languages:
- The LPA Intelligence Server allows embedding LPA Prolog for Windows in 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
- The Logic Server Application Programming Interface (API) allows both the extension and embedding of Prolog in C, C++, Java, Visual Basic (VB), Delphi, .NET, and any language or environment which can call a .dll or .so. It is implemented for Amzi! Prolog + Logic Server but the API specification can be made available for any implementation.
- JPL is a bi-directional Java Prolog bridge which ships with SWI-Prolog by default, allowing Java and Prolog to call each other (recursively). It is known to have good concurrency support and is under active development.
- InterProlog, a programming Java and Prolog, implementing bi-directional predicate/method calling between both languages. Java objects can be mapped into Prolog terms and vice versa. Allows the development of graphical user interfaces (GUIs) and other functions in Java while leaving logic processing in the Prolog layer. Supports XSB and SWI-Prolog.
- Prova provides native syntax integration with Java, agent messaging and reaction rules. Prova positions itself as a rule-based scripting (RBS) system for middleware. The language breaks new ground in combining imperative and declarative programming.
- PROL An embeddable Prolog engine for Java. It includes a small IDE and a few libraries.
- GNU Prolog for Java is an implementation of ISO Prolog as a Java library (gnu.prolog)
- Ciao provides interfaces to C, C++, Java, and relational databases.
- C#-Prolog is a Prolog interpreter written in (managed) C#. Can easily be integrated in C# programs. Characteristics: reliable and fairly fast interpreter, command line interface, Windows-interface, builtin DCG, XML-predicates, SQL-predicates, extendible. The complete source code is available, including a parser generator that can be used for adding special purpose extensions.
- A Warren Abstract Machine for PHP A Prolog compiler and interpreter in PHP 5.3. A library that can be used standalone or within Symfony2.1 framework which was translated from Stephan Buettcher's work in Java which can be found [here stefan
.buettcher .org /cs /wam / ] - tuProlog is a lightweight Prolog system for distributed applications and infrastructures, intentionally designed around a minimal core, to be either statically or dynamically configured by loading/unloading libraries of predicates. tuProlog natively supports multi-paradigm programming, providing a clean, seamless integration model between Prolog and mainstream object-oriented languages, namely Java, for tuProlog Java version, and any .NET-based language (C#, F#..), for tuProlog .NET version.
- Janus is a bi-directional interface between Prolog and Python using portable low-level primitives. It was initially developed for XSB by Anderson and Swift[76], but has been adopted as a joint initiative by the XSB, Ciao and SWI-Prolog teams.
History
The name Prolog was chosen by Philippe Roussel, at the suggestion of his wife, as an abbreviation for programmation en logique (French for programming in logic).[77] 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. According to Robert Kowalski, the first Prolog system was developed in 1972 by Colmerauer and Phillipe Roussel.[78][79][80] The first implementation of Prolog was an interpreter written in Fortran by Gerard Battani and Henri Meloni. David H. D. Warren took this interpreter to the University of Edinburgh, and there implemented an alternative front-end, which came to define the "Edinburgh Prolog" syntax used by most modern implementations. Warren also implemented the first compiler for Prolog, creating the influential DEC-10 Prolog in collaboration with Fernando Pereira. Warren later generalised the ideas behind DEC-10 Prolog, to create the Warren Abstract Machine.
European AI researchers favored Prolog while Americans favored
Pure Prolog was originally restricted to the use of a resolution theorem prover with Horn clauses of the form:
H :- B1, ..., Bn.
The application of the theorem-prover treats such clauses as procedures:
to show/solve H, show/solve B1 and ... and Bn.
Pure Prolog was soon extended, however, to include negation as failure, in which negative conditions of the form not(Bi) are shown by trying and failing to solve the corresponding positive conditions Bi.
Subsequent extensions of Prolog by the original team introduced constraint logic programming abilities into the implementations.
Use in industry
Prolog has been used in
See also
- Comparison of Prolog implementations
- Logico-linguistic modeling. A method for building knowledge-based system that uses Prolog.
- Answer set programming. A fully declarative approach to logic programming.
- Association for Logic Programming
Related languages
- The Gödel language is a strongly typed implementation of concurrent constraint logic programming. It is built on SICStus Prolog.
- Visual Prolog, formerly named PDC Prolog and Turbo Prolog, is a strongly typed object-oriented dialect of Prolog, which is very different from standard Prolog. As Turbo Prolog, it was marketed by Borland, but is now developed and marketed by the Danish firm Prolog Development Center (PDC) that originally produced it.
- Turing-complete.
- Mercury is an offshoot of Prolog geared toward software engineering in the large with a static, polymorphic type system, as well as a mode and determinism system.
- GraphTalk is a proprietary implementation of Warren's Abstract Machine, with additional object-oriented properties.
- In some ways[Scientific Community Metaphor.
- AgentSpeak is a variant of Prolog for programming agent behavior in multi-agent systems.
- Erlang began life with a Prolog-based implementation and maintains much of Prolog's unification-based syntax.
- Pilog is a declarative language built on top of PicoLisp, that has the semantics of Prolog, but uses the syntax of Lisp.
- λProlog is an extension of core Prolog that features polymorphic typing, modular programming, and higher-order programming, including direct support for terms with variable-binding operators through so-called λ-tree syntax and higher-order pattern unification.
Notes
- ^ The Prolog terminology differs from that of logic. A term of Prolog is (depending on the context) a term or an atomic formula of logic. An atom in a standard logic terminology means an atomic formula; an atom of Prolog (depending on the context) is a constant, function symbol or predicate symbol of logic.
References
- ISBN 978-3-540-00678-7.
- ISBN 978-0-321-41746-6.
- ISBN 978-0-13-629213-5.
- ^ ISBN 978-3-540-13299-8.
- ^ See Logic programming § History.
- S2CID 14621218.
- ISBN 978-0-387-97016-5.
- ^ Felty, Amy. "A logic programming approach to implementing higher-order term rewriting." Extensions of Logic Programming (1992): 135-161.
- ISBN 978-3-319-13314-0.
- ISBN 978-3-540-40174-2.
- ^ Fernando C. N. Pereira; Stuart M. Shieber (2005). Prolog and Natural Language Analysis. Microtome.
- ^ Watson (computer).
- ^ ISO/IEC 13211-1:1995 Prolog, 6.3.7 Terms - double quoted list notation. International Organization for Standardization, Geneva.
- ISBN 978-3-7357-3744-1– via Google Books.
- S2CID 438363.
- CiteSeerX 10.1.1.56.7278.
- ISBN 978-3-540-43959-2.
- ^ D. Barker-Plummer. Cliche programming in Prolog. In M. Bruynooghe, editor, Proc. Second Workshop on Meta-Programming in Logic, pages 247--256. Dept. of Comp. Sci., Katholieke Univ. Leuven, 1990.
- ^ Gegg-harrison, T. S. (1995). Representing Logic Program Schemata in Prolog. Procs Twelfth International Conference on Logic Programming. pp. 467–481.
- ISBN 978-0-201-17576-9.
- ^ CiteSeerX 10.1.1.35.4505.
- ^ "With regard to Prolog variables, variables only in the head are implicitly universally quantified, and those only in the body are implicitly existentially quantified". Retrieved 2013-05-04.
- ^ a b c ISO/IEC 13211: Information technology – Programming languages – Prolog. International Organization for Standardization, Geneva.
- ^ ISO/IEC 13211-2: Modules.
- hdl:10174/33387
- ^ a b Moura, Paulo (August 2004), "Logtalk", Association of Logic Programming, 17 (3), archived from the original on 2010-04-12, retrieved 2010-02-16
- ^ Abreu; Nogueira (2005), "Using a Logic Programming Language with Persistence and Contexts", Lecture Notes in Artificia Intelligence, 4369
- ^ Cabeza; Hermenegildo (2000), "A new module system for Prolog", Lecture Notes in Computer Science, 1861
- ^ Sagonas; Swift; Warren (1994), "XSB as an efficient deductive database engine", SIGMOD
- hdl:10174/33387
- ^ ISBN 978-0-262-19338-2.
- ISBN 978-3-540-59304-1.
- ^ "ISO/IEC 13211-1:1995/Cor 1:2007". ISO.
- ^ "ISO/IEC 13211-1:1995/Cor 2:2012". ISO.
- ^ "ISO/IEC 13211-1:1995/Cor 3:2017". ISO.
- ^ "ISO/IEC JTC1 SC22 WG17".[permanent dead link]
- ^ "X3J17 and the Prolog Standard". Archived from the original on 2009-08-23. Retrieved 2009-10-02.
- ^ David H. D. Warren. "An abstract Prolog instruction set". Technical Note 309, SRI International, Menlo Park, CA, October 1983.
- S2CID 16447071.
- ISBN 978-3-540-61040-3.
- ^ Wise, Michael J.; Powers, David M. W. (1986). Indexing Prolog Clauses via Superimposed Code Words and Field Encoded Words. International Symposium on Logic Programming. pp. 203–210.
- .
- S2CID 16695800.
- ^ Zhou, Neng-Fa; Sato, Taisuke (2003). "Efficient Fixpoint Computation in Linear Tabling" (PDF). Proceedings of the 5th ACM SIGPLAN International Conference on Principles and Practice of Declarative Programming: 275–283.
- S2CID 6153112.
- S2CID 10283148.
- ISBN 978-3-540-16492-0.
- .
- S2CID 2978041.
- ^ "Statically Allocated Systems".
- Reed Business Information. March 26, 1987. p. 34 – via Google Books.[permanent dead link]
- ^ "Computer science - Programming Languages, Syntax, Algorithms | Britannica". www.britannica.com. Retrieved 2023-07-12.
- ^ a b Logic programming for the real world. Zoltan Somogyi, Fergus Henderson, Thomas Conway, Richard O'Keefe. Proceedings of the ILPS'95 Postconference Workshop on Visions for the Future of Logic Programming.
- ^ "FAQ: Prolog Resource Guide 1/2 [Monthly posting]Section - [1-8] The Prolog 1000 Database". Faqs.org.
- ^ Jan Wielemaker and Vıtor Santos Costa: Portability of Prolog programs: theory and case-studies. CICLOPS-WLPE Workshop 2010 Archived 2010-07-16 at the Wayback Machine.
- ^ a b Kiselyov, Oleg; Kameyama, Yukiyoshi (2014). Re-thinking Prolog. Proc. 31st meeting of the Japan Society for Software Science and Technology.
- ^ Franzen, Torkel (1994), "Declarative vs procedural", Association of Logic Programming, 7 (3)
- S2CID 518049.
- .
- ISBN 978-0-262-16131-2.
- ISBN 978-3-540-89982-2.
- ^ S2CID 12235465.
- ISBN 978-0-262-15039-2.
- ].
- ISBN 978-3-540-17611-4.
- .
- ^ Colmerauer, Alain (1987). "Opening the Prolog III Universe". Byte. August.
- ISBN 978-3-540-45628-5.
- ^ "XPCE: the SWI-Prolog native GUI library". swi-prolog.org.
- ^ "prolog-mpi". Apps.lumii.lv. Retrieved 2010-09-16.
- ^ Ehud Shapiro. The family of concurrent logic programming languages ACM Computing Surveys. September 1989.
- S2CID 5404048.
- ^ Wielemaker, Jan; Hildebrand, Michiel; van Ossenbruggen, Jacco (2007), Heymans, S.; Polleres, A.; Ruckhaus, E.; Pearse, D.; Gupta, G. (eds.), "Using {Prolog} as the fundament for applications on the semantic web" (PDF), Proceedings of the 2nd Workshop on Applications of Logic Programming and to the Web, Semantic Web and Semantic Web Services, CEUR Workshop Proceedings, vol. 287, Porto, Portugal: CEUR-WS.org, pp. 84–98
- ^ Processing OWL2 Ontologies using Thea: An Application of Logic Programming. Vangelis Vassiliadis, Jan Wielemaker and Chris Mungall. Proceedings of the 5th International Workshop on OWL: Experiences and Directions (OWLED 2009), Chantilly, VA, United States, October 23–24, 2009
- S2CID 11754347.
- ^ Andersen, C. and Swift, T., 2023. The Janus System: a bridge to new prolog applications. In Prolog: The Next 50 Years (pp. 93-104). Cham: Springer Nature Switzerland.
- ^ Colmerauer, A. and Roussel, P., 1996. The birth of Prolog. In History of programming languages---II (pp. 331-367).
- S2CID 12259230.
- .
- ^ "Prolog: a brief history". Retrieved 21 November 2021.
- ^ Pountain, Dick (October 1984). "POP and SNAP". Byte. p. 381. Retrieved 23 October 2013.
- ^ terminusdb/terminusdb, TerminusDB, 2020-12-13, retrieved 2020-12-15
Further reading
- Blackburn, Patrick; Bos, Johan; Striegnitz, Kristina (2006). Learn Prolog Now!. College Publications. ISBN 978-1-904987-17-8. Archived from the originalon 2007-08-26. Retrieved 2008-12-02.
- ]
- William F. Clocksin, Christopher S. Mellish: Programming in Prolog: Using the ISO Standard. Springer, 5th ed., 2003, ISBN 978-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, ISBN 978-3-540-62971-9.
- ISBN 0-13-138645-X.
- Michael A. Covington, Natural Language Processing for Prolog Programmers, 1994, ISBN 978-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 a ISBN 0-12-416521-4.
- ISBN 0-262-15039-5.
- Robert Smith, John Gibson, Aaron Sloman: 'POPLOG's two-level virtual machine support for interactive languages', in Research Directions in Cognitive Science Volume 5: Artificial Intelligence, Eds D. Sleeman and N. Bernsen, Lawrence Erlbaum Associates, pp 203–231, 1992.
- ISBN 0-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.