Logic programming

Programming paradigm based on formal logic

Programming paradigms

* Action
* Array-oriented
* Automata-based
* Concurrent computing
* Actor-based
* Choreographic programming
* Multitier programming
* Relativistic programming
* Structured concurrency
* Data-driven
* Declarative (contrast: Imperative)
* Functional
* Functional logic
* Purely functional
* Logic
* Abductive logic
* Answer set
* Concurrent logic
* Functional logic
* Inductive logic
* Constraint
* Constraint logic
* Concurrent constraint logic
* Dataflow
* Flow-based
* Reactive
* Functional reactive
* Ontology
* Query language
* Differentiable
* Dynamic/scripting
* Event-driven
* Function-level (contrast: Value-level)
* Point-free style
* Concatenative
* Generic
* Imperative (contrast: Declarative)
* Procedural
* Object-oriented
* Intentional
* Language-oriented
* Domain-specific
* Literate
* Natural-language programming
* Metaprogramming
* Automatic
* Inductive programming
* Reflective
* Attribute-oriented
* Macro
* Template
* Non-structured (contrast: Structured)
* Array
* Nondeterministic
* Parallel computing
* Process-oriented
* Probabilistic
* Quantum
* Set-theoretic
* Stack-based
* Structured (contrast: Non-structured)
* Block-structured
* Object-oriented
* Agent-oriented
* Class-based
* Concurrent
* Prototype-based
* By separation of concerns:
* Aspect-oriented
* Role-oriented
* Subject-oriented
* Recursive
* Symbolic
* Value-level (contrast: Function-level)

* v
* t
* e

Logic programming is a programming paradigm which is largely based on formal logic. Any program written in a logic programming language is a set of sentences in logical form, expressing facts and rules about some problem domain. Major logic programming language families include Prolog, answer set programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:

`H :- B1, …, Bn.`

and are read declaratively as logical implications:

`H if B1 and … and Bn.`

`H` is called the head of the rule and `B1`, ..., `Bn` is called the body. Facts are rules that have no body, and are written in the simplified form:

`H.`

In the simplest case in which `H`, `B1`, ..., `Bn` are all atomic formulae, these clauses are called definite clauses or Horn clauses. However, there are many extensions of this simple case, the most important one being the case in which conditions in the body of a clause can also be negations of atomic formulas. Logic programming languages that include this extension have the knowledge representation capabilities of a non-monotonic logic.

In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal-reduction procedures:

to solve `H`, solve `B1`, and ... and solve `Bn`.

Consider the following clause as an example:

`fallible(X) :- human(X).`

based on an example used by Terry Winograd[1] to illustrate the programming language Planner. As a clause in a logic program, it can be used both as a procedure to test whether `X` is `fallible` by testing whether `X` is `human`, and as a procedure to find an `X` which is `fallible` by finding an `X` which is `human`. Even facts have a procedural interpretation. For example, the clause:

`human(socrates).`

can be used both as a procedure to show that `socrates` is `human`, and as a procedure to find an `X` that is `human` by "assigning" `socrates` to `X`.

The declarative reading of logic programs can be used by a programmer to verify their correctness. Moreover, logic-based program transformation techniques can also be used to transform logic programs into logically equivalent programs that are more efficient. In the Prolog family of logic programming languages, the programmer can also use the known problem-solving behaviour of the execution mechanism to improve the efficiency of programs.

## Contents

* 1 History
* 2 Concepts
* 2.1 Semantics
* 2.2 Logic and control
* 2.3 Problem solving
* 2.4 Negation as failure
* 2.5 Knowledge representation
* 3 Variants and extensions
* 3.1 Prolog
* 3.2 Abductive logic programming
* 3.3 Metalogic programming
* 3.4 Constraint logic programming
* 3.5 Concurrent logic programming
* 3.6 Concurrent constraint logic programming
* 3.7 Inductive logic programming
* 3.8 Higher-order logic programming
* 3.9 Linear logic programming
* 3.10 Object-oriented logic programming
* 3.11 Transaction logic programming
* 4 See also
* 5 Citations
* 6 Sources
* 6.1 General introductions
* 6.2 Other sources
* 7 Further reading
* 8 External links

## History[edit | edit source]

The use of mathematical logic to represent and execute computer programs is also a feature of the lambda calculus, developed by Alonzo Church in the 1930s. However, the first proposal to use the clausal form of logic for representing computer programs was made by Cordell Green.[2] This used an axiomatization of a subset of LISP, together with a representation of an input-output relation, to compute the relation by simulating the execution of the program in LISP. Foster and Elcock's Absys, on the other hand, employed a combination of equations and lambda calculus in an assertional programming language that places no constraints on the order in which operations are performed.[3]

Logic programming in its present form can be traced back to debates in the late 1960s and early 1970s about declarative versus procedural representations of knowledge in artificial intelligence. Advocates of declarative representations were notably working at Stanford, associated with John McCarthy, Bertram Raphael and Cordell Green, and in Edinburgh, with John Alan Robinson (an academic visitor from Syracuse University), Pat Hayes, and Robert Kowalski. Advocates of procedural representations were mainly centered at MIT, under the leadership of Marvin Minsky and Seymour Papert.[citation needed]

Although it was based on the proof methods of logic, Planner, developed at MIT, was the first language to emerge within this proceduralist paradigm.[4] Planner featured pattern-directed invocation of procedural plans from goals (i.e. goal-reduction or backward chaining) and from assertions (i.e. forward chaining). The most influential implementation of Planner was the subset of Planner, called Micro-Planner, implemented by Gerry Sussman, Eugene Charniak and Terry Winograd. It was used to implement Winograd's natural-language understanding program SHRDLU, which was a landmark at that time.[1] To cope with the very limited memory systems at the time, Planner used a backtracking control structure so that only one possible computation path had to be stored at a time. Planner gave rise to the programming languages QA-4, Popler, Conniver, QLISP, and the concurrent language Ether.[citation needed]

Hayes and Kowalski in Edinburgh tried to reconcile the logic-based declarative approach to knowledge representation with Planner's procedural approach. Hayes (1973) developed an equational language, Golux, in which different procedures could be obtained by altering the behavior of the theorem prover.[5] Kowalski, on the other hand, developed SLD resolution,[6] a variant of SL-resolution,[7] and showed how it treats implications as goal-reduction procedures. Kowalski collaborated with Colmerauer in Marseille, who developed these ideas in the design and implementation of the programming language Prolog.

The Association for Logic Programming was founded to promote Logic Programming in 1986.

Prolog gave rise to the programming languages ALF, Fril, Gödel, Mercury, Oz, Ciao, Visual Prolog, XSB, and λProlog, as well as a variety of  concurrent logic programming languages,[8] constraint logic programming languages and Datalog.[9]

## Concepts[edit | edit source]

### Semantics[edit | edit source]

Maarten van Emden and Robert Kowalski defined three semantics for Horn clause logic programs, model-theoretic, fixed-point, and proof-theoretic, and showed that they are equivalent.[10]

### Logic and control[edit | edit source]

Main article: Declarative programming

Logic programming can be viewed as controlled deduction. An important concept in logic programming is the separation of programs into their logic component and their control component. With pure logic programming languages, the logic component alone determines the solutions produced. The control component can be varied to provide alternative ways of executing a logic program. This notion is captured by the slogan

Algorithm = Logic + Control

where "Logic" represents a logic program and "Control" represents different theorem-proving strategies.[11]

### Problem solving[edit | edit source]

In the simplified, propositional case in which a logic program and a top-level atomic goal contain no variables, backward reasoning determines an and-or tree, which constitutes the search space for solving the goal. The top-level goal is the root of the tree. Given any node in the tree and any clause whose head matches the node, there exists a set of child nodes corresponding to the sub-goals in the body of the clause. These child nodes are grouped together by an "and". The alternative sets of children corresponding to alternative ways of solving the node are grouped together by an "or".

Any search strategy can be used to search this space. Prolog uses a sequential, last-in-first-out, backtracking strategy, in which only one alternative and one sub-goal is considered at a time. Other search strategies, such as parallel search, intelligent backtracking, or best-first search to find an optimal solution, are also possible.

In the more general case, where sub-goals share variables, other strategies can be used, such as choosing the subgoal that is most highly instantiated or that is sufficiently instantiated so that only one procedure applies. Such strategies are used, for example, in concurrent logic programming.

### Negation as failure[edit | edit source]

Main article: Negation as failure

For most practical applications, as well as for applications that require non-monotonic reasoning in artificial intelligence, Horn clause logic programs need to be extended to normal logic programs with negative conditions. A clause in a normal logic program has the form:

`H :- A1, …, An, not B1, …, not Bn. `

and is read declaratively as a logical implication:

`H if A1 and … and An and not B1 and … and not Bn.`

where `H` and all the `Ai` and `Bi` are atomic formulas. The negation in the negative literals ` not Bi` is commonly referred to as "negation as failure", because in most implementations, a negative condition ` not Bi` is shown to hold by showing that the positive condition ` Bi` fails to hold. For example:

canfly(X) :- bird(X), not abnormal(X).
abnormal(X) :- wounded(X).
bird(john).
bird(mary).
wounded(john).

Given the goal of finding something that can fly:

:- canfly(X).

there are two candidate solutions, which solve the first subgoal `bird(X)`, namely `X = john` and `X = mary`. The second subgoal `not abnormal(john)` of the first candidate solution fails, because `wounded(john)` succeeds and therefore `abnormal(john)` succeeds. However, the second subgoal `not abnormal(mary)` of the second candidate solution succeeds, because `wounded(mary)` fails and therefore `abnormal(mary)` fails. Therefore, `X = mary` is the only solution of the goal.

Micro-Planner had a construct, called "thnot", which when applied to an expression returns the value true if (and only if) the evaluation of the expression fails. An equivalent operator typically exists in modern Prolog's implementations. It is typically written as `not(Goal)` or `\+ Goal`, where `Goal` is some goal (proposition) to be proved by the program. This operator differs from negation in first-order logic: a negation such as `\+ X == 1` fails when the variable `X` has been bound to the atom `1`, but it succeeds in all other cases, including when `X` is unbound. This makes Prolog's reasoning non-monotonic: `X = 1, \+ X == 1` always fails, while `\+ X == 1, X = 1` can succeed, binding `X` to `1`, depending on whether `X` was initially bound (note that standard Prolog executes goals in left-to-right order).

The logical status of negation as failure was unresolved until Keith Clark [1978] showed that, under certain natural conditions, it is a correct (and sometimes complete) implementation of classical negation with respect to the completion of the program. Completion amounts roughly to regarding the set of all the program clauses with the same predicate on the left hand side, say

`H :- Body1.`
` …`
`H :- Bodyk.`

as a definition of the predicate

`H iff (Body1 or … or Bodyk)`

where "iff" means "if and only if". Writing the completion also requires explicit use of the equality predicate and the inclusion of a set of appropriate axioms for equality. However, the implementation of negation as failure needs only the if-halves of the definitions without the axioms of equality.

For example, the completion of the program above is:

`canfly(X) iff bird(X), not abnormal(X).`
`abnormal(X) iff wounded(X).`
` bird(X) iff X = john or X = mary.`
` X = X.`
` not john = mary.`
` not mary = john.`

The notion of completion is closely related to McCarthy's circumscription semantics for default reasoning, and to the closed world assumption.

As an alternative to the completion semantics, negation as failure can also be interpreted epistemically, as in the stable model semantics of answer set programming. In this interpretation not(Bi) means literally that Bi is not known or not believed. The epistemic interpretation has the advantage that it can be combined very simply with classical negation, as in "extended logic programming", to formalise such phrases as "the contrary can not be shown", where "contrary" is classical negation and "can not be shown" is the epistemic interpretation of negation as failure.

### Knowledge representation[edit | edit source]

The fact that Horn clauses can be given a procedural interpretation and, vice versa, that goal-reduction procedures can be understood as Horn clauses + backward reasoning means that logic programs combine declarative and procedural representations of knowledge. The inclusion of negation as failure means that logic programming is a kind of non-monotonic logic.

Despite its simplicity compared with classical logic, this combination of Horn clauses and negation as failure has proved to be surprisingly expressive. For example, it provides a natural representation for the common-sense laws of cause and effect, as formalised by both the situation calculus and event calculus. It has also been shown to correspond quite naturally to the semi-formal language of legislation. In particular, Prakken and Sartor[12] credit the representation of the British Nationality Act as a logic program[13] with being "hugely influential for the development of computational representations of legislation, showing how logic programming enables intuitively appealing representations that can be directly deployed to generate automatic inferences".

## Variants and extensions[edit | edit source]

### Prolog[edit | edit source]

Main article: Prolog

The programming language Prolog was developed in 1972 by Alain Colmerauer. It emerged from a collaboration between Colmerauer in Marseille and Robert Kowalski in Edinburgh. Colmerauer was working on natural-language understanding, using logic to represent semantics and using resolution for question-answering. During the summer of 1971, Colmerauer and Kowalski discovered that the clausal form of logic could be used to represent formal grammars and that resolution theorem provers could be used for parsing. They observed that some theorem provers, like hyper-resolution, behave as bottom-up parsers and others, like SL-resolution (1971), behave as top-down parsers.

It was in the following summer of 1972, that Kowalski, again working with Colmerauer, developed the procedural interpretation of implications. This dual declarative/procedural interpretation later became formalised in the Prolog notation

`H :- B1, …, Bn.`

which can be read (and used) both declaratively and procedurally. It also became clear that such clauses could be restricted to definite clauses or Horn clauses, where `H`, `B1`, ..., `Bn` are all atomic predicate logic formulae, and that SL-resolution could be restricted (and generalised) to LUSH or SLD-resolution. Kowalski's procedural interpretation and LUSH were described in a 1973 memo, published in 1974.[6]

Colmerauer, with Philippe Roussel, used this dual interpretation of clauses as the basis of Prolog, which was implemented in the summer and autumn of 1972. The first Prolog program, also written in 1972 and implemented in Marseille, was a French question-answering system. The use of Prolog as a practical programming language was given great momentum by the development of a compiler by David Warren in Edinburgh in 1977. Experiments demonstrated that Edinburgh Prolog could compete with the processing speed of other symbolic programming languages such as Lisp. Edinburgh Prolog became the de facto standard and strongly influenced the definition of ISO standard Prolog.

### Abductive logic programming[edit | edit source]

Abductive logic programming is an extension of normal Logic Programming that allows some predicates, declared as abducible predicates, to be "open" or undefined. A clause in an abductive logic program has the form:

`H :- B1, …, Bn, A1, …, An.`

where `H` is an atomic formula that is not abducible, all the `Bi` are literals whose predicates are not abducible, and the `Ai` are atomic formulas whose predicates are abducible. The abducible predicates can be constrained by integrity constraints, which can have the form:

`false :- L1, …, Ln.`

where the `Li` are arbitrary literals (defined or abducible, and atomic or negated). For example:

canfly(X) :- bird(X), normal(X).
false :- normal(X), wounded(X).
bird(john).
bird(mary).
wounded(john).

where the predicate `normal` is abducible.

Problem-solving is achieved by deriving hypotheses expressed in terms of the abducible predicates as solutions to problems to be solved. These problems can be either observations that need to be explained (as in classical abductive reasoning) or goals to be solved (as in normal logic programming). For example, the hypothesis `normal(mary)` explains the observation `canfly(mary)`. Moreover, the same hypothesis entails the only solution `X = mary` of the goal of finding something which can fly:

:- canfly(X).

Abductive logic programming has been used for fault diagnosis, planning, natural language processing and machine learning. It has also been used to interpret Negation as Failure as a form of abductive reasoning.

### Metalogic programming[edit | edit source]

Because mathematical logic has a long tradition of distinguishing between object language and metalanguage, logic programming also allows metalevel programming. The simplest metalogic program is the so-called "vanilla" meta-interpreter:

solve(true).
solve((A,B)):- solve(A),solve(B).
solve(A):- clause(A,B),solve(B).

where true represents an empty conjunction, and clause(A,B) means that there is an object-level clause of the form A :- B.

Metalogic programming allows object-level and metalevel representations to be combined, as in natural language. It can also be used to implement any logic which is specified as inference rules. Metalogic is used in logic programming to implement metaprograms, which manipulate other programs, databases, knowledge bases or axiomatic theories as data.

### Constraint logic programming[edit | edit source]

Main article: Constraint logic programming

Constraint logic programming combines Horn clause logic programming with constraint solving. It extends Horn clauses by allowing some predicates, declared as constraint predicates, to occur as literals in the body of clauses. A constraint logic program is a set of clauses of the form:

`H :- C1, …, Cn ◊ B1, …, Bn.`

where `H` and all the `Bi` are atomic formulas, and the `Ci` are constraints. Declaratively, such clauses are read as ordinary logical implications:

`H if C1 and … and Cn and B1 and … and Bn.`

However, whereas the predicates in the heads of clauses are defined by the constraint logic program, the predicates in the constraints are predefined by some domain-specific model-theoretic structure or theory.

Procedurally, subgoals whose predicates are defined by the program are solved by goal-reduction, as in ordinary logic programming, but constraints are checked for satisfiability by a domain-specific constraint-solver, which implements the semantics of the constraint predicates. An initial problem is solved by reducing it to a satisfiable conjunction of constraints.

The following constraint logic program represents a toy temporal database of `john's` history as a teacher:

teaches(john, hardware, T) :- 1990 ≤ T, T < 1999.
teaches(john, software, T) :- 1999 ≤ T, T < 2005.
teaches(john, logic, T) :- 2005 ≤ T, T ≤ 2012.
rank(john, instructor, T) :- 1990 ≤ T, T < 2010.
rank(john, professor, T) :- 2010 ≤ T, T < 2014.

Here `≤` and `<` are constraint predicates, with their usual intended semantics. The following goal clause queries the database to find out when `john` both taught `logic` and was a `professor`:

`:- teaches(john, logic, T), rank(john, professor, T).`

The solution is `2010 ≤ T, T ≤ 2012`.

Constraint logic programming has been used to solve problems in such fields as civil engineering, mechanical engineering, digital circuit verification, automated timetabling, air traffic control, and finance. It is closely related to abductive logic programming.

### Concurrent logic programming[edit | edit source]

Main article: Concurrent logic programming

Concurrent logic programming integrates concepts of logic programming with concurrent programming. Its development was given a big impetus in the 1980s by its choice for the systems programming language of the Japanese Fifth Generation Project (FGCS).[14]

A concurrent logic program is a set of guarded Horn clauses of the form:

`H :- G1, …, Gn | B1, …, Bn.`

The conjunction `G1, ... , Gn` is called the guard of the clause, and ` | ` is the commitment operator. Declaratively, guarded Horn clauses are read as ordinary logical implications:

`H if G1 and … and Gn and B1 and … and Bn.`

However, procedurally, when there are several clauses whose heads ` H ` match a given goal, then all of the clauses are executed in parallel, checking whether their guards `G1, ... , Gn` hold. If the guards of more than one clause hold, then a committed choice is made to one of the clauses, and execution proceeds with the subgoals ` B1, ..., Bn` of the chosen clause. These subgoals can also be executed in parallel. Thus concurrent logic programming implements a form of "don't care nondeterminism", rather than "don't know nondeterminism".

For example, the following concurrent logic program defines a predicate ` shuffle(Left, Right, Merge) `, which can be used to shuffle two lists `Left` and `Right`, combining them into a single list `Merge` that preserves the ordering of the two lists `Left` and `Right`:

shuffle([], [], []).
shuffle(Left, Right, Merge) :-
Left = [First | Rest] |
Merge = [First | ShortMerge],
shuffle(Rest, Right, ShortMerge).
shuffle(Left, Right, Merge) :-
Right = [First | Rest] |
Merge = [First | ShortMerge],
shuffle(Left, Rest, ShortMerge).

Here, `[]` represents the empty list, and `[Head | Tail]` represents a list with first element `Head` followed by list `Tail`, as in Prolog. (Notice that the first occurrence of ` | ` in the second and third clauses is the list constructor, whereas the second occurrence of ` | ` is the commitment operator.) The program can be used, for example, to shuffle the lists `[ace, queen, king]` and `[1, 4, 2]` by invoking the goal clause:

shuffle([ace, queen, king], [1, 4, 2], Merge).

The program will non-deterministically generate a single solution, for example ` Merge = [ace, queen, 1, king, 4, 2]`.

Arguably, concurrent logic programming is based on message passing, so it is subject to the same indeterminacy as other concurrent message-passing systems, such as Actors (see Indeterminacy in concurrent computation). Carl Hewitt has argued that concurrent logic programming is not based on logic in his sense that computational steps cannot be logically deduced.[15] However, in concurrent logic programming, any result of a terminating computation is a logical consequence of the program, and any partial result of a partial computation is a logical consequence of the program and the residual goal (process network). Thus the indeterminacy of computations implies that not all logical consequences of the program can be deduced.[neutrality is disputed]

### Concurrent constraint logic programming[edit | edit source]

Main article: Concurrent constraint logic programming

Concurrent constraint logic programming combines concurrent logic programming and constraint logic programming, using constraints to control concurrency. A clause can contain a guard, which is a set of constraints that may block the applicability of the clause. When the guards of several clauses are satisfied, concurrent constraint logic programming makes a committed choice to use only one.

### Inductive logic programming[edit | edit source]

Main article: Inductive logic programming

Inductive logic programming is concerned with generalizing positive and negative examples in the context of background knowledge: machine learning of logic programs. Recent work in this area, combining logic programming, learning and probability, has given rise to the new field of statistical relational learning and probabilistic inductive logic programming.

### Higher-order logic programming[edit | edit source]

Several researchers have extended logic programming with higher-order programming features derived from higher-order logic, such as predicate variables. Such languages include the Prolog extensions HiLog and λProlog.

### Linear logic programming[edit | edit source]

Basing logic programming within linear logic has resulted in the design of logic programming languages that are considerably more expressive than those based on classical logic. Horn clause programs can only represent state change by the change in arguments to predicates. In linear logic programming, one can use the ambient linear logic to support state change. Some early designs of logic programming languages based on linear logic include LO,[16] Lolli,[17] ACL,[18] and Forum.[19] Forum provides a goal-directed interpretation of all linear logic.

### Object-oriented logic programming[edit | edit source]

F-logic extends logic programming with objects and the frame syntax.

Logtalk extends the Prolog programming language with support for objects, protocols, and other OOP concepts. It supports most standard-compliant Prolog systems as backend compilers.

### Transaction logic programming[edit | edit source]

Transaction logic is an extension of logic programming with a logical theory of state-modifying updates. It has both a model-theoretic semantics and a procedural one. An implementation of a subset of Transaction logic is available in the Flora-2 system. Other prototypes are also available.

## See also[edit | edit source]

* Automated theorem proving
* Constraint logic programming
* Control theory
* Datalog
* Fril
* Functional programming
* Fuzzy logic
* Inductive logic programming
* Logic in computer science (includes Formal methods)
* Logic programming languages
* Programmable logic controller
* R++
* Reasoning system
* Rule-based machine learning
* Satisfiability
* Boolean satisfiability problem
* Linear logic

## Citations[edit | edit source]

This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (February 2012) (Learn how and when to remove this template message)

|

1. ^ a b Winograd, Terry (1972). "Understanding natural language". Cognitive Psychology. 3 (1): 1–191. doi:10.1016/0010-0285(72)90002-3.
2. ^ Green, Cordell. Application of Theorem Proving to Problem Solving (PDF). IJCAI 1969.
3. ^ Foster, J.M.; Elcock, E.W. (1969). ABSYS 1: An Incremental Compiler for Assertions: an Introduction. Fourth Annual Machine Intelligence Workshop. Machine Intelligence. Vol. 4\. Edinburgh, UK: Edinburgh University Press. pp. 423–429.
4. ^ Hewitt, Carl. Planner: A Language for Proving Theorems in Robots (PDF). IJCAI 1969.
5. ^ Hayes, Pat (1973). "Computation and Deduction". Proceedings of the 2nd MFCS Symposium. Czechoslovak Academy of Sciences. pp. 105–118.
6. ^ a b Kowalski, Robert (1973). "Predicate Logic as a Programming Language" (PDF). Department of Artificial Intelligence, Edinburgh University. Memo 70. `{{cite journal}}`: Cite journal requires `|journal=` (help) Also in Proceedings IFIP Congress, Stockholm, North Holland Publishing Co., 1974, pp. 569–574.
7. ^ Kowalski, Robert; Kuehner, Donald (Winter 1971). "Linear Resolution with Selection Function" (PDF). Artificial Intelligence. 2 (3–4): 227–260. doi:10.1016/0004-3702(71)90012-9.
8. ^ Shapiro, Ehud (1989). The family of concurrent logic programming languages (PDF). International Summer School on Logic, Algebra and Computation. Archived (PDF) from the original on February 23, 2017. Also appeared in Shapiro, E. (1989). "The family of concurrent logic programming languages". ACM Computing Surveys. 21 (3): 413–510. CiteSeerX 10.1.1.73.8108. doi:10.1145/72551.72555. S2CID 2497630.
9. ^ Sáenz-Perez, Fernando; Caballero, Rafael; García-Ruiz, Yolanda (December 2011). A Deductive Database with Datalog and SQL Query Language (PDF). Asian Symposium on Programming Languages and Systems. Springer. pp. 66–73.
10. ^ Van Emden, M.H.; Kowalski, R.A. (October 1976). "The semantics of predicate logic as a programming language". Journal of the ACM. 23 (4): 733–742. doi:10.1145/321978.321991. S2CID 11048276.
11. ^ R.A.Kowalski (July 1979). "Algorithm=Logic + Control". Communications of the ACM. 22 (7): 424–436. doi:10.1145/359131.359136. S2CID 2509896.
12. ^ Prakken, H.; Sartor, G. (October 2015). "Law and logic: a review from an argumentation perspective" (PDF). Artificial Intelligence. 227: 214–245. doi:10.1016/j.artint.2015.06.005.
13. ^ Sergot, M.J.; Sadri, F.; Kowalski, R.A.; Kriwaczek, F.; Hammond, P; Cory, H.T. (1986). "The British Nationality Act as a logic program" (PDF). Communications of the ACM. 29 (5): 370–386. doi:10.1145/5689.5920. S2CID 5665107.
14. ^ Shunichi Uchida and Kazuhiro Fuchi. Proceedings of the FGCS Project Evaluation Workshop. Institute for New Generation Computer Technology (ICOT). 1992.
15. ^ Hewitt, Carl (27 April 2016). "Inconsistency Robustness for Logic Programs". Hal Archives. pp. 21–26. Retrieved 7 November 2016.
16. ^ Andreoli, Jean-Marc (1 June 1992). "Logic Programming with Focusing Proofs in Linear Logic". Journal of Logic and Computation. 2 (3): 297–347. doi:10.1093/logcom/2.3.297.
17. ^ Hodas, Joshua; Miller, Dale (1994). "Logic Programming in a Fragment of Intuitionistic Linear Logic". Information and Computation. 110 (2): 327–365. doi:10.1006/inco.1994.1036.
18. ^ Kobayashi, Naoki; Yonezawa, Akinori (1994). Asynchronous communication model based on linear logic. US/Japan Workshop on Parallel Symbolic Computing. pp. 279–294. CiteSeerX 10.1.1.42.8749.
19. ^ Miller, Dale (30 September 1996). "Forum: A Multiple-Conclusion Specification Logic". Theoretical Computer Science. 165 (1): 201–232. doi:10.1016/0304-3975(96)00045-X.

## Sources[edit | edit source]

### General introductions[edit | edit source]

* Baral, C.; Gelfond, M. (1994). "Logic programming and knowledge representation" (PDF). The Journal of Logic Programming. 19–20: 73–148. doi:10.1016/0743-1066(94)90025-6.
* Kowalski, R. A. (1988). "The early years of logic programming" (PDF). Communications of the ACM. 31: 38–43. doi:10.1145/35043.35046. S2CID 12259230. [1]
* Lloyd, J. W. (1987). Foundations of Logic Programming. (2nd edition). Springer-Verlag.

### Other sources[edit | edit source]

* John McCarthy. "Programs with common sense". Symposium on Mechanization of Thought Processes. National Physical Laboratory. Teddington, England. 1958.
* Miller, Dale; Nadathur, Gopalan; Pfenning, Frank; Scedrov, Andre (1991). "Uniform proofs as a foundation for logic programming". Annals of Pure and Applied Logic. 51 (1–2): 125–157. doi:10.1016/0168-0072(91)90068-W.
* Ehud Shapiro (Editor). Concurrent Prolog. MIT Press. 1987.
* James Slagle. "Experiments with a Deductive Question-Answering Program". CACM. December 1965.
* Gabbay, Dov M.; Hogger, Christopher John; Robinson, J.A., eds. (1993-1998). Handbook of Logic in Artificial Intelligence and Logic Programming.Vols. 1–5, Oxford University Press.

## Further reading[edit | edit source]

* Carl Hewitt. "Procedural Embedding of Knowledge in Planner". IJCAI 1971.
* Carl Hewitt. "The Repeated Demise of Logic Programming and Why It Will Be Reincarnated". AAAI Spring Symposium: What Went Wrong and Why: Lessons from AI Research and Applications 2006: 2–9.
* Evgeny Dantsin, Thomas Eiter, Georg Gottlob, Andrei Voronkov: Complexity and expressive power of logic programming. ACM Comput. Surv. 33(3): 374–425 (2001)
* Ulf Nilsson and Jan Maluszynski, Logic, Programming and Prolog

## External links[edit | edit source]

Wikimedia Commons has media related to Logic programming.

* Logic Programming Virtual Library entry
* Bibliographies on Logic Programming
* Association for Logic Programming (ALP)
* Theory and Practice of Logic Programming (journal)
* Logic programming in C++ with Castor
* Logic programming in Oz
* Prolog Development Center
* Racklog: Logic Programming in Racket

* v
* t
* e

Types of programming languages

Paradigm|

* Actor-based
* Array
* Aspect-oriented
* Class-based
* Concatenative
* Concurrent
* Dataflow
* Declarative
* Differentiable
* Domain-specific
* Dynamic
* Esoteric
* Event-driven
* Extensible
* Functional
* Imperative
* Logic
* Macro
* Metaprogramming
* Object-based
* Object-oriented
* Pipeline
* Procedural
* Prototype-based
* Reflective
* Rule-based
* Scripting
* Stack-oriented
* Synchronous
* Tactile
* Template

Level|

* Machine
* Assembly
* Compiled
* Interpreted

* Low-level
* High-level
* Very high-level

Generation|

* First
* Second
* Third
* Fourth
* Fifth

Related|

* Non-English-based
* Visual

* v
* t
* e

Computable knowledge

Topics and
concepts|

* Alphabet of human thought
* Authority control
* Automated reasoning
* Commonsense knowledge
* Commonsense reasoning
* Computability
* Discovery system
* Formal system
* Inference engine
* Knowledge base
* Personal knowledge base
* Knowledge-based systems
* Knowledge engineering
* Knowledge extraction
* Knowledge graph
* Knowledge representation
* Knowledge retrieval
* Library classification
* Logic programming
* Ontology
* Question answering
* Semantic reasoner

Proposals and
implementations|

* Antikythera mechanism (ca. 100 BCE)
* Zairja (ca. 1000 CE)
* Ars Magna (1300)
* An Essay Towards a Real Character, and a Philosophical Language (1688)
* Calculus ratiocinator and characteristica universalis (1700)
* Dewey Decimal Classification (1876)
* Begriffsschrift (1879)
* Mundaneum (1910)
* Logical atomism (1918)
* Tractatus Logico-Philosophicus (1921)
* Hilbert's program (1920s)
* Incompleteness theorem (1931)
* World Brain (1938)
* Memex (1945)
* General Problem Solver (1959)
* Prolog (1972)
* Cyc (1984)
* Semantic Web (2001)
* Justapedia (2001)
* Evi (2007)
* Wolfram Alpha (2009)
* Watson (2011)
* Siri (2011)
* Google Knowledge Graph (2012)
* Wikidata (2012)
* Cortana (2014)
* Viv (2016)

In fiction|

* The Engine (Gulliver's Travels, 1726)
* Joe ("A Logic Named Joe", 1946)
* The Librarian (Snow Crash, 1992)
* Dr. Know (A.I. (film), 2001)
* Waterhouse (The Baroque Cycle, 2003)

See also: Logic machines in fiction and List of fictional computers
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template