Computational Logic and Agent Based Systems

Paolo Mancarella, Francesca ToniIl Milione 2008

Abstract

This paper presents a framework for integrating Computational Logic (CL) into multi-agent systems through the modular KGP (Knowledge, Goals, and Plan) agent model. By leveraging abductive logic, temporal reasoning, and argumentation, the authors bridge the gap between formal specifications and executable implementations. The resulting architecture is designed for dynamic, incomplete-information environments such as Service-Oriented Architectures and the Grid.

Introduction

Designing autonomous agents for open, dynamic environments presents a significant challenge: agents must handle incomplete information, adapt to rapid changes, and make complex decisions. Historically, a gap has existed between the formal mathematical specifications of agent behavior and their actual computational implementation. This research addresses this gap by utilizing Computational Logic (CL) to create "executable specifications." By grounding the agent's architecture in logic programming, formal descriptions of behavior are inherently paired with provably correct, executable proof procedures.

The KGP Agent Architecture

The core contribution of this work is the KGP (Knowledge, Goals, and Plan) model, a highly modular and hierarchical architecture for intelligent agents. Unlike traditional agents that often rely on rigid "sense-think-act" loops, the KGP model allows for dynamic control and reasoning.

The hierarchical architecture of the KGP agent model, illustrating the relationship between state, reasoning, capabilities, and cycle theories.

The architecture is composed of several distinct layers and components as shown in the diagram above:

  • Internal State: Central to the agent is its state, represented as a tuple containing the Knowledge Base (beliefs and past actions), a forest of trees for Goals and Plans, a Temporal Constraint Store, and time variable instantiations.
  • Reasoning and Physical Capabilities: The model includes specialized modules for Planning, Reactivity, Goal Decision, and Temporal Reasoning. Physical capabilities allow the agent to sense the environment and execute actions (actuating).
  • Transitions and Selection Operators: Transitions dictate how the internal state evolves, such as introducing new plans or revising goals. Selection operators help determine which transitions are most appropriate.
  • Cycle Theories: This novel control mechanism sits at the top of the hierarchy. It uses declarative preference policies to dynamically decide which transition to apply next based on the environment and internal state, allowing the agent to prioritize tasks like reactivity over long-term planning when necessary.

Implementation and Extensions

To realize this model computationally, the authors utilize extensions of logic programming. Specifically, the CIFF proof procedure (abductive logic programming with constraints) handles planning and temporal reasoning, while Gorgias (logic programming with priorities and argumentation) is used for goal decision-making.

The model has been implemented in the PROSOCS platform, a prototype built using Sicstus Prolog and JXTA. Furthermore, the architecture has been extended for the ARGUGRID project. In this context, KGP agents become "argumentative agents" capable of negotiating service compositions over the Grid using specialized communicative and social decision-making modules.

Key Insights

The integration of CL into agent design offers several advantages:

  1. Unified Framework: Theoretical models and executable code are tightly linked through logical proof procedures.
  2. Modularity: Encapsulating different reasoning types into distinct modules allows for the combination of various logic programming paradigms.
  3. Dynamic Control: Cycle theories enable agents to reason about their own control flow, adapting to immediate context.
  4. Argumentation for Social Interaction: Extending the model with argumentation allows agents to handle the complexities of negotiation and contract formation in distributed systems.

Conclusion

The KGP model provides a sound and operationalized framework for building intelligent agents. While the base model is robust, ongoing work focuses on fully realizing argumentative extensions for highly interactive, distributed environments. The successful mapping of the KGP framework to projects like ARGUGRID demonstrates the scalability and flexibility of modular, logic-based approaches in complex multi-agent service compositions.

Summary updated

BibTeX
@inproceedings{mancarella2008computational,
  author = {Paolo Mancarella and Francesca Toni},
  title = {{Computational Logic and Agent Based Systems}},
  booktitle = {Il Milione},
  year = {2008},
}
Figure