Executable Archaeology: Reanimating the Logic Theorist from its IPL-V Source

1. Problem Statement

The Logic Theorist (LT), developed by Allen Newell, J.C. Shaw, and Herbert Simon in 1955–1956, is widely recognized as the first artificial intelligence program. Despite its historical significance, the original code has been unexecutable for over half a century.

• The Obstacle: LT was written in Information Processing Language-V (IPL-V), a list-processing language created specifically for cognitive modeling. IPL-V is extinct; no maintained implementations exist in modern environments.
• The Gap: While the conceptual model of LT is well-documented, the specific behavior of the original code cannot be fully understood from descriptions alone. Previous attempts to run early AI often relied on emulating vintage hardware (e.g., IBM 7094), but the specific IPL-V code used in this study (from a 1963 RAND report) was not tied to a single hardware platform, making hardware emulation insufficient.
• The Challenge: Reconstructing the system requires not just running code, but faithfully recreating the abstract machine semantics of IPL-V, a language with unique features (symbolic cells, list-based stacks, J-functions) that differs significantly from its descendant, Lisp.

2. Methodology: "Executable Archaeology"

The author employs a methodology termed executable archaeology, which involves the faithful reconstruction and execution of historical code to study its behavior empirically.

• Source Material Transcription:
  • The primary source was Stefferud's 1963 RAND technical report (RM-3731), which contains a pedagogical re-coding of the original LT logic into standardized IPL-V.
  • The code was transcribed from the report into a Google spreadsheet by the author and Anthony Hay.
  • Error Correction: Rupert Lane's "gridlock" tool was used to extract tabular code from PDFs. Despite multiple human reviews, transcription errors persisted. The code was converted into S-expressions (.liplv files) compatible with a Lisp-based interpreter.
• Interpreter Construction:
  • A new IPL-V interpreter was written in Common Lisp.
  • Architecture: The interpreter emulates the IPL-V abstract machine, not specific hardware. It implements:
    • Cell Structure: A table of cells where every element (data, routines, control) is addressable by a symbol.
    • Control Cells (H0–H5): H0 (communication), H1 (program counter/call stack), H2 (free list for memory), H3 (cycle counter), and H4/H5.
    • Working Cells (W0–W9): Scratch storage.
    • Data Structures: Lists are stored as linked chains of cells. The push-down (stack) mechanism is itself implemented as linked lists ("lists all the way down").
    • Execution: A core function ipl-eval fetches instructions from the program counter (H1). J-functions (the built-in operations, e.g., J0–J150) are implemented as Lisp functions.
• Debugging Strategy (Human + AI Collaboration):
  • Phase 1 (Solo): The author handled initial transcription, interpreter construction, and crash debugging (stack overflows, missing J-functions).
  • Phase 2 (AI Collaboration): Once the system ran without crashing but produced incorrect logical results (non-fatal anomalies), the author utilized Large Language Models (LLMs) Google Gemini and Anthropic's Claude.
  • The "Bootstrapping" Problem: Since IPL-V is a dead language with no modern corpus, the LLMs had to learn the language semantics from the author's buggy Lisp interpreter.
  • The Breakthrough: The LLMs excelled at reading thousands of lines of execution traces to identify subtle state errors. Crucially, the author used "Simon's J's" (original 1962 punched cards from the Computer History Museum) as a ground truth. The LLM compared the author's Lisp implementation of the J74 (list copying) function against the 1962 source code, identifying a discrepancy that the manual's prose description had obscured. A one-line patch fixed the interpreter.

3. Key Contributions

1. A Working IPL-V Interpreter: The first modern, open-source implementation of the IPL-V abstract machine in Common Lisp, capable of executing original 1960s code.
2. Faithful Reanimation of the Logic Theorist: The successful execution of the Logic Theorist from Stefferud's 1963 source code. This is likely the first time this specific code has run in over 50 years.
3. Executable Archaeology Framework: A demonstration of how to study early AI systems by reconstructing their original execution environments rather than rewriting algorithms in modern languages.
4. Human-AI Debugging Synergy: A novel case study where LLMs were used not just for code generation, but to debug a dead language by cross-referencing modern implementations with historical primary sources (punched cards).

4. Results

• Theorem Proving: The reanimated LT attempted to prove 23 theorems from Chapter 2 of Principia Mathematica.
  • Success Rate: It successfully proved 16 of the 23 theorems.
  • Historical Consistency: These results match the historical record of the original system's behavior under similar search limits (20,000 IPL machine cycles).
  • Performance: The full run took approximately 574,000 IPL machine cycles and generated over 576,000 symbols. On a modern laptop, this completes in seconds, whereas it would have taken hours on the 1950s JOHNNIAC.
• Proof Traces: The system successfully generated proof traces, including a proof for Theorem 2.01 using substitution and sublevel replacement, and more complex proofs (e.g., 4.25) are available in the repository.

5. Significance

• Historical Insight: This work provides an empirical window into the origins of AI and cognitive psychology. It confirms that the original heuristic logic (means-ends analysis, subgoal decomposition) functioned exactly as described, validating the historical narrative of the "thinking machine."
• Linguistic Lineage: The project highlights the direct lineage between IPL-V and Lisp. The author notes that Newell, Shaw, and Simon had invented almost all conceptual elements of Lisp (list processing, recursion, higher-order functions, self-modification) by the late 1950s. The primary difference was syntax (IPL-V's assembly-like style vs. Lisp's homoiconic elegance) and automatic garbage collection.
• Methodological Shift: It challenges the standard approach of "re-implementing" historical algorithms in modern languages. By running the original code, researchers can study the specific constraints, bugs, and emergent behaviors of the original system, which are often lost in modern rewrites.
• Future Applications: The interpreter is general-purpose. The author plans to use it to resurrect other seminal AI programs, specifically the General Problem Solver (GPS) and EPAM (Elementary Perceiver and Memorizer), which are currently inaccessible due to the lack of an IPL-V runtime.

In conclusion, this paper represents a landmark in digital preservation, demonstrating that with the right combination of historical scholarship, modern engineering, and AI-assisted debugging, the "black box" of early computing history can be opened and executed again.