Programs with Common Sense

The problem it addresses

"Programs with Common Sense" is signed by John McCarthy and dated 1959, and it sets out a design for a program rather than a report of results.^[2] In an introductory note McCarthy himself called it probably the first paper on logical AI.^[1] The same note records that the paper was given at the Teddington conference on the mechanization of thought processes in December 1958 and printed in the proceedings of that conference; in the printed proceedings it appears as *Programs with common sense*, in the General Principles section.^[1][4]

The advice taker

The centre of the paper is a proposed program called the advice taker, described as a program for solving problems by manipulating sentences in formal languages.^[3] A formal language, in the everyday sense used here, is a set of symbols together with strict rules for combining them into sentences, so that reasoning can be treated as turning some sentences into others. The basic program, as the paper describes it, draws immediate conclusions from a list of premises, and when an imperative sentence is deduced the program takes a corresponding action.^[3] Facts and instructions are therefore written in the same notation: a person states what is the case and what should be done, and the machine derives consequences and acts on the instructions it can derive.

How it differs from earlier programs

McCarthy contrasts the advice taker with the Logic Theory Machine of Newell, Simon and Shaw and with Gelernter's geometry program.^[3] In those systems the formal system was the subject matter, but the heuristics — the rules of thumb that steer the search for a solution — were embodied in the program itself. In the advice taker, by contrast, the procedures are to be described as far as possible in the language itself.^[3] The difference is architectural: rather than hard-wiring a strategy into code, the paper wants the strategy written down as sentences the program can read, and therefore also revise.

Common sense as a criterion

The paper states the criterion it is after: a program has common sense if it automatically deduces for itself a sufficiently wide class of immediate consequences of anything it is told and what it already knows.^[3] Common sense is defined here not by a list of facts but by the breadth of what a program can infer without being told each step. That makes the goal measurable in principle — one can ask how wide a class of consequences the program derives — and it also makes it very demanding, since trivial consequences multiply quickly.

Learning by being told

The paper argues that a program can only learn something if it is first capable of being told it, and that declarative sentences have logical consequences an instructor can exploit.^[3] Teaching is thus not a separate mechanism bolted onto the reasoning: an instructor states something, and whatever follows from it becomes available. This is why the choice of a declarative formal language matters so much — it lets a person add knowledge without rewriting the program.

Five features, and a focus on the second

The paper lists five features a system needs in order to evolve intelligence of human order, and says the work concentrates mainly on the second of them: interesting changes in behaviour must be expressible in a simple way.^[3]

A joint project

McCarthy notes that the design of the system was to be a joint project with Marvin Minsky, who was not to be held responsible for the views expressed.^[3]

Why it matters

The paper's weight lies less in what it built than in how it framed the problem. Instead of splitting intelligence into a collection of special-purpose tricks, it asks for a program that holds a stock of sentences written in a formal language, derives consequences from them and acts on what it derives; it treats being told something as the precondition for learning, and it defines common sense as the breadth of inference.^[3] McCarthy later described the paper as probably the first on logical AI.^[1] The advice taker itself is a specification, not a finished machine, and the questions it raises — what to write down, in what notation, and how far the consequences should be followed — are the questions a knowledge-based program has to answer.