Conclusiones

This chapter describes our early work of developing a distributed abductive reasoning (DARE) system by proposing a new distributed abductive algorithm and the architecture of its multi- threaded distributed Qu-Prolog implementation. The DARE algorithm extends the Kakas- Mancarella abductive proof procedure by allowing the background knowledge and integrity constraints to be distributed over a group of agents of which a dynamically selected sub-group co-operate to produce a proof. The system is open in that it allows new agents to join or leave the group as they wish at any time. The abduced conditions for a collective proof can come from different agents but they are guaranteed to be consistent with the integrity constraints of all the agents who have contributed to the proof.

The DARE system has several potential applications such as the illustrated multi-agent schedul- ing and the previously mentioned multi-robot planning and collaborative interpretation of sen-

sor data. We have also developed a distributed abductive planner [MRBL09] as an extension

to DARE, based in the abductive Event Calculus planner in [Sha00], for supporting collabora-

tive planning in the context of multiple robots. Because of the openness feature of the DARE system the distributed abductive planner will allow plan repair and plan recovery to allow the computation of executable plans, even when agents leave the system. For example, suppose that a set of robots have collaboratively computed a plan (i.e., a sequence of actions as the assumed abducibles) for a specific goal (i.e., an abductive query) using DARE, and suppose one of the agents crashes or leaves before the plan can be executed, then the plan will no longer be valid. In this case, DARE can backtrack to the point where this agent first joined the collaborative planning, and re-plan (i.e., resume the distributed abductive inference) from there without the agent. Implementing such a distributed abductive planner with plan repair support is our future work.

However, DARE has a number of limitations, in particular the inflexibility of the algorithm execution and the lacking of arithmetic constraint support, preventing it from being applied in a larger problem domains. In our later work, we focused on addressing such limitations, and developed a new distributed abductive reasoning system that is much more generic and

Distributed Abductive REasoning with

Constraints (DAREC)

4.1

Introduction

The DARE system allows agents to dynamically form clusters and perform collaborative ab- duction over their distributed knowledge. The distributed proof procedure of DARE is based on the Kakas-Mancarella proof procedure (KM), and hence inherits the limitation of not be- ing able to make non-ground assumptions (i.e., assume non-ground abducibles). Note that in KM, negative non-abducible literals are treated as (non-base) abducibles. Consequently, DARE cannot accept non-ground negative queries. For example, consider a planning domain

with two agents α and β with Πα= {can f ly(P ilot, Day) ← f ree(P ilot), ¬storm(Day).} and

Πβ = {storm(wed).}, respectively, and with ICα = ICβ = ∅ where f ree is the only abducible

predicate. Given a query can f ly(X, Y ), no answer can be computed by α and β in DARE, because after reducing can f ly(X, Y ) to f ree(X), ¬storm(Y ), α cannot progress further as- suming f ree(X) or ¬storm(Y ), as they are not ground. One solution to this issue is to change

Πα to be Π0_α =                               

can f ly(P ilot, Day) ← pilot(P ilot), f ree(P ilot), day(Day), ¬storm(Day). pilot(p1). pilot(p2). day(mon). · · · day(sun).                               

This guarantees f ree(X) and ¬storm(Y ) to be eventually grounded and thus assumed by α. However, this solution may cause combinatorial explosion of agent interactions during the collaborative reasoning, e.g., there are 2 × 7 = 14 ways to ground f ree(X) and ¬storm(Day) in this example. In addition, if we are dealing with applications with unbound domains (e.g., the names of the pilots are unknown in the example), then we may not be able to guarantee the grounding of abducibles at all. Ideally, we would like to compute succinct answers of

the form f ree(X), Y 6= wed for the query can f ly(X, Y ) with respect to Πα and Πβ. To do

this, the abductive proof procedure needs to perform constructive negation instead of negation as failure for negative literals. Another limitation of DARE is the lack of support for finite domain and arithmetic constraints solving. Many applications of abduction, such as planning and scheduling, require reasoning with constraints over time and cost.

Furthermore, operationally the execution of the DARE distributed proof procedure is somewhat too rigid. For example, the collection of a new abducible is immediately followed by a global consistency derivation (GCD), which consists of multiple rounds of consistency checks by all the agents in the cluster. Little control can be imposed on the execution to reduce agent communications. Consider the following example of three agents α, β and γ, with

Πα =      p ← q, r. q ← a.      ICβ = {← a, c.} ICγ = {← a, d.}

and

ICα = Πβ = Πγ = ∅

where a is the only abducible. Suppose that α has to solve the goal p and the current cluster contains all three agents, and a left to right goal selection strategy is adopted. Then during α’s local abductive derivation (LAD), the abducible a can be selected before r, causing then a GCD among three agents. Although the GCD is successful, it is unnecessary if α had first chosen r in its LCD, i.e, r would fail and the LCD would backtrack without the need to check a with others. The focus of this chapter is to present a new distributed abductive reasoning system, called DAREC, that overcomes the limitations of DARE, thus supporting a wider class of distributed knowledge-based problem solving tasks. Specifically, DAREC differs from DARE in the follow- ing ways:

• DAREC allows the reasoning of inequalities over logical terms (e.g., f (a, X) 6= f (Y, b) gives either Y 6= a or X 6= b) and the reasoning of finite domain constraints (i.e., a type of Constraint Logic Programming constraints), by using an external inequality solver and finite domain constraint solvers.

• DAREC handles negative literal goals as integrity constraints instead of (non-base) ab- ducibles, and performs constructive negation. For example, a negative literal goal contain- ing universal or existential variables (e.g., ∀Day.¬storm(Day) or ∃Day.¬storm(Day)) can be treated as an integrity constraint (e.g., ∀Day. ← storm(Day) or ∃Day. ←

storm(Day)). Given a fact storm(wed), the computation of ∀Day. ← storm(Day)

returns no answer (i.e., fails), and that of ∃Day. ← storm(Day) succeeds and gives Day 6= wed.

• DAREC focuses collaborative abduction among a fixed set of agents, i.e., the cluster is always equal to the set of all the agents in the system.

In addition, DAREC has a completely new distributed proof procedure, which is based on

state rewriting/search process, where each state contains intermediate computational results such as the remaining goals, the assumed abducibles with their constraints (e.g., inequalities and CLP constraints), and the dynamically collected integrity constraints (e.g., derived from negative goals) that need to be satisfied by all agents. This process involves local computations by the agents and the interactions between agents through state passing:

1. after a query is sent to the system, an initial state containing only the query is created;

2. for any given state, an agent can apply a set of local abductive inference rules to rewrite it into a set of new states, using its local knowledge and integrity constraints;

3. if a state generated during the local computation by an agent contains a goal that the agent cannot reduce using its local knowledge, or contains an assumed abducible or a dynamically collected integrity constraint that has not been checked by all the agents, then the agent can pass the state to other agents for further processing;

4. if a state is generated without any remaining goal or unchecked abducible or unchecked collected integrity constraint, then an answer can be extracted from it.

The coordination between the local computations is controlled by the agent interaction strategy (e.g., when to pass a state) and the agent selection strategy (e.g., whom to pass a state to), which are application dependent and customisable in order to optimise the agent collaboration (e.g., reducing the number of interactions and communications).

The rest of this chapter is organised as follows. Section4.2 defines the DAREC framework for

knowledge representation. Section 4.3 describes the DAREC distributed proof procedure and

illustrates it with a simple running example. Section 4.4 proves the soundness and complete-

ness of the system. Section 4.5 discusses several potential extensions to the system. Finally,