» 
Arabic Bulgarian Chinese Croatian Czech Danish Dutch English Estonian Finnish French German Greek Hebrew Hindi Hungarian Icelandic Indonesian Italian Japanese Korean Latvian Lithuanian Malagasy Norwegian Persian Polish Portuguese Romanian Russian Serbian Slovak Slovenian Spanish Swedish Thai Turkish Vietnamese
Arabic Bulgarian Chinese Croatian Czech Danish Dutch English Estonian Finnish French German Greek Hebrew Hindi Hungarian Icelandic Indonesian Italian Japanese Korean Latvian Lithuanian Malagasy Norwegian Persian Polish Portuguese Romanian Russian Serbian Slovak Slovenian Spanish Swedish Thai Turkish Vietnamese

definitions - Prolog

prolog (n.)

1.(American)an introduction to a play

Prolog (n.)

1.a computer language designed in Europe to support natural language processing

   Advertizing ▼

Merriam Webster

PrologPro"log (?), n. & v. Prologue.

   Advertizing ▼

definition (more)

definition of Wikipedia

synonyms - Prolog

prolog (n.) (American)

preface, prologue  (à~to)

phrases

analogical dictionary



Wikipedia

Prolog

                   
Prolog
Paradigm(s) Logic programming
Appeared in 1972
Designed by Alain Colmerauer
Major implementations BProlog, Ciao, ECLiPSe, GNU Prolog, Jekejeke Prolog, Logic Programming Associates, Poplog Prolog, P#, Quintus, SICStus, Strawberry, SWI-Prolog, tuProlog, XSB, YAP-Prolog
Dialects ISO Prolog, Edinburgh Prolog
Influenced by PLANNER
Influenced Visual Prolog, Mercury, Oz, Erlang, Strand, KL0, KL1, Datalog
Usual filename extensions .pl .pro .P
Wikibooks logo Prolog at Wikibooks

Prolog is a general purpose logic programming language associated with artificial intelligence and computational linguistics.[1][2][3]

Prolog has its roots in first-order logic, a formal logic, and unlike many other programming languages, Prolog is declarative: the program logic is expressed in terms of relations, represented as facts and rules. A computation is initiated by running a query over these relations.[4]

The language was first conceived by a group around Alain Colmerauer in Marseille, France, in the early 1970s and the first Prolog system was developed in 1972 by Colmerauer with Philippe Roussel.[5][6]

Prolog was one of the first logic programming languages,[7] 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,[8] expert systems,[9] games, automated answering systems, ontologies and sophisticated control systems. Modern Prolog environments support creating graphical user interfaces, as well as administrative and networked applications.

Contents

  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.[4] Relations are defined by clauses. Given a query, the Prolog engine attempts to find a 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. Because of this, the programmer is permitted to use some amount of conventional imperative programming when the logical paradigm is inconvenient. It has a purely logical subset, called "pure Prolog", as well as a number of extralogical features.

  Data types

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

  • An atom is a general-purpose name with no inherent meaning. Examples of atoms include x, blue, 'Burrito', and 'some atom'.
  • Numbers can be floats or integers.
  • 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. Examples of compound terms are truck_year('Mazda', 1986) and '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, []. For example [1,2,3] or [red,green,blue].
  • 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. For example, "to be, or not to be".

  Rules and facts

Prolog programs describe relations, defined by means of clauses. Pure Prolog is restricted to Horn clauses. 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 ,/2 (meaning a 2-arity operator with name ,) denotes conjunction of goals, and ;/2 denotes 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 true/0 is always true.

Given the above fact, one can ask:

is tom a cat?

?- cat(tom).
Yes

what things are cats?

?- cat(X).
X = tom

Clauses with bodies are called rules. An example of a rule is:

animal(X):- cat(X).

If we add that rule and ask what things are animals?

?- animal(X).
X = tom

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) as well as to generate a list skeleton of a given length (length(X, 5)), and also 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) as well as 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.

  Evaluation

Execution of a Prolog program is initiated by the user's posting of a single goal, called the query. Logically, the Prolog engine tries to find a resolution refutation of the negated query. The resolution method used by Prolog is called SLD resolution. If the negated query can be refuted, it follows that the query, with the appropriate variable bindings in place, is a logical consequence of the program. In that case, all generated variable bindings are reported to the user, and the query is said to have succeeded. Operationally, Prolog's execution strategy can be thought of as a generalization of function calls in other languages, one difference being that multiple clause heads can match a given call. In that case, the system creates a choice-point, unifies the goal with the clause head of the first alternative, and continues with the goals of that first alternative. If any goal fails in the course of executing the program, all variable bindings that were made since the most recent choice-point was created are undone, and execution continues with the next alternative of that choice-point. This execution strategy is called chronological backtracking. For example:

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

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.

  Negation

The built-in Prolog predicate \+/1 provides negation as failure, which allows for non-monotonic reasoning. The goal \+ legal(X) in the rule

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

is evaluated as follows: Prolog attempts to prove the legal(X). If a proof for that goal can be found, the original goal (i.e., \+ legal(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 ?- illegal(X). can now not be used to enumerate all things that are illegal.

  Examples

Here follow some example programs written in Prolog.

  Hello world

An example of a query:

?- write('Hello world!'), nl.
Hello world!
true.
 
?-

  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

A design pattern is a general reusable solution to a commonly occurring problem in software design. In Prolog, design patterns go under various names: skeletons and techniques,[10][11] cliches,[12] program schemata,[13] and logic description schemata.[14] An alternative to design patterns is higher order programming.[15]

  Higher-order programming

By definition, first-order logic does not allow quantification over predicates. A higher-order predicate is a predicate that takes one or more other predicates as arguments. Prolog already has some built-in higher-order predicates such as call/1, call/2, call/3, findall/3, setof/3, and bagof/3.[16] 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.[15]

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.

  Modules

For programming in the large, Prolog provides a module system. The module system is standardised by ISO.[17] However, not all Prolog compilers support modules and there are compatibility problems between the module systems of the major Prolog compilers.[18] Consequently, modules written on one Prolog compiler will not necessarily work on others.

  Parsing

There is a special notation called definite clause grammars (DCGs). A rule defined via -->/2 instead of :-/2 is expanded by the preprocessor (expand_term/2, a facility analogous to macros in other languages) according to a few straightforward rewriting rules, resulting in ordinary Prolog clauses. Most notably, the rewriting equips the predicate with two additional arguments, which can be used to implicitly thread state around, analogous to monads in other languages. DCGs are often used to write parsers or list generators, as they also provide a convenient interface to list differences.

  Meta-interpreters and reflection

Prolog is a homoiconic language and provides many facilities for reflection. Its implicit execution strategy makes it possible to write a concise meta-circular evaluator (also called meta-interpreter) for pure Prolog code.[19] 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.

  Turing completeness

Pure Prolog is based on a subset of first-order predicate logic, Horn clauses, which is Turing-complete. Turing completeness of Prolog can be shown by using it to simulate a Turing machine:

turing(Tape0, Tape) :-
    perform(q0, [], Ls, Tape0, Rs),
    reverse(Ls, Ls1),
    append(Ls1, Rs, Tape).
 
perform(qf, Ls, Ls, Rs, Rs) :- !.
perform(Q0, Ls0, Ls, Rs0, Rs) :-
    symbol(Rs0, Sym, RsRest),
    once(rule(Q0, Sym, Q1, NewSym, Action)),
    action(Action, Ls0, Ls1, [NewSym|RsRest], Rs1),
    perform(Q1, Ls1, Ls, Rs1, Rs).
 
symbol([], b, []).
symbol([Sym|Rs], Sym, Rs).
 
action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
action(stay, Ls, Ls, Rs, Rs).
action(right, Ls0, [Sym|Ls0], [Sym|Rs], Rs).
 
left([], [], Rs0, [b|Rs0]).
left([L|Ls], Ls, Rs, [L|Rs]).

A simple example Turing machine is specified by the facts:

rule(q0, 1, q0, 1, right).
rule(q0, b, qf, 1, stay).

This machine performs incrementation by one of a number in unary encoding: It loops over any number of "1" cells and appends an additional "1" at the end. Example query and result:

?- turing([1,1,1], Ts).
Ts = [1, 1, 1, 1] ;

This illustrates how any computation can be expressed declaratively as a sequence of state transitions, implemented in Prolog as a relation between successive states of interest.

  Implementation

  ISO Prolog

The ISO Prolog standard consists of two parts. ISO/IEC 13211-1,[16][20] 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 two corrigenda: Cor.1:2007[21] and Cor.2:2012[22]. ISO/IEC 13211-2,[16] published in 2000, adds support for modules to the standard. The standard is maintained by the ISO/IEC JTC1/SC22/WG17[23] working group. ANSI X3J17 is the US Technical Advisory Group for the standard.[24]

  Compilation

For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-based Warren Abstract Machine (WAM) instruction set.[25] 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.[26] Devising efficient implementation methods for Prolog code is a field of active research in the logic programming community, and various other execution methods are employed in some implementations. These include clause binarization and stack-based virtual machines.[citation needed]

  Tail recursion

Prolog systems typically implement a well-known optimization method called tail call optimization (TCO) for deterministic predicates exhibiting tail recursion or, more generally, tail calls: A clause's stack frame is discarded before performing a call in a tail position. Therefore, deterministic tail-recursive predicates are executed with constant stack space, like loops in other languages.

  Term indexing

Finding clauses that are unifiable with a term in a query is linear in the number of clauses. Term indexing uses a data structure that enables sublinear-time lookups.[27] Indexing only affects program performance, it does not affect semantics.

  Tabling

Some Prolog systems, (BProlog, XSB and Yap), implement a memoization method called tabling, which frees the user from manually storing intermediate results.[28][29]

  Implementation in hardware

During the Fifth Generation Computer Systems project, there were attempts to implement Prolog in hardware with the aim of achieving faster execution with dedicated architectures.[30][31][32] Furthermore, Prolog has a number of properties that may allow speed-up through parallel execution.[33] A more recent approach has been to compile restricted Prolog programs to a field programmable gate array.[34] However, rapid progress in general-purpose hardware has consistently overtaken more specialised architectures.

  Criticism

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.[35] Most applications are small by industrial standards, with few exceeding 100,000 lines of code.[35][36] Programming in the large is considered to be complicated because not all Prolog compilers support modules, and there are compatibility problems between the module systems of the major Prolog compilers.[18] 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."[37]

Software developed in Prolog has been criticised for having a high performance penalty compared to conventional programming languages. However, advances in implementation methods have reduced the penalties to as little as 25%-50% for some applications.[38]

  Extensions

Various implementations have been developed from Prolog to extend logic programming capabilities in numerous directions. These include types, modes, constraint logic programming (CLP), object-oriented logic programming (OOLP), concurrency, linear logic (LLP), functional and higher-order logic programming capabilities, plus interoperability with knowledge bases:

  Types

Prolog is an untyped language. Attempts to introduce types date back to the 1980s,[39][40] and as of 2008 there are still attempts to extend Prolog with types.[41] Type information is useful not only for type safety but also for reasoning about Prolog programs.[42]

  Modes

The syntax of Prolog does not specify which arguments of a predicate are inputs and which are outputs.[43] However, this information is significant and it is recommended that it be included in the comments.[44] Modes provide valuable information when reasoning about Prolog programs[42] and can also be used to accelerate execution.[45]

  Constraints

Constraint logic programming extends Prolog to include concepts from constraint satisfaction.[46][47] A constraint logic program allows constraints in the body of clauses, such as: A(X,Y) :- X+Y>0. It is suited to large-scale combinatorial optimisation problems.[48] and is thus useful for applications in industrial settings, such as automated time-tabling and production scheduling. Most Prolog systems ship with at least one constraint solver for finite domains, and often also with solvers for other domains like rational numbers.

  Higher-order programming

HiLog and λProlog extend Prolog with higher-order programming features. ISO Prolog now supports the built-in predicates call/2, call/3, ... which facilitate higher-order programming and lambda abstractions.

maplist(_Cont, [], []).
maplist(Cont, [X1|X1s], [X2|X2s]) :-
   call(Cont, X1, X2),
   maplist(Cont, X1s, X2s).

  Object-orientation

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.

  Graphics

Prolog systems that provide a graphics library are SWI-prolog,[49] Visual-prolog and B-Prolog.

  Concurrency

Prolog-MPI is an open-source SWI-Prolog extension for distributed computing over the Message Passing Interface.[50] Also there are various concurrent Prolog programming languages.[51]

  Web programming

Some Prolog implementations, notably SWI-Prolog, support server-side web programming with support for web protocols, HTML and XML.[52] There are also extensions to support semantic web formats such as RDF and OWL.[53][54] Prolog has also been suggested as a client-side language.[55]

  Adobe Flash

Cedar is a free and basic Prolog interpreter. From version 4 and above Cedar has a FCA (Flash Cedar App) support. This provides a new platform to programming in Prolog through ActionScript.

  Other

  Interfaces to other languages

Frameworks exist which can bridge between Prolog and other languages:

  • The Logic Server API allows both the extension and embedding of Prolog in C, C++, Java, VB, Delphi, .NET and any language/environment which can call a .dll or .so. It is implemented for Amzi! Prolog Amzi! Prolog + Logic Server but the API specification can be made available for any implementation.
  • JPL is a bi-directional Java Prolog bridge which ships with SWI-Prolog by default, allowing Java and Prolog to call each other (recursively). It is known to have good concurrency support and is under active development.
  • InterProlog, a programming library bridge between Java and Prolog, implementing bi-directional predicate/method calling between both languages. Java objects can be mapped into Prolog terms and vice-versa. Allows the development of GUIs and other functionality in Java while leaving logic processing in the Prolog layer. Supports XSB, SWI-Prolog and YAP.
  • Prova provides native syntax integration with Java, agent messaging and reaction rules. Prova positions itself as a rule-based scripting (RBS) system for middleware. The language breaks new ground in combining imperative and declarative programming.
  • 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.

  History

The name Prolog was chosen by Philippe Roussel as an abbreviation for programmation en logique (French for programming in logic). It was created around 1972 by Alain Colmerauer with Philippe Roussel, based on Robert Kowalski's procedural interpretation of Horn clauses. It was motivated in part by the desire to reconcile the use of logic as a declarative knowledge representation language with the procedural representation of knowledge that was popular in North America in the late 1960s and early 1970s. According to Robert Kowalski, the first Prolog system was developed in 1972 by Alain Colmerauer and Phillipe Roussel.[5] The first implementations of Prolog were interpreters, however, David H. D. Warren created the Warren Abstract Machine, an early and influential Prolog compiler which came to define the "Edinburgh Prolog" dialect which served as the basis for the syntax of most modern implementations.

Much of the modern development of Prolog came from the impetus of the Fifth Generation Computer Systems project (FGCS), which developed a variant of Prolog named Kernel Language for its first operating system.

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.

  See also

  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 known as 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 it is now developed and marketed by the Danish firm PDC (Prolog Development Center) that originally produced it.
  • Datalog is a subset of Prolog. It is limited to relationships that may be stratified and does not allow compound terms. In contrast to Prolog, Datalog is not Turing-complete.
  • Mercury is an off-shoot of Prolog geared toward software engineering in the large with a static, polymorphic type system, as well as a mode and determinism system.
  • CSC GraphTalk is a proprietary implementation of Warren's Abstract Machine, with additional object-oriented properties.
  • In some ways[which?] Prolog is a subset of Planner. The ideas in Planner were later further developed in the Scientific Community Metaphor.
  • AgentSpeak is a variant of Prolog for programming agent behavior in multi-agent systems.

  References

  1. ^ Clocksin, William F.; Mellish, Christopher S. (2003). Programming in Prolog. Berlin ; New York: Springer-Verlag. ISBN 978-3-540-00678-7. 
  2. ^ Bratko, Ivan (2001). Prolog programming for artificial intelligence. Harlow, England ; New York: Addison Wesley. ISBN 0-201-40375-7. 
  3. ^ Covington, Michael A. (1994). Natural language processing for Prolog programmers. Englewood Cliffs, N.J.: Prentice Hall. ISBN 978-0-13-629213-5. 
  4. ^ a b Lloyd, J. W. (1984). Foundations of logic programming. Berlin: Springer-Verlag. ISBN 3-540-13299-6. 
  5. ^ a b Kowalski, R. A. (1988). "The early years of logic programming". Communications of the ACM 31: 38. DOI:10.1145/35043.35046.  edit
  6. ^ Colmerauer, A.; Roussel, A. (1993). "The birth of Prolog". ACM SIGPLAN Notices 28 (3): 37. DOI:10.1145/155360.155362.  edit
  7. ^ See Logic programming#History.
  8. ^ Stickel, M. E. (1988). "A prolog technology theorem prover: Implementation by an extended prolog compiler". Journal of Automated Reasoning 4 (4): 353–380. DOI:10.1007/BF00297245.  edit
  9. ^ Merritt, Dennis (1989). Building expert systems in Prolog. Berlin: Springer-Verlag. ISBN 0-387-97016-9. 
  10. ^ Kirschenbaum, M.; Sterling, L.S. (1993). "Applying Techniques to Skeletons". Constructing Logic Programs, (ed. J.M.J. Jacquet): 27–140 
  11. ^ Sterling, Leon (2002). Patterns for Prolog Programming. "Computational Logic: Logic Programming and Beyond". Lecture Notes in Computer Science. Lecture Notes in Computer Science 2407: 17–26. DOI:10.1007/3-540-45628-7_15. ISBN 978-3-540-43959-2. 
  12. ^ 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.
  13. ^ Gegg-harrison, T. S. (1995). "Representing Logic Program Schemata in Prolog". Procs. Twelfth International Conference on Logic Programming: 467–481 
  14. ^ Deville, Yves (1990). Logic programming: systematic program development. Wokingham, England: Addison-Wesley. ISBN 0-201-17576-2. 
  15. ^ a b Naish, Lee (1996). "Higher-order logic programming in Prolog". Higher-order logic programming in Prolog. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.35.4505. Retrieved 2010-11-02 
  16. ^ a b c ISO/IEC 13211: Information technology — Programming languages — Prolog. International Organization for Standardization, Geneva.
  17. ^ ISO/IEC 13211-2: Modules.
  18. ^ a b Paulo Moura, Logtalk in Association of Logic Programming Newsletter. Vol 17 n. 3, August 2004. [1]
  19. ^ Shapiro, Ehud Y.; Sterling, Leon (1994). The art of Prolog: advanced programming techniques. Cambridge, Mass: MIT Press. ISBN 0-262-19338-8. 
  20. ^ A. Ed-Dbali; Deransart, Pierre; L. Cervoni; (1996). Prolog: the standard: reference manual. Berlin: Springer. ISBN 3-540-59304-7. 
  21. ^ ISO/IEC 13211-1:1995/Cor.1:2007
  22. ^ ISO/IEC 13211-1:1995/Cor 2:2012
  23. ^ WG17 Working Group
  24. ^ X3J17 Committee
  25. ^ David H. D. Warren. "An abstract Prolog instruction set". Technical Note 309, SRI International, Menlo Park, CA, October 1983.
  26. ^ Van Roy, P.; Despain, A. M. (1992). "High-performance logic programming with the Aquarius Prolog compiler". Computer 25: 54. DOI:10.1109/2.108055.  edit
  27. ^ Graf, Peter (1995). Term indexing. Berlin ; New York: Springer. ISBN 978-3-540-61040-3. 
  28. ^ Swift, T. (1999). Annals of Mathematics and Artificial Intelligence 25 (3/4): 201–200. DOI:10.1023/A:1018990308362.  edit
  29. ^ Neng-Fa Zhou and Taisuke Sato (2003): Efficient Fixpoint Computation in Linear Tabling, In Proceedings of the 5th ACM SIGPLAN Conference on Principles and practice of declaritive programming, pp. 275–283.
  30. ^ Abe, S.; Bandoh, T.; Yamaguchi, S.; Kurosawa, K.; Kiriyama, K. (1987). High performance integrated Prolog processor IPP. pp. 100. DOI:10.1145/30350.30362.  edit
  31. ^ "A Prolog processor based on a pattern matching memory device - Third International Conference on Logic Programming - Lecture Notes in Computer Science". Springer Berlin / Heidelberg. 1986. DOI:10.1007/3-540-16492-8_73. 
  32. ^ Taki, K.; Nakajima, K.; Nakashima, H.; Ikeda, M. (1987). "Performance and architectural evaluation of the PSI machine". ACM SIGPLAN Notices 22 (10): 128. DOI:10.1145/36205.36195.  edit
  33. ^ Gupta, G.; Pontelli, E.; Ali, K. A. M.; Carlsson, M.; Hermenegildo, M. V. (2001). "Parallel execution of prolog programs: a survey". ACM Transactions on Programming Languages and Systems 23 (4): 472. DOI:10.1145/504083.504085.  edit
  34. ^ http://www.cl.cam.ac.uk/~am21/research/sa/byrdbox.ps.gz
  35. ^ 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.
  36. ^ The Prolog 1000 database http://www.faqs.org/faqs/prolog/resource-guide/part1/section-9.html
  37. ^ Jan Wielemaker and Vıtor Santos Costa: Portability of Prolog programs: theory and case-studies. CICLOPS-WLPE Workshop 2010.
  38. ^ Sterling, Leon (1990). The Practice of Prolog. MIT Press. p. 32. ISBN 0-262-19301-9. "Although some CAD algorithms run between 2 to 4 times slower than their counterparts in C, the interactive response of the editor is comparable to a similar program written in C." 
  39. ^ Mycroft, A.; O'Keefe, R. A. (1984). "A polymorphic type system for prolog☆". Artificial Intelligence 23 (3): 295. DOI:10.1016/0004-3702(84)90017-1.  edit
  40. ^ Pfenning, Frank (1992). Types in logic programming. Cambridge, Mass: MIT Press. ISBN 0-262-16131-1. 
  41. ^ Schrijvers, Tom; Santos Costa, Vitor; Wielemaker, Jan; Demoen, Bart (2008). "Towards Typed Prolog". Logic programming : 24th international conference, ICLP 2008, Udine, Italy, December 9-13, 2008 : proceedings. Lecture Notes in Computer Science. 5366. pp. 693–697. DOI:10.1007/978-3-540-89982-2_59. ISBN 9783540899822.  edit
  42. ^ a b Apt, K. R.; Marchiori, E. (1994). "Reasoning about Prolog programs: From modes through types to assertions". Formal Aspects of Computing 6 (6): 743. DOI:10.1007/BF01213601.  edit
  43. ^ O'Keefe, Richard A. (1990). The craft of Prolog. Cambridge, Mass: MIT Press. ISBN 0-262-15039-5. 
  44. ^ Covington et al; Roberto Bagnara; O'Keefe; Jan Wielemaker; Simon Price (2010). "Coding guidelines for Prolog". arXiv:0911.2899 [cs.PL]. 
  45. ^ Roy, P.; Demoen, B.; Willems, Y. D. (1987). "Improving the execution speed of compiled Prolog with modes, clause selection, and determinism". Tapsoft '87. Lecture Notes in Computer Science. 250. pp. 111. DOI:10.1007/BFb0014976. ISBN 3-540-17611-X.  edit
  46. ^ Jaffar, J. (1994). "Constraint logic programming: a survey". The Journal of Logic Programming 19-20: 503–581. DOI:10.1016/0743-1066(94)90033-7.  edit
  47. ^ Colmerauer, Alain (1987). "Opening the Prolog III Universe". Byte August. 
  48. ^ Wallace, M. (20022002). "Constraint Logic Programming". Computational Logic: Logic Programming and Beyond. Lecture Notes in Computer Science. 2407. pp. 512. DOI:10.1007/3-540-45628-7_19. ISBN 3540456287.  edit
  49. ^ "XPCE graphics library". http://www.swi-prolog.org/packages/xpce/. 
  50. ^ "prolog-mpi". Apps.lumii.lv. http://apps.lumii.lv/prolog-mpi/. Retrieved 2010-09-16. 
  51. ^ Ehud Shapiro. The family of concurrent logic programming languages ACM Computing Surveys. September 1989.
  52. ^ Wielemaker, J.; Huang, Z.; Van Der Meij, L. (2008). "SWI-Prolog and the web". Theory and Practice of Logic Programming 8 (03). DOI:10.1017/S1471068407003237.  edit
  53. ^ Jan Wielemaker and Michiel Hildebrand and Jacco van Ossenbruggen (2007), S.Heymans, A. Polleres, E. Ruckhaus, D. Pearse, and G. Gupta, ed., "Using {Prolog} as the fundament for applications on the semantic web", Proceedings of the 2nd Workshop on Applicatiions of Logic Programming and to the web, Semantic Web and Semantic Web Services, CEUR Workshop Proceedings (Porto, Portugal: CEUR-WS.org) 287: 84–98, http://ftp.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-287/paper_1.pdf 
  54. ^ 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
  55. ^ Loke, S. W.; Davison, A. (2001). "Secure Prolog-based mobile code". Theory and Practice of Logic Programming 1. DOI:10.1017/S1471068401001211.  edit

  Further reading

  • Patrick Blackburn, Johan Bos, Kristina Striegnitz, Learn Prolog Now!, 2006, ISBN 1-904987-17-6.
  • Ivan Bratko, PROLOG Programming for Artificial Intelligence, 2000, ISBN 0-201-40375-7.
  • 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. Previous editions described Edinburgh Prolog.)
  • William F. Clocksin: Clause and Effect. Prolog Programming for the Working Programmer. Springer, 2003, ISBN 978-3-540-62971-9.
  • Alain Colmerauer and Philippe Roussel, The birth of Prolog, in The second ACM SIGPLAN conference on History of programming languages, p. 37-52, 1992.
  • 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-62921
  • 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.
  • Leon Sterling and Ehud Shapiro, The Art of Prolog: Advanced Programming Techniques, 1994, ISBN 0-262-19338-8.
  • Robert Kowalski, The Early Years of Logic Programming, CACM January 1988.
  • ISO/IEC 13211: Information technology — Programming languages — Prolog. International Organization for Standardization, Geneva.
  • Richard O'Keefe, The Craft of Prolog, ISBN 0-262-15039-5.
  • David H D Warren, Luis M. Pereira and Fernando Pereira, Prolog - the language and its implementation compared with Lisp. ACM SIGART Bulletin archive, Issue 64. Proceedings of the 1977 symposium on Artificial intelligence and programming languages, pp 109 – 115.

  External links

   
               

 

All translations of Prolog


sensagent's content

  • definitions
  • synonyms
  • antonyms
  • encyclopedia

Dictionary and translator for handheld

⇨ New : sensagent is now available on your handheld

   Advertising ▼

sensagent's office

Shortkey or widget. Free.

Windows Shortkey: sensagent. Free.

Vista Widget : sensagent. Free.

Webmaster Solution

Alexandria

A windows (pop-into) of information (full-content of Sensagent) triggered by double-clicking any word on your webpage. Give contextual explanation and translation from your sites !

Try here  or   get the code

SensagentBox

With a SensagentBox, visitors to your site can access reliable information on over 5 million pages provided by Sensagent.com. Choose the design that fits your site.

Business solution

Improve your site content

Add new content to your site from Sensagent by XML.

Crawl products or adds

Get XML access to reach the best products.

Index images and define metadata

Get XML access to fix the meaning of your metadata.


Please, email us to describe your idea.

WordGame

The English word games are:
○   Anagrams
○   Wildcard, crossword
○   Lettris
○   Boggle.

Lettris

Lettris is a curious tetris-clone game where all the bricks have the same square shape but different content. Each square carries a letter. To make squares disappear and save space for other squares you have to assemble English words (left, right, up, down) from the falling squares.

boggle

Boggle gives you 3 minutes to find as many words (3 letters or more) as you can in a grid of 16 letters. You can also try the grid of 16 letters. Letters must be adjacent and longer words score better. See if you can get into the grid Hall of Fame !

English dictionary
Main references

Most English definitions are provided by WordNet .
English thesaurus is mainly derived from The Integral Dictionary (TID).
English Encyclopedia is licensed by Wikipedia (GNU).

Copyrights

The wordgames anagrams, crossword, Lettris and Boggle are provided by Memodata.
The web service Alexandria is granted from Memodata for the Ebay search.
The SensagentBox are offered by sensAgent.

Translation

Change the target language to find translations.
Tips: browse the semantic fields (see From ideas to words) in two languages to learn more.

last searches on the dictionary :

3945 online visitors

computed in 0.078s

I would like to report:
section :
a spelling or a grammatical mistake
an offensive content(racist, pornographic, injurious, etc.)
a copyright violation
an error
a missing statement
other
please precise:

Advertize

Partnership

Company informations

My account

login

registration

   Advertising ▼

ISM ADAMO PROLOGUE SADDLE WHITE/BLACK (99.99 USD)

Commercial use of this term

ISM Adamo Prologue Saddle Black (95.0 USD)

Commercial use of this term

Prima Luna Prologue 8 CD Player. (1295.0 GBP)

Commercial use of this term

ISM Adamo Bicycle Ergo Prologue Saddle White Electric,BMX,Cruiser,Cyclocross (94.99 USD)

Commercial use of this term

Renaissance - Prologue NEW CD (1.68 GBP)

Commercial use of this term

ISM Adamo Prologue Ergo Saddle CroMo Black Road Bike TTrial Triathlon Split Seat (124.9 USD)

Commercial use of this term

PROLOG Programming for Artificial Intelligence (International computer science s (3.97 USD)

Commercial use of this term

Gran Turismo 5 Prologue (Sony Playstation 3, 2008) (7.0 USD)

Commercial use of this term

The Miller's Prologue and Tale (Selected Tales from Chaucer) (3.97 USD)

Commercial use of this term

DEATHMATE SILVER PROLOGUE VALIANT IMAGE COMICS 1993 (2.95 AUD)

Commercial use of this term

JUSTICE SOCIETY 2007 SERIES #9 THY KINGDOM COME PROLOGUE DC NICE!!! (1.59 USD)

Commercial use of this term

NEW ISM Adamo Prologue Saddle Black 135mm wide 270mm long (95.0 USD)

Commercial use of this term

Gran Turismo 5 Prologue (Sony Playstation 3, 2008) PS3 * GOOD CONDITION! (4.99 USD)

Commercial use of this term

The Craft of Prolog (Logic Programming) (32.21 USD)

Commercial use of this term

NEW ISM Adamo Prologue Saddle White 135mm wide 270mm long (100.0 USD)

Commercial use of this term

Centerpointe Holosync Awakening Prologue, Inside Secrets and Super Longevity (65.0 USD)

Commercial use of this term

PROLOGUE ELVEN WARRIOR Lord of the Rings 6" Toy Biz LOOSE COMPLETE FREE SHIP (19.95 USD)

Commercial use of this term

Verso Prologue Cover for iPad (all generations), Samsung Galaxy Tab & Note, New (10.06 USD)

Commercial use of this term

VERSO PROLOGUE Antique Book Leather Look Case Cover Stand Kindle Fire HD HDX 7" (16.95 USD)

Commercial use of this term