Symbol Manipulation
Symbol manipulation is the processing of discrete, meaning-bearing tokens such as variables, words, logical formulas or algebraic expressions according to explicit rules, so that the result of a computation is itself a structured expression rather than a number. Differentiating x times sin(x) to get sin(x) plus x times cos(x) by applying the product rule and the derivative of sine is the standard illustration: the program never evaluates the function at any point, it rewrites a formula into another formula. This is the style of computing that symbolic artificial intelligence was built on, in contrast with numerical computing and with the sub-symbolic learning found in neural networks.
What makes symbol manipulation distinct is that its data are structures, typically trees or lists, and its operations are pattern matching and rewriting. Expressions are stored as nested structures, with a root operator and arguments below it. A rule has a pattern on the left and a replacement on the right, so a derivative rule matches the shape of a product and produces a sum; correctness comes from the rules being valid transformations. Because the structures can nest to any depth, programs must handle recursion naturally, and because the same symbols can stand for different things in different programs, the interpretation lies partly with the human or the larger system, which is the point at which questions about meaning and grounding arise.
The tools of the tradition were designed around this idea. The list processing of Newell, Shaw and Simon's IPL, and then John McCarthy's Lisp (1958, with the 1960 paper Recursive functions of symbolic expressions and their computation by machine), made code and data into the same kind of structure, so programs could build and transform other programs. Early demonstrations included James Slagle's SAINT (1961), which performed symbolic integration at the level of a first-year calculus student, and the Logic Theorist's proof search. Computer algebra systems followed: Macsyma, begun in 1968 at MIT's Project MAC by Carl Engelman, William Martin and Joel Moses among others, was written in Lisp and its descendant Maxima remains in use, alongside REDUCE, Maple, and Mathematica (1988). Expert systems of the 1970s and 1980s, such as DENDRAL and MYCIN, applied the same rule-and-structure approach to chemistry and medicine.
The strengths are exactness, transparency and composability, and the weaknesses are brittleness and the labor of knowledge entry. A symbolic result can be proved, inspected and reused, and a rule that is wrong can be found and fixed. But rules cover only what their authors anticipated, handling noisy perception such as recognizing a face or reading speech proved very hard to write by hand, and common-sense knowledge turned out to be vast. Such difficulties, together with the frame problem and the cost of acquiring knowledge from experts, drove the shift toward statistical and neural learning from the late 1980s, and the older approach acquired the nickname good old-fashioned AI, from John Haugeland's 1985 book.
A common misconception is that symbol manipulation is obsolete. In fact it is everywhere in ordinary software: compilers, SQL query optimizers, spreadsheets, type checkers, regular-expression engines and formal verification tools all rewrite structured symbols, as do theorem provers and the algebra systems engineers use daily. A second misconception is that symbols are inherently meaningful; a symbol system shuffles tokens by form, and the connection to the world is supplied by interpretation, which is Searle's and Harnad's point. A third is that the opposition to sub-symbolic methods is absolute, when many systems have layers of both.
The neuro-symbolic revival shows the older idea returning in a new role. Language models are strong at fuzzy recognition and generation but unreliable at exact calculation and multi-step deduction, so current systems let a neural component propose and a symbolic component check or execute: models call calculators, computer algebra and code interpreters, and DeepMind's AlphaGeometry (2024) paired a language model that suggests constructions with a symbolic deduction engine that verifies them. The division of labor, learned intuition plus exact rules, echoes the original ambition of the Logic Theorist with a different source of guidance.
Read symbol manipulation as computation on the form of expressions rather than on quantities: exact, inspectable and compositional, brittle where the world is messy, and still the backbone of programming languages, algebra systems, proof checkers and the symbolic half of neuro-symbolic AI.