This article includes a list of references, related reading, or external links, but its sources remain unclear because it lacks inline citations. Please help to improve this article by introducing more precise citations. (February 2015) (Learn how and when to remove this template message)

**Abductive logic programming** (**ALP**) is a high-level knowledge-representation framework that can be used to solve problems declaratively, based on abductive reasoning. It extends normal logic programming by allowing some predicates to be incompletely defined, declared as abducible predicates. Problem solving is effected by deriving hypotheses on these abducible predicates (abductive hypotheses) as solutions of problems to be solved. These problems can be either observations that need to be explained (as in classical abduction) or goals to be achieved (as in normal logic programming). It can be used to solve problems in diagnosis, planning, natural language and machine learning. It has also been used to interpret negation as failure as a form of abductive reasoning.

Abductive logic programs have three components, where:

- P is a logic program of exactly the same form as in logic programming
- A is a set of predicate names, called the abducible predicates
- IC is a set of first-order classical formulae.

Normally, the logic program P does not contain any clauses whose head (or conclusion) refers to an abducible predicate. (This restriction can be made without loss of generality.) Also in practice, many times, the integrity constraints in IC are often restricted to the form of denials, i.e. clauses of the form:

false:- A1,...,An, not B1, ..., not Bm.

Such a constraint means that it is not possible for all A1,...,An to be true and at the same time all of B1,...,Bm to be false.

The clauses in P define a set of non-abducible predicates and through this they provide a description (or model) of the problem domain. The integrity constraints in IC specify general properties of the problem domain that need to be respected in any solution of a problem.

A problem, *G*, which expresses either an observation that needs to be explained or a goal that is desired, is represented by a conjunction of positive and negative (NAF) literals. Such problems are solved by computing "abductive explanations" of *G*.

An abductive explanation of a problem *G* is a set of positive (and sometimes also negative) ground instances of the abducible predicates, such that, when these are added to the logic program P, the problem *G* and the integrity constraints IC both hold. Thus abductive explanations extend the logic program P by the addition of full or partial definitions of the abducible predicates. In this way, abductive explanations form solutions of the problem according to the description of the problem domain in P and IC. The extension or completion of the problem description given by the abductive explanations provides new information, hitherto not contained in the solution to the problem. Quality criteria to prefer one solution over another, often expressed via integrity constraints, can be applied to select specific abductive explanations of the problem *G*.

Computation in ALP combines the backwards reasoning of normal logic programming (to reduce problems to sub-problems) with a kind of integrity checking to show that the abductive explanations satisfy the integrity constraints.

The following two examples, written in simple structured English rather than in the strict syntax of ALP, illustrate the notion of abductive explanation in ALP and its relation to problem solving.

The abductive logic program, , has in the following sentences:

Grass is wetifit rained.

Grass is wetifthe sprinkler was on.

The sun was shining.

The abducible predicates in are "it rained" and "the sprinkler was on" and the only integrity constraint in is:

falseifit rained and the sun was shining.

The observation that the grass is wet has two potential explanations, "it rained" and "the sprinkler was on", which entail the observation. However, only the second potential explanation, "the sprinkler was on", satisfies the integrity constraint.

Consider the abductive logic program consisting of the following (simplified) clauses:

X is a citizenifX is born in the USA.

X is a citizenifX is born outside the USAandX is a resident of the USAandX is naturalized.

X is a citizenifX is born outside the USAandY is the mother of XandY is a citizenandX is registered.

Mary is the mother of John.

Mary is a citizen.

together with the five abducible predicates, "is born in the USA", "is born outside the USA", "is a resident of the USA", "is naturalized" and "is registered" and the integrity constraint:

falseifJohn is a resident of the USA.

The goal "John is citizen" has two abductive solutions, one of which is "John is born in the USA", the other of which is "John is born outside the USA" and "John is registered". The potential solution of becoming a citizen by residence and naturalization fails because it violates the integrity constraint.

A more complex example that is also written in the more formal syntax of ALP is the following.

The abductive logic program below describes a simple model of the lactose metabolism of the bacterium E. coli. The program, *P*, describes (in its first rule) that E. coli can feed on the sugar lactose if it makes two enzymes permease and galactosidase. Like all enzymes, these are made if they are coded by a gene (Gene) that is expressed (described by the second rule). The two enzymes of permease and galactosidase are coded by two genes, lac(y) and lac(z) respectively (stated in the fifth and sixth rule of the program), in a cluster of genes (lac(X)) – called an operon – that is expressed when the amounts (amt) of glucose are low and lactose are high or when they are both at medium level (see the fourth and fifth rule). The abducibles, *A*, declare all ground instances of the predicates "amount" as assumable. This reflects that in the model the amounts at any time of the various substances are unknown. This is incomplete information that is to be determined in each problem case.
The integrity constraints, *IC*, state that the amount of any substance (S) can only take one value.

- Domain knowledge (P)
feed(lactose) :- make(permease), make(galactosidase). make(Enzyme) :- code(Gene, Enzyme), express(Gene). express(lac(X)) :- amount(glucose, low), amount(lactose, hi). express(lac(X)) :- amount(glucose, medium), amount(lactose, medium). code(lac(y), permease). code(lac(z), galactosidase). temperature(low) :- amount(glucose, low).

- Integrity constraints (IC)
false :- amount(S, V1), amount(S, V2), V1 ≠ V2.

- Abducibles (A)
abducible_predicate(amount).

The problem goal is . This can arise either as an observation to be explained or as a state of affairs to be achieved by finding a plan. This goal has two abductive explanations:

The decision which of the two to adopt could depend on additional information that is available, e.g. it may be known that when the level of glucose is low then the organism exhibits a certain behaviour – in the model such additional information is that the temperature of the organism is low – and by observing the truth or falsity of this it is possible to choose the first or second explanation respectively.

Once an explanation has been chosen, then this becomes part of the theory, which can be used to draw new conclusions. The explanation and more generally these new conclusions form the solution of the problem.

As shown in the Theorist system,^{[1]}^{[2]} abduction can also be used for default reasoning.
Moreover, abduction in ALP can simulate negation as failure in normal logic programming.

Consider the classic example of reasoning by default that a bird can fly if it cannot be shown that the bird is abnormal. Here is a variant of the example using negation as failure:

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

Here is the same example using an abducible predicate `normal_flying_bird(_)`

with an integrity constraint in ALP:

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

The abducible predicate `normal_flying_bird(_),`

is the contrary of the predicate `abnormal_flying_bird(_)`

.

Using abduction in ALP it is possible to conclude `canfly(mary)`

under the assumption `normal_flying_bird(mary)`

. The conclusion can be derived from the assumption because it cannot be shown that the integrity constraint is violated, which is because it cannot be shown that `wounded(mary).`

In contrast, it is not possible to conclude `canfly(john),`

because the assumption `normal_flying_bird(john)`

together with the fact `wounded(john)`

violates the integrity constraint. This manner of reasoning in ALP simulates reasoning with negation as failure.^{[3]}

Conversely, it is possible to simulate abduction in ALP using negation as failure with the stable model semantics.^{[4]} This can be done by adding, for every abducible predicate `p,`

an additional contrary predicate `negp,`

and a pair of clauses:

```
p :- not(negp).
negp :- not(p).
```

This pair of clauses has two stable models, one in which `p,`

is true, and the other in which `negp,`

is true. This technique for simulating abduction is commonly used in answer set programming to solve problems using a *generate and test* methodology.

The formal semantics of the central notion of an abductive explanation in ALP can be defined in the following way.

Given an abductive logic program, , an abductive explanation for a problem is a set of ground atoms on abducible predicates such that:

- is consistent

This definition leaves open the choice of the underlying semantics of logic programming through which we give the exact meaning of the entailment relation and the notion of consistency of the (extended) logic programs. Any of the different semantics of logic programming such as the completion, stable or well-founded semantics can (and have been used in practice) to give different notions of abductive explanations and thus different forms of ALP frameworks.

The above definition takes a particular view on the formalization of the role of the integrity constraints as restrictions on the possible abductive solutions. It requires that these are entailed by the logic program extended with an abductive solution, thus meaning that in any model of the extended logic program (which one can think of as an ensuing world given ) the requirements of the integrity constraints are met. In some cases this may be unnecessarily strong and the weaker requirement of consistency, namely that is consistent, can be sufficient, meaning that there exists at least one model (possible ensuing world) of the extended program where the integrity constraints hold. In practice, in many cases, these two ways of formalizing the role of the integrity constraints coincide as the logic program and its extensions always have a unique model. Many of the ALP systems use the entailment view of the integrity constraints as this can be easily implemented without the need for any extra specialized procedures for the satisfaction of the integrity constraints since this view treats the constraints in the same way as the problem goal. In many practical cases, the third condition in this formal definition of an abductive explanation in ALP is either trivially satisfied or it is contained in the second condition via the use of specific integrity constraints that capture consistency.

Most of the implementations of ALP extend the SLD resolution-based computational model of logic programming. ALP can also be implemented by means of its link with Answer Set Programming (ASP), where the ASP systems can be employed. Examples of systems of the former approach are ACLP, A-system, CIFF, SCIFF, ABDUAL and ProLogICA.