# Inductive logic programming

> Mediated Wiki article. Canonical URL: https://mediated.wiki/source/Inductive_logic_programming
> Markdown URL: https://mediated.wiki/source/Inductive_logic_programming.md
> Source: https://en.wikipedia.org/wiki/Inductive_logic_programming
> Source revision: 1354719067
> License: Creative Commons Attribution-ShareAlike 4.0 International (https://creativecommons.org/licenses/by-sa/4.0/)

Learning logic programs from data

A photo of Family sample for Inductive Logic Programming article

**Inductive logic programming** (**ILP**) is a subfield of [symbolic artificial intelligence](/source/Symbolic_artificial_intelligence) which uses [logic programming](/source/Logic_programming) as a uniform representation for examples, background knowledge and hypotheses. The term "*inductive*" here refers to [philosophical](/source/Inductive_reasoning) (i.e. suggesting a theory to explain observed facts) rather than [mathematical](/source/Mathematical_induction) (i.e. proving a property for all members of a well-ordered set) induction. Given an encoding of the known background knowledge and a set of examples represented as a logical [database](/source/Database) of facts, an ILP system will derive a hypothesised logic program which [entails](/source/Entailment) all the positive and none of the negative examples.

- Schema: *positive examples* + *negative examples* + *background knowledge* ⇒ *hypothesis*.

[Bioinformatics](/source/Bioinformatics) and [drug design](/source/Drug_design) have been highlighted as a principal application area of inductive logic programming techniques.[1]

## History

Building on earlier work on [Inductive inference](/source/Inductive_inference), [Gordon Plotkin](/source/Gordon_Plotkin) was the first to formalise induction in a [clausal](/source/Horn_clause) setting around 1970, adopting an approach of generalising from examples.[2][3] In 1981, [Ehud Shapiro](/source/Ehud_Shapiro) introduced several ideas that would shape the field in his new approach of model inference, an algorithm employing refinement and backtracing to search for a complete axiomatisation of given examples.[2][4] His first implementation was the [Model Inference System](https://en.wikipedia.org/w/index.php?title=Model_Inference_System&action=edit&redlink=1) in 1981:[5][6] a [Prolog](/source/Prolog) program that inductively inferred [Horn clause](/source/Horn_clause) logic programs from positive and negative examples.[2] The term *Inductive Logic Programming* was first introduced in a paper by [Stephen Muggleton](/source/Stephen_Muggleton) in 1990, defined as the intersection of machine learning and logic programming.[2] Muggleton and Wray Buntine introduced predicate invention and [inverse resolution](/source/Inverse_resolution) in 1988.[2][7]

Several inductive logic programming systems that proved influential appeared in the early 1990s. [FOIL](/source/First-order_inductive_learner), introduced by [Ross Quinlan](/source/Ross_Quinlan) in 1990[8] was based on upgrading [propositional](/source/Propositional_calculus) learning algorithms [AQ](https://en.wikipedia.org/w/index.php?title=AQ_(machine_learning)&action=edit&redlink=1) and [ID3](/source/ID3_algorithm).[9] [Golem](/source/Golem_(ILP)), introduced by Muggleton and Feng in 1990, went back to a restricted form of Plotkin's least generalisation algorithm.[9][10] The [Progol](/source/Progol) system, introduced by Muggleton in 1995, first implemented inverse entailment, and inspired many later systems.[9][11][12] [Aleph](/source/Aleph_(ILP)), a descendant of Progol introduced by Ashwin Srinivasan in 2001, is still one of the most widely used systems as of 2022[\[update\]](https://en.wikipedia.org/w/index.php?title=Inductive_logic_programming&action=edit).[13]

At around the same time, the first practical applications emerged, particularly in [bioinformatics](/source/Bioinformatics), where by 2000 inductive logic programming had been successfully applied to drug design, carcinogenicity and mutagenicity prediction, and elucidation of the structure and function of proteins.[14] Unlike the focus on [automatic programming](/source/Automatic_programming) inherent in the early work, these fields used inductive logic programming techniques from a viewpoint of [relational data mining](/source/Relational_data_mining). The success of those initial applications and the lack of progress in recovering larger traditional logic programs shaped the focus of the field.[15]

Recently, classical tasks from automated programming have moved back into focus, as the introduction of meta-interpretative learning makes predicate invention and learning recursive programs more feasible. This technique was pioneered with the [Metagol](https://en.wikipedia.org/w/index.php?title=Metagol&action=edit&redlink=1) system introduced by Muggleton, Dianhuan Lin, Niels Pahlavi and Alireza Tamaddoni-Nezhad in 2014.[16] This allows ILP systems to work with fewer examples, and brought successes in learning string transformation programs, answer set grammars and general algorithms.[17]

## Setting

Inductive logic programming has adopted several different learning settings, the most common of which are learning from [entailment](/source/Entailment) and learning from interpretations.[18] In both cases, the input is provided in the form of *background knowledge B*, a logical theory (commonly in the form of [clauses](/source/Clause_(logic)) used in [logic programming](/source/Logic_programming)), as well as positive and negative examples, denoted E + {\textstyle E^{+}} and E − {\textstyle E^{-}} respectively. The output is given as a *hypothesis* *H*, itself a logical theory that typically consists of one or more clauses.

The two settings differ in the format of examples presented.

### Learning from entailment

As of 2022[\[update\]](https://en.wikipedia.org/w/index.php?title=Inductive_logic_programming&action=edit), learning from entailment is by far the most popular setting for inductive logic programming.[19] In this setting, the *positive* and *negative* examples are given as finite sets E + {\textstyle E^{+}} and E − {\textstyle E^{-}} of positive and negated [ground](/source/Ground_expression) [literals](/source/Literal_(mathematical_logic)), respectively. A *correct hypothesis* *H* is a set of clauses satisfying the following requirements, where the turnstile symbol ⊨ {\displaystyle \models } stands for [logical entailment](/source/Logical_entailment):[20][21][22] Completeness: B ∪ H ⊨ E + Consistency: B ∪ H ∪ E − ⊭ false {\displaystyle {\begin{array}{llll}{\text{Completeness:}}&B\cup H&\models &E^{+}\\{\text{Consistency: }}&B\cup H\cup E^{-}&\not \models &{\textit {false}}\end{array}}} Completeness requires any generated hypothesis *H* to explain all positive examples E + {\textstyle E^{+}} , and consistency forbids generation of any hypothesis *H* that is inconsistent with the negative examples E − {\textstyle E^{-}} , both given the background knowledge *B*.

In Muggleton's setting of concept learning,[23] "completeness" is referred to as "sufficiency", and "consistency" as "strong consistency". Two further conditions are added: "*Necessity*", which postulates that *B* does not entail E + {\textstyle E^{+}} , does not impose a restriction on *H*, but forbids any generation of a hypothesis as long as the positive facts are explainable without it. "Weak consistency", which states that no contradiction can be derived from B ∧ H {\textstyle B\land H} , forbids generation of any hypothesis *H* that contradicts the background knowledge *B*. Weak consistency is implied by strong consistency; if no negative examples are given, both requirements coincide. Weak consistency is particularly important in the case of noisy data, where completeness and strong consistency cannot be guaranteed.[23]

### Learning from interpretations

In learning from interpretations, the *positive* and *negative* examples are given as a set of complete or partial [Herbrand structures](/source/Herbrand_structure), each of which are themselves a finite set of ground literals. Such a structure *e* is said to be a model of the set of clauses B ∪ H {\textstyle B\cup H} if for any [substitution](/source/Substitution_(logic)) θ {\textstyle \theta } and any clause h e a d ← b o d y {\textstyle \mathrm {head} \leftarrow \mathrm {body} } in B ∪ H {\textstyle B\cup H} such that b o d y θ ⊆ e {\textstyle \mathrm {body} \theta \subseteq e} , h e a d θ ⊆ e {\displaystyle \mathrm {head} \theta \subseteq e} also holds. The goal is then to output a hypothesis that is *complete,* meaning every positive example is a model of B ∪ H {\textstyle B\cup H} , and *consistent,* meaning that no negative example is a model of B ∪ H {\textstyle B\cup H} .[24]

## Approaches to ILP

An *inductive logic programming system* is a program that takes as an input logic theories B , E + , E − {\displaystyle B,E^{+},E^{-}} and outputs a correct hypothesis H with respect to theories B , E + , E − {\displaystyle B,E^{+},E^{-}} . A system is *complete* if and only if for any input logic theories B , E + , E − {\displaystyle B,E^{+},E^{-}} any correct hypothesis H with respect to these input theories can be found with its hypothesis search procedure. Inductive logic programming systems can be roughly divided into two classes, search-based and meta-interpretative systems.

Search-based systems exploit that the space of possible clauses forms a [complete lattice](/source/Complete_lattice) under the [subsumption](/source/Theta-subsumption) relation, where one clause C 1 {\textstyle C_{1}} subsumes another clause C 2 {\textstyle C_{2}} if there is a [substitution](/source/Substitution_(logic)) θ {\textstyle \theta } such that C 1 θ {\textstyle C_{1}\theta } , the result of applying θ {\textstyle \theta } to C 1 {\textstyle C_{1}} , is a subset of C 2 {\textstyle C_{2}} . This lattice can be traversed either bottom-up or top-down.

### Bottom-up search

Bottom-up methods to search the subsumption lattice have been investigated since Plotkin's first work on formalising induction in clausal logic in 1970.[2][3] Techniques used include least general generalisation, based on [anti-unification](/source/Anti-unification_(computer_science)), and inverse resolution, based on inverting the [resolution](/source/Resolution_(logic)) inference rule.

#### Least general generalisation

A *least general generalisation algorithm* takes as input two clauses C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} and outputs the least general generalisation of C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} , that is, a clause C {\textstyle C} that subsumes C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} , and that is subsumed by every other clause that subsumes C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} . The least general generalisation can be computed by first computing all *selections* from C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} , which are pairs of literals ( L , M ) ∈ ( C 1 × C 2 ) {\displaystyle (L,M)\in (C_{1}\times C_{2})} sharing the same predicate symbol and negated/unnegated status. Then, the least general generalisation is obtained as the disjunction of the least general generalisations of the individual selections, which can be obtained by [first-order syntactical anti-unification](/source/First-order_syntactical_anti-unification).[25]

To account for background knowledge, inductive logic programming systems employ *relative least general generalisations*, which are defined in terms of subsumption relative to a background theory. In general, such relative least general generalisations are not guaranteed to exist; however, if the background theory *B* is a finite set of [ground](/source/Ground_expression) [literals](/source/Literal_(mathematical_logic)), then the negation of *B* is itself a clause. In this case, a relative least general generalisation can be computed by disjoining the negation of *B* with both C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} and then computing their least general generalisation as before.[26]

Relative least general generalisations are the foundation of the bottom-up system [Golem](/source/Golem_(ILP)).[9][10]

#### Inverse resolution

Inverse resolution is an [inductive reasoning](/source/Inductive_reasoning) technique that involves [inverting](https://en.wiktionary.org/wiki/invert) the [resolution operator](/source/Resolution_(logic)).

Inverse resolution takes information about the [resolvent](/source/Resolvent_(logic)) of a resolution step to compute possible resolving clauses. Two types of inverse resolution operator are in use in inductive logic programming: V-operators and W-operators. A V-operator takes clauses R {\textstyle R} and C 1 {\textstyle C_{1}} as input and returns a clause C 2 {\textstyle C_{2}} such that R {\textstyle R} is the resolvent of C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} . A W-operator takes two clauses R 1 {\textstyle R_{1}} and R 2 {\textstyle R_{2}} and returns three clauses C 1 {\textstyle C_{1}} , C 2 {\textstyle C_{2}} and C 3 {\textstyle C_{3}} such that R 1 {\textstyle R_{1}} is the resolvent of C 1 {\textstyle C_{1}} and C 2 {\textstyle C_{2}} and R 2 {\textstyle R_{2}} is the resolvent of C 2 {\textstyle C_{2}} and C 3 {\textstyle C_{3}} .[27]

Inverse resolution was first introduced by [Stephen Muggleton](/source/Stephen_Muggleton) and Wray Buntine in 1988 for use in the inductive logic programming system Cigol.[7] By 1993, this spawned a surge of research into inverse resolution operators and their properties.[27]

### Top-down search

The ILP systems Progol,[12] Hail [28] and Imparo [29] find a hypothesis H using the principle of the **inverse entailment**[12] for theories B, E, H: B ∧ H ⊨ E ⟺ B ∧ ¬ E ⊨ ¬ H {\displaystyle B\land H\models E\iff B\land \neg E\models \neg H} . First they construct an intermediate theory F called a bridge theory satisfying the conditions B ∧ ¬ E ⊨ F {\displaystyle B\land \neg E\models F} and F ⊨ ¬ H {\displaystyle F\models \neg H} . Then as H ⊨ ¬ F {\displaystyle H\models \neg F} , they generalize the negation of the bridge theory F with anti-entailment.[30] However, the operation of anti-entailment is computationally more expensive since it is highly nondeterministic. Therefore, an alternative hypothesis search can be conducted using the inverse subsumption (anti-subsumption) operation instead, which is less non-deterministic than anti-entailment.

Questions of completeness of a hypothesis search procedure of specific inductive logic programming system arise. For example, the Progol hypothesis search procedure based on the inverse entailment inference rule is not complete by *Yamamoto's example*.[31] On the other hand, Imparo is complete by both anti-entailment procedure [32] and its extended inverse subsumption [33] procedure.

### Metainterpretive learning

Rather than explicitly searching the hypothesis graph, metainterpretive or *meta-level* systems encode the inductive logic programming program as a meta-level logic program which is then solved to obtain an optimal hypothesis. Formalisms used to express the problem specification include [Prolog](/source/Prolog) and [answer set programming](/source/Answer_set_programming), with existing Prolog systems and answer set solvers used for solving the constraints.[34]

And example of a Prolog-based system is [Metagol](https://en.wikipedia.org/w/index.php?title=Metagol&action=edit&redlink=1), which is based on a [meta-interpreter in Prolog](/source/Meta-interpreters_in_Prolog), while ASPAL and ILASP are based on an encoding of the inductive logic programming problem in answer set programming.[35]

### Evolutionary learning

[Evolutionary algorithms](/source/Evolutionary_algorithm) in ILP use a population-based approach to evolve hypotheses, refining them through selection, crossover, and mutation. Methods like [EvoLearner](https://en.wikipedia.org/w/index.php?title=EvoLearner&action=edit&redlink=1) have been shown to outperform traditional approaches on structured machine learning benchmarks. [36]

## List of implementations

- [1BC and 1BC2: first-order naive Bayesian classifiers:](http://www.cs.bris.ac.uk/Research/MachineLearning/1BC/)

- [ACE (A Combined Engine)](http://dtai.cs.kuleuven.be/ACE/)

- [Aleph](http://web.comlab.ox.ac.uk/oucl/research/areas/machlearn/Aleph/)

- [Atom](http://www.ahlgren.info/research/atom/) [Archived](https://web.archive.org/web/20140326152728/http://www.ahlgren.info/research/atom) 2014-03-26 at the [Wayback Machine](/source/Wayback_Machine)

- [Claudien](https://archive.today/20121231073113/http://dtai.cs.kuleuven.be/claudien/)

- [DL-Learner](http://dl-learner.org) [Archived](https://web.archive.org/web/20190815184411/http://dl-learner.org/) 2019-08-15 at the [Wayback Machine](/source/Wayback_Machine)

- [DMax](http://dtai.cs.kuleuven.be/dmax/)

- [FastLAS (Fast Learning from Answer Sets)](https://spike-imperial.github.io/FastLAS/)

- [FOIL (First Order Inductive Learner)](/source/First_Order_Inductive_Learner)

- [Golem](/source/Golem_(ILP))

- [ILASP (Inductive Learning of Answer Set Programs)](http://www.ilasp.com/)

- Imparo[32]

- [Inthelex (INcremental THEory Learner from EXamples)](http://lacam.di.uniba.it:8000/systems/inthelex/) [Archived](https://web.archive.org/web/20111128110512/http://lacam.di.uniba.it:8000/systems/inthelex/) 2011-11-28 at the [Wayback Machine](/source/Wayback_Machine)

- [Lime](https://web.archive.org/web/20020516195248/http://cs.anu.edu.au/people/Eric.McCreath/lime.html)

- [Metagol](https://github.com/metagol/metagol)

- [Mio](https://archive.today/20130219215544/http://libra.msra.cn/Publication/3392493/mio-user-s-manual)

- MIS (Model Inference System) by Ehud Shapiro

- [Ontolearn](https://github.com/dice-group/Ontolearn)

- [Popper](https://github.com/logic-and-learning-lab/Popper)

- [PROGOL](/source/PROGOL)

- [RSD](http://ida.felk.cvut.cz/zelezny/rsd/index.htm)

- Warmr (now included in ACE)

- [ProGolem](http://ilp.doc.ic.ac.uk/ProGolem/) [37][38]

## Probabilistic inductive logic programming

Probabilistic inductive logic programming adapts the setting of inductive logic programming to learning [probabilistic logic programs](/source/Probabilistic_logic_programming). It can be considered as a form of [statistical relational learning](/source/Statistical_relational_learning) within the formalism of probabilistic logic programming.[39][40]

Given

1. background knowledge as a probabilistic logic program B, and

1. a set of positive and negative examples E + {\textstyle E^{+}} and E − {\textstyle E^{-}}

the goal of probabilistic inductive logic programming is to find a probabilistic logic program H {\textstyle H} such that the probability of positive examples according to H ∪ B {\textstyle {H\cup B}} is maximized and the probability of negative examples is minimized.[40]

This problem has two variants: parameter learning and structure learning. In the former, one is given the structure (the clauses) of H and the goal is to infer the probabilities annotations of the given clauses, while in the latter the goal is to infer both the structure and the probability parameters of H. Just as in classical inductive logic programming, the examples can be given as examples or as (partial) interpretations.[40]

### Parameter Learning

Parameter learning for languages following the distribution semantics has been performed by using an [expectation-maximisation algorithm](/source/Expectation-maximisation_algorithm) or by [gradient descent](/source/Gradient_descent). An expectation-maximisation algorithm consists of a cycle in which the steps of expectation and maximization are repeatedly performed. In the expectation step, the distribution of the hidden variables is computed according to the current values of the probability parameters, while in the maximisation step, the new values of the parameters are computed. Gradient descent methods compute the gradient of the target function and iteratively modify the parameters moving in the direction of the gradient.[40]

### Structure Learning

Structure learning was pioneered by [Daphne Koller](/source/Daphne_Koller) and Avi Pfeffer in 1997,[41] where the authors learn the structure of [first-order](/source/First-order_logic) rules with associated probabilistic uncertainty parameters. Their approach involves generating the underlying [graphical model](/source/Graphical_model) in a preliminary step and then applying expectation-maximisation.[40]

In 2008, [De Raedt](https://en.wikipedia.org/w/index.php?title=Luc_De_Raedt&action=edit&redlink=1) et al. presented an algorithm for performing [theory compression](https://en.wikipedia.org/w/index.php?title=Theory_compression&action=edit&redlink=1) on [ProbLog](/source/ProbLog) programs, where theory compression refers to a process of removing as many clauses as possible from the theory in order to maximize the probability of a given set of positive and negative examples. No new clause can be added to the theory.[40][42]

In the same year, Meert, W. et al. introduced a method for learning parameters and structure of [ground](/source/Ground_term) probabilistic logic programs by considering the [Bayesian networks](/source/Bayesian_network) equivalent to them and applying techniques for learning Bayesian networks.[43][40]

ProbFOIL, introduced by De Raedt and Ingo Thon in 2010, combined the inductive logic programming system [FOIL](/source/First-order_inductive_learner) with [ProbLog](/source/ProbLog). Logical rules are learned from probabilistic data in the sense that both the examples themselves and their classifications can be probabilistic. The set of rules has to allow one to predict the probability of the examples from their description. In this setting, the parameters (the probability values) are fixed and the structure has to be learned.[44][40]

In 2011, Elena Bellodi and Fabrizio Riguzzi introduced SLIPCASE, which performs a beam search among probabilistic logic programs by iteratively refining probabilistic theories and optimizing the parameters of each theory using expectation-maximisation.[45] Its extension SLIPCOVER, proposed in 2014, uses bottom clauses generated as in [Progol](/source/Progol) to guide the refinement process, thus reducing the number of revisions and exploring the search space more effectively. Moreover, SLIPCOVER separates the search for promising clauses from that of the theory: the space of clauses is explored with a [beam search](/source/Beam_search), while the space of theories is searched [greedily](/source/Greedy_search).[46][40]

## See also

- [Commonsense reasoning](/source/Commonsense_reasoning)

- [Formal concept analysis](/source/Formal_concept_analysis)

- [Inductive reasoning](/source/Inductive_reasoning)

- [Inductive programming](/source/Inductive_programming)

- [Inductive probability](/source/Inductive_probability)

- [Statistical relational learning](/source/Statistical_relational_learning)

- [Version space learning](/source/Version_space_learning)

## References

1. **[^](#cite_ref-1)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 822. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. ^ [***a***](#cite_ref-Nienhuys-Cheng-1997a_2-0) [***b***](#cite_ref-Nienhuys-Cheng-1997a_2-1) [***c***](#cite_ref-Nienhuys-Cheng-1997a_2-2) [***d***](#cite_ref-Nienhuys-Cheng-1997a_2-3) [***e***](#cite_ref-Nienhuys-Cheng-1997a_2-4) [***f***](#cite_ref-Nienhuys-Cheng-1997a_2-5) Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). *Foundations of inductive logic programming*. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. pp. 174–177. [ISBN](/source/ISBN_(identifier)) [978-3-540-62927-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-62927-6).

1. ^ [***a***](#cite_ref-Plotkin-1970_3-0) [***b***](#cite_ref-Plotkin-1970_3-1) Plotkin, G.D. (1970). [*Automatic Methods of Inductive Inference*](https://www.era.lib.ed.ac.uk/bitstream/handle/1842/6656/Plotkin1972.pdf) (PDF) (PhD). University of Edinburgh. [hdl](/source/Hdl_(identifier)):[1842/6656](https://hdl.handle.net/1842%2F6656).

1. **[^](#cite_ref-4)** Shapiro, Ehud Y. (1981). [*Inductive inference of theories from facts*](http://ftp.cs.yale.edu/publications/techreports/tr192.pdf) (PDF) (Technical report). Department of Computer Science, Yale University. 192. Reprinted in Lassez, J.-L.; Plotkin, G., eds. (1991). *Computational logic : essays in honor of Alan Robinson*. MIT Press. pp. 199–254. [ISBN](/source/ISBN_(identifier)) [978-0-262-12156-9](https://en.wikipedia.org/wiki/Special:BookSources/978-0-262-12156-9).

1. **[^](#cite_ref-5)** Shapiro, Ehud Y. (1981). ["The model inference system"](https://www.ijcai.org/Proceedings/81-2/Papers/100.pdf) (PDF). *Proceedings of the 7th international joint conference on Artificial intelligence*. Vol. 2. Morgan Kaufmann. p. 1064.

1. **[^](#cite_ref-6)** Shapiro, Ehud Y. (1983). *Algorithmic program debugging*. MIT Press. [ISBN](/source/ISBN_(identifier)) [0-262-19218-7](https://en.wikipedia.org/wiki/Special:BookSources/0-262-19218-7).

1. ^ [***a***](#cite_ref-Muggleton-1988_7-0) [***b***](#cite_ref-Muggleton-1988_7-1) Muggleton, S.H.; Buntine, W. (1988). "Machine invention of first-order predicate by inverting resolution". *Proceedings of the 5th International Conference on Machine Learning*. pp. 339–352. [doi](/source/Doi_(identifier)):[10.1016/B978-0-934613-64-4.50040-2](https://doi.org/10.1016%2FB978-0-934613-64-4.50040-2). [ISBN](/source/ISBN_(identifier)) [978-0-934613-64-4](https://en.wikipedia.org/wiki/Special:BookSources/978-0-934613-64-4).

1. **[^](#cite_ref-8)** Quinlan, J. R. (August 1990). ["Learning logical definitions from relations"](https://doi.org/10.1007%2Fbf00117105). *Machine Learning*. **5** (3): 239–266. [doi](/source/Doi_(identifier)):[10.1007/bf00117105](https://doi.org/10.1007%2Fbf00117105). [ISSN](/source/ISSN_(identifier)) [0885-6125](https://search.worldcat.org/issn/0885-6125).

1. ^ [***a***](#cite_ref-Nienhuys-Cheng-1997b_9-0) [***b***](#cite_ref-Nienhuys-Cheng-1997b_9-1) [***c***](#cite_ref-Nienhuys-Cheng-1997b_9-2) [***d***](#cite_ref-Nienhuys-Cheng-1997b_9-3) Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). *Foundations of inductive logic programming*. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. pp. 354–358. [ISBN](/source/ISBN_(identifier)) [978-3-540-62927-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-62927-6).

1. ^ [***a***](#cite_ref-Muggleton-1990_10-0) [***b***](#cite_ref-Muggleton-1990_10-1) Muggleton, Stephen H.; Feng, Cao (1990). "Efficient Induction of Logic Programs". In Arikawa, Setsuo; Goto, Shigeki; Ohsuga, Setsuo; Yokomori, Takashi (eds.). [*Algorithmic Learning Theory, First International Workshop, ALT '90, Tokyo, Japan, October 8-10, 1990, Proceedings*](https://dblp.org/rec/conf/alt/MuggletonF90.bib). Springer/Ohmsha. pp. 368–381. - See also Muggleton, Stephen H.; Feng, Cao (1992). ["Efficient Induction of Logic Programs"](https://books.google.com/books?id=IYAewM0zvTYC&dq=S.+Muggleton+and+C.+Feng.+Efficient+induction+of+logic+programs.+In+Proceedings+of+the+First+Conference+on+Algorithmic+Learning+Theory,+Tokyo,+1990.+Omsha.&pg=PA281). In Muggleton, Stephen H. (ed.). *Inductive Logic Programming*. The APIS Series. Vol. 38. Academic Press. p. 281. [ISBN](/source/ISBN_(identifier)) [978-0-12-509715-4](https://en.wikipedia.org/wiki/Special:BookSources/978-0-12-509715-4).

1. **[^](#cite_ref-11)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 808. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. ^ [***a***](#cite_ref-Muggleton-1995_12-0) [***b***](#cite_ref-Muggleton-1995_12-1) [***c***](#cite_ref-Muggleton-1995_12-2) Muggleton, S.H. (1995). "Inverting entailment and Progol". *New Generation Computing*. **13** (3–4): 245–286. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.31.1630](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.31.1630). [doi](/source/Doi_(identifier)):[10.1007/bf03037227](https://doi.org/10.1007%2Fbf03037227). [S2CID](/source/S2CID_(identifier)) [12643399](https://api.semanticscholar.org/CorpusID:12643399).

1. **[^](#cite_ref-13)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 808. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-14)** Džeroski, Sašo (2001), Džeroski, Sašo; [Lavrač, Nada](/source/Nada_Lavra%C4%8D) (eds.), ["Relational Data Mining Applications: An Overview"](http://link.springer.com/10.1007/978-3-662-04599-2_14), *Relational Data Mining*, Berlin, Heidelberg: Springer Berlin Heidelberg, pp. 339–364, [doi](/source/Doi_(identifier)):[10.1007/978-3-662-04599-2_14](https://doi.org/10.1007%2F978-3-662-04599-2_14), [ISBN](/source/ISBN_(identifier)) [978-3-642-07604-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-642-07604-6), retrieved 2023-11-27{{[citation](https://en.wikipedia.org/wiki/Template:Citation)}}: CS1 maint: work parameter with ISBN ([link](https://en.wikipedia.org/wiki/Category:CS1_maint:_work_parameter_with_ISBN))

1. **[^](#cite_ref-15)** De Raedt, Luc (2008), [*Logical and Relational Learning*](https://dx.doi.org/10.1007/978-3-540-68856-3), Cognitive Technologies, Berlin, Heidelberg: Springer, p. 14, [Bibcode](/source/Bibcode_(identifier)):[2008lrl..book.....D](https://ui.adsabs.harvard.edu/abs/2008lrl..book.....D), [doi](/source/Doi_(identifier)):[10.1007/978-3-540-68856-3](https://doi.org/10.1007%2F978-3-540-68856-3), [ISBN](/source/ISBN_(identifier)) [978-3-540-20040-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-20040-6)

1. **[^](#cite_ref-16)** Muggleton, Stephen H.; Lin, Dianhuan; Pahlavi, Niels; Tamaddoni-Nezhad, Alireza (2013-05-01). ["Meta-interpretive learning: application to grammatical inference"](https://dx.doi.org/10.1007/s10994-013-5358-3). *Machine Learning*. **94** (1): 25–49. [doi](/source/Doi_(identifier)):[10.1007/s10994-013-5358-3](https://doi.org/10.1007%2Fs10994-013-5358-3). [ISSN](/source/ISSN_(identifier)) [0885-6125](https://search.worldcat.org/issn/0885-6125). [S2CID](/source/S2CID_(identifier)) [254738603](https://api.semanticscholar.org/CorpusID:254738603).

1. **[^](#cite_ref-17)** Cropper, Andrew; Dumančić, Sebastijan; Evans, Richard; Muggleton, Stephen (2022). ["Inductive logic programming at 30"](https://doi.org/10.1007%2Fs10994-021-06089-1). *Machine Learning*. **111** (1): 147–172. [doi](/source/Doi_(identifier)):[10.1007/s10994-021-06089-1](https://doi.org/10.1007%2Fs10994-021-06089-1). [ISSN](/source/ISSN_(identifier)) [0885-6125](https://search.worldcat.org/issn/0885-6125).

1. **[^](#cite_ref-18)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 779–782. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-19)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 779–782. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-20)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 779–782. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-21)** Džeroski, Sašo (1996). ["Inductive Logic Programming and Knowledge Discovery in Databases"](https://web.archive.org/web/20210927141157/http://kt.ijs.si/SasoDzeroski/pdfs/1996/Chapters/1996_InductiveLogicProgramming.pdf) (PDF). In Fayyad, U.M.; Piatetsky-Shapiro, G.; Smith, P.; Uthurusamy, R. (eds.). *Advances in Knowledge Discovery and Data Mining*. MIT Press. pp. 117–152 See §5.2.4. Archived from [the original](http://kt.ijs.si/SasoDzeroski/pdfs/1996/Chapters/1996_InductiveLogicProgramming.pdf) (PDF) on 2021-09-27. Retrieved 2021-09-27.

1. **[^](#cite_ref-22)** De Raedt, Luc (1997). ["Logical settings for concept-learning"](https://linkinghub.elsevier.com/retrieve/pii/S0004370297000416). *Artificial Intelligence*. **95** (1): 187–201. [doi](/source/Doi_(identifier)):[10.1016/S0004-3702(97)00041-6](https://doi.org/10.1016%2FS0004-3702%2897%2900041-6).

1. ^ [***a***](#cite_ref-Muggleton-1999_23-0) [***b***](#cite_ref-Muggleton-1999_23-1) Muggleton, Stephen (1999). "Inductive Logic Programming: Issues, Results and the Challenge of Learning Language in Logic". *Artificial Intelligence*. **114** (1–2): 283–296. [doi](/source/Doi_(identifier)):[10.1016/s0004-3702(99)00067-3](https://doi.org/10.1016%2Fs0004-3702%2899%2900067-3).; here: Sect.2.1

1. **[^](#cite_ref-24)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 779–782. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-25)** Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). *Foundations of inductive logic programming*. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. p. 255. [ISBN](/source/ISBN_(identifier)) [978-3-540-62927-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-62927-6).

1. **[^](#cite_ref-26)** Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). *Foundations of inductive logic programming*. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. p. 286. [ISBN](/source/ISBN_(identifier)) [978-3-540-62927-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-62927-6).

1. ^ [***a***](#cite_ref-Nienhuys-Cheng-1997c_27-0) [***b***](#cite_ref-Nienhuys-Cheng-1997c_27-1) Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). *Foundations of inductive logic programming*. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. p. 197. [ISBN](/source/ISBN_(identifier)) [978-3-540-62927-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-62927-6).

1. **[^](#cite_ref-28)** Ray, O.; Broda, K.; Russo, A.M. (2003). ["Hybrid abductive inductive learning"](https://link.springer.com/chapter/10.1007/978-3-540-39917-9_21). *Proceedings of the 13th international conference on inductive logic programming*. LNCS. Vol. 2835. Springer. pp. 311–328. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.212.6602](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.212.6602). [doi](/source/Doi_(identifier)):[10.1007/978-3-540-39917-9_21](https://doi.org/10.1007%2F978-3-540-39917-9_21). [ISBN](/source/ISBN_(identifier)) [978-3-540-39917-9](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-39917-9).

1. **[^](#cite_ref-29)** Kimber, T.; Broda, K.; Russo, A. (2009). ["Induction on failure: learning connected Horn theories"](https://link.springer.com/chapter/10.1007/978-3-642-04238-6_16). *Proceedings of the 10th international conference on logic programing and nonmonotonic reasoning*. LNCS. Vol. 575. Springer. pp. 169–181. [doi](/source/Doi_(identifier)):[10.1007/978-3-642-04238-6_16](https://doi.org/10.1007%2F978-3-642-04238-6_16). [ISBN](/source/ISBN_(identifier)) [978-3-642-04238-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-642-04238-6).

1. **[^](#cite_ref-30)** Yamamoto, Yoshitaka; Inoue, Katsumi; Iwanuma, Koji (2012). ["Inverse subsumption for complete explanatory induction"](https://link.springer.com/content/pdf/10.1007/s10994-011-5250-y.pdf) (PDF). *Machine Learning*. **86**: 115–139. [doi](/source/Doi_(identifier)):[10.1007/s10994-011-5250-y](https://doi.org/10.1007%2Fs10994-011-5250-y). [S2CID](/source/S2CID_(identifier)) [11347607](https://api.semanticscholar.org/CorpusID:11347607).

1. **[^](#cite_ref-31)** Yamamoto, Akihiro (1997). ["Which hypotheses can be found with inverse entailment?"](https://link.springer.com/chapter/10.1007/3540635149_58). *International Conference on Inductive Logic Programming*. Lecture Notes in Computer Science. Vol. 1297. Springer. pp. 296–308. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.54.2975](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.54.2975). [doi](/source/Doi_(identifier)):[10.1007/3540635149_58](https://doi.org/10.1007%2F3540635149_58). [ISBN](/source/ISBN_(identifier)) [978-3-540-69587-5](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-69587-5).

1. ^ [***a***](#cite_ref-Kimber-2012_32-0) [***b***](#cite_ref-Kimber-2012_32-1) Kimber, Timothy (2012). [*Learning definite and normal logic programs by induction on failure*](https://web.archive.org/web/20221021035457/https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.560694) (PhD). Imperial College London. ethos 560694. Archived from [the original](https://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.560694) on 2022-10-21. Retrieved 2022-10-21.

1. **[^](#cite_ref-33)** Toth, David (2014). "Imparo is complete by inverse subsumption". [arXiv](/source/ArXiv_(identifier)):[1407.3836](https://arxiv.org/abs/1407.3836) [[cs.AI](https://arxiv.org/archive/cs.AI)].

1. **[^](#cite_ref-34)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 795. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-35)** Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://jair.org/index.php/jair/article/view/13507). *Journal of Artificial Intelligence Research*. **74**: 795. [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

1. **[^](#cite_ref-36)** Heindorf, Stefan; Blübaum, Lukas; Düsterhus, Nick; Werner, Till; Golani, Varun Nandkumar; Demir, Caglar; Ngonga Ngomo, Axel-Cyrille (2022). *EvoLearner: Learning Description Logics with Evolutionary Algorithms*. WWW. [arXiv](/source/ArXiv_(identifier)):[2111.04879](https://arxiv.org/abs/2111.04879).

1. **[^](#cite_ref-37)** Muggleton, Stephen; Santos, Jose; Tamaddoni-Nezhad, Alireza (2009). ["ProGolem: a system based on relative minimal generalization"](https://link.springer.com/chapter/10.1007/978-3-642-13840-9_13). *International Conference on Inductive Logic Programming*. Springer. pp. 131–148. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.297.7992](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.297.7992). [doi](/source/Doi_(identifier)):[10.1007/978-3-642-13840-9_13](https://doi.org/10.1007%2F978-3-642-13840-9_13). [ISBN](/source/ISBN_(identifier)) [978-3-642-13840-9](https://en.wikipedia.org/wiki/Special:BookSources/978-3-642-13840-9).

1. **[^](#cite_ref-38)** Santos, Jose; Nassif, Houssam; Page, David; Muggleton, Stephen; Sternberg, Mike (2012). ["Automated identification of features of protein-ligand interactions using Inductive Logic Programming: a hexose binding case study"](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3458898). *BMC Bioinformatics*. **13**: 162. [doi](/source/Doi_(identifier)):[10.1186/1471-2105-13-162](https://doi.org/10.1186%2F1471-2105-13-162). [PMC](/source/PMC_(identifier)) [3458898](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3458898). [PMID](/source/PMID_(identifier)) [22783946](https://pubmed.ncbi.nlm.nih.gov/22783946).

1. **[^](#cite_ref-39)** De Raedt, Luc; Kersting, Kristian (2008), [*Probabilistic Inductive Logic Programming*](https://dx.doi.org/10.1007/978-3-540-78652-8_1), Berlin, Heidelberg: Springer Berlin Heidelberg, pp. 1–27, [doi](/source/Doi_(identifier)):[10.1007/978-3-540-78652-8_1](https://doi.org/10.1007%2F978-3-540-78652-8_1), [ISBN](/source/ISBN_(identifier)) [978-3-540-78651-1](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-78651-1), retrieved 2023-12-09

1. ^ [***a***](#cite_ref-Riguzzi-2014_40-0) [***b***](#cite_ref-Riguzzi-2014_40-1) [***c***](#cite_ref-Riguzzi-2014_40-2) [***d***](#cite_ref-Riguzzi-2014_40-3) [***e***](#cite_ref-Riguzzi-2014_40-4) [***f***](#cite_ref-Riguzzi-2014_40-5) [***g***](#cite_ref-Riguzzi-2014_40-6) [***h***](#cite_ref-Riguzzi-2014_40-7) [***i***](#cite_ref-Riguzzi-2014_40-8) Riguzzi, Fabrizio; Bellodi, Elena; Zese, Riccardo (2014-09-18). ["A History of Probabilistic Inductive Logic Programming"](https://doi.org/10.3389%2Ffrobt.2014.00006). *Frontiers in Robotics and AI*. **1**. [doi](/source/Doi_(identifier)):[10.3389/frobt.2014.00006](https://doi.org/10.3389%2Ffrobt.2014.00006). [ISSN](/source/ISSN_(identifier)) [2296-9144](https://search.worldcat.org/issn/2296-9144).

1. **[^](#cite_ref-41)** Koller, Daphne; Pfeffer, Avi (August 1997). [*Learning probabilities for noisy first-order rules*](http://www.robotics.stanford.edu/~koller/Papers/Koller+Pfeffer:IJCAI97.pdf) (PDF). [IJCAI](/source/IJCAI).

1. **[^](#cite_ref-42)** De Raedt, L.; Kersting, K.; Kimmig, A.; Revoredo, K.; Toivonen, H. (March 2008). ["Compressing probabilistic Prolog programs"](http://link.springer.com/10.1007/s10994-007-5030-x). *Machine Learning*. **70** (2–3): 151–168. [doi](/source/Doi_(identifier)):[10.1007/s10994-007-5030-x](https://doi.org/10.1007%2Fs10994-007-5030-x). [hdl](/source/Hdl_(identifier)):[10138/143971](https://hdl.handle.net/10138%2F143971). [ISSN](/source/ISSN_(identifier)) [0885-6125](https://search.worldcat.org/issn/0885-6125).

1. **[^](#cite_ref-43)** Blockeel, Hendrik; Meert, Wannes (2007), ["Towards Learning Non-recursive LPADs by Transforming Them into Bayesian Networks"](https://dx.doi.org/10.1007/978-3-540-73847-3_16), *Inductive Logic Programming*, Lecture Notes in Computer Science, vol. 4455, Berlin, Heidelberg: Springer Berlin Heidelberg, pp. 94–108, [doi](/source/Doi_(identifier)):[10.1007/978-3-540-73847-3_16](https://doi.org/10.1007%2F978-3-540-73847-3_16), [ISBN](/source/ISBN_(identifier)) [978-3-540-73846-6](https://en.wikipedia.org/wiki/Special:BookSources/978-3-540-73846-6), retrieved 2023-12-09{{[citation](https://en.wikipedia.org/wiki/Template:Citation)}}: CS1 maint: work parameter with ISBN ([link](https://en.wikipedia.org/wiki/Category:CS1_maint:_work_parameter_with_ISBN))

1. **[^](#cite_ref-44)** De Raedt, Luc; Thon, Ingo (2011), Frasconi, Paolo; Lisi, Francesca A. (eds.), ["Probabilistic Rule Learning"](http://link.springer.com/10.1007/978-3-642-21295-6_9), *Inductive Logic Programming*, vol. 6489, Berlin, Heidelberg: Springer Berlin Heidelberg, pp. 47–58, [doi](/source/Doi_(identifier)):[10.1007/978-3-642-21295-6_9](https://doi.org/10.1007%2F978-3-642-21295-6_9), [ISBN](/source/ISBN_(identifier)) [978-3-642-21294-9](https://en.wikipedia.org/wiki/Special:BookSources/978-3-642-21294-9), [S2CID](/source/S2CID_(identifier)) [11727522](https://api.semanticscholar.org/CorpusID:11727522), retrieved 2023-12-09{{[citation](https://en.wikipedia.org/wiki/Template:Citation)}}: CS1 maint: work parameter with ISBN ([link](https://en.wikipedia.org/wiki/Category:CS1_maint:_work_parameter_with_ISBN))

1. **[^](#cite_ref-45)** Bellodi, Elena; Riguzzi, Fabrizio (2012), ["Learning the Structure of Probabilistic Logic Programs"](https://dx.doi.org/10.1007/978-3-642-31951-8_10), *Inductive Logic Programming*, Berlin, Heidelberg: Springer Berlin Heidelberg, pp. 61–75, [doi](/source/Doi_(identifier)):[10.1007/978-3-642-31951-8_10](https://doi.org/10.1007%2F978-3-642-31951-8_10), [ISBN](/source/ISBN_(identifier)) [978-3-642-31950-1](https://en.wikipedia.org/wiki/Special:BookSources/978-3-642-31950-1), retrieved 2023-12-09{{[citation](https://en.wikipedia.org/wiki/Template:Citation)}}: CS1 maint: work parameter with ISBN ([link](https://en.wikipedia.org/wiki/Category:CS1_maint:_work_parameter_with_ISBN))

1. **[^](#cite_ref-46)** Bellodi, Elena; Riguzzi, Fabrizio (2014-01-15). ["Structure learning of probabilistic logic programs by searching the clause space"](https://dx.doi.org/10.1017/s1471068413000689). *Theory and Practice of Logic Programming*. **15** (2): 169–212. [arXiv](/source/ArXiv_(identifier)):[1309.2080](https://arxiv.org/abs/1309.2080). [doi](/source/Doi_(identifier)):[10.1017/s1471068413000689](https://doi.org/10.1017%2Fs1471068413000689). [hdl](/source/Hdl_(identifier)):[11392/2269014](https://hdl.handle.net/11392%2F2269014). [ISSN](/source/ISSN_(identifier)) [1471-0684](https://search.worldcat.org/issn/1471-0684). [S2CID](/source/S2CID_(identifier)) [17669522](https://api.semanticscholar.org/CorpusID:17669522).

This article incorporates text from a [free content](/source/Free_content) work. Licensed under CC-BY 4.0 ([license statement/permission](http://creativecommons.org/licenses/by/4.0/)). Text taken from [*A History of Probabilistic Inductive Logic Programming​*](http://journal.frontiersin.org/article/10.3389/frobt.2014.00006/), Fabrizio Riguzzi, Elena Bellodi and Riccardo Zese, [Frontiers Media](/source/Frontiers_Media).

## Further reading

- Muggleton, S.; De Raedt, L. (1994). ["Inductive Logic Programming: Theory and methods"](https://doi.org/10.1016%2F0743-1066%2894%2990035-3). *The Journal of Logic Programming*. 19–20: 629–679. [doi](/source/Doi_(identifier)):[10.1016/0743-1066(94)90035-3](https://doi.org/10.1016%2F0743-1066%2894%2990035-3).

- Lavrac, N.; Dzeroski, S. (1994). [*Inductive Logic Programming: Techniques and Applications*](https://web.archive.org/web/20040906084947/http://www-ai.ijs.si/SasoDzeroski/ILPBook/). New York: Ellis Horwood. [ISBN](/source/ISBN_(identifier)) [978-0-13-457870-5](https://en.wikipedia.org/wiki/Special:BookSources/978-0-13-457870-5). Archived from [the original](http://www-ai.ijs.si/SasoDzeroski/ILPBook/) on 2004-09-06. Retrieved 2004-09-22.

- Visual example of inducing the grandparenthood relation by the [Atom system](#Implementations). [http://john-ahlgren.blogspot.com/2014/03/inductive-reasoning-visualized.html](http://john-ahlgren.blogspot.com/2014/03/inductive-reasoning-visualized.html) [Archived](https://web.archive.org/web/20140326101408/http://john-ahlgren.blogspot.com/2014/03/inductive-reasoning-visualized.html) 2014-03-26 at the [Wayback Machine](/source/Wayback_Machine)

- Cropper, Andrew; Dumančić, Sebastijan (2022-06-15). ["Inductive Logic Programming At 30: A New Introduction"](https://doi.org/10.1613%2Fjair.1.13507). *Journal of Artificial Intelligence Research*. **74**: 765-850. [arXiv](/source/ArXiv_(identifier)):[2008.07912](https://arxiv.org/abs/2008.07912). [doi](/source/Doi_(identifier)):[10.1613/jair.1.13507](https://doi.org/10.1613%2Fjair.1.13507). [ISSN](/source/ISSN_(identifier)) [1076-9757](https://search.worldcat.org/issn/1076-9757).

v t e Programming paradigms Imperative Structured Jackson structures Block-structured Modular Non-structured Procedural Programming in the large and in the small Design by contract Invariant-based Nested function Object-oriented Class-based, Prototype-based, Object-based Agent Immutable object Persistent Uniform function call syntax Declarative Functional Recursive Anonymous function (Partial application) Higher-order Purely functional Total Strict GADTs Dependent types Functional logic Point-free style Expression-oriented Applicative, Concatenative Function-level, Value-level Monad Dataflow Flow-based Reactive (Functional reactive) Signals Streams Synchronous Logic Abductive logic Answer set Constraint (Constraint logic) Inductive logic Nondeterministic Ontology Probabilistic logic Query Domain- specific language (DSL) Algebraic modeling Array Automata-based (Action) Command (Spacecraft) Differentiable End-user Grammar-oriented Interface description Language-oriented List comprehension Low-code Modeling Natural language Non-English-based Page description Pipes and filters Probabilistic Quantum Scientific Scripting Set-theoretic Simulation Stack-based System Tactile Templating Transformation (Graph rewriting, Production, Pattern) Visual Concurrent, parallel Actor-based Automatic mutual exclusion Choreographic programming Concurrent logic (Concurrent constraint logic) Concurrent OO Macroprogramming Multitier programming Organic computing Parallel programming models Partitioned global address space Process-oriented Relativistic programming Service-oriented Structured concurrency Metaprogramming Attribute-oriented Automatic (Inductive) Dynamic Extensible Generic Homoiconicity Interactive Macro (Hygienic) Metalinguistic abstraction Multi-stage Program synthesis (Bayesian, by demonstration, by example, vibe coding) Reflective Self-modifying code Symbolic Template Separation of concerns Aspects Components Data-driven Data-oriented Event-driven Features Literate Roles Subjects Comparisons/Lists Comparison (multi-paradigm, object-oriented, functional), List (OO, by type)

---
Adapted from the Wikipedia article [Inductive logic programming](https://en.wikipedia.org/wiki/Inductive_logic_programming) by Wikipedia contributors ([contributor history](https://en.wikipedia.org/wiki/Inductive_logic_programming?action=history)). Available under [Creative Commons Attribution-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-sa/4.0/). Changes may have been made.