pith. sign in

arxiv: 1907.10953 · v1 · pith:HGNLKMWAnew · submitted 2019-07-25 · 💻 cs.LG · cs.AI· stat.ML

Learning higher-order logic programs

Andrew Cropper , Rolf Morel , Stephen H. Muggleton This is my paper

Pith reviewed 2026-05-24 16:10 UTC · model grok-4.3

classification 💻 cs.LG cs.AIstat.ML
keywords inductive logic programminghigher-order programsmeta-interpretive learninghypothesis spacesample complexitypredicate inventionprogram induction
0
0 comments X

The pith

Learning higher-order programs reduces textual complexity and hypothesis space size in inductive logic programming.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper tries to establish that extending meta-interpretive learning to include higher-order definitions as background knowledge lets systems learn higher-order logic programs instead of first-order ones. If true, programs can be expressed with less text, which shrinks the hypothesis space that must be searched and lowers the number of examples needed. A sympathetic reader would care because smaller search spaces make it practical to learn more complex behaviors from limited data. The authors implement the idea in two systems and test it on robot strategies, chess, list transformations, and string decryption.

Core claim

Our theoretical results show that learning higher-order programs, rather than first-order programs, can reduce the textual complexity required to express programs which in turn reduces the size of the hypothesis space and sample complexity. We extend meta-interpretive learning to support learning higher-order programs by allowing for higher-order definitions to be used as background knowledge. Both new systems support learning higher-order programs and higher-order predicate invention, such as inventing functions for map/3 and conditions for filter/3.

What carries the argument

Higher-order definitions supplied as background knowledge in meta-interpretive learning, which enables programs using abstractions such as map and filter.

If this is right

  • Reduced textual complexity for expressing the target programs.
  • Smaller hypothesis space sizes and therefore lower sample complexity.
  • Support for higher-order predicate invention during learning.
  • Higher predictive accuracy and shorter learning times on the tested domains.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same reduction might appear in other inductive synthesis settings that allow reusable abstractions.
  • One could test whether the benefit persists when the higher-order definitions themselves must be discovered rather than given.
  • The approach might make logic-based learners more competitive with systems that already use higher-order constructs by default.

Load-bearing premise

Suitable higher-order definitions can be supplied as background knowledge in advance without introducing new sources of complexity that offset the claimed reduction in hypothesis space size.

What would settle it

An experiment on one of the four domains where supplying higher-order definitions increases the number of examples or the search time needed compared with first-order learning.

Figures

Figures reproduced from arXiv: 1907.10953 by Andrew Cropper, Rolf Morel, Stephen H. Muggleton.

Figure 1
Figure 1. Figure 1: Example encrypted and decrypted messages. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Decryption programs. Figure (a) shows a first-order program. Figure (b) shows a [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Example metarules. The letters P, Q, and R denote existentially quantified higher￾order variables. The letters A, B, and C denote universally quantified first-order variables. Definition 2 (Higher-order definition) A higher-order definition is a set of higher￾order Horn clauses where the head atoms have the same predicate symbol. Three example higher-order definitions are: Example 1 (Map definition) map([]… view at source ↗
Figure 4
Figure 4. Figure 4: Decryption programs. Figure (a) shows a first-order program represented in [PITH_FULL_IMAGE:figures/full_fig_p011_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Metagol’s learning procedure described using Prolog. Note that this code is the [PITH_FULL_IMAGE:figures/full_fig_p013_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Prolog code for Metagolho. To prove this atom Metagol could unify map/3 with Q and then try to prove the atom map([1,2,3],[c,d,e],R). However, the proof of map([1,2,3],[c,d,e],R) would fail because there is no suitable substitution for R. The only possible substitution for R is succ/2, which will clearly not allow the proof to succeed. The only way Metagol can learn a consistent hypothesis is by successive… view at source ↗
Figure 7
Figure 7. Figure 7: Three forms of BK used by Metagolho described in Prolog syntax. The curry rules are slightly unusual but are necessary to use the interpreted BK (e.g. curry1 allows us to use the map/3 definition). As this scenario illustrates, the real power and novelty of Metagolho is the combination of abstraction (learning higher-order programs) and invention (predicate invention). In this scenario, abstraction has all… view at source ↗
Figure 8
Figure 8. Figure 8: HEXMILho code examples. The "[]" symbol in the map/3 definition is special syntax we use to represent lists. Note that due to lists being encoded as strings, the prepend external atom is required to manipulate the lists in the map/3 definition. considers constants that it encounters when it evaluates whether a hypothesis covers an example, in which case it only considers the constant symbols pertaining to … view at source ↗
Figure 9
Figure 9. Figure 9: Figures (a) and (b) show initial/final state waiter examples respectively. In the initial state, the cups are empty and each guest has a preference for tea (T) or coffee (C). In the final state, the cups are facing up and are full with the guest’s preferred drink. 5.2.1 Materials Examples are f/2 atoms where the first argument is the initial state and the second is the final state. A state is a list of gro… view at source ↗
Figure 10
Figure 10. Figure 10: Compiled BK in the robot waiter experiment. We omit the definitions for brevity. [PITH_FULL_IMAGE:figures/full_fig_p021_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Prolog robot waiter experiment results which show learning performance when [PITH_FULL_IMAGE:figures/full_fig_p022_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: ASP robot waiter experiment results which show learning performance when [PITH_FULL_IMAGE:figures/full_fig_p023_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: An example first-order waiter program learned by Metagol. [PITH_FULL_IMAGE:figures/full_fig_p023_13.png] view at source ↗
Figure 15
Figure 15. Figure 15: Chess initial/final state example. X is the file, and Y is the rank. We generate a positive example as follows. For the initial state for the Prolog experiments, we select a random subset of n pieces from the interval [1, 16] and randomly place them on the board. For the ASP experiments the interval is [1, 5]. For the final state, we update the initial state so that each pawn finishes at rank 8. To genera… view at source ↗
Figure 16
Figure 16. Figure 16: Compiled BK used in the chess experiment. [PITH_FULL_IMAGE:figures/full_fig_p024_16.png] view at source ↗
Figure 17
Figure 17. Figure 17: Prolog chess experimental results which show predictive accuracy when varying [PITH_FULL_IMAGE:figures/full_fig_p025_17.png] view at source ↗
Figure 18
Figure 18. Figure 18: ASP chess experimental results which show predictive accuracy when varying the [PITH_FULL_IMAGE:figures/full_fig_p026_18.png] view at source ↗
Figure 19
Figure 19. Figure 19: Figure (a) shows the target first-order chess program, which Metagol could not [PITH_FULL_IMAGE:figures/full_fig_p026_19.png] view at source ↗
Figure 20
Figure 20. Figure 20: Examples of the droplast problem. Note that in the experimental code we treat [PITH_FULL_IMAGE:figures/full_fig_p027_20.png] view at source ↗
Figure 21
Figure 21. Figure 21: Compiled BK used in the droplast experiment. [PITH_FULL_IMAGE:figures/full_fig_p027_21.png] view at source ↗
Figure 22
Figure 22. Figure 22: Prolog droplast experimental results which show predictive accuracy when vary [PITH_FULL_IMAGE:figures/full_fig_p028_22.png] view at source ↗
Figure 23
Figure 23. Figure 23: ASP droplast experimental results which show predictive accuracy when varying [PITH_FULL_IMAGE:figures/full_fig_p028_23.png] view at source ↗
Figure 24
Figure 24. Figure 24: Figure (a) shows the higher-order program often learned by Metagol [PITH_FULL_IMAGE:figures/full_fig_p028_24.png] view at source ↗
Figure 25
Figure 25. Figure 25: Examples of the more complex double droplast problem. [PITH_FULL_IMAGE:figures/full_fig_p029_25.png] view at source ↗
Figure 26
Figure 26. Figure 26: Figure (a) shows a the higher-order double droplast program learned by Metagolho. For readability Figure (b) shows the folded program in which non-reused invented predicates are removed. Note how in Figure (b) the predicate symbol f1/2 is used both as an argument to map/3 and as a standard literal in the clause defined by the head f(A,B). 5.5 Encryption In this final experiment, we revisit the encryption … view at source ↗
Figure 27
Figure 27. Figure 27: Prolog encryption experiment results which show learning performance when [PITH_FULL_IMAGE:figures/full_fig_p030_27.png] view at source ↗
read the original abstract

A key feature of inductive logic programming (ILP) is its ability to learn first-order programs, which are intrinsically more expressive than propositional programs. In this paper, we introduce techniques to learn higher-order programs. Specifically, we extend meta-interpretive learning (MIL) to support learning higher-order programs by allowing for \emph{higher-order definitions} to be used as background knowledge. Our theoretical results show that learning higher-order programs, rather than first-order programs, can reduce the textual complexity required to express programs which in turn reduces the size of the hypothesis space and sample complexity. We implement our idea in two new MIL systems: the Prolog system \namea{} and the ASP system \nameb{}. Both systems support learning higher-order programs and higher-order predicate invention, such as inventing functions for \tw{map/3} and conditions for \tw{filter/3}. We conduct experiments on four domains (robot strategies, chess playing, list transformations, and string decryption) that compare learning first-order and higher-order programs. Our experimental results support our theoretical claims and show that, compared to learning first-order programs, learning higher-order programs can significantly improve predictive accuracies and reduce learning times.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

1 major / 1 minor

Summary. The paper extends meta-interpretive learning (MIL) to higher-order programs by permitting higher-order definitions as background knowledge. It presents theoretical results claiming that higher-order programs reduce textual complexity relative to first-order programs, thereby shrinking hypothesis-space size and sample complexity. Two implementations are described (a Prolog system and an ASP system) that also support higher-order predicate invention. Experiments on robot strategies, chess, list transformations, and string decryption compare first-order and higher-order learning and report improved predictive accuracy and reduced runtimes for the higher-order case.

Significance. If the claimed reduction in hypothesis-space cardinality holds after accounting for the enlarged signature, the work would provide a principled route to more compact and sample-efficient ILP. The dual-system implementation and the experimental coverage across four domains are concrete strengths; the support for inventing higher-order predicates such as map/3 and filter/3 conditions adds practical value.

major comments (1)
  1. [theoretical results] The central theoretical claim (stated in the abstract and developed in the theoretical-results section) asserts that higher-order definitions reduce |H| and sample complexity. This reduction is not automatic once the language bias is enlarged by the higher-order predicates and their associated clauses; an explicit cardinality comparison or covering-number bound that includes the cost of the added background knowledge is required to establish the net decrease.
minor comments (1)
  1. [abstract] The abstract refers to the two systems as “namea” and “nameb”; the full names and citation details should appear at first use in the main text.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the constructive review and for highlighting the need for a more precise accounting in the theoretical claims. We address the single major comment below.

read point-by-point responses

  1. Referee: The central theoretical claim (stated in the abstract and developed in the theoretical-results section) asserts that higher-order definitions reduce |H| and sample complexity. This reduction is not automatic once the language bias is enlarged by the higher-order predicates and their associated clauses; an explicit cardinality comparison or covering-number bound that includes the cost of the added background knowledge is required to establish the net decrease.

    Authors: We agree that establishing a net reduction in hypothesis-space size requires an explicit comparison that accounts for the enlarged signature. Section 3 of the manuscript shows that, for programs expressible in both settings, higher-order definitions can reduce textual complexity (measured by the number of symbols in the shortest program), which in turn yields a smaller hypothesis space when the search is bounded by program length. However, the current proofs do not include a direct cardinality argument that subtracts the additional hypotheses introduced by the higher-order background-knowledge predicates themselves. We will revise the theoretical section to add a clarifying discussion of this point and, where feasible, a bound that incorporates the cost of the added language bias. This revision will make explicit the conditions under which the claimed net decrease holds. revision: partial

Circularity Check

0 steps flagged

No circularity: theoretical claims rest on new MIL extensions without self-referential reduction

full rationale

The paper extends meta-interpretive learning by allowing higher-order definitions as background knowledge and claims this reduces textual complexity, hypothesis space size, and sample complexity. No quoted equations, definitions, or self-citations in the abstract or description reduce the central claim to a fit, renaming, or prior self-work by construction. The derivation is presented as following from the new language bias and theoretical analysis of program length, which is independent of the target result. The skeptic concern about net |H| cardinality is a potential gap in the proof but does not constitute circularity under the specified criteria, as no load-bearing step is shown to be equivalent to its inputs by definition.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract-only review; no explicit free parameters, axioms, or invented entities are stated.

pith-pipeline@v0.9.0 · 5743 in / 976 out tokens · 18523 ms · 2026-05-24T16:10:27.484834+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

43 extracted references · 43 canonical work pages

  1. [1]

    Top-down induction of first-order logical decision trees

    Hendrik Blockeel and Luc De Raedt. Top-down induction of first-order logical decision trees. Artif. Intell., 101(1-2):285–297, 1998

    work page 1998

  2. [2]

    Anselm Blumer, Andrzej Ehrenfeucht, David Haussler, and Manfred K. Warmuth. Occam’s razor.Inf. Process. Lett., 24(6):377–380, 1987

    work page 1987

  3. [3]

    A representation for pattern-knowledge in chess endgames

    Ivan Bratko and Donald Michie. A representation for pattern-knowledge in chess endgames. Ad- vances in Computer Chess, 2:31–56, 1980

    work page 1980

  4. [4]

    On understanding types, data abstraction, and polymorphism.ACM Comput

    Luca Cardelli and Peter Wegner. On understanding types, data abstraction, and polymorphism.ACM Comput. Surv., 17(4):471–522, 1985

    work page 1985

  5. [5]

    K.L. Clark. Negation as failure. In M. L. Ginsberg, editor, Readings in Nonmonotonic Reasoning, pages 311–325. Kaufmann, Los Altos, CA, 1987

    work page 1987

  6. [6]

    Efficiently learning efficient programs

    Andrew Cropper. Efficiently learning efficient programs . PhD thesis, Imperial College London, UK, 2017

    work page 2017

  7. [7]

    Muggleton

    Andrew Cropper and Stephen H. Muggleton. Learning efficient logical robot strategies involving composable objects. In Qiang Yang and Michael Wooldridge, editors, Proceedings of the Twenty- Fourth International Joint Conference on Artificial Intelligence, IJCAI 2015, Buenos Aires, Argentina, July 25-31, 2015, pages 3423–3429. AAAI Press, 2015

    work page 2015

  8. [8]

    Muggleton

    Andrew Cropper and Stephen H. Muggleton. Learning higher-order logic programs through abstrac- tion and invention. In Subbarao Kambhampati, editor, Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI 2016, New York, NY, USA, 9-15 July 2016 , pages 1418–1424. IJCAI/AAAI Press, 2016

    work page 2016

  9. [9]

    Muggleton

    Andrew Cropper and Stephen H. Muggleton. Metagol system. https://github.com/metagol/metagol, 2016

    work page 2016

  10. [10]

    Muggleton

    Andrew Cropper and Stephen H. Muggleton. Learning efficient logic programs. Machine Learning, Apr 2018

    work page 2018

  11. [11]

    Muggleton

    Andrew Cropper, Alireza Tamaddoni-Nezhad, and Stephen H. Muggleton. Meta-interpretive learn- ing of data transformation programs. In Katsumi Inoue, Hayato Ohwada, and Akihiro Yamamoto, editors, Inductive Logic Programming - 25th International Conference, ILP 2015, Kyoto, Japan, August 20-22, 2015, Revised Selected Papers, volume 9575 ofLecture Notes in Co...

    work page 2015

  12. [12]

    Derivation reduction of metarules in meta-interpretive learn- ing

    Andrew Cropper and Sophie Tourret. Derivation reduction of metarules in meta-interpretive learn- ing. In Fabrizio Riguzzi, Elena Bellodi, and Riccardo Zese, editors, Inductive Logic Programming - 28th International Conference, ILP 2018, Ferrara, Italy, September 2-4, 2018, Proceedings , volume 11105 of Lecture Notes in Computer Science, pages 1–21. Springer, 2018

    work page 2018

  13. [13]

    A model building framework for answer set programming with external computations

    Thomas Eiter, Michael Fink, Giovambattista Ianni, Thomas Krennwallner, Christoph Redl, and Peter Schüller. A model building framework for answer set programming with external computations. TPLP, 16(4):418–464, 2016

    work page 2016

  14. [14]

    The discovery of the equator or con- cept driven learning

    Werner Emde, Christopher Habel, and Claus-Rainer Rollinger. The discovery of the equator or con- cept driven learning. In Alan Bundy , editor,Proceedings of the 8th International Joint Conference on Artificial Intelligence. Karlsruhe, FRG, August 1983, pages 455–458. William Kaufmann, 1983

    work page 1983

  15. [15]

    Towards inductive generalization in higher order logic

    Cao Feng and Stephen Muggleton. Towards inductive generalization in higher order logic. In Derek H. Sleeman and Peter Edwards, editors, Proceedings of the Ninth International Workshop on Machine Learning (ML 1992), Aberdeen, Scotland, UK, July 1-3, 1992, pages 154–162. Morgan Kauf- mann, 1992

    work page 1992

  16. [16]

    Feser, Swarat Chaudhuri, and Isil Dillig

    John K. Feser, Swarat Chaudhuri, and Isil Dillig. Synthesizing data structure transformations from input-output examples. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Lan- guage Design and Implementation, Portland, OR, USA, June 15-17, 2015, pages 229–239, 2015

    work page 2015

  17. [17]

    Inductive synthesis of recursive logic programs: Achievements and prospects

    Pierre Flener and Serap Yilmaz. Inductive synthesis of recursive logic programs: Achievements and prospects. J. Log. Program., 41(2-3):141–195, 1999

    work page 1999

  18. [18]

    Example-directed syn- thesis: a type-theoretic interpretation

    Jonathan Frankle, Peter-Michael Osera, David Walker, and Steve Zdancewic. Example-directed syn- thesis: a type-theoretic interpretation. In Rastislav Bodík and Rupak Majumdar, editors,Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20 - 22, 2016, pages 802–815....

    work page 2016

  19. [19]

    Classical negation in logic programs and disjunctive databases

    Michael Gelfond and Vladimir Lifschitz. Classical negation in logic programs and disjunctive databases. New Generation Comput., 9(3/4):365–386, 1991

    work page 1991

  20. [20]

    Automating string processing in spreadsheets using input-output examples

    Sumit Gulwani. Automating string processing in spreadsheets using input-output examples. In Proceedings of the 38th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2011, Austin, TX, USA, January 26-28, 2011, pages 317–330, 2011

    work page 2011

  21. [21]

    The heuristic search and the game of chess

    Larry Harris. The heuristic search and the game of chess. a study of quiescence, sacrifices, and plan oriented play . InComputer Chess Compendium, pages 136–142. Springer, 1988. Learning higher-order logic programs 35

    work page 1988

  22. [22]

    Completing causal networks by meta- level abduction

    Katsumi Inoue, Andrei Doncescu, and Hidetomo Nabeshima. Completing causal networks by meta- level abduction. Machine Learning, 91(2):239–277, 2013

    work page 2013

  23. [23]

    Exploiting answer set programming with exter- nal sources for meta-interpretive learning

    Tobias Kaminski, Thomas Eiter, and Katsumi Inoue. Exploiting answer set programming with exter- nal sources for meta-interpretive learning. TPLP, 18(3-4):571–588, 2018

    work page 2018

  24. [24]

    Efficient exhaustive generation of functional programs using monte-carlo search with iterative deepening

    Susumu Katayama. Efficient exhaustive generation of functional programs using monte-carlo search with iterative deepening. In PRICAI 2008: Trends in Artificial Intelligence, 10th Pacific Rim Interna- tional Conference on Artificial Intelligence, Hanoi, Vietnam, December 15-19, 2008. Proceedings, pages 199–210, 2008

    work page 2008

  25. [25]

    Data-driven induction of functional programs

    Emanuel Kitzelmann. Data-driven induction of functional programs. In ECAI 2008 - 18th European Conference on Artificial Intelligence, Patras, Greece, July 21-25, 2008, Proceedings , pages 781–782, 2008

    work page 2008

  26. [26]

    J.W . Lloyd. Logic for Learning. Springer, Berlin, 2003

    work page 2003

  27. [27]

    Waldinger

    Zohar Manna and Richard J. Waldinger. A deductive approach to program synthesis. ACM Trans. Program. Lang. Syst., 2(1):90–121, 1980

    work page 1980

  28. [28]

    Making robots conscious of their mental states

    John McCarthy . Making robots conscious of their mental states. InMachine Intelligence 15, Intelligent Agents [St. Catherine’s College, Oxford, July 1995], pages 3–17, 1995

    work page 1995

  29. [29]

    Mitchell

    Tom M. Mitchell. Machine learning. McGraw Hill series in computer science. McGraw-Hill, 1997

    work page 1997

  30. [30]

    Luke Ong

    Rolf Morel, Andrew Cropper, and C.-H. Luke Ong. Typed meta-interpretive learning of logic pro- grams. In Francesco Calimeri, Nicola Leone, and Marco Manna, editors, Logics in Artificial Intel- ligence - 16th European Conference, JELIA 2019, Rende, Italy, May 7-11, 2019, Proceedings , volume 11468 of Lecture Notes in Computer Science, pages 198–213. Springer, 2019

    work page 2019

  31. [31]

    Inverse entailment and progol

    Stephen Muggleton. Inverse entailment and progol. New Generation Comput., 13(3&4):245–286, 1995

    work page 1995

  32. [32]

    Stephen Muggleton and Wray L. Buntine. Machine invention of first order predicates by inverting resolution. In Machine Learning, Proceedings of the Fifth International Conference on Machine Learn- ing, Ann Arbor, Michigan, USA, June 12-14, 1988, pages 339–352, 1988

    work page 1988

  33. [33]

    Flach, Katsumi Inoue, and Ashwin Srinivasan

    Stephen Muggleton, Luc De Raedt, David Poole, Ivan Bratko, Peter A. Flach, Katsumi Inoue, and Ashwin Srinivasan. ILP turns 20 - biography and future challenges. Machine Learning, 86(1):3–23, 2012

    work page 2012

  34. [34]

    Muggleton, Dianhuan Lin, Niels Pahlavi, and Alireza Tamaddoni-Nezhad

    Stephen H. Muggleton, Dianhuan Lin, Niels Pahlavi, and Alireza Tamaddoni-Nezhad. Meta- interpretive learning: application to grammatical inference. Machine Learning, 94(1):25–49, 2014

    work page 2014

  35. [35]

    Muggleton, Dianhuan Lin, and Alireza Tamaddoni-Nezhad

    Stephen H. Muggleton, Dianhuan Lin, and Alireza Tamaddoni-Nezhad. Meta-interpretive learning of higher-order dyadic datalog: predicate invention revisited. Machine Learning, 100(1):49–73, 2015

    work page 2015

  36. [36]

    Type-and-example-directed program synthesis

    Peter-Michael Osera and Steve Zdancewic. Type-and-example-directed program synthesis. In David Grove and Steve Blackburn, editors, Proceedings of the 36th ACM SIGPLAN Conference on Program- ming Language Design and Implementation, Portland, OR, USA, June 15-17, 2015 , pages 619–630. ACM, 2015

    work page 2015

  37. [37]

    Ross Quinlan

    J. Ross Quinlan. Learning logical definitions from relations. Machine Learning, 5:239–266, 1990

    work page 1990

  38. [38]

    Interactive concept-learning and constructive induction by analogy .Machine Learning, 8:107–150, 1992

    Luc De Raedt and Maurice Bruynooghe. Interactive concept-learning and constructive induction by analogy .Machine Learning, 8:107–150, 1992

    work page 1992

  39. [39]

    Abstraction in artificial intelligence and complex systems

    Lorenza Saitta and Jean-Daniel Zucker. Abstraction in artificial intelligence and complex systems . Springer, 2013

    work page 2013

  40. [40]

    Schapire

    Robert E. Schapire. The strength of weak learnability . Machine Learning, 5:197–227, 1990

    work page 1990

  41. [41]

    Srinivasan

    A. Srinivasan. The ALEPH manual. Machine Learning at the Computing Laboratory, Oxford University, 2001

    work page 2001

  42. [42]

    The appropriateness of predicate invention as bias shift operation in ILP

    Irene Stahl. The appropriateness of predicate invention as bias shift operation in ILP. Machine Learning, 20(1-2):95–117, 1995

    work page 1995

  43. [43]

    SWI-Prolog.Theory and Practice of Logic Programming, 12(1-2):67–96, 2012

    Jan Wielemaker, Tom Schrijvers, Markus Triska, and Torbjörn Lager. SWI-Prolog.Theory and Practice of Logic Programming, 12(1-2):67–96, 2012

    work page 2012