## Section: New Results

### Diagnostic and causal reasoning

Participants : Philippe Besnard, Marie-Odile Cordier, Yves Moinard.

This work stems on
[34] , [35] , [36] and is related to diagnosis where observed symptoms
have to be explained by faults. The previously
existing proposals are ad-hoc or,
as in [40] , [62] , they are too close to standard logic in order to make a
satisfactory diagnosis. Our proposal
starts from propositional logic
and introduces *causal formulas* , built on causal atoms such as
( *causes* ) intended to mean:
“ causes ”.
There are also *taxonomy atoms* such as ( IS_A )
(roughly is of kind ).
The user describes the system thanks to classical formulas, causal formulas,
and taxonomy atoms.
Then, a set of inference rules computes where
can be explained by some . These explanations are formalized
by *explanation atoms* of the kind (* explains
if_possible * ):
when all the _{i} 's are possible
together in the context of the given data, then *( explains
)* .
The simplest generating rule states
that if (* causes * ) then
(* explains * if_possible {} ).
One rule states that if
(* causes * ), thus
here “if_possible{} ” is equivalent to
“if_possible{, } ”.
Despite this rule, the connexions between
*causes* and are rather loose. These connexions are
a known difficulty in causal formalisms. Our solution
avoids too much connexions between these two operators, while keeping the
formalism simple and natural enough.
Our system [37] , [38]
deals with alternative effects without too much computational
effort.

This kind of formalism is well fitted for an implementation in logic programming, precisely in the Answer Set Programming (ASP) [31] version. Indeed, not only ASP is closed to classical logic, thus allowing an immediate translation of the rules into an ASP language, but also ASP is known to be good in finding paths in graphs. ASP is a fast evolving area and the systems (e.g. DLV [74] and claspD [56] ) are becoming more and more efficient and user friendly. This last aspect is important since, even if an ASP program is written in a language allowing to express directly rules of the kind of our formalism, writing an ASP program generally happens to be more bothering than expected due to some limitations of the systems: reduced kind of objects (till very recently: no lists or sets, reduced use of functions,...) and difficulty in writing real "sub programs" (generally, a specific part of program should be rewritten differently for each occurrence). These two limitations are not crucial from a theoretical point of view. They are due to the novelty of this branch of logic programming, and are now in the way of being overcome. In particular, DLV-Complex [41] allows lists and function symbols, plus and easy way to built "pre definite predicates" in another language when necessary. Also, DLV Templates [42] allows "templates" which make "routines" easy to write. These are crucial improvements that simplify the task of a user. Then, gaining efficiency can be done by modifying the original rules, while keeping them close to their logical expression, and again this task is easier when using some "routines". Then, ASP is really easy to use and, since the core formalisms '(such as DLV or claspD) are also evolving rapidly, we can deal with more complex situations. Due to the natural way ASP rules can now be written, a user can directly write a program adapted to his needs without the need to learn a dedicated tool. Part of these results should appear in the "Logic programming and ASP" chapter in a book called "Panorama actuel de l'intelligence artificielle, ses bases méthodologiques, ses développements" , supervided by Pierre Marquis, Odile Papini and Henri Prade.