Paradigm | Logic programming |
---|---|
Designed by | Alain Colmerauer, Robert Kowalski |
First appeared | 1972 |
Filename extensions | .pl , .pro , .P |
Major implementations | |
B-Prolog, Ciao, ECLiPSe, GNU Prolog, Jekejeke Prolog, Poplog Prolog, P#, Quintus 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, KL0, KL1, Mercury, Oz, Strand, Visual Prolog, XSB | |
|
Prolog is a logic programming language associated with artificial intelligence and computational linguistics.[1][2][3]
Prolog Tutorial. Robinson: A program is a theory (in some logic) and computation is deduction from the theory. Wirth: Program = data structure + algorithm. Kowalski: Algorithm = logic + control. Prolog, which stands for PROgramming in LOGic, is the most widely available language in the logic programming paradigm. Login to Prolog from PrologLogin.com.Your Prolog username is the same as your Ledcor username. ? Resources: Prolog Dashboards are now available on PowerBI. User Guides: Step-by-step guides that show how to use every form in Prolog. Training Videos are now available.More coming soon.
Prolog has its roots in first-order logic, a formal logic, and unlike many other programming languages, Prolog is intended primarily as a declarative programming language: 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 Alain Colmerauer and his group 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 the most popular among such languages today, with several free and commercial implementations available. The language has been used for theorem proving,[8]expert systems,[9]term rewriting,[10]type systems,[11] and automated planning,[12] as well as its original intended field of use, natural language processing.[13][14] Modern Prolog environments support the creation of 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.
- 1Syntax and semantics
- 2Programming in Prolog
- 9Implementation
- 11Extensions
- 15See also
Syntax and semantics[edit]
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 resolutionrefutation 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[edit]
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. ISO standard compatible Prolog systems can check the Prolog flag 'bounded'. 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]
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'
.[15]
ISO Prolog provides the
atom/1
, number/1
, integer/1
, and float/1
predicates for type-checking.[16]Rules and facts[edit]
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
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 logical operator
,/2
(meaning an arity 2 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:
which is equivalent to the rule:
The built-in predicate
true/0
is always true.Given the above fact, one can ask:
is tom a cat?
what things are cats?
Clauses with bodies are called rules. An example of a rule is:
If we add that rule and ask what things are animals?
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.Execution[edit]
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:
This results in the following query being evaluated as true:
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: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[edit]
Iterative algorithms can be implemented by means of recursive predicates.[17]
Negation[edit]
The built-in Prolog predicate
+/1
provides negation as failure, which allows for non-monotonic reasoning. The goal + illegal(X)
in the ruleis 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[edit]
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.[18]Here follow some example programs written in Prolog.
Picture collage maker 4 serial key code. Picture Collage Maker Pro 4.0+Key-P.M.4.Picture Collage Maker Pro 4.1.4 Crack is an influential and easy-to-use picture collage software that assistance operators for making photo collages. Picture Collage Maker Pro With Serial Key a simple-to-use Windows package that goes normal pictures and pictures into spectacular keepsakes to share with. Picture Collage Maker Pro 41.4 serial key free download is a picture plus photos college application essentially designed fascinating and great image collage with your electronic pictures and photos. It provides you the least difficult way to producing super awesome picture collage Crack than any other application of its type. Picture Collage Maker Pro 4.1.4 Crack is a powerful and easy-to-use photo collage application that help users for creating photo collages and digital scrapbooks from ordinary photos with very easy and quick method. Download Picture Collage Maker Pro 4.1.4 License Key from our website and enjoy this paid software registration without any cost 100 percent working and free registration.
Hello World[edit]
An example of a query:
Compiler optimization[edit]
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:
or equivalently using DCG notation:
Quicksort[edit]
The quicksort sorting algorithm, relating a list to its sorted version:
Design patterns[edit]
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,[19][20] cliches,[21] program schemata,[22] and logic description schemata.[23]An alternative to design patterns is higher order programming.[24]
Higher-order programming[edit]
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,[25] 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
.[26] 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.[24]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:
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: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[edit]
For programming in the large, Prolog provides a module system. The module system is standardised by ISO.[27] However, not all Prolog compilers support modules, and there are compatibility problems between the module systems of the major Prolog compilers.[28] Consequently, modules written on one Prolog compiler will not necessarily work on others.
Parsing[edit]
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,[clarification needed] 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[edit]
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:
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 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:[29]:330This interpreter uses a table of built-in Prolog predicates of the form[29]:327
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[edit]
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:
A simple example Turing machine is specified by the facts:
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:
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[edit]
ISO Prolog[edit]
The ISO Prolog standard consists of two parts. ISO/IEC 13211-1,[26][30] published in 1995, aims to standardize the existing practices of the many implementations of the core elements of Prolog. It has clarified aspects of the language that were previously ambiguous and leads to portable programs. There are three corrigenda: Cor.1:2007[31], Cor.2:2012,[32] and Cor.3:2017.[33] ISO/IEC 13211-2,[26] published in 2000, adds support for modules to the standard. The standard is maintained by the ISO/IEC JTC1/SC22/WG17[34] working group. ANSI X3J17 is the US Technical Advisory Group for the standard.[35]
Compilation[edit]
For efficiency, Prolog code is typically compiled to abstract machine code, often influenced by the register-based Warren Abstract Machine (WAM) instruction set.[36] 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.[37] 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[edit]
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[edit]
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.[38] 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.[39][40]
Hashing[edit]
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[edit]
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.[41][42]
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.[43]
Tabling is a space–time tradeoff; execution time can be reduced by using more memory to store intermediate results.
Implementation in hardware[edit]
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.[44][45][46] Furthermore, Prolog has a number of properties that may allow speed-up through parallel execution.[47] A more recent approach has been to compile restricted Prolog programs to a field programmable gate array.[48] However, rapid progress in general-purpose hardware has consistently overtaken more specialised architectures.
Limitations[edit]
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.[49] Most applications are small by industrial standards, with few exceeding 100,000 lines of code.[49][50]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.[28] 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.'[51]
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'.[52]
Prolog is not purely declarative: because of constructs like the cut operator, a procedural reading of a Prolog program is needed to understand it.[53] The order of clauses in a Prolog program is significant, as the execution strategy of the language depends on it.[54] 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.[52]
Extensions[edit]
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[edit]
Prolog is an untyped language. Attempts to introduce types date back to the 1980s,[55][56] and as of 2008 there are still attempts to extend Prolog with types.[57] Type information is useful not only for type safety but also for reasoning about Prolog programs.[58]
Modes[edit]
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.[59] However, this information is significant and it is recommended that it be included in the comments.[60] Modes provide valuable information when reasoning about Prolog programs[58] and can also be used to accelerate execution.[61]
Constraints[edit]
Constraint logic programming extends Prolog to include concepts from constraint satisfaction.[62][63] 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[64] 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[edit]
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[edit]
Prolog systems that provide a graphics library are SWI-Prolog,[65]Visual Prolog, WIN-PROLOG, and B-Prolog.
Concurrency[edit]
Prolog-MPI is an open-source SWI-Prolog extension for distributed computing over the Message Passing Interface.[66] Also there are various concurrent Prolog programming languages.[67]
Web programming[edit]
Some Prolog implementations, notably SWI-Prolog and Ciao, support server-sideweb programming with support for web protocols, HTML and XML.[68] There are also extensions to support semantic web formats such as RDF and OWL.[69][70] Prolog has also been suggested as a client-side language.[71]
Adobe Flash[edit]
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[edit]
- 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[edit]
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[14]
See also[edit]
- Logico-linguistic modeling. A method for building knowledge-based system that uses Prolog.
- Answer set programming. A fully declarative approach to logic programming.
Related languages[edit]
- 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 typedobject-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.
- 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.
- 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.
References[edit]
- ^Clocksin, William F.; Mellish, Christopher S. (2003). Programming in Prolog. Berlin ; New York: Springer-Verlag. ISBN978-3-540-00678-7.
- ^Bratko, Ivan (2012). Prolog programming for artificial intelligence (4th ed.). Harlow, England ; New York: Addison Wesley. ISBN978-0-321-41746-6.
- ^Covington, Michael A. (1994). Natural language processing for Prolog programmers. Englewood Cliffs, N.J.: Prentice Hall. ISBN978-0-13-629213-5.
- ^ abLloyd, J. W. (1984). Foundations of logic programming. Berlin: Springer-Verlag. ISBN978-3-540-13299-8.
- ^ abKowalski, R. A. (1988). 'The early years of logic programming'(PDF). Communications of the ACM. 31: 38. doi:10.1145/35043.35046.
- ^Colmerauer, A.; Roussel, P. (1993). 'The birth of Prolog'(PDF). ACM SIGPLAN Notices. 28 (3): 37. doi:10.1145/155360.155362.
- ^See Logic programming § History.
- ^Stickel, M. E. (1988). 'A prolog technology theorem prover: Implementation by an extended prolog compiler'. Journal of Automated Reasoning. 4 (4): 353–380. CiteSeerX10.1.1.47.3057. doi:10.1007/BF00297245.
- ^Merritt, Dennis (1989). Building expert systems in Prolog. Berlin: Springer-Verlag. ISBN978-0-387-97016-5.
- ^Felty, Amy. 'A logic programming approach to implementing higher-order term rewriting.' Extensions of Logic Programming (1992): 135-161.
- ^Kent D. Lee (19 January 2015). Foundations of Programming Languages. Springer. pp. 298–. ISBN978-3-319-13314-0.
- ^Ute Schmid (21 August 2003). Inductive Synthesis of Functional Programs: Universal Planning, Folding of Finite Programs, and Schema Abstraction by Analogical Reasoning. Springer Science & Business Media. ISBN978-3-540-40174-2.
- ^Fernando C. N. Pereira; Stuart M. Shieber (2005). Prolog and Natural Language Analysis. Microtome.
- ^ abAdam Lally; Paul Fodor (31 March 2011). 'Natural Language Processing With Prolog in the IBM Watson System'. Association for Logic Programming. See also Watson (computer).
- ^ISO/IEC 13211-1:1995 Prolog, 6.3.7 Terms - double quoted list notation. International Organization for Standardization, Geneva.
- ^Verify Type of a Term - SWI-Prolog
- ^Carlsson, Mats (27 May 2014). SICStus Prolog User's Manual 4.3: Core reference documentation. BoD – Books on Demand. ISBN9783735737441 – via Google Books.
- ^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:0911.2899. doi:10.1017/S1471068411000391.
- ^Kirschenbaum, M.; Sterling, L.S. (1993). 'Applying Techniques to Skeletons'. Constructing Logic Programs, (ed. J.M.J. Jacquet): 27–140. CiteSeerX10.1.1.56.7278
- ^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:10.1007/3-540-45628-7_15. ISBN978-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
- ^Deville, Yves (1990). Logic programming: systematic program development. Wokingham, England: Addison-Wesley. ISBN978-0-201-17576-9.
- ^ abNaish, Lee (1996). Higher-order logic programming in Prolog (Report). Department of Computer Science, University of Melbourne. CiteSeerX10.1.1.35.4505. Retrieved 2010-11-02.
- ^'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.
- ^ abcISO/IEC 13211: Information technology — Programming languages — Prolog. International Organization for Standardization, Geneva.
- ^ISO/IEC 13211-2: Modules.
- ^ abMoura, Paulo (August 2004), 'Logtalk', Association of Logic Programming, 17 (3)
- ^ abShapiro, Ehud Y.; Sterling, Leon (1994). The Art of Prolog: Advanced Programming Techniques. Cambridge, Massachusetts: MIT Press. ISBN978-0-262-19338-2.
- ^A. Ed-Dbali; Deransart, Pierre; L. Cervoni (1996). Prolog: the standard: reference manual. Berlin: Springer. ISBN978-3-540-59304-1.
- ^'ISO/IEC 13211-1:1995/Cor 1:2007 -'.
- ^'ISO/IEC 13211-1:1995/Cor 2:2012 -'.
- ^'ISO/IEC 13211-1:1995/Cor 3:2017 -'.
- ^'ISO/IEC JTC1 SC22 WG17'.
- ^'X3J17 and the Prolog Standard'.
- ^David H. D. Warren. 'An abstract Prolog instruction set'. Technical Note 309, SRI International, Menlo Park, CA, October 1983.
- ^Van Roy, P.; Despain, A. M. (1992). 'High-performance logic programming with the Aquarius Prolog compiler'. Computer. 25: 54–68. doi:10.1109/2.108055.
- ^Graf, Peter (1995). Term indexing. Springer. ISBN978-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.
- ^Colomb, Robert M. (1991). 'Enhancing unification in PROLOG through clause indexing'. The Journal of Logic Programming. 10: 23–44. doi:10.1016/0743-1066(91)90004-9.
- ^Swift, T. (1999). 'Tabling for non‐monotonic programming'. Annals of Mathematics and Artificial Intelligence. 25 (3/4): 201–240. doi:10.1023/A:1018990308362.
- ^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.
- ^Swift, T.; Warren, D. S. (2011). 'XSB: Extending Prolog with Tabled Logic Programming'. Theory and Practice of Logic Programming. 12 (1–2): 157–187. arXiv:1012.5123. doi:10.1017/S1471068411000500.
- ^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:10.1145/30350.30362. ISBN978-0818607769.
- ^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:10.1007/3-540-16492-8_73. ISBN978-3-540-16492-0.
- ^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.
- ^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.
- ^'Statically Allocated Systems'.
- ^ abLogic 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'.
- ^Jan Wielemaker and Vıtor Santos Costa: Portability of Prolog programs: theory and case-studies. CICLOPS-WLPE Workshop 2010.
- ^ abKiselyov, 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)
- ^Dantsin, Evgeny; Eiter, Thomas; Gottlob, Georg; Voronkov, Andrei (2001). 'Complexity and Expressive Power of Logic Programming'. ACM Computing Surveys. 33 (3): 374–425. CiteSeerX10.1.1.616.6372. doi:10.1145/502807.502810.
- ^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.
- ^Pfenning, Frank (1992). Types in logic programming. Cambridge, Massachusetts: MIT Press. ISBN978-0-262-16131-2.
- ^Schrijvers, Tom; Santos Costa, Vitor; Wielemaker, Jan; Demoen, Bart (2008). 'Towards Typed Prolog'. In Maria Garcia de la Banda; Enrico Pontelli (eds.). 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. ISBN9783540899822.
- ^ abApt, K. R.; Marchiori, E. (1994). 'Reasoning about Prolog programs: From modes through types to assertions'. Formal Aspects of Computing. 6 (S1): 743. CiteSeerX10.1.1.57.395. doi:10.1007/BF01213601.
- ^O'Keefe, Richard A. (1990). The craft of Prolog. Cambridge, Massachusetts: MIT Press. ISBN978-0-262-15039-2.
- ^Michael Covington; Roberto Bagnara; et al. (2010). 'Coding guidelines for Prolog'. arXiv:0911.2899 [cs.PL].
- ^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:10.1007/BFb0014976. ISBN978-3-540-17611-4.
- ^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.
- ^Colmerauer, Alain (1987). 'Opening the Prolog III Universe'. Byte. August.
- ^Wallace, M. (2002). 'Constraint Logic Programming'. Computational Logic: Logic Programming and Beyond. Lecture Notes in Computer Science. 2407. pp. 512–556. doi:10.1007/3-540-45628-7_19. ISBN978-3540456285.
- ^'XPCE graphics library'.
- ^'prolog-mpi'. Apps.lumii.lv. Retrieved 2010-09-16.
- ^Ehud Shapiro. The family of concurrent logic programming languagesACM Computing Surveys. September 1989.
- ^Wielemaker, J.; Huang, Z.; Van Der Meij, L. (2008). 'SWI-Prolog and the web'(PDF). Theory and Practice of Logic Programming. 8 (3): 363. doi:10.1017/S1471068407003237.
- ^Jan Wielemaker and Michiel Hildebrand and Jacco van Ossenbruggen (2007), S. Heymans; A. Polleres; E. Ruckhaus; D. Pearse; G. Gupta (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, Porto, Portugal: CEUR-WS.org, 287, 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
- ^Loke, S. W.; Davison, A. (2001). 'Secure Prolog-based mobile code'. Theory and Practice of Logic Programming. 1 (3): 321. arXiv:cs/0406012. CiteSeerX10.1.1.58.6610. doi:10.1017/S1471068401001211.
- ^http://apice.unibo.it/xwiki/bin/view/Tuprolog/WebHome#
- ^Pountain, Dick (October 1984). 'POP and SNAP'. BYTE. p. 381. Retrieved 23 October 2013.
Further reading[edit]
- Blackburn, Patrick; Bos, Johan; Striegnitz, Kristina (2006). Learn Prolog Now!. ISBN978-1-904987-17-8.
- Ivan Bratko, Prolog Programming for Artificial Intelligence, 4th ed., 2012, ISBN978-0-321-41746-6. Book supplements and source code[permanent dead link]
- William F. Clocksin, Christopher S. Mellish: Programming in Prolog: Using the ISO Standard. Springer, 5th ed., 2003, ISBN978-3-540-00678-7. (This edition is updated for ISO Prolog. Previous editions described Edinburgh Prolog.)
- William F. Clocksin: Clause and Effect. Prolog Programming for the Working Programmer. Springer, 2003, ISBN978-3-540-62971-9.
- Michael A. Covington, Donald Nute, Andre Vellino, Prolog Programming in Depth, 1996, ISBN0-13-138645-X.
- Michael A. Covington, Natural Language Processing for Prolog Programmers, 1994, ISBN978-0-13-629213-5
- M. S. Dawe and C.M.Dawe, Prolog for Computer Sciences, Springer Verlag 1992.
- ISO/IEC 13211: Information technology — Programming languages — Prolog. International Organization for Standardization, Geneva.
- Feliks Kluźniak and Stanisław Szpakowicz (with a contribution by Janusz S. Bień). Prolog for Programmers. Academic Press Inc. (London), 1985, 1987 (available under a Creative Commons license at sites.google.com/site/prologforprogrammers/{{Dead[permanent dead link] link|date=August 2019 |bot=InternetArchiveBot |fix-attempted=yes }}). ISBN0-12-416521-4.
- Richard O'Keefe, The Craft of Prolog, ISBN0-262-15039-5.
- Robert Smith, John Gibson, Aaron Sloman: 'POPLOG's two-level virtual machine support for interactive languages', 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, ISBN0-262-19338-8.
- David H D Warren, Luis M. Pereira and Fernando Pereira, Prolog - the language and its implementation compared with Lisp. ACM SIGART Bulletin archive, Issue 64. Proceedings of the 1977 symposium on Artificial intelligence and programming languages, pp 109–115.
Wikibooks has more on the topic of: Prolog
Retrieved from 'https://en.wikipedia.org/w/index.php?title=Prolog&oldid=917620620'
Go to the first, previous, next, last section, table of contents.Jasper is a bi-directional interface between programs written inJava and programs written in Prolog. The Java-side of the interfaceconstists of a Java package (
jasper
) containing classesrepresenting the SICStus emulator. The Prolog part is designed as anextension to the foreign language interface, which means thatforeign/3
declarations are used to map Java-methods on Prologpredicates and provide automatic conversion of arguments.Jasper can be operated in two different ways, depending on whichemulator is used as top-level application; the Java Runtime System orthe SICStus Development System. When the Java Runtime System is used asa top-level application, the SICStus runtime kernel is loaded intothe Java Runtime System. When the Java Runtime System is loaded into theSICStus Development System, it is loaded as any other foreign resource,i.e. by using
load_foreign_resource/1
. This distinction is notvisible to the programmer, but it is useful to have a picture of how theinterface works.Note: Some of the information in this chapter is arecapitulation of the information in the chapter section Mixing C and Prolog. The intention is that this chapter should be possible to readfairly independently.
- Java Resources Online: Useful links to online Java resources
Prerequisites
The low-level interface uses the JNI (Java Native Interface) to call Cfunctions from Java. The JNI is a native interface standard developed bySun Microsystems. See section Resources. Since the interface usesthe JNI, it is necessary that the Java VM which is to be used hassupport for JNI. Even though the JNI is intended as a standard, not allvendors support it. If your Java installation does not support the JNI,Sun's Java Runtime Environment provides a minimal executionenviroment for running Java code. It can be downloaded from
The rest of this chapter assumes that there is a Java installation withJNI support available.
Calling Java from Prolog
Java methods are called from Prolog much in the same way as C functionsare called (see section Calling C from Prolog); by creating a foreignresource. When loaded, this resource installs a set of predicates whichare mapped onto Java-methods and when invoked, converts the Prologarguments to the corresponding Java-types before calling the Javamethod itself.
In fact, a foreign resource (as defined in section Foreign Resource and Conversion Declarations) isnot language specific itself. The language is instead specified in thesecond argument to the
foreign/3
fact and it is possible to mixforeign C functions with foreign Java methods.How a foreign resource is created in general is described in detail insection Creating the Linked Foreign Resource. The following section(s) willfocus on the Java-specific parts of foreign resources.
Static and Dynamic Linking
There is no support for static linking of foreign resources containingJava declarations, since Java implementations usually do not supportstatic linking.
Declarating Java-methods
Java-methods are declared similarly to C-functions. There are twomajor differences. The first is how methods are identified. It is notenough to simply use an atom as the C interface does. Instead, a term
method/3
is introduced:foreign(+MethodIdentifier,
java
, +Predicate)- A hook predicate, specifies the Prolog interface to a Java method.MethodIdentifier is
method/3
term as describedabove. Predicate specifies the name of the Prolog predicate thatwill be used to call MethodIdentifier. Predicate also specifieshow the predicate arguments are to be translated into the correspondingJava arguments.
Conversions between Prolog Arguments and Java Types
The following table lists the possible values of arguments of thepredicate specification to
foreign/3
. The value declares whichconversion between corresponding Prolog argument and Java type will takeplace.Note: The conversion declarations (composed of the declaratorsspecified below) together with the
method/3
term are used by theglue-code generator to create the method's type signature, i.e. astring which can uniquely identify a method within a class. This meansthat unlike the C interface, the conversion declarations for a Javamethod will affect the lookup of the method-name (in the C interface,only the function name is relevant). So, if a method is declared asfoo(+integer)
, there must be a method which has the namefoo
and takes one argument of type int
, or an argumentwhich can be automatically converted to an int
(a short
,for example).long
type is 64 bitswide and there is no standardized support for 64 bits integers in C, thevalue will be truncated. So, this declaration is really only useful inorder to indicate which method should be used. For example:In order to be able to indicate that the latter of the foo
methods should be called, a +long
declaration must be used, evenif the value itself will be truncated in the call.Prolog: +float
Java: float
float
.Prolog: +double
Java: double
double
.Prolog: +term
Java: SPTerm
SPTerm
.Prolog: +object(Class)
Java: SPTerm
Class
.Prolog: +atom
Java: SPTerm
SPTerm
.Prolog: +boolean
Java: boolean
true
,false
}. The Javamethod will receive a boolean
.Prolog: +chars
Java: String
String
.Prolog: +string
Java: String
String
.Prolog: -atom
Java: SPTerm
SPTerm
which can be modified. The argument willbe bound to the value of the atom when the method returns.Prolog: -chars
Java: StringBuffer
StringBuffer
which can be modified. Theargument will be bound to a list of the character codes of theStringBuffer
object. Prolog: -string
Java: StringBuffer
StringBuffer
which can be modified. Theargument will be bound to an atom converted from the StringBuffer
object.Prolog: [-integer]
Java: int M()
int
. The value will be convertedto a Prolog integer.Prolog: [-byte]
Java: byte M()
byte
. The value will be convertedto a Prolog integer.Prolog: [-short]
Java: short M()
short
. The value will be convertedto a Prolog integer.Prolog: [-long]
Java: long M()
long
. The value will be convertedand possibly truncated to a Prolog integer.Prolog: [-float]
Java: float M()
float
. The value will be convertedto a Prolog float.Prolog: [-double]
Java: double M()
double
. The value will be convertedto a Prolog float.Prolog: [-term]
Java: SPTerm M()
SPTerm
whichwill be converted to a Prolog term.Prolog: [-object(Class)]
Java: SPTerm M()
Prolog: [-atom]
Java: SPTerm M()
SPTerm
whichwill be converted to a Prolog atom.Prolog: [-boolean]
Java: boolean M()
boolean
. The value will be converted toa Prolog atom in {true
,false
}.Prolog: [-chars]
Java: String M()
String
whichwill be converted to a list of character codes.Prolog: [-string]
Java: String M()
String
whichwill be converted to an atom.Calling Java from Prolog: An Example
The following is an simple, but complete example of how a Java method can be calledfrom Prolog.
First, we must write the resource file. Let us call it `simple.pl'.
This file is the processed with the script
splfr
(see section Interface Predicates) to produce a foreign resource:Note that we do not specify any Java files to
splfr
as we wouldspecify C files when building foreign resources for C code. This isbecause the C code can be compiled into the resource itself, while theJava code must be loaded at runtime into the JVM. This means that theresource will only contain the glue-code for calling the JVM, and noactual Java code. Hence, these resources are usually quite small.Note also that the use of
+dynamic
is implicit and obligatory;resources with Java-calls must be dynamic.Now, we need some Java code to call:
This Java code must now be compiled. Refer to the documentation of yourJava implementation exactly how to do this. On Solaris, this might look like:
Now we are ready to call the method
simple/2
from inside SICStus.What has happened is that the predicate
simple/2
has beeninstalled as a predicate defined in Java (this is not exactly true; thepredicate is defined as a C-function which calls the Java method). Whenwe load the simple
module, we will first load the jasper
module (and thereby the JVM) and then load the simple
foreignresource, which defines the simple/2
predicate.Calling Prolog from Java
Calling Prolog from Java is done by using the Java package
jasper
. This package contains a set of Java classes which can beused to create and manipulate terms, ask queries and request one or moresolutions. The functionality provided by this set of classes isbasically the same as the functionality provided by the C-Prologinterface (see section Mixing C and Prolog).The usage is easiest described by an example. The following is a Javaversion of the
train
example. See section Train Example (connections).This is how it works:
- First, we import all the
jasper
-classes. To find them, theclass-path should be set to contain the path to the SICStus libraries($SP_PATH/library
). How this is done depends on the operatingsystem and which Java implementation is used, but typically there is aenvironment variableCLASSPATH
which contains the path. The pathcan often also be set on the commandline using an option such as`-classpath'. Refer to your Java documentation for more details. - Before any predicates can be called, the SICStus emulator must beinitialized. This is done by instantiating the
SICStus
class. NOTE: This class must only be instantiated once per Javaprocess. Multiple SICStus-objects are not supported.Most methods take a reference to this object as their firstargument. This is implicit in the rest of this chapter, unless otherwisestated. - The next step is to load the Prolog code. This is done by the method
load
. Corresponds toSP_load()
in theC-interface. See section Loading Prolog Code. - Now, everything is set up to start making queries. In order to make aquery, the actual query term must be created. This is done by creatingan object of the
SPPredicate
class: - At this point, we have created a predicate object for the predicate
connected/4
. It is now time to create the arguments for thequery. The arguments are placed in an array which is passed to asuitable method to make the query.The arguments consist of objects of the classSPTerm
. Forexample, if we need two atoms and a variable for the querythe following Java code will do it for us: - Now it is time to make the query. As in the C-Prolog interface, thereare three ways of making a query.
- The main Java resource is Sun's own Java homepage:
- Yahoo:
- Information about the JNI can be found at:
- The ACM student magazine Crossroads has published an article onthe JNI, available online at:
Go to the first, previous, next, last section, table of contents.