5.6 Related Work
5.6.3 Speculative Multi-agent Reasoning Systems
Speculative reasoning is another example of abduction-based multi-agent reasoning systems. It
was first proposed by Satoh [SIIS00] to address two important issues arising during the query-
answer interactions between logic programming based agents (each of which has its knowledge as a logic program and computes answers for received queries with a top-down inference algorithm). First, answers may not be returned in timely fashion due to either the physical communication channel delays or the long computation process by the queried agent. Secondly, the queried agent may not return all the answers at once (e.g., an answer is returned as soon as it is found), and it may also need to revise its previous answer that has already been sent to the querying agent during the collaboration. In a speculative computation system, after a goal is sent out as an external query, the sender agent may use some default answers of the goal to continue its local inference, and hence prevent the agent from wasting idle CPU cycles while waiting for a returned answer. When a new or revised answer is returned, the query sender agent may reuse previous computation as much as possible by discarding only the part of the computation that was done using old and inconsistent answers for the query, and by revising the part of the computation that was done using old but consistent answers to use the returned answer. Abduction is used during local inference to support the answer revision process, e.g., answers
used for sent goals are treated as assumptions. The first such system [SIIS00] was developed
for master-slave structured systems (i.e., there is only one agent that can send queries) where an answer to a (ground) query is simply either yes or no. Since then it has been extended for
hierarchical MAS [SY02] (i.e., each agent can have only one parent and can send queries to its
children only), and for constraint processing [SCH03,HSM+10] where the answers can be a set
of constraints over the variables in the (non-ground) query, and finally for hierarchical MAS
to support negation and non-ground answers with constraints [MBG+10]. In all these system,
goals that can be sent out as queries are called askable goals and have the form A@S where A is an atom and S is an agent identifier. Their operational meaning is very similar to that of
the askable atoms in DAREC2. However, whereas in speculative computation when an askable
goal is selected, the agent identifier must be ground, in DAREC2 it can also be a variable
are query answering, whereas in DAREC (and DAREC2) they are state passing.
5.7
Conclusion
In this chapter we have presented the DAREC2 system for multi-agent abductive reasoning
with confidentiality. In DAREC2 , non-abducible predicates are divided into two sets: public
and local. Thus, agents can specify their confidential knowledge with private atoms (with public predicate) and their shared knowledge with askable atoms (with local predicate). The
DAREC2 distributed abductive algorithm is built on from that of DAREC. Optimisations and
small modifications are made to the local inference rules in order to handle askable (atom) goals and private (atom) goals correctly and efficiently. The new algorithm can guarantee confidential reasoning through the use of the secure safe goal selection strategy and the lazy agent interaction
strategy. A prototype of the system has been implemented in Prolog. In Chapter 6 we will
describe our experimental results of the system prototype, and in Chapter 7we will provide a
(a) Execution Flow Chart for the Idle State of WT
(b) Execution Flow Chart for the Interrupt Handling State of WT
(c) Execution Flow Chart for the Working State of WT
Experiments and Benchmarking
In order to test our DAREC2 system prototype and study its performance, collections of dis-
tributed logic programs (LPs) of various sizes and structures are needed. Each collection
represents the agents’ knowledge of a DAREC2 framework. However, it is always difficult to
find testing LPs required for specific experiments. Therefore, we have developed an experimen-
tal environment for DAREC2. This environment can randomly generate distributed abductive
LPs according to a list of parameters such as the number of agents, and the size and structure of their LPs. It also provides a facility that supports the auto-execution of the system for each experiment. Each auto-execution consists of generating input knowledge files, launching
DAREC2 agents, submitting queries and collecting answers. During the execution of DAREC2,
profiling information, such as execution time and communication cost, are collected to allow us to investigate the scalability of the system. It is worth pointing out that our environment is general enough for generating centralised LPs. Therefore, it can also be used to provide testing data sets for systems such as ACLP and ASystem.
The rest of this chapter is organised as follows. Section 6.1 describes how the distributed LP
generator works and how different types of LPs can be produced. Section 6.2 describes the
auto-testing structure of our environment and discusses some of the DAREC2 experimental
results. Section 6.3 concludes this chapter.
6.1
A Random Generator for Distributed Abductive Con-
straint Logic Programs (GenDACLP)
A general-purpose generator for distributed abductive constraint logic programs, called Gen- DACLP, has been developed in Java. Although arbitrary logic programs (LPs) can be randomly produced by the generator according to a set of tunable parameters, the LPs that are useful for
our experiments are those where the distributed computation (by the DAREC2 agents) always
terminates and never flounders.
In order to guarantee flounder-free for a DAREC2 computation, the union of the distributed LP
generated for each agent must satisfy the allowedness condition [DC89] – any variable appearing
in a rule must also appear either in the head or in a positive body literal. On the other hand, in order to guarantee termination for a distributed abductive task, both the query and the
union of all agents’ LPs need to satisfy the abductive non-recursive property [Ver99]. However,
since the LPs are generated independently from the queries, in practice it is not feasible to check this property for arbitrarily generated LPs with respect to all the possible queries. In
fact, as shown in [Ver99] the sole cause of non-terminating derivations is repeated reductions
of the same abducible constraint. For example, suppose p(X) ← a(f (X)) is a rule in a LP where a/1 is the only abducible predicate, and suppose that during the inference (by SLDFNA,
ASystem or DAREC2) for some query, an abducible constraint ∀X. ← a(X), ¬p(X) is collected.
Then if at some point later in its derivation an abducible a(X) is assumed, the checking of the abducible constraint will generate a new goal p(X), whose further reduction will cause a(f (X)) to be assumed and the same abducible constraint be checked again, i.e., the inference will not terminate and keep assuming new abducibles a(X), a(f (X)), a(f (f (X)), . . ..
An easy and practical way to prevent such situation from arising is to enforce that in the Her- brand Base of the LP the set of all abducible atoms is always finite. The current implementation of GenDACLP simply ensures that in the generated LPs:
• there is no function symbol.
Thus, every generated LP will satisfy the abductive non-recursive property and DAREC2 will
terminate given any (bounded) query [Ver99] (so will SLDNFA and ASystem). Another advan-
tage of generating LPs with such conditions is that the experiment environment can also be used for other theorem provers employing top-down or bottom up algorithms.