Symbolic AI techniques: every major method, 1956 to today

Symbolic AI techniques are the methods that let a program reason with explicit symbols rather than learned weights: logic and theorem proving, search, planning, knowledge representation, rule-based expert systems, constraint and SAT solving, non-monotonic reasoning, cognitive architectures and symbolic learning. Each one produces answers that can be traced step by step to stated facts and rules.

1. What counts as a symbolic AI technique

The pillar page defines symbolic AI as the approach that represents knowledge as explicit, human-readable symbols and reaches conclusions with logic, inference and search. A technique is one reusable method inside that approach: a representation, an inference procedure, a search strategy, or a way of learning symbolic structures from data. For this page we use a working test.

The test includes some methods that learn from data, such as decision trees and inductive logic programming, because what they learn is itself a readable symbolic structure. It excludes methods whose result is a vector of weights, even when they are trained on symbolic data. It also includes a few results that are not procedures, such as the Cook–Levin theorem and the frame problem, because they set the limits every technique works within. Several techniques are older than the field: Boole’s logic (1847), Frege’s first-order logic (1879) and von Neumann’s minimax (1928) became AI techniques when programs began to use them. The history of symbolic AI tells the story in order; this page is organised by method, and the standard textbook treatment of most of these techniques is Russell and Norvig [1].

2. The master table: every major technique

The table is in chronological order. Each technique links to the section of its family page that explains how it works, with a worked example and its limits. The year is the first publication or first working system we could verify; where a technique has two important dates (the idea and the name, or the idea and the practical version), both are given. Still used today? is a short judgement: yes means in routine production or research use, historical means its ideas survive but the technique itself is rarely run, and plain text marks a niche or research-only status.

3. How the families descend from 1956

By 1960 three ideas were on the table. Logic as representation: McCarthy’s Advice Taker proposal (1958) held that a program should store what it knows as sentences of formal logic and act on what it can deduce. Heuristic search: the Logic Theorist (1956) proved theorems by searching backward from the goal with rules of thumb, and GPS generalised the idea as means–ends analysis. Models of human thought: Newell and Simon built GPS as a theory of how people solve problems, the line that led to production rules, semantic memory and, eventually, cognitive architectures. Every family in this page descends from one or more of them.

The descent is not a tidy tree. Planning combined logic with search. Constraint solving and SAT turned logical questions into search problems and then made the search fast. Symbolic learning took its hypothesis languages from logic and its strategies from search. Today’s working systems draw on several families at once: CompCert is a compiler proved correct in a proof assistant; a modern planner is a heuristic search over a logical model; and neuro-symbolic systems such as AlphaGeometry pair a neural network that proposes with a symbolic engine that deduces.

4. The ten families

Each family below has its own page with an explanation of every technique in it, worked examples, a timeline and references. The summaries here say what the family is for, name its landmark techniques, and say where it stands today.

4.1 Logic programming and theorem proving

The oldest family, and the one the others borrow from. Its raw material is propositional and first-order logic used as a working language rather than as philosophy. The decisive step was J. Alan Robinson’s resolution principle and unification algorithm (1965): one inference rule that is refutation-complete for first-order logic, and one matching operation that makes it mechanical [2]. Herbrand’s theorem (1930) had already shown that such a search can, in principle, find every proof.

Two lines grew from resolution. Logic programming restricted it to Horn clauses so that running a program is a proof search: Kowalski’s SLD resolution [3], Prolog (1972) [4], Datalog for databases and, after Gelfond and Lifschitz’s stable models (1988) [5], answer set programming for hard combinatorial problems. Theorem proving kept full logic: automatic provers such as Otter, Vampire and E search for proofs on their own, while interactive proof assistants in the LCF tradition, such as Isabelle, HOL, Rocq (formerly Coq) and Lean, let a person steer and have a small kernel check every step. Logic programming and theorem proving, in depth →

4.2 Formal verification and program synthesis

Verification asks whether a program or circuit does what its specification says for every input, not just the tested ones. Hoare logic (1969) proves properties of programs one statement at a time [6]. Model checking, introduced independently by Clarke and Emerson and by Queille and Sifakis in 1981–82, explores every state of a finite model against a temporal-logic formula and returns a counterexample when the property fails [7] [8]. Abstract interpretation (Cousot and Cousot, 1977) proves the absence of whole classes of errors by computing over sound approximations of a program’s values [9]. Term rewriting and Knuth–Bendix completion (1970) supply the equational reasoning underneath [10].

Synthesis runs the other way, from a specification to a program. Manna and Waldinger extracted programs from constructive proofs [11]; inductive synthesis, made mainstream by Sumit Gulwani’s FlashFill (2011), infers programs from examples [12]. The results that matter most today are verified systems: CompCert, a C compiler proved correct in Coq [13], and seL4, a microkernel proved correct in Isabelle/HOL [14]. Both lean on the provers and SMT solvers of neighbouring families. Formal verification and program synthesis, in depth →

4.3 Search algorithms

Almost every symbolic technique reduces, somewhere, to search through a space of states. Uninformed strategies, breadth-first, depth-first and uniform-cost search, guarantee coverage. Heuristic search adds an estimate of the remaining cost. A* (Hart, Nilsson and Raphael, 1968) always expands the node with the lowest estimated total cost [15]:

where g(n) is the cost so far and h(n) the estimate. If h never overestimates the true remaining cost h*, the first goal A* expands is optimal. IDA* (Korf, 1985) gives the same guarantee with memory linear in the depth [16]. Games add an adversary: minimax picks the move with the best worst case, and alpha–beta pruning, found independently by several researchers from 1956 and analysed by Knuth and Moore in 1975 [17], skips branches that cannot change the answer; it was the search inside Deep Blue in 1997. Monte Carlo tree search (Coulom; Kocsis and Szepesvári, 2006) replaced the hand-written evaluation with random playouts [18] [19], and AlphaGo (2016) made it a hybrid by guiding it with neural networks [20]. Search algorithms, in depth →

4.4 AI planning

Planning is search in which the states are logical descriptions of the world and the moves are actions with preconditions and effects. McCarthy’s situation calculus (1963, developed with Hayes in 1969) gave the logical account [21]. STRIPS (Fikes and Nilsson, 1971) gave the practical one: each action has a precondition list, an add list and a delete list, and everything not deleted is assumed to stay true, which sidesteps much of the frame problem [22].

Later planners changed how the search is organised. Partial-order planning commits to an order between steps only where it has to; HTN planning decomposes tasks using known recipes; Graphplan (Blum and Furst, 1995) and SATPlan (Kautz and Selman, 1992) compiled planning into a layered graph or a SAT formula [23] [24]. PDDL (1998) standardised the input language for the International Planning Competition [25], and heuristic-search planners such as Fast Downward (Helmert, 2006) [26] are the standard today. AI planning, in depth →

4.5 Constraint satisfaction, SAT and SMT

Many problems are best stated as constraints: a set of variables, a domain of possible values for each, and constraints that the chosen values must satisfy together.

Montanari (1974) formalised networks of constraints [27]; backtracking search, arc consistency (Mackworth’s AC-3, 1977) [28] and constraint propagation prune the space; constraint logic programming (Jaffar and Lassez, 1987) put constraint solving inside Prolog [29]. Propositional satisfiability (SAT) is the special case with true-or-false variables. Cook (1971) proved it NP-complete [30]; DPLL (1962) gave the basic algorithm [31]; conflict-driven clause learning (GRASP, 1996; Chaff, 2001) made it practical on very large industrial formulas [32] [33]. SMT solvers such as Z3 (2008) [34] and cvc5 add theories of arithmetic, arrays and bit-vectors. Together they are probably the most heavily used symbolic AI in industry: hardware and software verification, scheduling, test generation and package-dependency resolution. Constraint satisfaction, SAT and SMT, in depth →

4.6 Knowledge representation

Knowledge representation decides what a system can say before any reasoning happens. Semantic networks (Quillian, 1968) put concepts in a graph with is-a links [35]; frames (Minsky, 1974) added slots and defaults [36]; conceptual dependency and scripts (Schank; Schank and Abelson, 1977) represented the meaning of sentences and stereotyped events [37]; conceptual graphs (Sowa, 1976) gave networks a logical reading [38].

The trade-off between how much a language can express and how fast it can be reasoned with became a field of its own. KL-ONE [39] led to description logics, decidable fragments of first-order logic that became the basis of OWL, a W3C standard since 2004. RDF (1999) standardised facts as triples; Gruber’s 1993 definition of an ontology as an explicit specification of a conceptualisation became the standard one [40]; Cyc (1984) tried to hand-encode common sense. Knowledge graphs, from Google’s in 2012 to Wikidata, are today’s large-scale semantic networks, usually with lighter reasoning. Knowledge representation, in depth →

4.7 Non-monotonic reasoning

Classical logic is monotonic: adding premises never removes a conclusion.

Common sense is not. “Tweety is a bird” suggests that Tweety flies, until you learn that Tweety is a penguin. In 1980 Reiter’s default logic and McCarthy’s circumscription offered two formal answers [41] [42]; Moore’s autoepistemic logic (1985) reasoned about what an agent knows it does not know [43]; Clark’s negation as failure (1978) is the version that runs inside Prolog and Datalog [44].

Truth maintenance systems (Doyle, 1979; de Kleer’s ATMS, 1986) do the bookkeeping: they record why each belief is held so it can be withdrawn when its support goes [45] [46]. The frame problem (McCarthy and Hayes, 1969) and the event calculus (Kowalski and Sergot, 1986) deal with change over time [47]. Much of this research now runs as answer set programming. Non-monotonic reasoning, in depth →

4.8 Expert systems

Expert systems took production rules (IF conditions THEN action, from Post and later Newell and Simon) and filled them with a specialist’s knowledge. DENDRAL (from 1965) inferred molecular structures; MYCIN (early 1970s) identified the bacteria behind infections by backward chaining and weighed evidence with certainty factors [48]; PROSPECTOR (SRI, late 1970s) advised on mineral exploration and was reported in 1982 to have recognised a hidden deposit [49]; XCON, or R1 (1980), configured DEC computer orders [50]. Shells such as EMYCIN, OPS5 and CLIPS separated the inference engine from the knowledge.

The engineering breakthrough was Forgy’s Rete algorithm (1982), which caches partial matches so that each change to working memory re-matches only what it touches [51]. The limit was the knowledge-acquisition bottleneck that Feigenbaum identified in 1977 [52]: rules had to be drawn out of experts by hand and maintained indefinitely. Rete-derived engines such as Drools and CLIPS still run business rules, eligibility checks and compliance logic. Expert systems, in depth →

4.9 Cognitive architectures

A cognitive architecture is a fixed set of mechanisms meant to model a whole mind rather than one task. Hearsay-II, a speech-understanding system built at Carnegie Mellon in the 1970s, introduced the blackboard: independent knowledge sources post and revise hypotheses on a shared structure [53]. Soar (Laird, Newell and Rosenbloom, 1987) models all behaviour as search in problem spaces [54], and learns by chunking: when it resolves an impasse, it compiles the result into a new rule [55].

ACT-R (John R. Anderson; ACT-R in 1993, from the ACT theory of 1976) combines production rules with declarative memory chunks whose activation predicts human reaction times and errors [56]. These systems are used today mainly in cognitive science, human-factors modelling and simulation, not in commercial AI products. Cognitive architectures, in depth →

4.10 Symbolic machine learning

Symbolic machine learning learns models that are themselves symbolic: rules, trees, logic programs, formulas. Mitchell’s version spaces (1977) framed learning as search through a space of hypotheses [57]; Quinlan’s ID3 (1986) and C4.5 (1993) grew decision trees [58]; AQ (Michalski, 1969) and CN2 (Clark and Niblett, 1989) induced rules. Explanation-based learning (1986) generalised from a single example by explaining it with domain knowledge [59].

Inductive logic programming (Muggleton, 1991, with systems such as FOIL, Progol and Aleph) learns Prolog clauses from examples plus background knowledge [60]. Case-based reasoning reuses past cases through Aamodt and Plaza’s retrieve–reuse–revise–retain cycle [61]; structure-mapping (Gentner, 1983) models analogy [62]. Genetic programming (Koza, 1992) and symbolic regression search over programs and formulas [63] [64]. What these learners produce can be read and checked; the price is that they struggle with raw perception and noisy, high-dimensional data. Symbolic machine learning, in depth →

5. Which technique for which problem

A starting point, not a rulebook. Real systems combine several rows, and a problem that fits none of them cleanly, such as recognising objects in images, is usually a job for machine learning, with a symbolic technique checking the result.

6. Where the techniques break

The same four problems recur across every family, and they are the reason symbolic AI lost ground to machine learning for perception and language. They are covered in depth on the pillar page; here is where each one bites.

• Combinatorial explosion. Search, planning, SAT and theorem proving all face spaces that grow exponentially with problem size, and the Cook–Levin theorem says no general escape is known. The families answered with heuristics (A*), pruning (alpha–beta), propagation (arc consistency), learning from failure (CDCL) and decomposition (HTN). These make many real instances fast; they do not change the worst case.
• The knowledge-acquisition bottleneck. Expert systems, ontologies and Cyc depend on knowledge someone has to write down and keep correct. Symbolic learning (ID3, ILP) was the field’s own answer; modern systems increasingly compile knowledge from structured sources instead of interviewing experts.
• Brittleness. Rule systems and planners know exactly what they were told. A case one step outside the rules gets no answer or a wrong one. Non-monotonic reasoning makes rules defeasible, but it cannot supply rules nobody wrote.
• Symbol grounding. Every family assumes the symbols are already given: that someone has decided this pixel region is a block and that one a table. Connecting symbols to the world takes people, sensors or learned perception, which is why the most capable systems today are hybrids.

7. Symbolic techniques and fail-safe models

A fail-safe model is an AI model built so that when it fails, the failure drives it toward a controlled, safe state: it abstains when evidence is missing, and its learning can narrow what it does but never widen what it is authorised to do. Several techniques in the master table supply exactly the parts such a model needs.

• Checkers that can say “not entailed”. Resolution, Datalog evaluation and SAT or SMT solving either produce a proof or a satisfying assignment, or establish that none exists under the given rules. Datalog’s fixed point is complete, so absence from it is meaningful: the honest answer is “unknown”, not a guess.
• Contradiction detection. Description-logic reasoners and SAT solvers report when a set of statements is inconsistent and can point to a conflicting subset, which lets a system refuse to admit a fact that contradicts what it already holds.
• Recorded reasons. Truth maintenance systems keep, for each belief, the reasons it is held, so a belief can be withdrawn when those reasons fail, and a person can see why it was held in the first place.
• Learning that only narrows. In version-space learning every new example can only remove hypotheses; it never adds one outside the hypothesis language. That is the shape of bounded learning a fail-safe model requires, although Mitchell’s setting was concept learning, not safety.
• Constraints before choice. A constraint or planning model states what is admissible before the search chooses; a sound solver cannot return an answer that violates a hard constraint.

None of these makes a system fail-safe on its own. The property depends on authority: whether the symbolic layer decides what counts as true and what may be done, or merely advises a model that can ignore it. A model may propose; only the floor admits a fact. The techniques also bring their limits with them (§6). A symbolic floor is only as good as its sources and rules, so a fail-safe model built from these parts will say “unknown” more often than a model that guesses. That is the intended trade. Our papers The Orchestration Gap and Traversing Data in Symbolic Systems make the argument in more detail.

Peel, by Perslis Research, is built on this principle. To our knowledge it is the first fail-safe model; the exact claim and the closest earlier work are on What is a fail-safe model? There is no neural network in the loop that decides; knowledge is typed, sourced cards; and learning is readable counts. Peel is a research prototype, not a certified safety system. How Perslis uses symbolic methods is described on Symbolic AI at Perslis, and the related explainers on symbolic systems and symbolic flows cover the representation and pipeline side.

8. Questions

What are the main symbolic AI techniques?

They fall into ten families: logic programming and theorem proving, formal verification and program synthesis, search algorithms, AI planning, constraint satisfaction with SAT and SMT solving, knowledge representation, non-monotonic reasoning, expert systems, cognitive architectures, and symbolic machine learning. Well-known individual techniques include resolution, Prolog, A*, alpha-beta pruning, STRIPS, frames, the Rete algorithm, DPLL and CDCL, and inductive logic programming.

What was the first symbolic AI technique?

The first program built as artificial intelligence, the Logic Theorist of 1956 by Allen Newell, Cliff Shaw and Herbert Simon, proved theorems by heuristic search, and their General Problem Solver introduced means-ends analysis. Some of the tools are older than the field: propositional logic goes back to George Boole in 1847, first-order logic to Gottlob Frege in 1879, and the minimax principle to John von Neumann in 1928.

Which symbolic AI techniques are still used today?

Many, usually without the AI label. SAT and SMT solvers, model checking and abstract interpretation verify hardware and software; A* and its descendants plan paths; alpha-beta search and Monte Carlo tree search play games; PDDL planners schedule operations; Datalog and answer set programming solve database and combinatorial problems; Rete-based engines such as Drools run business rules; OWL ontologies and knowledge graphs organise data; and proof assistants such as Lean, Rocq and Isabelle check mathematics and verified software.

Is A* search symbolic AI?

Yes. A* searches a space of explicit, discrete states connected by named operators, and its guarantee is a proof: if the heuristic never overestimates the remaining cost, the first goal A* expands is on an optimal path. It was published in 1968 by Peter Hart, Nils Nilsson and Bertram Raphael and remains one of the most widely used symbolic AI techniques, in games, robotics and route planning.

What is the difference between SAT and SMT solvers?

A SAT solver decides whether a formula over true-or-false variables can be satisfied. An SMT solver, short for satisfiability modulo theories, does the same for formulas that also mention integers, real numbers, arrays, bit-vectors or other data types, by combining a SAT solver with a specialised decision procedure for each theory. Z3 and cvc5 are widely used SMT solvers.

What is the difference between forward chaining and backward chaining?

Forward chaining starts from the known facts and fires every rule whose conditions hold, adding conclusions until nothing new appears; production-rule engines work this way. Backward chaining starts from a question and works back to the facts that would prove it, turning each rule's conditions into sub-goals; Prolog and the MYCIN expert system work this way.

Are decision trees symbolic AI?

The model is symbolic: a decision tree is a readable set of if-then tests. The way it is built is statistical: algorithms such as ID3 and C4.5 choose each split by measuring information gain on data. That is why decision trees, rule induction and inductive logic programming are grouped together as symbolic machine learning.

How do symbolic AI techniques relate to neuro-symbolic AI?

Neuro-symbolic systems combine a neural network with one or more of these techniques. AlphaGo guided Monte Carlo tree search with neural networks, AlphaGeometry paired a language model with a symbolic deduction engine, and language models that call solvers, databases or proof checkers use SAT, SMT, Datalog or theorem proving as the exact half of the system.

9. References

1. S. Russell, P. Norvig. Artificial Intelligence: A Modern Approach, 4th ed. Pearson, 2020.
2. J. A. Robinson. A Machine-Oriented Logic Based on the Resolution Principle. Journal of the ACM 12(1):23–41, 1965. doi:10.1145/321250.321253
3. R. Kowalski. Predicate Logic as Programming Language. Proceedings of IFIP Congress 74, 569–574, 1974.
4. A. Colmerauer, P. Roussel. The Birth of Prolog. In History of Programming Languages II, ACM, 1996. doi:10.1145/234286.1057820
5. M. Gelfond, V. Lifschitz. The Stable Model Semantics for Logic Programming. Proceedings of the 5th International Conference and Symposium on Logic Programming, MIT Press, 1070–1080, 1988.
6. C. A. R. Hoare. An Axiomatic Basis for Computer Programming. Communications of the ACM 12(10):576–580, 1969.
7. E. M. Clarke, E. A. Emerson. Design and Synthesis of Synchronization Skeletons Using Branching Time Temporal Logic. Logics of Programs Workshop 1981, LNCS 131, Springer, 1982.
8. J.-P. Queille, J. Sifakis. Specification and Verification of Concurrent Systems in CESAR. International Symposium on Programming, LNCS 137, Springer, 1982.
9. P. Cousot, R. Cousot. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. POPL 1977, 238–252.
10. D. E. Knuth, P. B. Bendix. Simple Word Problems in Universal Algebras. In J. Leech (ed.), Computational Problems in Abstract Algebra, Pergamon, 263–297, 1970.
11. Z. Manna, R. Waldinger. A Deductive Approach to Program Synthesis. ACM Transactions on Programming Languages and Systems 2(1):90–121, 1980.
12. S. Gulwani. Automating String Processing in Spreadsheets Using Input-Output Examples. POPL 2011. doi:10.1145/1926385.1926423
13. X. Leroy. Formal Verification of a Realistic Compiler. Communications of the ACM 52(7):107–115, 2009.
14. G. Klein et al. seL4: Formal Verification of an OS Kernel. SOSP 2009; extended in ACM Transactions on Computer Systems 32(1), 2014. doi:10.1145/2560537
15. P. E. Hart, N. J. Nilsson, B. Raphael. A Formal Basis for the Heuristic Determination of Minimum Cost Paths. IEEE Transactions on Systems Science and Cybernetics 4(2):100–107, 1968.
16. R. E. Korf. Depth-First Iterative-Deepening: An Optimal Admissible Tree Search. Artificial Intelligence 27(1):97–109, 1985.
17. D. E. Knuth, R. W. Moore. An Analysis of Alpha-Beta Pruning. Artificial Intelligence 6(4):293–326, 1975.
18. R. Coulom. Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search. Computers and Games 2006, LNCS 4630, Springer, 2007.
19. L. Kocsis, C. Szepesvári. Bandit Based Monte-Carlo Planning. ECML 2006, LNCS 4212, Springer.
20. D. Silver et al. Mastering the Game of Go with Deep Neural Networks and Tree Search. Nature 529:484–489, 2016.
21. J. McCarthy, P. J. Hayes. Some Philosophical Problems from the Standpoint of Artificial Intelligence. In Machine Intelligence 4, Edinburgh University Press, 1969.
22. R. E. Fikes, N. J. Nilsson. STRIPS: A New Approach to the Application of Theorem Proving to Problem Solving. Artificial Intelligence 2(3–4):189–208, 1971.
23. A. L. Blum, M. L. Furst. Fast Planning Through Planning Graph Analysis. Artificial Intelligence 90(1–2):281–300, 1997 (IJCAI 1995).
24. H. Kautz, B. Selman. Planning as Satisfiability. ECAI 1992, 359–363.
25. D. McDermott et al. PDDL: The Planning Domain Definition Language. Technical report, Yale Center for Computational Vision and Control, 1998.
26. M. Helmert. The Fast Downward Planning System. Journal of Artificial Intelligence Research 26:191–246, 2006. doi:10.1613/jair.1705
27. U. Montanari. Networks of Constraints: Fundamental Properties and Applications to Picture Processing. Information Sciences 7:95–132, 1974. doi:10.1016/0020-0255(74)90008-5
28. A. K. Mackworth. Consistency in Networks of Relations. Artificial Intelligence 8(1):99–118, 1977.
29. J. Jaffar, J.-L. Lassez. Constraint Logic Programming. POPL 1987, 111–119.
30. S. A. Cook. The Complexity of Theorem-Proving Procedures. STOC 1971, 151–158.
31. M. Davis, G. Logemann, D. Loveland. A Machine Program for Theorem-Proving. Communications of the ACM 5(7):394–397, 1962. doi:10.1145/368273.368557
32. J. P. Marques-Silva, K. A. Sakallah. GRASP: A Search Algorithm for Propositional Satisfiability. IEEE Transactions on Computers 48(5):506–521, 1999 (ICCAD 1996).
33. M. W. Moskewicz, C. F. Madigan, Y. Zhao, L. Zhang, S. Malik. Chaff: Engineering an Efficient SAT Solver. DAC 2001. doi:10.1145/378239.379017
34. L. de Moura, N. Bjørner. Z3: An Efficient SMT Solver. TACAS 2008, LNCS 4963. doi:10.1007/978-3-540-78800-3_24
35. M. R. Quillian. Semantic Memory. In M. Minsky (ed.), Semantic Information Processing, MIT Press, 1968.
36. M. Minsky. A Framework for Representing Knowledge. MIT AI Laboratory Memo 306, 1974.
37. R. C. Schank, R. P. Abelson. Scripts, Plans, Goals and Understanding. Lawrence Erlbaum, 1977.
38. J. F. Sowa. Conceptual Graphs for a Data Base Interface. IBM Journal of Research and Development 20(4):336–357, 1976.
39. R. J. Brachman, J. G. Schmolze. An Overview of the KL-ONE Knowledge Representation System. Cognitive Science 9(2):171–216, 1985.
40. T. R. Gruber. A Translation Approach to Portable Ontology Specifications. Knowledge Acquisition 5(2):199–220, 1993.
41. R. Reiter. A Logic for Default Reasoning. Artificial Intelligence 13(1–2):81–132, 1980.
42. J. McCarthy. Circumscription: A Form of Non-Monotonic Reasoning. Artificial Intelligence 13(1–2):27–39, 1980.
43. R. C. Moore. Semantical Considerations on Nonmonotonic Logic. Artificial Intelligence 25(1):75–94, 1985.
44. K. L. Clark. Negation as Failure. In H. Gallaire, J. Minker (eds.), Logic and Data Bases, Plenum, 293–322, 1978.
45. J. Doyle. A Truth Maintenance System. Artificial Intelligence 12(3), 1979.
46. J. de Kleer. An Assumption-Based TMS. Artificial Intelligence 28(2):127–162, 1986.
47. R. Kowalski, M. Sergot. A Logic-Based Calculus of Events. New Generation Computing 4(1):67–95, 1986.
48. E. H. Shortliffe, B. G. Buchanan. A Model of Inexact Reasoning in Medicine. Mathematical Biosciences 23(3–4):351–379, 1975.
49. A. N. Campbell, V. F. Hollister, R. O. Duda, P. E. Hart. Recognition of a Hidden Mineral Deposit by an Artificial Intelligence Program. Science 217(4563):927–929, 1982. doi:10.1126/science.217.4563.927
50. J. McDermott. R1: A Rule-Based Configurer of Computer Systems. Artificial Intelligence 19(1):39–88, 1982.
51. C. L. Forgy. Rete: A Fast Algorithm for the Many Pattern/Many Object Pattern Match Problem. Artificial Intelligence 19(1):17–37, 1982.
52. E. A. Feigenbaum. The Art of Artificial Intelligence: Themes and Case Studies of Knowledge Engineering. IJCAI 1977.
53. L. D. Erman, F. Hayes-Roth, V. R. Lesser, D. R. Reddy. The Hearsay-II Speech-Understanding System: Integrating Knowledge to Resolve Uncertainty. ACM Computing Surveys 12(2):213–253, 1980. doi:10.1145/356810.356816
54. J. E. Laird, A. Newell, P. S. Rosenbloom. SOAR: An Architecture for General Intelligence. Artificial Intelligence 33(1):1–64, 1987. doi:10.1016/0004-3702(87)90050-6
55. J. E. Laird, P. S. Rosenbloom, A. Newell. Chunking in Soar: The Anatomy of a General Learning Mechanism. Machine Learning 1(1):11–46, 1986.
56. J. R. Anderson. Rules of the Mind. Lawrence Erlbaum, 1993.
57. T. M. Mitchell. Generalization as Search. Artificial Intelligence 18(2):203–226, 1982.
58. J. R. Quinlan. Induction of Decision Trees. Machine Learning 1(1):81–106, 1986.
59. T. M. Mitchell, R. M. Keller, S. T. Kedar-Cabelli. Explanation-Based Generalization: A Unifying View. Machine Learning 1(1):47–80, 1986.
60. S. Muggleton. Inductive Logic Programming. New Generation Computing 8(4):295–318, 1991.
61. A. Aamodt, E. Plaza. Case-Based Reasoning: Foundational Issues, Methodological Variations, and System Approaches. AI Communications 7(1):39–59, 1994.
62. D. Gentner. Structure-Mapping: A Theoretical Framework for Analogy. Cognitive Science 7(2):155–170, 1983.
63. J. R. Koza. Genetic Programming: On the Programming of Computers by Means of Natural Selection. MIT Press, 1992.
64. M. Schmidt, H. Lipson. Distilling Free-Form Natural Laws from Experimental Data. Science 324(5923):81–85, 2009.