algo(13/40)The Dawn of AI: Learning, Logic & Heuristics

The Genesis of the Three Core Pillars

In the span of four years (1959–1963), the field of Artificial Intelligence transformed from speculative philosophy into a rigorous engineering discipline. Three specific works defined this era, moving beyond simple calculation to establish the three pillars that still uphold modern AI: Learning from Experience, Formal Symbolic Logic, and Heuristic Search.

Below is an analysis of these foundational studies.

1. The Pillar of Learning: Arthur Samuel (1959)

Paper: Some Studies in Machine Learning Using the Game of Checkers

Paradigm: Reinforcement Learning & Search

Before Arthur Samuel, computers were viewed as “fast calculators” that could only perform tasks explicitly programmed by humans. Samuel shattered this misconception by proving that a computer could learn to play a game better than its creator.1

The Core Innovation: Scoring Polynomials

Samuel’s program did not “know” how to win; it knew how to evaluate a board state. He defined a scoring function (a polynomial) based on features of the board, such as piece advantage, king advantage, and mobility.2

The evaluation function $f(x)$ looked somewhat like this:

$$f(x) = \sum_{i=1}^{n} w_i v_i$$

Where:

• $v_i$ represents a feature (e.g., total number of kings).
• $w_i$ represents the weight (importance) of that feature.

Mechanisms of Learning

Samuel introduced two forms of learning that are precursors to modern Reinforcement Learning:3

1. Rote Learning: The program memorized every board position it encountered and the ultimate outcome.4 This saved search time.
2. Generalization: The program played thousands of games against itself (“Self-Play”).5 If the current weights 6$w$ led to a loss, the system adjusted them.7 If they led to a win, they were reinforced.

Legacy: Samuel introduced Minimax and Alpha-Beta Pruning (heuristically) to search game trees.8 He proved that computers could exhibit non-deterministic behavior based on experience, laying the groundwork for everything from AlphaGo to ChatGPT.9

2. The Pillar of Logic: John McCarthy (1960)

Paper: Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I

Paradigm: Symbolic AI & Functional Programming

While Samuel focused on numerical weights, John McCarthy focused on representation. He argued that for a machine to be intelligent, it must manipulate “symbols” (ideas, words, lists) rather than just numbers. To do this, he invented LISP (LISt Processor).

The Core Innovation: S-Expressions

McCarthy introduced the concept of Symbolic Expressions (S-expressions).10 He demonstrated that complex logical propositions could be represented as nested lists.

This paper introduced concepts that are now standard in Computer Science:

• Recursion: Using a function that calls itself to solve problems (essential for traversing trees).11
• Conditionals: The invention of the if-then-else logic structure within a programming language.
• Garbage Collection: Automatic memory management, allowing the machine to reclaim memory from unused data.

Code as Data (Homoiconicity)

McCarthy’s most profound insight was that the code used to write the program could be represented in the same data structure as the data itself. This allowed LISP programs to write and modify other LISP programs — a key requirement for an AI that could “improve itself.”

Legacy: This paper shifted AI from “number crunching” to Symbolic AI (GOFAI — Good Old-Fashioned AI). It provided the language in which AI would be written for the next 30 years.

3. The Pillar of Heuristics: James Slagle (1963)

Paper: A Heuristic Program that Solves Symbolic Integration Problems in Freshman Calculus

Paradigm: Search & Expert Systems

By 1963, we had learning (Samuel) and a language for logic (McCarthy). James Slagle combined these to tackle a domain considered to require high human intelligence: Symbolic Integration in Calculus.12

His program, SAINT (Symbolic Automatic INTegrator), was one of the first attempts to model human problem-solving steps.

The Core Innovation: Heuristic Search

Calculus integration is “hard” because there is no single algorithm that solves every integral; you must try different techniques (substitution, integration by parts, etc.) until one works. A “brute force” search of all techniques is computationally impossible.

Slagle implemented Heuristics (rules of thumb) to guide the search. SAINT worked in three stages:

1. Canonical simplification: Simplify the expression (e.g., $x + 0 \rightarrow x$).
2. Heuristic Application: Apply a “likely” technique (e.g., “If the structure looks like $u dv$, try Integration by Parts”).
3. Goal Tree Search: If a technique splits the problem into sub-problems, create a tree and solve the leaves recursively.

The Results

SAINT took an MIT freshman calculus exam and scored an ‘A’, solving all but two distinct problems. It proved that computers could manipulate abstract symbols to solve ill-defined problems.

Legacy: Slagle’s work is the great-grandfather of Computer Algebra Systems (like Mathematica or Wolfram Alpha) and Expert Systems. It demonstrated that “Intelligence” could be simulated by narrowing the search space using domain-specific rules.

Summary of the Genesis

PioneerYearSystem/ConceptContribution to AISamuel1959CheckersReinforcement Learning: Weights, self-play, and optimization.McCarthy1960LISPSymbolic Logic: Representing knowledge as recursive lists.Slagle1963SAINTHeuristic Search: Using “rules of thumb” to navigate complex problem spaces.

These three works essentially defined the boundaries of the field: Representation (how we state the problem), Search (how we look for the answer), and Learning (how we get better at searching).