1  Classical AI

What is AI, really?

Artificial Intelligence is the strangest field in computer science to define, because the definition keeps moving. Every time we teach a computer to do something that previously required intelligence — playing chess at world-champion level, recognising a friend’s face in a crowd, translating French into English — the achievement quietly stops counting. Larry Tesler captured the pattern in a single sentence: intelligence is whatever machines haven’t done yet.1 The phenomenon has a name in the literature, the AI effect, and it makes any definition pinned to a specific task obsolete the moment that task succumbs to engineering.

Even so, two foundational definitions from the field’s first generation are worth holding in mind, because the rest of this book is, in one form or another, an argument between them.

The first comes from Marvin Minsky in 1968: artificial intelligence is the science of making machines do things that would require intelligence if done by men.2 This is a functional definition. It doesn’t say how — by logic, by learning, by some unimagined third way — but it fixes the target: replicate human-grade cognitive performance, whatever the machinery. It is also the definition the AI effect erodes most sharply; once the machine does the thing, the goalposts move and the thing no longer counts.

The second comes from Arthur Samuel, nine years earlier, in the paper that gave the field the term machine learning. Working on a checkers program that improved by playing itself, Samuel argued that the right way to make computers solve hard problems was to let them learn from experience rather than to spell out every move.3 This is a mechanistic definition pointing in a specific direction: not “build something that performs like a human” but “build something that figures things out without being told every step.” Samuel’s bet was, in retrospect, the bet that won. The neural networks, deep learning systems, and language models of the chapters ahead are all descendants of his framing.

The two definitions are not contradictory; they are complementary. Minsky names the target — human-grade competence. Samuel names a method — learning rather than authoring. Most of the history of AI is what happens when you commit to Minsky’s target with a tool other than Samuel’s method.

For the working practitioner, though, both definitions sit one level above where the actual work happens. In practice, AI is the branch of computer science that tackles problems for which we do not have a direct algorithmic solution. Two distinct classes of problem live under that umbrella, and the distinction structures everything that follows.

The first class is the intractable problems: combinatorial puzzles where an exact algorithm exists in principle, but the number of cases to check grows so fast that no machine, present or imaginable, can finish the job in useful time. Routing a delivery fleet through a hundred cities, scheduling thousands of flights, packing a container, playing chess at depth — same shape every time. The algorithm is known; it is just useless. AI’s job is to find good-enough answers fast.

The second class is the ill-structured problems, a term the field owes to Herbert Simon’s 1973 paper of the same name.4 These are problems where we lack not just an efficient algorithm but the structure of the problem itself: the inputs are perceptual rather than symbolic, the goal cannot be stated cleanly, common sense and context intrude. Recognising a face, understanding what a sentence means, deciding whether a chest X-ray looks worrying. The shape of “intelligence” most people mean in casual conversation lives almost entirely in this class.

This two-class division is the spine of the rest of the chapter — and, in a sense, of the whole book. Good Old-Fashioned AI (GOFAI), the rationalist programme that dominated the field for its first three decades, attacked both classes with a single methodology: explicit symbols, explicit rules, explicit search. It succeeded brilliantly on the intractable class and stalled almost completely on the ill-structured one. The empirical line that chapters 2 through 4 open — machine learning, deep learning, large language models — is the answer the field eventually found for the ill-structured class. The intractable class never went away; the heuristic methods of this chapter remain the working backbone of every routing system, every game-playing engine, every constraint solver in production today.

Neither paradigm was wrong; each turned out to be essential for a different class of problem. The modern systems that reason, plan, and act, which Part II will describe, only work because both halves are in good working order.

The pillars of good old-fashioned AI

The rest of this chapter opens the rationalist line of attack: two pillars, mapped one-to-one onto the two classes above.

Search and Optimization is GOFAI’s answer to the intractable class. When the algorithm exists but cannot finish, AI replaces exactness with strategy — heuristics, metaheuristics, adversarial search, constraint satisfaction. We walk through each in turn.

Knowledge Representation and Reasoning is GOFAI’s answer to the ill-structured class. When the problem lacks structure, AI tries to impose it: formalise the world as symbols, write down the rules that connect them, let inference do the rest. We see what this looked like at its best — and, by the end of the chapter, where it ran out of road.

A third section then introduces the classical agent shell that ties perception, deliberation, and action into a loop. That shell is fifty years old and remains the scaffold into which Part II will eventually drop large language models. A brief conclusion looks ahead to the next three chapters, where the empirical line begins.

Symbolic vs. statistical AI

Symbolic AI builds intelligence the way one builds a machine. The designer decides what the system needs to know, encodes that knowledge in explicit symbols and rules, and produces behaviour by manipulating the symbols according to logical operations. The dictionary, the law book, the deductive proof — these are the model objects. Allen Newell and Herbert Simon called the underlying bet the physical symbol system hypothesis: a system that can store and manipulate symbols according to rules has, they argued, the necessary and sufficient means for general intelligent action.5 If the bet is right, the path to intelligent machines runs through better symbol-manipulation. The Logic Theorist, the General Problem Solver, expert systems like MYCIN, the planning systems of the 1970s — all of them inhabit this tradition.

Statistical AI builds intelligence the way one trains an animal. The designer chooses an architecture with adjustable parameters, presents the system with enough examples of inputs and desired outputs, and lets an optimisation procedure find — across many iterations — a parameter setting that maps one to the other. The training corpus is the model object. Nothing is encoded explicitly; everything is absorbed from the data. The Perceptron was the first machine in this tradition, and every modern deep-learning system descends from the same lineage.

The mechanical difference is where knowledge lives. In a symbolic system, knowledge lives in a hand-authored rule base that a human can read line by line, debug, and amend. In a statistical system, knowledge lives in a pile of learned numbers — weights, probabilities, embeddings — that no human can read at all. Both kinds of knowledge are operational; only one is legible. That asymmetry is the source of nearly every modern argument about AI transparency, alignment, and accountability, and we will return to it repeatedly.

The tension between the two paradigms was real, and the field paid for it in two long winters of reduced funding — the symbolic camp’s collapse under common-sense knowledge in the late 1980s, and the connectionist branch’s earlier near-death after Perceptrons. The introduction tells that history in full. What matters here, structurally, is that neither paradigm was wrong in isolation. The symbolic camp built shells without competent cognition; the statistical camp built cognition without auditable shells. The synthesis we will arrive at by chapter 6 needs both halves in good working order, and the rest of Part I is what those halves look like up close.

Search and optimization

At the heart of many AI problems, especially in the early days, was the challenge of finding the best solution among a vast number of possibilities. This is what search and optimization are for.

When perfect is impossible

Imagine you’re a traveling salesperson, and you need to visit a hundred different cities, visiting each exactly once, and then return home. Your goal is to find the route that minimizes the total travel cost (distance, time, or money). This is a classic example of a hard problem in computer science, known as the Traveling Salesman Problem (TSP). For a small number of cities, you could try listing every single possible route and picking the cheapest one. This is called a brute force search.

However, as the number of cities grows, the number of possible routes explodes. For just 20 cities, there are over 2.4 quintillion (2.4 followed by 18 zeros!) unique routes. Even the fastest supercomputer couldn’t check them all before the universe ends. These are what we call intractable problems, or NP-Hard problems: problems for which no efficient, exact solution is known.

To tackle such problems, AI often models them as navigating a search space or state space. This conceptual space represents all possible configurations or situations relevant to the problem. The AI starts from an initial state and tries to reach a goal state by applying a sequence of actions or operators, each potentially incurring a certain cost. Since finding the absolute perfect solution is often impossible or impractical within this vast space, AI shifts its goal. Instead of perfection, it seeks approximate solutions. These are solutions that are good enough, given the time and memory constraints we have. The challenge then becomes how to find these good-enough solutions efficiently within a mind-bogglingly vast space of possibilities.

Heuristics and metaheuristics

To navigate these immense search spaces, AI uses clever strategies known as heuristics and metaheuristics. A heuristic is a problem-specific rule of thumb strategy that uses some known properties of a problem to improve search performance. It’s not guaranteed to find the absolute best solution, but it often finds a very good one much faster than a brute-force approach.

Consider your GPS navigation app. When you ask for directions, it doesn’t calculate every single possible route from your current location to your destination. Instead, it uses a heuristic, often based on an algorithm called A∗. If your destination is northeast of your position, the A∗ algorithm will prioritize roads going north or east, assuming they are more likely to get you there faster than roads going to the west or the south. Of course, this isn’t always perfect–there might be a faster detour to the west, or a highway that’s counter-intuitive. Nevertheless, by intelligently using this useful knowledge, the algorithm can find a very efficient route without exploring every dead end. It’s a smart shortcut that balances speed with a high probability of finding a good solution.

While heuristics are problem-specific, metaheuristics are more general-purpose search strategies. They leverage knowledge about the search paradigm itself and can be applied even when very little is known about the specific problem’s structure. They’re often used when nothing else works. A prime example of a metaheuristic approach is evolutionary algorithms. These computational strategies are inspired by certain aspects of the biological process of evolution.

Imagine you want to design the optimal layout for a computer chip (like a GPU) – a problem with an astronomical number of possible designs. An evolutionary algorithm would start with a population of random chip designs. Then, through cycles of breeding (combining elements from two good designs to create a new one) and selection (keeping only the best-performing designs), the algorithm iteratively evolves better and better designs. Just like biological evolution, it seems to magically discover quasi-optimal design elements just by sheer luck and relentless repetition, without needing explicit instructions for every design choice. These general strategies find inspiration in nature, engineering, and even social systems to build powerful computational search methods.

Specialized search beyond simple paths

Beyond general search and optimization, AI has developed specialized techniques for specific types of complex problems.

Constraint satisfaction

Sometimes, the goal isn’t to find the best path, but simply any solution that meets a specific set of requirements. These are constraint satisfaction problems. Here, the AI needs to find values for a set of variables such that all given conditions, or constraints, are simultaneously met.

Think about solving a Sudoku puzzle. You need to fill in numbers from 1 to 9 in each cell, but with strict rules: each row, column, and 3x3 box must contain all digits from 1 to 9 without repetition. The AI’s task is to find a set of numbers for all empty cells that satisfies all these constraints.

Another common example is creating a university class schedule. You have classes, rooms, professors, and students, and a multitude of constraints: Professor A can’t teach two classes at the same time; Room B can only hold 50 students; Class C requires a lab; no two classes can be in the same room at the same time. The AI’s job is to assign times and rooms to all classes such that every single constraint is satisfied. The structure of these problems, defined by the variables and their interdependencies, allows AI to use specialized search techniques to efficiently find a valid solution.

Knowledge representation and reasoning

Beyond just searching for solutions, a truly intelligent system needs to know things about the world. This brings us to the second pillar of GOFAI: Knowledge Representation. This field explores how AI can efficiently represent, store, and use domain knowledge in a way that computers can understand and process.

The fundamental goal of knowledge representation is to organize concepts and facts, as well as the relationships between them. This organization allows AI to reason about these facts and discover new relations. Ultimately, it’s about giving AI a structured way to understand and make sense of information, much like how humans build a mental model of the world around them. Without a clear way to represent what it knows, an AI would be unable to make logical inferences or apply its knowledge to new situations.

From raw observations to understanding

To truly grasp how AI knows things, it’s helpful to understand the progression from raw observations to actionable understanding. At the most basic level, we encounter Data, which consists of raw, unprocessed facts or observations. This could be a list of numbers, individual words, or pixels in an image. In isolation, data has no inherent meaning; for example, the number 30 by itself is just a number.

When we introduce context or metadata, data transforms into Information. For instance, if we know 30 is a temperature reading taken in Celsius at noon on July 1st in Havana, it becomes information. This contextualization helps us relate different observations and gives them initial meaning.

Finally, when information is enriched with semantics and rules, enabling inference, reasoning, and the discovery of new relations, it becomes Knowledge. For example, if the AI knows that temperatures above 30 degrees Celsius in July in Havana indicate a heatwave, it possesses knowledge. This knowledge allows it to draw inferences (it’s a heatwave!), discover new relations (heatwaves can lead to increased energy consumption), and even take actions (warn residents about high temperatures). It’s this ability to add meaning and logical connections that truly transforms information into actionable knowledge.

Ways to represent knowledge

Just as humans use different ways to store and recall information, from precise definitions to vague intuitions, AI employs various methods for knowledge representation, each with its own strengths and weaknesses.

One key distinction lies between explicit and implicit representations. Explicit knowledge is clearly defined and directly encoded, often in rules or symbols. It’s much like a precisely written dictionary or a rulebook where every term and every rule is spelled out. This approach is central to Symbolic AI. For instance, Ontologies are explicit representations that define concepts within a domain and their strict relationships. Think of a meticulously designed family tree formally defining parent, child, sibling, and ancestor, along with rules such as if A is a parent of B, and B is a parent of C, then A is a grandparent of C.

Conversely, implicit knowledge is learned from patterns in data, rather than being directly programmed. It’s more akin to human intuition or a gut feeling developed from vast experience, and is fundamental to Statistical AI. Embeddings, for example, are numerical representations where concepts like words, images, or even entire documents are transformed into points in a multi-dimensional space. Systems like Word2Vec learn these embeddings by analyzing how words are used together, so words with similar meanings or contexts (e.g., king and queen) end up being numerically close to each other in this space, even though no human explicitly programmed that relationship.

Another way to categorize knowledge representations is by their formality. Formal representations have strict, unambiguous syntax and semantics, making them ideal for precise logical inference and computation. Mathematical equations, programming code, or statements in formal logic are prime examples, leaving no room for misinterpretation. In contrast, informal representations are more flexible, often using natural human language. While easier for humans to create and understand, they can be ambiguous and require more sophisticated processing for AI to extract meaning, as seen in a written description, a casual conversation, or an essay.

Finally, we distinguish between structured and unstructured representations. Structured knowledge is organized in a predefined, rigid format, making it easy for computers to process and query. Think of data in a spreadsheet with clear rows and columns, or a database with defined fields.

Knowledge graphs, for instance, are structured representations that organize facts as a network of interconnected entities (nodes) and their relationships (edges). A knowledge graph might have a node for Paris, a node for France, and an edge labeled is-capital-of connecting them, allowing AI to easily query and infer facts.

Conversely, unstructured knowledge exists in free-form text, images, audio, or video, without a predefined schema. Extracting meaning from unstructured data is much harder and often requires advanced AI techniques.

Vector databases, for example, are often used to store and efficiently search implicit representations (embeddings) derived from unstructured data. You could take millions of research papers (unstructured text), convert each into an embedding (implicit representation), and store them in a vector database. Then, when a user asks a question, the database can find the most similar papers based on their embeddings, even though the papers themselves are unstructured.

Drawing inference from knowledge

Knowledge representation isn’t merely about storing information; its ultimate purpose is to enable AI to draw inferences and make decisions. This process of deriving new conclusions from existing knowledge is known as reasoning, and it can take both formal and informal forms.

Formal reasoning, deeply rooted in logic, is about deriving new conclusions from existing knowledge using strict, unambiguous rules. This is the hallmark of Symbolic AI. It’s a process of deduction, where if the initial premises are true and the rules are applied correctly, the conclusion is guaranteed to be true. For example, if a knowledge base contains the rules All birds can fly and A sparrow is a bird, a formal reasoner can deduce, with absolute certainty, A sparrow can fly. Such rule-based systems are precise and auditable, but they are limited by the completeness and accuracy of the explicitly programmed rules.

In contrast, informal reasoning is about drawing conclusions based on patterns, similarities, or analogies, often without strict logical guarantees. This type of reasoning is more akin to human intuition or common sense. It’s less about strict deduction and more about finding connections and probabilities. For example, if an AI has learned implicit representations (embeddings) of various animals, and it sees a new animal that is numerically close to many dogs, it might infer it’s a dog, even without explicit rules for every single feature.

This distinction shapes what AI can and cannot do. While formal reasoning provides certainty within defined boundaries, informal reasoning allows AI to operate in ambiguous, unstructured environments. The latter, particularly reasoning by analogy in embeddings and language models, will be explored in more detail in later chapters, showcasing how AI can make sense of the world even when explicit rules are unavailable.

What is the best representation for knowledge?

The choice of how to represent knowledge is a critical decision in AI design. Different representation types are chosen based on the specific problem, the type of data available, and the AI paradigm being used (Symbolic vs. Statistical). For instance, a Symbolic AI system designed for medical diagnosis might rely heavily on formal, explicit ontologies of diseases and symptoms. Conversely, a Statistical AI system for image recognition might primarily use implicit, unstructured representations of pixels that it learns from millions of example images.

This challenge highlights a theoretical result known as the Ugly Duckling Theorem. This theorem, in essence, states that without a specific purpose or bias, all objects are equally similar or dissimilar to one another. This implies that there is no single, universally best way to represent knowledge or measure similarity without a context or goal in mind. For example, an ugly duckling is only ugly relative to a flock of swans; it might be beautiful among other ducklings.

Therefore, the human responsibility in choosing the right representation is paramount. This choice directly impacts what an AI can know, how it can reason, and ultimately, the reliability and fairness of its inferences. Aligning the representation with the problem’s nature is a key part of building human-centered tools that truly understand and assist us.

The classical agent

The two pillars I have just walked through — search and knowledge representation — share an unstated assumption. Both treat intelligence as something a machine does once: pose the problem, run the algorithm, return the answer. Real intelligent systems are not like that. A self-driving car does not solve a planning problem at the start of the trip and then drive blind. A medical diagnostic system does not run inference once and ignore the next ten years of evidence. Intelligent behaviour, in any system worth building, is a loop.

The classical AI literature has a name for that loop and the entity that runs it. The name is agent. The canonical statement is in chapter 2 of Stuart Russell and Peter Norvig’s Artificial Intelligence: A Modern Approach — the textbook that has trained roughly every working AI researcher since 1995.6 I am going to walk through it slowly, because chapter 6 of this book returns to exactly this definition, and what looks like a tidy fifty-year-old abstraction is, in fact, the empty shell into which large language models slot.

An agent is an entity that perceives its environment through sensors, deliberates over what to do, acts on the environment through actuators, and observes the consequences. Sensors and actuators are whatever the situation requires: cameras and wheels for a robot, a network connection and a function-call schema for a software agent, eyes and hands for the agent you are. The deliberation step is the variable. Different cognitive architectures fill it differently. What stays constant is the loop — perceive, deliberate, act, observe, repeat.

Russell and Norvig divide agents into four classes by how much structure their deliberation has.

A simple reflex agent maps the current percept directly to an action through a fixed table of condition–action rules. If the thermostat reads above 22°C, turn off the heater. No memory, no model of the world, no reasoning about consequences. Reflex agents are fast and brittle: they work exactly as well as their rule table covers the situations they meet.

A model-based reflex agent maintains an internal model of how the world works and how its own actions change it. The thermostat that remembers the heater is currently on and accounts for the lag between turning it off and the temperature actually dropping is model-based. The agent reacts not just to what it senses, but to what it believes is true and not currently in the percept.

A goal-based agent carries an explicit representation of what it is trying to achieve and chooses actions by reasoning about which ones move it closer to the goal. The chess-playing program from earlier in this chapter — the one that searches a tree of moves toward the state checkmate — is goal-based. The goal is a flag in state space; the agent’s job is to find a path to it.

A utility-based agent generalises the previous case. Instead of a single binary goal, it has a utility function that scores every possible outcome on a continuous scale, and it chooses actions that maximise expected utility. A trip planner that trades off cost, time, and comfort to recommend an itinerary is utility-based. Most modern decision-making systems live here. The goal is not “arrive”; the goal is “arrive in the best way.”

Before you build any of these, you have to specify the problem. Russell and Norvig propose a four-part recipe — PEAS: the Performance measure by which you score the agent’s behaviour, the Environment the agent operates in, the Actuators it has available to act, and the Sensors it has available to perceive. PEAS is not an algorithm; it is a discipline. Before writing a line of code for a vacuum-cleaning robot, you write down: Performance — cleanliness of floor per unit time, with a power-consumption penalty; Environment — apartment with rugs, hardwood, furniture, an occasional cat; Actuators — drive motors, suction motor, brush; Sensors — bump detector, dirt sensor, optical odometry. Skip PEAS and you build a system that solves a problem nobody asked for. Most failed AI projects are PEAS failures.

The perceive–deliberate–act–observe shell predates large language models by more than half a century. In 1971 the SRI team built STRIPS, the first symbolic planner to formalise the deliberation step as search through a space of world-changing actions.7 In 1987 Michael Bratman gave the deliberation step a richer interior — beliefs, desires, intentions — that the BDI literature spent the 1990s engineering into working systems. None of those systems became transformative, because none of them had a brain capable enough to fill the deliberation slot in any but the narrowest worlds. The slot sat empty for fifty years.

In chapter 6, we will see what happens when you slot a modern reasoning language model into it. The agent shell is the same. The cognition inside is new.

The need for learning

Good Old-Fashioned AI (GOFAI), with its focus on search, optimization, and explicit knowledge representation, laid the essential groundwork for the field of Artificial Intelligence. Its strengths lie in domains where problems are well-defined, rules are clear, and knowledge can be precisely encoded. GOFAI systems offered precision and control, making them dependable for tasks like proving theorems or playing well-defined board games.

However, the ambitions of GOFAI soon ran into fundamental limitations when faced with the messy complexity of the real world. These systems proved to be brittle: a small change outside their programmed domain could break them entirely. They struggled immensely with common-sense knowledge, which is vast and often unstated. The sheer scale of real-world information made it an insurmountable challenge to explicitly program every piece of knowledge and every rule. GOFAI was excellent at solving problems for which it was explicitly programmed, but it couldn’t adapt, generalize, or handle unstructured data effectively. This revealed a gap in AI’s capabilities that no amount of hand-coded rules could close.

The limitations of GOFAI pointed to one conclusion: to build truly intelligent and adaptable systems, AI needed to move beyond simply executing pre-programmed rules. It revealed a need for systems that could learn from experience and data, without being explicitly programmed for every single scenario or piece of knowledge.

This growing realization of the power of learning-based approaches, which were developing concurrently with GOFAI, redirected the field. It showed that AI could discover its own patterns and adapt to unforeseen situations, offering a path to overcome the brittleness of purely symbolic systems.

Recognizing these limitations and actively seeking new approaches is a hallmark of the ongoing, human-driven effort to build more capable and adaptable AI. This is the techno-pragmatist ethos at work: acknowledge what breaks, learn from the attempt that broke, and build the next tool with that knowledge in hand.

You now have the symbolic half of the argument: what it bet, what it built, and the perceive–deliberate–act–observe shell it left behind with the deliberation slot empty. The rest of Part I opens the empiricist substrate from the inside — how machines learn, why depth turned out to be the variable, and how one architecture specialised to language. The shell waits, empty, until something is finally competent enough to fill it.

  1. The quote is widely circulated as “AI is whatever hasn’t been done yet.” Tesler himself clarified on his personal site that his original phrasing was the slightly different intelligence is whatever machines haven’t done yet. See Larry Tesler, Tesler’s Theorem and Other Adages and Coinages, nomodes.com/larry-tesler-consulting/adages-and-coinages. The phenomenon is discussed in the literature as the AI effect; Pamela McCorduck’s Machines Who Think (2nd ed., A K Peters, 2004) traces several earlier instances of the same pattern.↩︎

  2. Marvin Minsky (ed.), Semantic Information Processing, MIT Press, 1968. The functional definition appears in Minsky’s introduction and has been quoted in essentially every general AI textbook since. The full quote: “Artificial intelligence is the science of making machines do things that would require intelligence if done by men.”↩︎

  3. Arthur L. Samuel, Some Studies in Machine Learning Using the Game of Checkers, IBM Journal of Research and Development, Vol. 3, No. 3, 1959, pp. 210–229. The widely circulated phrasing “the field of study that gives computers the ability to learn without being explicitly programmed” is apocryphal — it does not appear verbatim in the original paper, though it accurately summarises Samuel’s working programme. The 1959 paper itself argues that “programming computers to learn from experience should eventually eliminate the need for much of this detailed programming effort.”↩︎

  4. Herbert A. Simon, The Structure of Ill-Structured Problems, Artificial Intelligence, Vol. 4, No. 3–4, 1973, pp. 181–201. Simon distinguishes well-structured problems — where initial state, operators, and goal are crisply defined — from ill-structured ones, where one or more of those elements is missing or perceptual, and argues that the same information-processing framework can be brought to bear on both. The distinction has anchored half a century of research on cognition, design, and AI.↩︎

  5. Newell, A. & Simon, H. A. Computer Science as Empirical Inquiry: Symbols and Search. Communications of the ACM, 19(3), 1976. The physical-symbol-system hypothesis is stated on p. 116.↩︎

  6. Russell, S. & Norvig, P. Artificial Intelligence: A Modern Approach, §2, 4th ed. Pearson, 2020.↩︎

  7. Fikes, R. E. & Nilsson, N. J. STRIPS: A New Approach to the Application of Theorem Proving to Problem Solving. Artificial Intelligence, 2, 1971.↩︎