Information Technology Reference
In-Depth Information
can be associated with more than one types). Now the intelligibility gap between a
module
t
andauser
u
with respect to a set of dependency types
W
is defined as:
)
=
t
|
t
>
W
t
\
Nr
∗
(
Gap
(
t
,
u
,
W
T
(
u
))
Note that since we want to perform all tasks in
W
, we must get all the depen-
dencies that are due to any of these tasks, which is actually the union of all the
dependencies for every task denoted in W. In our example we have:
Gap(
HelloWorld.java
,
u
, {_edit})
Ø
Gap(
HelloWorld.java
,
u
, {_compile})
=
=
{
javac
}
Gap(
HelloWorld.java
,
u
, {_edit, _compile})
=
{
javac
}
Disjunctive Dependencies
If the dependencies are interpreted disjunctively and a task cannot be carried out,
there can be more than one ways to compute the intelligibility gap. To this end
we must find the possible “explanations” (the possible modules) whose availability
would entail a consequence (the performability of the task). For example assume
that
James
, from Fig.
8.7
, wants to compile the file HelloWorld.java. Since he cannot
compile it, he would like to know what he should do. What we have to do in this
case is to find and deliver to him the possible facts that would allow him to perform
the task.
In order to find the possible explanations of a consequence we can use
abduc-
tion
[
119
-
121
].
Abductive reasoning
allows inferring an atom as an explanation of
a given consequence. There are several models and formalizations of abduction.
Below we describe how the intelligibility gap can be computed using logic-based
abduction.
Logic-based abduction can be described as follows: Given a logical theory
T
formalizing a particular application domain, a set
M
of predicates describing some
manifestations (observations or symptoms), and a set
H
of predicates containing
possible individual hypotheses, find an explanation for
M
, that is, a suitable set
S
⊆
H
such that
S
T
is consistent and logically entails
M
.
Consider for example that
James
(from Fig.
8.7
) wants to compile the file
HelloWorld.java
. He cannot compile it and therefore he wants to find the pos-
sible ways of compiling it. In this case the set
T
would contain all the tasks and
their dependencies, as well as the taxonomies of modules and tasks (the upper part
of Fig.
8.7
). The set
M
would contain the task that cannot be performed (i.e. the
fact
IsCompilable(HelloWorld.java)
). Finally the set
H
would contain
all existing modules that are possible explanations for the performability of the task
(i.e. all modules in the lower part of Fig.
8.7
). Then
JavaCompiler(
javac
)
will be an abductive explanation, denoting the adequacy of this module for the com-
pilability of the file. If there are more than one possible explanations (e.g. if there are
several java compilers), logic-based abduction would return all of them. However,
one can define criteria for picking one explanation as “the best explanation” rather
than returning all of them.
∪
