Sat . 19 Feb 2019

Prolog

prologistix, www.prologistix.com
Prolog is a general-purpose logic programming language associated with artificial intelligence and computational linguistics

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

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

Prolog was one of the first logic programming languages, and remains the most popular among such languages today, with several free and commercial implementations available The language has been used for theorem proving, expert systems, as well as its original intended field of use, natural language processing Modern Prolog environments support creating graphical user interfaces, as well as administrative and networked applications

Prolog is well-suited for specific tasks that benefit from rule-based logical queries such as searching databases, voice control systems, and filling templates

Contents

  • 1 Syntax and semantics
    • 11 Data types
    • 12 Rules and facts
    • 13 Execution
    • 14 Loops and recursion
    • 15 Negation
  • 2 Programming in Prolog
    • 21 Hello world
    • 22 Compiler optimization
    • 23 Quicksort
  • 3 Design patterns
  • 4 Higher-order programming
  • 5 Modules
  • 6 Parsing
  • 7 Meta-interpreters and reflection
  • 8 Turing completeness
  • 9 Implementation
    • 91 ISO Prolog
    • 92 Compilation
    • 93 Tail recursion
    • 94 Term indexing
    • 95 Hashing
    • 96 Tabling
    • 97 Implementation in hardware
  • 10 Limitations
  • 11 Extensions
    • 111 Types
    • 112 Modes
    • 113 Constraints
    • 114 Object-orientation
    • 115 Graphics
    • 116 Concurrency
    • 117 Web programming
    • 118 Adobe Flash
    • 119 Other
  • 12 Interfaces to other languages
  • 13 History
  • 14 Use in industry
  • 15 See also
    • 151 Related languages
  • 16 References
  • 17 Further reading
  • 18 External links

Syntax and semantics

Main article: Prolog syntax and semantics

In Prolog, program logic is expressed in terms of relations, and a computation is initiated by running a query 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 refutation of the negated query If the negated query can be refuted, ie, 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, red, 'Taco', 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,

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, or
  • 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:

cattom

which is equivalent to the rule:

cattom :- true

The built-in predicate true/0 is always true

Given the above fact, one can ask:

is tom a cat

- cattom Yes

what things are cats

- catX X = tom

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

animalX :- catX

If we add that rule and ask what things are animals

- animalX 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 lengthList, L, given a list List as well as to generate a list skeleton of a given length lengthX, 5, and also to generate both list skeletons and their lengths together lengthX, L Similarly, append/3 can be used both to append two lists appendListA, ListB, X given lists ListA and ListB as well as to split a given list into parts appendX, 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

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:

mother_childtrude, sally father_childtom, sally father_childtom, erica father_childmike, tom siblingX, Y :- parent_childZ, X, parent_childZ, Y parent_childX, Y :- father_childX, Y parent_childX, Y :- mother_childX, Y

This results in the following query being evaluated as true:

- siblingsally, erica Yes

This is obtained as follows: Initially, the only matching clause-head for the query siblingsally, 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, ie, the conjunction parent_childZ,sally, parent_childZ,erica The next goal to be proved is the leftmost one of this conjunction, ie, parent_childZ, sally Two clause heads match this goal The system creates a choice-point and tries the first alternative, whose body is father_childZ, sally This goal can be proved using the fact father_childtom, sally, so the binding Z = tom is generated, and the next goal to be proved is the second part of the above conjunction: parent_childtom, 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_childFather, Child

enumerates all valid answers on backtracking

Notice that with the code as stated above, the query - siblingsally, 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 \+ illegalX in the rule

legalX :- \+ illegalX

is evaluated as follows: Prolog attempts to prove illegalX If a proof for that goal can be found, the original goal ie, \+ illegalX 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" ie contains no variables Soundness is lost if the argument contains variables and the proof procedure is complete In particular, the query - legalX can now not 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

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_optimizedProg0, Prog :- optimization_pass_1Prog0, Prog1, optimization_pass_2Prog1, Prog2, optimization_pass_3Prog2, 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, Pivot, Smalls, Bigs :- X @< Pivot -> Smalls = , partitionXs, Pivot, Rest, Bigs ; Bigs = , partitionXs, Pivot, Smalls, Rest quicksort --> quicksort --> , quicksortSmaller, , quicksortBigger

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, cliches, program schemata, and logic description schemata An alternative to design patterns is higher order programming

Higher-order programming

Main articles: Higher-order logic and 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, 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 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

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:

perfectN :- between1, inf, N, U is N // 2, findallD, between1,U,D, N mod D =:= 0, Ds, sumlistDs, N

This can be used to enumerate perfect numbers, and also to check whether a number is perfect

As another example, the predicate maplist applies a predicate P to all corresponding positions in a pair of lists:

maplist_, , maplistP, , :- callP, X, Y, maplistP, Xs, Ys

When P is a predicate that for all X, PX,Y unifies Y with a single unique value, maplistP, Xs, Ys is equivalent to applying the map function in functional programming as Ys = mapFunction, Xs

Higher-order programming style in Prolog was pioneered in HiLog and λProlog

Modules

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

Parsing

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

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 difference lists

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:

solvetrue solveSubgoal1,Subgoal2 :- solveSubgoal1, solveSubgoal2 solveHead :- clauseHead, Body, solveBody

where true represents an empty conjunction, and clauseHead, 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 operator that are easily read and inspected using built-in mechanisms like 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::330

solvetrue, 1 :- ! solveSubgoal1,Subgoal2, Certainty :- !, solveSubgoal1, Certainty1, solveSubgoal2, Certainty2, Certainty is minCertainty1, Certainty2 solveGoal, 1 :- builtinGoal, !, Goal solveHead, Certainty :- clause_cfHead, Body, Certainty1, solveBody, Certainty2, Certainty is Certainty1 Certainty2

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

builtinA is B builtinreadX % etc

and clauses represented as clause_cfHead, Body, Certainty Given those, it can be called as solveGoal, 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 predicate logic, Horn clauses, which is Turing-complete Turing completeness of Prolog can be shown by using it to simulate a Turing machine:

turingTape0, Tape :- performq0, , Ls, Tape0, Rs, reverseLs, Ls1, appendLs1, Rs, Tape performqf, Ls, Ls, Rs, Rs :- ! performQ0, Ls0, Ls, Rs0, Rs :- symbolRs0, Sym, RsRest, onceruleQ0, Sym, Q1, NewSym, Action, actionAction, Ls0, Ls1, , Rs1, performQ1, Ls1, Ls, Rs1, Rs symbol, b, symbol, Sym, Rs actionleft, Ls0, Ls, Rs0, Rs :- leftLs0, Ls, Rs0, Rs actionstay, Ls, Ls, Rs, Rs actionright, Ls0, , , Rs left, , Rs0, left, Ls, Rs,

A simple example Turing machine is specified by the facts:

ruleq0, 1, q0, 1, right ruleq0, 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, Ts Ts = ;

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

Implementation

Further information: Comparison of Prolog implementations

ISO Prolog

The ISO Prolog standard consists of two parts ISO/IEC 13211-1, published in 1995, aims to standardize the existing practices of the many implementations of the core elements of Prolog It has clarified aspects of the language that were previously ambiguous and leads to portable programs There are two corrigenda: Cor1:2007 and Cor2:2012 ISO/IEC 13211-2, published in 2000, adds support for modules to the standard The standard is maintained by the ISO/IEC JTC1/SC22/WG17 working group ANSI X3J17 is the US Technical Advisory Group for the standard

Compilation

For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-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 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

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

Main article: 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 sub-linear-time lookups Indexing only affects program performance, it does not affect semantics Most Prologs only use indexing on the first term, as indexing on all terms is expensive, but techniques based on field-encoded words or superimposed codewords provide fast indexing across the full query and head

Hashing

Some Prolog systems, such as LPA 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, BProlog, XSB Yap, B-Prolog and Ciao, implement a memoization method called tabling, which frees the user from manually storing intermediate results

Subgoals encountered in a query evaluation are maintained in a table, along with answers to these subgoals If a subgoal is re-encountered, the evaluation reuses information from the table rather than re-performing resolution against program clauses

Tabling is a space-time tradeoff; execution time can be reduced by using more memory to store intermediate results

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 Furthermore, Prolog has a number of properties that may allow speed-up through parallel execution A more recent approach has been to compile restricted Prolog programs to a field programmable gate array However, rapid progress in general-purpose hardware has consistently overtaken more specialised architectures

Limitations

Although Prolog is widely used in research and education, Prolog and other logic programming languages have not had a significant impact on the computer industry in general Most applications are small by industrial standards, with few exceeding 100,000 lines of code Programming in the 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 Portability of Prolog code across implementations has also been a problem, but developments since 2007 have meant: "the portability within the family of Edinburgh/Quintus derived Prolog implementations is good enough to allow for maintaining portable real-world applications"

Software developed in Prolog has been criticised for having a high performance penalty compared to conventional programming languages In particular, Prolog's non-deterministic evaluation strategy can be problematic when programming deterministic computations, or when even using "don't care non-determinism" where a single choice is made instead of backtracking over all possibilities Cuts and other language constructs may have to be used to achieve desirable performance, destroying one of Prolog's main attractions, the ability to run programs "backwards and forwards"

Prolog is not purely declarative: because of constructs like the cut operator, a procedural reading of a Prolog program is needed to understand it The order of clauses in a Prolog program is significant, as the execution strategy of the language depends on it Other logic programming languages, such 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

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, and as of 2008 there are still attempts to extend Prolog with types Type information is useful not only for type safety but also for reasoning about Prolog programs

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 However, this information is significant and it is recommended that it be included in the comments Modes provide valuable information when reasoning about Prolog programs and can also be used to accelerate execution

Constraints

Constraint logic programming extends Prolog to include concepts from constraint satisfaction A constraint logic program allows constraints in the body of clauses, such as: AX,Y :- X+Y>0 It is suited to large-scale combinatorial optimisation problems 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

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

Graphics

Prolog systems that provide a graphics library are SWI-prolog, Visual-prolog, LPA Prolog for Windows and B-Prolog

Concurrency

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

Web programming

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

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

  • F-logic extends Prolog with frames/objects for 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 the embedding of LPA Prolog within C, C#, C++, Java, VB, Delphi, Net, Lua, Python and other languages It exploits the dedicated string data-type which LPA Prolog provides
  • 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, with support for SWI-Prolog and YAP planned for 2013
  • 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 gnuprolog
  • 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
  • Jekejeke Prolog API provides tightly coupled concurrent call-in and call-out facilities between Prolog and Java or Android, with the marked possibility to create individual knowledge base objects It can be used to embed the ISO Prolog interpreter in standalones, applets, servlets, APKs, etc
  • A Warren Abstract Machine for PHP A Prolog compiler and interpreter in PHP 53 A library that can be used standalone or within Symfony21 framework

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 Colmerauer and Phillipe Roussel 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

European AI researchers favored Prolog while Americans favored Lisp, reportedly causing many nationalistic debates on the merits of the languages 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 notBi 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 Watson Watson uses IBM's DeepQA software and the Apache UIMA Unstructured Information Management Architecture framework The system was written in various languages, including Java, C++, and Prolog, and runs on the SUSE Linux Enterprise Server 11 operating system using Apache Hadoop framework to provide distributed computing Prolog is used for pattern matching over natural language parse trees The developers have stated: "We required a language in which we could conveniently express pattern matching rules over the parse trees and other annotations such as named entity recognition results, and a technology that could execute these rules very efficiently We found that Prolog was the ideal choice for the language due to its simplicity and expressiveness"

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 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 offshoot 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 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
  • Erlang began life with a Prolog-based implementation and maintains much of Prolog's unification-based syntax

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, NJ: 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" PDF Communications of the ACM 31: 38 doi:101145/3504335046 
  6. ^ Colmerauer, A; Roussel, P 1993 "The birth of Prolog" PDF ACM SIGPLAN Notices 28 3: 37 doi:101145/155360155362 
  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:101007/BF00297245 
  9. ^ Merritt, Dennis 1989 Building expert systems in Prolog Berlin: Springer-Verlag ISBN 0-387-97016-9 
  10. ^ Fernando C N Pereira; Stuart M Shieber 2005 Prolog and Natural Language Analysis Microtome 
  11. ^ a b Adam Lally; Paul Fodor 31 March 2011 "Natural Language Processing With Prolog in the IBM Watson System" Association for Logic Programming  See also Watson computer
  12. ^ Covington, Michael A; Bagnara, Roberto; O'Keefe, Richard A; Wielemaker, Jan; Price, Simon 2011 "Coding guidelines for Prolog" Theory and Practice of Logic Programming 12 6: 889–927 arXiv:09112899 doi:101017/S1471068411000391 
  13. ^ Kirschenbaum, M; Sterling, LS 1993 "Applying Techniques to Skeletons" Constructing Logic Programs, ed JMJ Jacquet: 27–140 
  14. ^ Sterling, Leon 2002 "Patterns for Prolog Programming" Computational Logic: Logic Programming and Beyond Lecture Notes in Computer Science / Lecture Notes in Artificial Intelligence 2407 pp 17–26 doi:101007/3-540-45628-7_15 ISBN 978-3-540-43959-2 
  15. ^ 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
  16. ^ Gegg-harrison, T S 1995 Representing Logic Program Schemata in Prolog Procs Twelfth International Conference on Logic Programming pp 467–481 
  17. ^ Deville, Yves 1990 Logic programming: systematic program development Wokingham, England: Addison-Wesley ISBN 0-201-17576-2 
  18. ^ a b Naish, Lee 1996 Higher-order logic programming in Prolog Report Department of Computer Science, University of Melbourne Retrieved 2010-11-02 
  19. ^ With regard to Prolog variables, variables only in the head are implicitly universally quantified, and those only in the body are implicitly existentially quantified http://okmijorg/ftp/Prolog/quantificationtxt Retrieved 2013-05-04
  20. ^ a b c ISO/IEC 13211: Information technology — Programming languages — Prolog International Organization for Standardization, Geneva
  21. ^ ISO/IEC 13211-2: Modules
  22. ^ a b Paulo Moura, Logtalk in Association of Logic Programming Newsletter Vol 17 n 3, August 2004
  23. ^ a b Shapiro, Ehud Y; Sterling, Leon 1994 The Art of Prolog: Advanced Programming Techniques Cambridge, Mass: MIT Press ISBN 0-262-19338-8 
  24. ^ A Ed-Dbali; Deransart, Pierre; L Cervoni; 1996 Prolog: the standard: reference manual Berlin: Springer ISBN 3-540-59304-7  CS1 maint: Multiple names: authors list link
  25. ^ ISO/IEC 13211-1:1995/Cor1:2007
  26. ^ ISO/IEC 13211-1:1995/Cor 2:2012
  27. ^ WG17 Working Group
  28. ^ X3J17 Committee
  29. ^ David H D Warren "An abstract Prolog instruction set" Technical Note 309, SRI International, Menlo Park, CA, October 1983
  30. ^ Van Roy, P; Despain, A M 1992 "High-performance logic programming with the Aquarius Prolog compiler" Computer 25: 54 doi:101109/2108055 
  31. ^ Graf, Peter 1995 Term indexing Springer ISBN 978-3-540-61040-3 
  32. ^ 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 
  33. ^ Colomb, Robert M 1991 "Enhancing unification in PROLOG through clause indexing" The Journal of Logic Programming 10: 23 doi:101016/0743-10669190004-9 
  34. ^ Swift, T 1999 "Tabling for non‐monotonic programming" Annals of Mathematics and Artificial Intelligence 25 3/4: 201–200 doi:101023/A:1018990308362 
  35. ^ 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 
  36. ^ Swift, T; Warren, D S 2011 "XSB: Extending Prolog with Tabled Logic Programming" Theory and Practice of Logic Programming 12: 157 doi:101017/S1471068411000500 
  37. ^ Abe, S; Bandoh, T; Yamaguchi, S; Kurosawa, K; Kiriyama, K 1987 "High performance integrated Prolog processor IPP" Proceedings of the 14th annual international symposium on Computer architecture - ISCA '87 p 100 doi:101145/3035030362 ISBN 0818607769 
  38. ^ Robinson, Ian 1986 A Prolog processor based on a pattern matching memory device Third International Conference on Logic Programming Lecture Notes in Computer Science 225 Springer pp 172–179 doi:101007/3-540-16492-8_73 ISBN 978-3-540-16492-0 
  39. ^ Taki, K; Nakajima, K; Nakashima, H; Ikeda, M 1987 "Performance and architectural evaluation of the PSI machine" ACM SIGPLAN Notices 22 10: 128 doi:101145/3620536195 
  40. ^ 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:101145/504083504085 
  41. ^ http://wwwclcamacuk/~am21/research/sa/byrdboxpsgz
  42. ^ 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
  43. ^ The Prolog 1000 database http://wwwfaqsorg/faqs/prolog/resource-guide/part1/section-9html
  44. ^ Jan Wielemaker and Vıtor Santos Costa: Portability of Prolog programs: theory and case-studies CICLOPS-WLPE Workshop 2010
  45. ^ a b Kiselyov, Oleg; Kameyama, Yukiyoshi 2014 Re-thinking Prolog Proc 31st meeting of the Japan Society for Software Science and Technology 
  46. ^ Torkel Franzen 1994 Declarative vs procedural Association of Logic Programming Newsletter Vol 73
  47. ^ Dantsin, Evgeny; Eiter, Thomas; Gottlob, Georg; Voronkov, Andrei 2001 "Complexity and Expressive Power of Logic Programming" ACM Computing Surveys 33 3: 374–425 doi:101145/502807502810 
  48. ^ Mycroft, A; O'Keefe, R A 1984 "A polymorphic type system for prolog" Artificial Intelligence 23 3: 295 doi:101016/0004-37028490017-1 
  49. ^ Pfenning, Frank 1992 Types in logic programming Cambridge, Mass: MIT Press ISBN 0-262-16131-1 
  50. ^ Schrijvers, Tom; Santos Costa, Vitor; Wielemaker, Jan; Demoen, Bart 2008 "Towards Typed Prolog" In Maria Garcia de la Banda; Enrico Pontelli Logic programming : 24th international conference, ICLP 2008, Udine, Italy, December 9-13, 2008 : proceedings Lecture Notes in Computer Science 5366 pp 693–697 doi:101007/978-3-540-89982-2_59 ISBN 9783540899822 
  51. ^ 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:101007/BF01213601 
  52. ^ O'Keefe, Richard A 1990 The craft of Prolog Cambridge, Mass: MIT Press ISBN 0-262-15039-5 
  53. ^ Michael Covington; et al 2010 "Coding guidelines for Prolog" arXiv:09112899  
  54. ^ 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 p 111 doi:101007/BFb0014976 ISBN 3-540-17611-X 
  55. ^ Jaffar, J 1994 "Constraint logic programming: a survey" The Journal of Logic Programming 19-20: 503–581 doi:101016/0743-10669490033-7 
  56. ^ Colmerauer, Alain 1987 "Opening the Prolog III Universe" Byte August 
  57. ^ Wallace, M 2002 "Constraint Logic Programming" Computational Logic: Logic Programming and Beyond Lecture Notes in Computer Science 2407 pp 512–556 doi:101007/3-540-45628-7_19 ISBN 3540456287 
  58. ^ "XPCE graphics library" 
  59. ^ "prolog-mpi" Appslumiilv Retrieved 2010-09-16 
  60. ^ Ehud Shapiro The family of concurrent logic programming languages ACM Computing Surveys September 1989
  61. ^ Wielemaker, J; Huang, Z; Van Der Meij, L 2008 "SWI-Prolog and the web" Theory and Practice of Logic Programming 8 03 doi:101017/S1471068407003237 
  62. ^ Jan Wielemaker and Michiel Hildebrand and Jacco van Ossenbruggen 2007, S Heymans; A Polleres; E Ruckhaus; D Pearse; G Gupta, eds, "Using 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, Porto, Portugal: CEUR-WSorg, 287, pp 84–98 
  63. ^ 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
  64. ^ Loke, S W; Davison, A 2001 "Secure Prolog-based mobile code" Theory and Practice of Logic Programming 1 doi:101017/S1471068401001211 
  65. ^ Pountain, Dick October 1984 "POP and SNAP" BYTE p 381 Retrieved 23 October 2013 

Further reading

  • Blackburn, Patrick; Bos, Johan; Striegnitz, Kristina 2006 Learn Prolog Now! 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
  • 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 978-0-13-629213-5
  • M S Dawe and CMDawe, 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 Creative Commons license at https://sitesgooglecom/site/prologforprogrammers/ ISBN 0-12-416521-4
  • Richard O'Keefe, The Craft of Prolog, 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
  • Leon Sterling and Ehud Shapiro, The Art of Prolog: Advanced Programming Techniques, 1994, 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

External links

  • complangprolog FAQ
  • Prolog: The ISO standard
  • DECsystem-10 Prolog User’s Manual plain text describes a typical Edinburgh Prolog
  • Prolog Tutorial by JRFisher
  • Runnable examples by Lloyd Allison
  • On-line guide to Prolog Programming by Roman Bartak
  • Prolog and Logic Programming by Dr Peter Hancox
  • Adventure in Prolog, online tutorial by Dennis Merritt
  • Building Expert Systems in Prolog, online book by Dennis Merritt
  • Object Oriented Language: Prolog, OOLP and other extensions by Richard Katz
  • Amzi! Prolog + Logic Server™ by Dennis Merritt
  • Prolog Tutorial I by Clive Spenser, LPA
  • Prolog Tutorial II by Clive Spenser, LPA
  • JIProlog by Ugo Chirico

pro logo, prolog tutorial, prologistix, prologistix staffing, prologistix temp agency, prologue, prologue meaning, prologue romeo and juliet, prologue to the canterbury tales, www.prologistix.com


Prolog Information about

Prolog


  • user icon

    Prolog beatiful post thanks!

    29.10.2014


Prolog
Prolog
Prolog viewing the topic.
Prolog what, Prolog who, Prolog explanation

There are excerpts from wikipedia on this article and video

Random Posts

IP address blocking

IP address blocking

IP address blocking prevents connection between a server or website and certain IP addresses or rang...
Gisele Bündchen

Gisele Bündchen

Gisele Caroline Bündchen1 Portuguese pronunciation: ʒiˈzɛli kaɾoˈlini ˈbĩtʃẽj, German pronuncia...
Sheldon, West Midlands

Sheldon, West Midlands

Sheldon is an area of east Birmingham, England Historically part of Warwickshire, it is close to the...
Beverly, Chicago

Beverly, Chicago

Beverly is one of the 77 community areas of Chicago, Illinois It is located on the South Side on the...