Symbolic AI

Symbolic AI is the approach to artificial intelligence (AI) that represents knowledge as human-readable symbols, such as bird, penguin, or "Socrates is a man", and reasons over them with explicit rules, logic, and search. It dominated AI research from the 1956 Dartmouth workshop through the 1980s, and philosopher John Haugeland later named it "Good Old-Fashioned AI" (GOFAI) in 1985. Every conclusion a symbolic system reaches can be traced to rules a person wrote and can read, which makes it auditable, and every piece of its knowledge has to be written down by hand, which makes it hard to scale.

How Symbolic AI Works#

A symbolic system has two parts. The knowledge base stores facts ("Socrates is a man") and rules ("all men are mortal") in a formal language such as first-order logic, if-then production rules, or a knowledge graph. The inference engine applies the rules to derive facts nobody stored ("Socrates is mortal"). Forward chaining starts from the known facts and fires every rule whose conditions hold until nothing new appears. Backward chaining starts from a goal and works back to the facts that would prove it, the strategy built into the logic programming language Prolog.

The theory behind the approach is Allen Newell and Herbert Simon's physical symbol system hypothesis from 1976, which holds that manipulating symbols is both necessary and sufficient for general intelligence. A forward-chaining engine fits in a few lines of plain Python:

# Knowledge base: IF every premise is a known fact THEN add the conclusion
rules = [
    ({"has_feathers", "lays_eggs"}, "bird"),
    ({"bird", "cannot_fly", "swims"}, "penguin"),
]
facts = {"has_feathers", "lays_eggs", "cannot_fly", "swims"}

# Forward chaining: keep firing rules until no new fact appears
changed = True
while changed:
    changed = False
    for premises, conclusion in rules:
        if premises <= facts and conclusion not in facts:
            facts.add(conclusion)
            changed = True
            print(f"{conclusion} <- {sorted(premises)}")

The engine prints bird <- ['has_feathers', 'lays_eggs'] and then penguin <- ['bird', 'cannot_fly', 'swims']: the second rule fires only because the first one added bird, and each printed line is a complete explanation of why its conclusion holds, the kind of reasoning trace that explainable AI (XAI) methods try to reconstruct for neural networks.

Expert Systems#

Symbolic AI reached industry in the 1970s and 1980s as expert systems. Stanford's MYCIN identified the bacteria behind severe infections and recommended antibiotics from about 600 rules elicited from physicians, and Digital Equipment Corporation's XCON configured customer orders for VAX computers. Expert systems surround the basic engine with a knowledge engineer, who interviews domain experts and encodes what they know as rules, and an explanation facility, which replays the rules behind each answer.

The interview step became the bottleneck. Experts struggle to state their intuitions as rules, large rule bases break on cases nobody anticipated, and the systems cannot learn from data. Doug Lenat's Cyc project, started in 1984 to hand-encode common sense, has spent decades on that problem. When expert system budgets collapsed in the late 1980s, the field entered its second "AI winter".

Symbolic AI vs. Statistical AI#

Statistical AI learns patterns from examples, the approach behind modern machine learning (ML) and deep learning (DL). The two paradigms fail in opposite places:

• Symbolic AI: Exact, transparent, and usable with no training data at all, which suits arithmetic, planning, regulations, and formal proofs. It cannot handle raw perception, since nobody can write rules that recognize a cat from pixel values, and it breaks on inputs its rules did not anticipate.
• Statistical AI: Learns perception and language directly from data and tolerates noise, but it needs large datasets, its decisions are hard to inspect, and language models can produce fluent, wrong answers known as hallucinations.

Where Symbolic AI Is Used Today#

• Rules engines and compliance: Tax software and business rules engines encode regulations as explicit rules, so every result traces back to the clause that produced it.
• Planning and scheduling: Automated planners search over symbolic descriptions of actions, preconditions, and effects to schedule logistics, factory work, and spacecraft operations.
• Formal verification: SAT and SMT solvers such as Microsoft's Z3 prove properties of chips and software, and proof assistants such as Lean check mathematical proofs step by step.
• Knowledge graphs: Search engines and Wikidata store billions of facts as entities and relations that queries can traverse.

Neuro-Symbolic AI#

Neuro-symbolic AI combines the two paradigms: neural networks handle perception and pattern recognition, and symbolic components handle rules, constraints, and exact reasoning. Language models that call a calculator, a SQL database, or a code interpreter through function calling use the same division of labor. In vision pipelines, a detector such as Ultralytics YOLO26 turns pixels into symbols, the class names of the objects it finds, and plain rules reason over them:

from ultralytics import YOLO

# Neural perception: detect objects and keep their class names as symbolic facts
model = YOLO("yolo26n.pt")
results = model("https://ultralytics.com/images/bus.jpg")
result = results[0]
facts = {result.names[int(c)] for c in result.boxes.cls}

# Symbolic reasoning: IF a bus AND a person are present THEN raise an alert
if {"bus", "person"} <= facts:
    print("Rule fired: pedestrians next to a bus")

Changing the rule changes the system's behavior immediately, with no retraining. Google DeepMind's AlphaGeometry applies the same split to mathematics: a neural language model proposes auxiliary constructions, a symbolic deduction engine proves the result from them, and together they solved 25 of 30 International Mathematical Olympiad geometry problems in a 2024 Nature paper.