Abstract
This paper introduces the "micro-actor," a streamlined implementation of Carl Hewitt’s Actor model specifically designed for knowledge representation in artificial intelligence. By treating every piece of information—whether a static fact or a complex procedure—as an independent, message-passing object, the authors propose a modular system that eliminates side effects and naturally supports parallel processing. The framework is evaluated through a logical proof-of-concept involving mathematical operations, demonstrating how complex queries can be decomposed into autonomous message exchanges.
Introduction
In the mid-1970s, AI researchers faced significant hurdles in building flexible "question-answering" systems. A core challenge was knowledge representation: the difficulty of storing both "facts" (assertions) and "theorems" (procedures) in a way that a computer could easily manipulate and extend. Traditional systems often maintained a rigid separation between data and procedures, leading to architectural brittleness. While Carl Hewitt’s "Actor" model offered a conceptual solution by treating all entities as autonomous actors, its implementation was computationally expensive and complex. This paper proposes the "micro-actor" structure to bridge this gap, retaining the power of the actor concept while ensuring efficient implementation in LISP.
The Micro-Actor Architecture
A micro-actor is defined as an independent object that functions simultaneously as a procedure and a data point. In this paradigm, the only permissible action is message sending. Every micro-actor consists of three internal components that govern its behavior and state.
- Control Part: This serves as the "engine" of the actor. Programmed in LISP and common to all actors, it matches incoming messages against the "script" to determine whether to reply or initiate further actions.
- Script: The script contains the "theorems" or procedural knowledge. It consists of pattern-action pairs; when an incoming message matches a pattern, the corresponding action is triggered.
- Acquaintance (Memory Space): This is the actor’s local memory, storing "facts" such as specific values, attributes, or relationships to other actors.
To manage complex, concurrent interactions, messages utilize a "Sentence Number" (e.g., "N L"). This tagging system allows an actor to track which specific request a reply belongs to, facilitating multiple simultaneous conversations without cross-talk.
Implementation and Logic Flow
The authors evaluate the micro-actor concept through a logical proof-of-concept centered on mathematical operations. Rather than using large-scale datasets, the system's logic is demonstrated using a set of specialized micro-actors: WARIKIRERU (divisible), WARU (divide), DEARU (be), AMARI (remainder), and SHOH (quotient).
The system's capability is showcased through a "divisibility" logic flow. When a user asks a question such as "Is X divisible by 2?", the system coordinates a sequence of autonomous message exchanges.
In this example:
- An actor representing the value of X (e.g., 4) is queried for its value.
- The WARIKIRERU actor defines the high-level logic of divisibility.
- The WARU actor performs the actual calculation.
- The AMARI actor stores and returns the remainder.
- The DEARU actor checks if the remainder is zero.
The system successfully decomposes the high-level query into discrete steps, arriving at the correct answer ("yes") through decentralized communication.
Key Insights
The micro-actor model offers several advantages for AI system design:
- Uniformity of Action: By removing the distinction between function calls, variable lookups, and data retrieval, the system achieves a radical simplification that enhances predictability.
- Absence of Side Effects: Since actors do not share a global state and communicate only via discrete messages, the system avoids "spooky action at a distance," making debugging and scaling more manageable.
- Inherent Parallelism: The ability of a micro-actor to converse with several others simultaneously makes the model a natural fit for parallel processing architectures.
- Modular Evolution: New knowledge can be integrated by simply adding new micro-actors. As long as the new actor adheres to existing message patterns, the system can evolve without requiring a total rewrite.
Limitations and Future Work
Despite its conceptual strengths, the authors identify several limitations. The implementation remains non-trivial, and the current system is heavily dependent on LISP and specific co-routine pseudo-implementations, which may hinder portability. Furthermore, while the arithmetic examples are successful, the scalability of this architecture for the massive, ambiguous knowledge bases required for natural language processing remains an open question. The authors suggest that the next logical step is implementing this model on dedicated parallel hardware to fully realize its performance potential.
Summary updated