Logic-LM Framework for Epistemic Planning

• Logic-LM Framework is a computational system that integrates logic programming paradigms for multi-agent epistemic planning with precise updates to knowledge structures.
• It combines bottom-up ASP encoding with top-down Prolog implementation to efficiently compute and manage Kripke models in vast state spaces.
• The framework supports explicit operators for both world-altering and knowledge-revealing actions, enabling integrated planning in dynamic epistemic environments.

The Logic-LM Framework is a computational system that applies logic programming techniques to multi-agent reasoning in the logics of knowledge, with a particular focus on modeling, updating, and planning in domains where agents possess differing information about the world. Designed to compute pointed Kripke models and to support both world-altering and knowledge-affecting actions, the framework distinguishes itself by combining detailed logic programming encodings—especially in Prolog—with formal operators for knowledge transformation and explicit procedural constructs for planning in complex epistemic environments.

1. Logic Programming Approaches for Knowledge and Model Computation

The framework employs two principal logic programming paradigms for encoding and computing models of multi-agent epistemic logic:

• Answer Set Programming (ASP) Encoding:

The initial encoding leverages ASP to "ground" the initial state of a multi-agent theory, introducing facts for fluents and agents, and employing choice rules to guess both the membership of states in the Kripke structure and the truth values of fluents at those states. Accessibility relations (representing knowledge modalities) are similarly hypothesized. ASP rules further construct knowledge atoms (e.g., k(A,S,L) for "agent A knows literal L at state S") and enforce consistency via constraints. While elegant, this methodology is impacted by severe grounding bottlenecks for large state spaces, as the combinatorial explosion of possible states and relations rapidly exhausts computational resources.

• Prolog-based (Top-down) Implementation:

To address grounding inefficiencies, a Prolog encoding is introduced, representing Kripke models as structured terms (e.g., kripke(N,E) with nodes N and edges E), and pointed models as sit(kripke(N,E),Node). Modal evaluation is conducted through recursive predicates (e.g., hold/2 and iterated_hold/3) that explore only the necessary fragments of the Kripke structure, leveraging Prolog's top-down search to scale to domains with vastly more theoretical states.

2. Kripke Models and Operators on Knowledge Structures

Kripke models, formally given as $M=(S, \pi, \{R_i\}_{i \in \text{AGENTS}})$ with $S$ as a set of states, $\pi$ as the fluent interpretation, and $R_i$ as the accessibility/knowledge relation for agent $i$, are central to the representation of knowledge in the framework.

• Encoding:

In ASP, states and relations are enumerated as atoms. In Prolog, they are manipulated through term structures; operations to add, remove, or modify nodes and edges are defined as predicates (e.g., node_minus/3, edge_minus/3).

• Update and Combination Operators:
  • State Removal ($M \setminus U$): Omit a set $U$ of states and their incident edges.
  • Edge Removal ($M \setminus X$): Omit specific accessibility relations.
  • Union ($M_1 \uplus M_2$): Merge compatible models, uniting their states, interpretation, and relations (formally: $M[S]=M_1[S] \cup M_2[S]$, $M[\pi]=M_1[\pi] \cup M_2[\pi]$, $M[i]=M_1[i] \cup M_2[i]$).
  • Knowledge Union: A domain-specific operation for combining agent knowledge perspectives in multi-agent planning.

The operators are implemented explicitly as Prolog predicates, providing the machinery for model transformation and updates in response to agent actions.

3. Multi-Agent Planning Language and Execution Mechanism

The Logic-LM Framework incorporates a high-level action language (denoted “mA” in the paper), enabling explicit modeling of:

• Executability Conditions:

Actions are associated with modal preconditions (e.g., "action $a$ executable if $\delta$ holds"), expressed and checked via modal formula evaluation in the Kripke model.

• World-Altering Actions:

These actions utilize the function $\mathrm{res}(a,u)$, which minimally adjusts the interpretation at state $u$ to enforce effect literals, and are lifted to all relevant states in the Kripke structure. The operation supports minimal change updates, ensuring that only necessary fluents are altered.

• Knowledge-Revealing Actions (Announcements and Sensing):

Public announcements result in the removal of states or relations incompatible with the announced formula, while private/sensing actions update knowledge selectively (e.g., only for involved agents), potentially creating copies of Kripke structures to represent divergent knowledge.

• Transition Function ($\mathrm{succ}(a,(M,s))$):

Maps a pointed Kripke model and action to an updated model via the prescribed operators, capturing the effects of both physical and epistemic changes.

• Planning via Search:

Search predicates (e.g., depthplan/3, breadthplan/3) recursively apply the transition function over sequences of actions to discover plans that move the system from the initial state to a goal satisfying specific modal formulas. The Prolog implementation shares logic with traditional search algorithms but is augmented with Kripke structure manipulation.

4. Applications and Case Studies

Several canonical and challenging examples are used to demonstrate the capabilities and scalability of the framework:

Case Study	Key Features	Computational Features
Box with a Coin Example	Agents with different initial knowledge manipulate a locked box;	Models world and knowledge via
	actions include "peek," "distract," revealing/obstructing attention.	Kripke structure transformation
Sum and Product Puzzle	Agents possess sum and product, deduce numbers through reasoning;	Initial Kripke: 2352 states;
	demonstrates significant scaling advantage for Prolog encoding.	ASP infeasible; Prolog scaled
Muddy Children Problem	Reasoning about common knowledge and iterative announcements.	Encoding generalizes to puzzles

The framework's representation power, coupled with its symbolic manipulation efficiency (notably when deployed in Prolog), enables the solution of multi-agent, multi-step epistemic planning tasks that are otherwise intractable with bottom-up logic programming approaches.

5. Formal Language, Mathematical Definitions, and Semantic Conditions

The logical language of the framework encompasses:

• Syntax:

Built from fluents, Boolean connectives ($\vee, \wedge, \neg$), and modal operators $K_i$ for each agent. Modal formulas include constructs like $K_i \psi$, $\neg\psi$, $\psi \wedge \phi$.

• Semantics:

Satisfaction defined on Kripke structures as: 1. $(M,s) \models \varphi$ iff $\pi(s) \models \varphi$ (base case: fluents) 2. $(M,s) \models K_i \varphi$ iff $$\forall s' \ [(s,s') \in R_i \implies (M,s') \models \varphi]$$ 3. $(M,s) \models \neg \varphi$ iff $(M,s) \not\models \varphi$

• Special Model Classes:

The framework recognizes properties like reflexivity, symmetry, and transitivity, with formal definitions reflecting standard epistemic modal logic practice.

• Transformation and Transition Operators:

Formally codified, with precise update behavior for state and edge removal, unioning, and action-induced transitions, these operators are the critical link between abstract modal logic and executable model updates.

6. Comparative Evaluation and Methodological Significance

The Logic-LM Framework is assessed in relation to alternative computational methods for epistemic reasoning:

• ASP vs. Prolog:

The "bottom-up" ASP approach is hampered by grounding complexity in large models, making it impractical for tasks with large Kripke structures. In contrast, Prolog's "top-down" evaluation computes only the required fragments, offering substantial scalability.

• Relation to Dynamic Epistemic Logic (DEL):

While DEL and modal logic literature have long defined public/private announcement operations, the distinctive contribution here is their integration into a high-level action planning language and direct logic programming implementation, facilitating seamless combination of physical world updates and knowledge transformations.

• Integrated Planning Capability:

Unlike frameworks restricted to either knowledge representation or planning, Logic-LM provides a unified platform enabling combined world and epistemic action planning.

---

The Logic-LM Framework exemplifies the use of logic programming for sophisticated epistemic model generation and transformation, supporting fully realized multi-agent planning with dynamic knowledge and world updates. Its explicit operators and modal logic encoding, with scalable Prolog implementations, establish a practical and extensible foundation for reasoning about and planning in complex knowledge-driven environments.