Query-Answer Causality in Databases: Abductive Diagnosis and

View-Updates
Babak Salimi and Leopoldo Bertossi
School of Computer Science
Carleton University
Ottawa, Canada.
{bsalimi,bertossi}@scs.carleton.ca

Abstract tuple (of constants) t is an actual cause for an answer ā to

Causality has been recently introduced in a conjunctive query Q from a relational database instance
databases, to model, characterize and pos- D if there is a “contingent” subset of tuples Γ, accompany-
sibly compute causes for query results (an- ing t, such that, after removing Γ from D, removing t from
swers). Connections between query causality D  Γ causes ā to switch from being an answer to being
and consistency-based diagnosis and database re- a non-answer (i.e. not being an answer). Usually, actual
pairs (wrt. integrity constrain violations) have causes and contingent tuples are restricted to be among a
been established in the literature. In this work pre-specified set of endogenous tuples, which are admissi-
we establish connections between query causal- ble, possible candidates for causes, as opposed to exoge-
ity and abductive diagnosis and the view-update nous tuples.
problem. The unveiled relationships allow us to A cause t may have different associated contingency sets Γ.
obtain new complexity results for query causality Intuitively, the smaller they are the strongest is t as a cause
-the main focus of our work- and also for the two (it need less company to undermine the query answer). So,
other areas. some causes may be stronger than others. This idea is for-
mally captured through the notion of causal responsibility,
Causality is an important notion that appears at the foun- and introduced in (Meliou et al., 2010a). It reflects the rel-
dations of many scientific disciplines, in the practice of ative degree of actual causality. In applications involving
technology, and also in our everyday life. Causality is un- large data sets, it is crucial to rank potential causes accord-
avoidable to understand and manage uncertainty in data, ing to their responsibilities (Meliou et al., 2010b,a).
information, knowledge, and theories. In data management Furthermore, view-conditioned causality was proposed in
in particular, there is a need to represent, characterize and (Meliou et al., 2010b, 2011) as a restricted form of query
compute the causes that explain why certain query results causality, to determine causes for a set of unexpected query
are obtained or not, or why natural semantic conditions, results, but conditioned to the correctness of prior knowl-
such as integrity constraints, are not satisfied. Causality edge about some other set of results.
can also be used to explain the contents of a view, i.e. of
a predicate with virtual contents that is defined in terms of Actual causation, as used in (Meliou et al., 2010a,b, 2011),
other physical, materialized relations (tables). can be traced back to (Halpern & Pearl, 2001, 2005), which
provides a model-based account of causation on the ba-
In this work we concentrate on causality as defined for- sis of counterfactual dependence. 2 Causal responsibility
and applied to relational databases. Most of the work on was introduced in Chockler & Halpern (2004), to provide
causality has been developed in the context of knowledge a graded, quantitative notion of causality when multiple
representation, and little has been said about causality in causes may over-determine an outcome.
data management. Furthermore, in a world of big uncer-
tain data, the necessity to understand the data beyond sim- Model-based diagnosis (Struss, 2008, sec. 10.3), an area of
ple query answering, introducing explanations in different
forms, has become particularly relevant. causes cancer”, which refer some sort of related events, actual
causation specifies a particular instantiation of a causal relation-
The notion of causality-based explanation for a query re- ship, e.g., “Joe’s smoking is a cause for his cancer”.
2
sult was introduced in (Meliou et al., 2010a), on the basis As discussed in (Salimi & Bertossi, 2015), some objections
of the deeper concept of actual causation. 1 Intuitively, a to the Halpern-Pearl model of causality and the corresponding
changes (Halpern, 2014, 2015) do not affect results in the con-
1
In contrast with general causal claims, such as “smoking text of databases.
knowledge representation, addresses the problem of, given i.e. about updating a database through views. An impor-
the specification of a system in some logical formalism and tant aspect of the problem is that one want the base, source
a usually unexpected observation about the system, obtain- database, i.e. the base relations, to change in a minimally
ing explanations for the observation, in the form of a diag- way while still producing the view updates. Put in differ-
nosis for the unintended behavior. Since this and causal- ent terms, it is an update propagation problem, from views
ity are related to explanations, a first connection between to base relations. This classical and important problem in
causality and consistency-based diagnosis (Reiter, 1987), a databases.
form of model-based diagnosis, was established in (Salimi
The delete-propagation problem (Buneman et al., 2002;
& Bertossi, 2014, 2015): Causality and the responsibility
Kimelfeld, 2012; Kimelfeld et al., 2012) is a particular case
problem can be formulated as consistency-based diagnosis
of the view-update problem where only tuple deletions are
problems, which allowed to extend the results in (Meliou
allowed on/from the views. If the views are defined by
et al., 2010a). However, no precise connection has been es-
monotone queries, only database deletions can give an ac-
tablished so far between causality and abductive diagnosis
count of view deletions. So, in this case, a minimal set (in
(Console et al., 1991; Eiter & Gottlob, 1995), another form
some sense) of deletions from the base relations is expected
of model-based diagnosis.
to be performed. This is “minimal source-side-effect” case.
The definition of causality for query answers applies to It is also possible to consider minimizing the side-effect on
monotone queries (Meliou et al., 2010a,b). However, all the view, which also requires that other tuples in the (vir-
complexity and algorithmic results in (Meliou et al., 2010a; tual) view contents are not affected (deleted) (Buneman et
Salimi & Bertossi, 2015) have been restricted to first-order al., 2002).
(FO) monotone queries. Other important classes of mono-
In this work we provide a precise connection between dif-
tone queries, such as Datalog queries (Ceri et al., 1989;
ferent variants of the delete-propagation problem and query
Abiteboul et al., 1995), possibly with recursion, require fur-
causality. In particular, we show that the minimal source-
ther investigation.
side-effect problem is related to the most-responsible cause
In (Salimi & Bertossi, 2015) connections were established problem, which was formulated and investigated in (Salimi
between query causality, database repairs (Bertossi, 2011), & Bertossi, 2015); and also that the “minimal view side-
and consistency-based diagnosis. In particular, complexity effect problem” is related to view-conditioned causality we
results for several causality problems were obtained from already mentioned above.
the repair connection. In the line of this kind of research,
The established connections between abductive diagnoses,
in this work we unveil natural connections between ac-
query causality and delete-propagation problems allow us
tual causation and abductive diagnosis, and also the view-
to adopt (and possibly adapt) established results for some
update problem in databases (more on this latter connection
of them for application to the others. In this way we obtain
later in the section).
some new complexity results.
As opposed to consistency-based diagnoses, which is usu-
More precisely, our main results are as follows: 3
ally practiced with FO specifications, abductive diagnosis
is commonly performed under a logic programming (LP) 1. We establish precise connections between causality
approach (in the general sense of LP) to knowledge rep- for Datalog queries and abductive diagnosis. More
resentation (Denecker & Kakas, 2002; Eiter et al., 1997; precisely, we establish mutual characterizations of
Gottlob et al., 2010b). Since Datalog can be seen as a form each in terms of the other, and computational reduc-
of LP, we manage to extend and formulate the notion of tions, between actual causes for Datalog queries and
query-answer causality to Datalog queries via the abduc- abductive diagnosis from Datalog specifications.
tive diagnosis connection, in this way extending causality
to a new class of queries, e.g. recursive queries, and obtain- We profit from these connections to obtain new al-
ing complexity results on causality for them. gorithmic and complexity results for each of the two
problems separately.
Abductive reasoning/diagnosis has been applied to the view
update problem in databases (Kakas & Mancarella, 1990; (a) We characterize and obtain causes in terms of-
Console et al., 1995), which is about characterizing and and from abductive diagnoses.
computing updates of physical database relations that give (b) We show that deciding tuple causality for Data-
an account of (or have as result) the intended updates on log queries, possibly recursive, is NP-complete
views. The idea is that abductive diagnosis provides (ab- in data.
duces) the reasons for the desired view updates, and they (c) We identify a class of Datalog queries for which
are given as changes on base tables.
3
In this work we also explore fruitful connections of causal- The possible connections between the areas and problems in
this paper were suggested in (Bertossi & Salimi, 2014), but no
ity with this view-update problem (Abiteboul et al., 1995), precise results were formulated there.
2
 deciding causality is tractable in combined com- 1.1 CAUSALITY AND RESPONSIBILITY
plexity. In the rest of this work, unless otherwise stated, we will
assume that a database instance D is split in two disjoint
2. We establish and profit from precise connections be-
sets, D = Dn ∪ Dx , where D n and D x denote the sets of
tween delete-propagation and causality. More pre-
endogenous and exogenous tuples, respectively; and Q is a
cisely, we show that:
monotone query.
(a) Most-responsible causes and view-conditioned Definition 1.1. A tuple τ ∈ D n is a counterfactual cause
causes can obtained from solutions to different for an answer ā to Q in D if D |= Q(ā) and D  {τ } |=
variants of the delete-propagation problem and Q(ā). A tuple τ ∈ D n is an actual cause for ā if there
vice-versa. exists Γ ⊆ Dn , called a contingency set, such that τ is a
(b) Computing the size of the solution to a min- counterfactual cause for ā in D  Γ. 
imum source-side-effect problem is hard for Causes(D, Q(ā)) denotes the set of actual causes for ā.
F P NP (log(n)) . This set is non-empty on the assumption that Q(ā) is true in
(c) Deciding weather an answer has a view- D. When the query Q is boolean, Causes(D, Q) contains
conditioned cause is NP-complete. the causes for the answer yes in D.
(d) We can identify some new classes of queries for The definition of query-answer causality can be applied
which computing minimum source-side-effect without any conceptual changes to Datalog queries. In the
delete-propagation is tractable. case of a Datalog, the query Q(x̄) is a whole program Π
that accesses an underlying extensional database E that is
1 PRELIMINARIES AND CAUSALITY not part of the query. Program Π contains a rule that de-
fines a top answer-collecting predicate Ans(x̄). Now, ā is
DECISION PROBLEMS an answer to query Π on E when Π ∪ E |= Ans(ā). Here,
We consider relational database schemas of the form S = entailment (|=) means that the RHS belongs to the minimal
(U, P), where U is the possibly infinite database domain model of the LHS. A Datalog query is boolean if the top
and P is a finite set of database predicates 4 of fixed arities. answer-predicate is propositional, say ans. In the case of
A database instance D compatible with S can be seen as Datalog, we sometimes use the notation Causes(E, Π(ā))
a finite set of ground atomic formulas (in databases aka. or Causes(E, Π), depending on whether Π has a Ans(x̄)
atoms or tuples), of the form P (c 1 , ..., cn ), where P ∈ P or ans as answer predicate, resp.
has arity n, and the constants c 1 , . . . , cn ∈ U . Given a τ ∈ Causes(D, Q(ā)), we collect all subset-
minimal contingency sets associated with τ :
A conjunctive query (CQ) is a formula Q(x̄) of the first-
order (FO) language L(S) associated to S of the form Cont (D, Q(ā), τ ) := {Λ ⊆ Dn | D  Λ |= Q(ā),
∃ȳ(P1 (s̄1 ) ∧ · · · ∧ Pm (s̄m )), where the Pi (s̄i ) are atomic D  (Λ ∪ {τ }) |= Q(ā), and
formulas, i.e. Pi ∈ P, and the s̄i are sequences of terms, ∀Λ  Λ, D  (Λ ∪ {τ }) |= Q(ā)}.
i.e. variables or constants of U . The x̄ in Q(x̄) shows all
The responsibility of actual cause τ for answer ā, denoted
the free variables in the formula, i.e. those not appearing in 1
ρQ(ā)(τ ), is (|Γ|+1) , where |Γ| is the size of the smallest
ȳ. A sequence c̄ of constants is an answer to query Q(x̄) if
contingency set for τ . Responsibility can be extend to all
D |= Q[c̄], i.e. the query becomes true in D when the vari-
tuples in D n by setting their value to 0, and they are not
ables are replaced by the corresponding constants in c̄. We
actual causes for Q.
denote the set of all answers to an open conjunctive query
Q(x̄) with Q(D). Example 1.1. Consider a database D with relations
Author(Name,Journal) and Journal(JName,Topic,#Paper), and
A conjunctive query is boolean (a BCQ), if x̄ is empty, i.e.
contents as below:
the query is a sentence, in which case, it is true or false in
Author Name JName
D, denoted by D |= Q and D |= Q, respectively. When Q Joe TKDE
Journal JName
TKDE
Topic
XML
#Paper
30
is a BCQ, or contains no free variables, Q(D) = {yes} if John
Tom
TKDE
TKDE
TKDE CUBE 31
TODS XML 32
Q is true, and Q(D) = ∅, otherwise. John TODS

A query Q is monotone if for every two instances D 1 ⊆ Consider the conjunctive query:
D2 , Q(D1 ) ⊆ Q(D2 ), i.e. the set of answers grows mono- Q(Name, Topic) : ∃Journal JName #Paper(Author(Name,JName)
tonically with the instance. For example, CQs and unions ∧ Journal(JName,Topic,#Paper), (1)
of CQ (UCQs) are monotone queries. Datalog queries (Ceri
et al., 1989; Abiteboul et al., 1995), although not FO, are which has the following answers: Q(D) Name Topic
Joe XML
also monotone (cf. Section 1.1 for more details). Joe CUBE
Tom XML
4
As opposed to built-in predicates (e.g. =) that we assume do Tom CUBE
John XML
not appear, unless explicitly stated otherwise. John CUBE
3
Assume John, XML is an unexpected answer to Q, and present some problems and results that we use throughout
we want to compute its causes assuming that all tuples are this paper. The first is the causality problem, about decid-
endogenous. ing whether a tuple is an actual cause for a query answer.
It turns out that Author(John, TODS) is an actual cause, Definition 1.2. For a boolean monotone query Q, the
with contingency sets Γ 1 = {Author(John, TKDE)} causality decision problem (CDP) is (deciding about mem-
and Γ2 ={Journal(TKDE, XML, 32)}, because bership of):
Author(John, TODS) is a counterfactual cause for an- CDP(Q) := {(D, τ ) | τ ∈ Dn , and τ ∈
swer John, XML in both of D  Γ 1 and D  Γ2 . Causes(D, Q)}. 
Therefore, the responsibility of Author(John, TODS) is 12 .
This problem is tractable for UCQs (Salimi & Bertossi,
Likewise, Journal(TKDE, XML, 32), Author(John, TKDE),
2015). The next is the responsibility problem, about de-
Journal(TODS,XML, 32) are actual causes for John, XML
ciding responsibility (above a given bound) of a tuple for a
with responsibility 12 .
query result.
Now, under the assumption that the tuples in Journal Definition 1.3. For a boolean monotone query Q, the re-
are the endogenous tuples, the only actual causes sponsibility decision problem (RDP) is (deciding about
for answer John, XML are Author(John, TKDE) and membership of):
Author(John, TODS).  RDP(Q) = {(D, τ, v) | τ ∈ Dn , v ∈ {0} ∪
{ k1 | k ∈ N+ }, D |= Q and ρQ(τ ) > v}. 
A Datalog query Q(x̄) is a whole program Π consisting
of positive rules that accesses an underlying extensional This problem is NP-complete for UCQs (Salimi &
database E that is not part of the query. Program Π Bertossi, 2015), but tractable for linear CQs (Meliou et
contains a rule that defines a top answer-collecting predi- al., 2010a). Roughly speaking, a CQ is linear if its atoms
cate Ans(x̄), by means of a rule of the form Ans(x̄) ← can be ordered in a way that every variable appears in
P1 (s̄1 ), . . . , Pm (s̄m ). Now, ā is an answer to query Π on a continuous sequence of atoms that does not contain a
E when Π ∪ E |= Ans(ā). Here, entailment (|=) means self-join (i.e. a join involving the same predicate), e.g.
that the RHS belongs to the minimal model of the LHS. ∃xvyu(A(x) ∧ S1 (x, v) ∧ S2 (v, y) ∧ R(y, u) ∧ S3 (y, z))
So, the extension Ans(D) of Ans in the minimal model of is linear, but not ∃xyz(A(x) ∧ B(y) ∧ C(z) ∧ W (x, y, z)),
the program contains the answers to the query. for which RDP is NP-complete. The class of CQs for which
RDP is tractable can be extended to weakly linear. 5
A Datalog query is boolean if the top answer-predicate is
propositional, say ans, i.e. defined by a rule of the form The functional, non-decision version of RDP, about com-
ans ← P1 (s̄1 ), . . . , Pm (s̄m ). In this case, the query is true puting the responsibility, i.e. an optimization problem, is
if Π∪D |= ans, equivalently, if ans belongs to the minimal complete for FP NP (log(n)) for UCQs (Salimi & Bertossi,
model of Π ∪ E (Ceri et al., 1989; Abiteboul et al., 1995). 2015).
CQs can be expressed as Datalog queries, e.g. (1) becomes: Finally, we have the problem of deciding weather a tuple is
a most responsible cause:
Ans Q (Name, Topic) ←− Author(Name,JName), Definition 1.4. For a boolean monotone query Q, the most
Journal(JName,Topic,#Paper). responsible cause decision problem (MRDP) is:
MRCD(Q) = {(D, τ ) | τ ∈ Dn and
The definition of query-answer causality can be ap- 0 < ρQ (τ ) is a maximum for D}. 
plied without any conceptual changes to Datalog queries.
For UCQs this problem is complete for P NP (log(n)) (Salimi
In the case of Datalog, we sometimes use the nota-
& Bertossi, 2015).
tion Causes(E, Π(ā)) or Causes(E, Π), depending on
whether Π has a Ans(x̄) or ans as answer predicate, resp. 1.2 VIEW-CONDITIONED CAUSALITY
In (Meliou et al., 2010a), causality for non-query answers A form of conditional causality was informally introduced
is defined on basis of sets of potentially missing tuples that in (Meliou et al., 2010b), to characterize causes for a query
account for the missing answer. Computing actual causes answer that are conditioned by the other answers to the
and their responsibilities for non-answers becomes a rather query. The notion was made precise in (Meliou et al.,
simple variation of causes for answers. In this work we 2011), in a more general, non-relational setting that in par-
focus on causality for query answers. ticular includes the case of several queries. In them the no-
tion of view-conditioned causality was used, and we adapt
The complexity of the computational and decision prob-
lems that arise in query causality have been investigated in 5
Computing sizes of minimum contingency sets is reduced to
(Meliou et al., 2010a; Salimi & Bertossi, 2015). Here we the max-flow/min-cut problem in a network.
4
it in the following to the case of a single query, possibly Under the abductive approach to diagnosis (Console et al.,
with several answers. 1991; Eiter & Gottlob, 1995; Poole, 1992, 1994), it is com-
mon that the system specification rather explicitly describes
Consider an instance D = D n ∪ Dx , and a monotone
causality information, specially in action theories where the
query Q with Q(D) = {ā 1 , . . . ān }. Fix an answer, say
effects of actions are directly represented by Horn formu-
āk ∈ Q(D), while the other answers will be used as a con-
las. By restricting the explanation formulas to the pred-
dition on āk ’s causality. Intuitively, ā k is somehow unex-
icates describing primitive causes (action executions), an
pected, and we look for causes, by considering the other
explanation formula which entails an observation gives also
answers as “correct”. The latter assumption has, in tech-
a cause for the observation (Denecker & Kakas, 2002). In
nical terms, the effect of reducing the spectrum of contin-
this case, and is some sense, causality information is im-
gency sets, by keeping Q(D)’s extension fixed, as a view,
posed by the system specifier (Poole, 1992).
modulo the answer ā k at hand.
Definition 1.5. (a) A tuple τ ∈ D n is called a view- In database causality we do not have, at least not initially, a
conditioned counterfactual cause (VCC-cause) for an- system description, 6 but just a set of tuples. It is when we
swer āk to Q if D  {τ } |= Q(āk ) and D  {τ } |= pose a query that we create something like a description,
Q(āi ), for i ∈ {1, . . . , n}  {k}. and the causal relationships between tuples are captured by
the combination of atoms in the query. If the query is a
(b) A tuple τ ∈ D n is an view-conditioned actual cause Datalog query (in particular, a CQ), then we have a Horn
(VC-cause) for ā k if there exists a contingency set, Γ ⊆ specification too.
Dn , such τ is a VCC-cause for āk in D  Γ.
In this section we will establish connections between ab-
(c) vc-Causes(D, Q(āk )) denotes the set of all VC causes ductive diagnosis and database causality. 7 For that, we have
for āk .  to be more precise about the kind of abduction problems we
Intuitively, a tuple τ is a VC-cause for ā k if there is a con- will consider.
tingent state of the database that entails all the answers to
2.1 BACKGROUND ON DATALOG ABDUCTIVE
Q and τ is a counterfactual cause for ā k , but not for the
DIAGNOSIS
rest of the answers. Obviously, VC-causes for ā k are also
actual causes, but not necessarily the other way around: A Datalog abduction problem (Eiter et al., 1997) is of
vc-Causes(D, Q(ak )) ⊆ Causes(D, Q(ak )). the form AP = Π, E, Hyp, Obs , where: (a) Π is a
set of Datalog rules, (b) E is a set of ground atoms (the
Example 1.2. (ex. 1.1 cont.) Consider the same instance
extensional database), whose predicates do not appear in
D, query Q, and the answer John, XML , which does not
heads of rules in Π, (c) Hyp, the hypothesis, is a finite set
have any VC-cause. To see this, take for example, the tuple
of ground atoms, the abducible atoms in this case, 8 and
Author(John, TODS) that is an actual cause for John, XML ,
(d) Obs, the observation, is a finite conjunction of ground
with two contingency sets, Γ 1 and Γ2 . It is easy to verify
atoms. As it is common, we will start with the assumption
that none of these contingency sets satisfies the condition
that Π ∪ E ∪ Hyp |= Obs.
in Definition 1.5, e.g. the original answer John, CUBE is
not such anymore from D  Γ 1 . The same argument can The abduction problem is about computing a minimal Δ ⊆
be applied to all actual causes for John, XML .  Hyp (under certain minimality criterion), such that Π∪E ∪
Δ |= Obs. More specifically:
This example shows that it makes sense to study the com-
plexity of deciding whether a query answer has a VC-actual Definition 2.1. Consider a Datalog abduction problem
cause or not. AP = Π, E, Hyp, Obs
Definition 1.6. For a monotone query Q, the view- (a) An abductive diagnosis (or simply, a solution) for AP
conditioned cause problem is (deciding about membership is a subset-minimal Δ ⊆ Hyp, such that Π ∪ E ∪ Δ |=
of): Obs. This requires that no proper subset of Δ has this
VCP(Q) = {(D, ā) | ā ∈ Q(D) and
6
vc-Causes(D, Q(ā)) = ∅ }.  Having integrity constraints would go in that direction, but
we are not considering their presence in this work. However, see
2 CAUSALITY AND ABDUCTION (Salimi & Bertossi, 2015, sec. 5) for a consistency-based diagno-
sis connection.
In general logical terms, an abductive explanation of an ob- 7
In (Salimi & Bertossi, 2015) we established such a con-
servation is a formula that, together with the background nection between another form of model-based diagnosis (Struss,
logical theory, entails the observation. So, one could see an 2008), namely consistency-based diagnosis (Reiter, 1987). For re-
lationships and comparisons between consistency-based and ab-
abductive explanation as a cause for the observation. How-
ductive diagnosis see (Console et al., 1991).
ever, it has been argued that causes and abductive explana- 8
It is common to accept as hypothesis all the possible ground
tions are not necessarily the same (Psillos, 1996; Denecker instantiations of abducible predicates. We assume abducible
& Kakas, 2002). predicates do not appear in rule heads.
5
 property. Sol (AP) denotes the set of abductive diag- TODS

noses for problem AP. John

John, TODS, TKDE, XML, 30, 32
TKDE XML
(b) A hypothesis h ∈ Hyp is relevant for AP if h con- Joe 30
tained in at least one diagnosis of AP. Rel(AP) col-
lects all relevant hypothesis for AP.  32 Joe, TKDE Tom, TKDE TKDE, CUBE, 31
Tom CUBE

31
We are interested in deciding, for a fixed Datalog program, (a) (b)

if an hypothesis is relevant or not, with all the data as input. Figure 1: (a) H(D). (b) A tree decomposition of H(D).
More precisely, we consider the following decision prob-
with h ⊆ λ(n). (c) For every v ∈ V , the set of nodes
lem.
{n | v ∈ λ(n)} induces a connected subtree of T .
Definition 2.2. Given a Datalog program Π, the relevance
The width of a tree decomposition (T , λ) of H = V, H ,
decision problem (RLDP) for Π is (deciding about the
with T = N, E , is defined as max {|λ(n)|−1 : n ∈ N }.
membership of):
The tree-width t w (H) of H is the minimum width over all
RLDP(Π) = {(E , Hyp, Obs, h) | h ∈ Rel(AP), with
its tree decompositions.
AP = Π, E, Hyp, Obs and h ∈ Hyp}. 
Intuitively, the tree-width of a hypergraph H is a measure
As it is common, we will assume that |Obs|, i.e. the number of the “tree-likeness” of H. A set of vertices that form a
of atoms in the conjunction, is bounded above by a numer- cycle in H are put into a same bag, which becomes (the
ical parameter p. It is common that p = 1 (a single atomic bag of a) node in the corresponding tree-decomposition.
observation). If the tree-width of the hypergraph under consideration
is bounded by a fixed constant, then many otherwise in-
Definition 2.2 suggests that we are interested in the data tractable problems become tractable (Gottlob et al., 2010a).
complexity of the relevance problem for Datalog abduction.
That is, the Datalog program is fixed and hypotheses and It is possible to associate an hypergraph to any finite struc-
input structure may change and maybe regarded as data. ture D (think of a relational database): If its universe
In contrast, under combined complexity the program is also (the active domain in the case of a relational database) is
part of the input, and the complexity is measured also in V , define the hypergraph H(D) = (V, H), with H =
terms of the program size. { {a1 , . . . , an } | D contains a ground atom P (a 1 . . . an )
for some predicate symbol P }.
The following result is obtained by showing that the NP-
complete combined complexity of the relevance problem Example 2.1. Consider instance D in Example 1.1.
for Propositional Datalog Abduction (PDA) (established in The hypergraph H(D) associated to D is shown in
(Friedrich et al., 1990)), coincides with the data complexity Figure 1(a). Its vertices are the elements of adom(D) =
of the relevance problem for (non-propositional) Datalog {John, Jone, Tom, TODS , TKDE , XML, Cube, 30 , 31 ,
Abduction. For this, techniques developed in (Eiter et al., 32 }, the active domain of D. For example, since
1997) can be used. Journal (TKDE , XML, 30 ) ∈ D, {TKDE , XML, 30 } is
one of the hyperedges.
Proposition 2.1. For every Datalog program Π,
RLDP(Π) ∈ NP, and there are programs Π  for The dashed ovals show four sets of vertices, i.e. hyper-
which RLDP(Π ) is NP-hard.  edges, that together form a cycle. Their elements are put
into the same bag of the tree-decomposition. Figure 1(b)
It is clear from this result that the combined complexity shows a possible tree-decomposition of H(D). In it, the
of deciding relevance for Datalog abduction is also in- maximum |λ(n)| − 1 is 6 − 1, corresponding to the top box
tractable. However, a tractable case of combined complex- bag of the tree. So, t w (H(D)) ≤ 5. 
ity is identified in (Gottlob et al., 2010b), on the basis of The following is a fixed-parameter tractability result for
the notions of tree-decomposition and bounded tree-width, the relevance decision problem for Datalog abduction prob-
which we now briefly present. lems with a program Π that is guarded, which means that
Let H = V, H be a hypergraph. V is the set of vertices, in every rule body there is an atom that contains (guards)
and H the set of hyperedges, i.e. of subsets of V . A tree- all the variables appearing in that body.
decomposition T of H is a pair (T , λ), where T = N, E Theorem 2.2. (Gottlob et al., 2010b) Let k be an
is a tree and λ is a labeling function that assigns to each integer. For Datalog abduction problems AP =
node n ∈ N , a subset λ(n) of V (λ(n) is aka. bag), i.e. Π, E, Hyp, Obs where Π is guarded, and t w (H(E)) ≤ k,
λ(n) ⊆ V , such that, for every node n ∈ N , the following relevance can be decided in polynomial time in |AP|. 9
hold: (a) For every v ∈ V , there exists n ∈ N with
v ∈ λ(n). (b) For every h ∈ H, there exists a node n ∈ N 9
This is Theorem 7.9 in (Gottlob et al., 2010b).
6
More precisely, the decision problem: RLDP = More precisely, consider a Datalog abduction problem
{( Π, E , Hyp, Obs , h) | h ∈ Rel( Π, E , Hyp, Obs ), h ∈ AP = Π, E, Hyp, Obs , where E is the underlying exten-
Hyp, Π is guarded, and t w (H(E)) ≤ k} is tractable.  sional database, and Obs is a conjunction of ground atoms.
This is a case of tractable combined complexity with a fixed Now we construct a query-causality setting: D := D x ∪
parameter that is the tree-width of the extensional database. Dn , D x := E, and D n := Hyp. Consider the program
Π := Π ∪ {ans ← Obs} (with ans a fresh propositional
2.2 QUERY CAUSALITY FROM ABDUCTIVE atom). So, Π is seen as a monotone query on D.
DIAGNOSIS
Proposition 2.5. A hypothesis h is relevant for AP, i.e.
In this section we first show that, for the class of Datalog h ∈ Rel(AP), iff h is an actual cause for ans wrt. Π  , D.
theories (system specifications), abductive inference corre- 
sponds to actual causation for monotone queries. That is,
Now we will use the results obtained so far in this section to
abductive diagnoses for an observation essentially contain
obtain new complexity results for Datalog query causality.
actual causes for the observation.
Actually, the following result is obtained from Propositions
Assume that Π is a boolean, possibly recursive Datalog 2.1 and 2.3:
query. Consider the relational instance D = D x ∪ Dn . Proposition 2.6. For boolean Datalog queries Π, CDP(Π)
Also assume that Π ∪ D |= ans. So, the decision problem is NP-complete (in data). 
in Definition 1.2 takes the form CDP(Π) := {(D, τ ) | τ ∈
Dn , and τ ∈ Causes(D, Π)}. This result should be contrasted with the tractability of
same problem for UCQs (Salimi & Bertossi, 2015).
We now show that actual causes for ans can be obtained
from abductive diagnoses of the associated causal Datalog We now introduce a fixed-parameter tractable case of this
abduction problem (CDAP): AP c := Π, Dx , Dn , ans , problem. For this we take advantage of the tractable case of
where D x is the extensional database for Π (and then Π ∪ Datalog abduction presented in Section 2.1. The following
Dx becomes the background theory), D n becomes the set is a consequence of Theorem 2.2 and Proposition 2.3.
of hypothesis, and atom ans is the observation. Proposition 2.7. For guarded Datalog queries Π and a ex-
n
Proposition 2.3. t ∈ D is an actual cause for ans iff tensional instances D = D x ∪ Dn , with D x of bounded
t ∈ Rel (AP c ).  tree-width, CDP is fixed-parameter tractable in combined
Example 2.2. Consider the instance D with relations R complexity, with the parameter being the tree-width bound.
and S as below, and the query Π : ans ← R(x, y), S(y), 
which is true in D. Assume all tuples are endogenous.
3 VIEW-UPDATES AND QUERY
R X Y S X
a1 a4 a1 CAUSALITY
a2 a1 a2 There is a close relationship between query causality and
a3 a3 a3 the view-update problem in the form of delete-propagation,
which was first suggested in (Kimelfeld, 2012; Kimelfeld
AP c = Π, ∅, D, ans has two (subset-minimal) abduc- et al., 2012) (see also (Buneman et al., 2002)). We start by
tive diagnoses: Δ1 = {S(a1 ), R(a2 , a1 )} and Δ2 = formalizing some specific computational problems related
{S(a3 ), R(a3 , a3 )}. Then, Rel (AP c ) = {S(a3 ), to the general delete-propagation problem.
R(a3 , a3 ), S(a1 ), R(a2 , a1 )}. It is easy to see that the rel-
evant hypothesis are actual causes for ans.  3.1 DELETE-PROPAGATION PROBLEMS
We are interested in obtaining responsibilities of actual Given a monotone query Q, we can think of it as defining a
causes for ans. view with virtual contents Q(D). If ā ∈ Q(D), which may
Definition 2.3. Given a CDAP, AP c = Π, Dx , Dn , ans , not be intended, we may try to delete some tuples from D,
with Sol (AP c ) = ∅, N ⊆ D n is a necessary-hypothesis so that ā disappears from Q(D). This is a common case of
set if N is subset-minimal such that Sol (AP cN ) = ∅, with the problem of database updates through views (Abiteboul
AP cN := Π, Dx , Dn  N, ans .  et al., 1995). In this work we consider some variations of
Proposition 2.4. The responsibility of a tuple t for ans is this problem, in both their functional and the decision ver-
1
|N | , where N is a necessary-hypothesis set with minimum
sions.
cardinality for AP c and t ∈ N .  Definition 3.1. For an instance D, and a monotone query
In order to represent Datalog abduction in terms of query- Q:
answer causality, we show that abductive diagnoses from (a) For ā ∈ Q(D), the minimal source-side-effect problem
Datalog programs are formed essentially by actual causes is about computing a subset-minimal Λ ⊆ D, such that
for the observation. ā ∈/ Q(D  Λ).
7
(b) The minimal source-side-effect decision problem is Now we show that, in order to minimize the side-effect on
(deciding about the membership of): the source (cf. Definition 3.1(c)), it is good enough to pick
MSSEP s(Q) = {(D, D , ā) | ā ∈ Q(D), D ⊆ D, a most responsible cause for ā with any of its minimum-
ā ∈ Q(D ), and D  is subset-maximal}. cardinality contingency sets.
(The superscript s stands for subset-minimal.) Proposition 3.2. Consider an instance D, a view V defined
(c) For ā ∈ Q(D), the minimum source side-effect prob- by a monotone query Q, and ā ∈ V(D): D  ⊆ D is
lem is about computing a minimum-cardinality Λ ⊆ a solution to the minimum source-side-effect problem, i.e.
D, such that ā ∈
/ Q(D  Λ). (D, D , ā) ∈ MSSEP c(Q), iff there is a t ∈ D  D  ,
(d) The minimum source side-effect decision problem is such that t ∈ MRC(D, Q(ā)), Λ := D  (D  ∪ {t}) ∈
(deciding about the membership of): Cont (D, Q(ā), t), and there is no Λ  ∈ Cont (D, Q(ā), t)
MSSEP c(Q) = {(D, D , ā) | ā ∈ Q(D), D ⊆ D, with |Λ | < |Λ|. 
/ Q(D ), and D  has maximum cardinality}.
ā ∈ Next, we show that in order to check if there exists a so-
(Here c stands for minimum cardinality.)  lution to the view side-effect-free problem for ā ∈ V(D)
Definition 3.2. (Buneman et al., 2002) For an instance D, (cf. Definition 3.2), it is good enough to check if ā has a
and a monotone query Q: view-conditioned cause. 10
(a) For ā ∈ Q(D), the view side-effect-free problem is Proposition 3.3. Consider an instance D, a view V defined
about computing a Λ ⊆ D, such that Q(D)  {ā} = by a monotone query Q, and ā ∈ V(D): There is a solution
Q(D  Λ). to the view side-effect-free problem for ā, i.e. (D, ā) ∈
(b) The view side-effect-free decision problem is (deciding VSEF P(Q), iff vc-Causes(D, Q(ā)) = ∅. 
about the membership of):
VSEF P(Q) = {(D, ā) | ā ∈ Q(D), and exists Example 3.1. (ex. 1.1 cont.) Consider the same instance
D ⊆ D with Q(D)  {ā} = Q(D  )}.  D, query Q, and answer John, XML .

3.2 VIEW DELETIONS VS. CAUSES Consider the following sets of tuples:
In this section we first establish mutual reductions between S1 ={ Author(John, TKDE), Journal(TODS, XML, 32)},
the different variants of the delete propagation problem S2 ={ Author(John, TODS), Journal(TKDE, XML, 30)},
and both query and view-conditioned causality. On this
basis, we obtain next some complexity results for view- S3 ={ Journal(TODS, XML, 30), Journal(TKDE, XML, 30)},
conditioned causality and the minimum source-side-effect S4 ={ Author(John, TODS), Author(John, TKDE)}.
problem.
Each of the subinstances D  S i , i = 1, . . . , 4, is a solu-
In this section all tuples in the instances involved are as- tion to both the minimum and minimal source-side-effect
sumed to be endogenous. Consider a relational database problems. These solutions essentially contain the actual
D, a view V defined by a monotone query Q. So, the vir- causes for answer John, XML , as computed in Exam-
tual view extension, V(D), is Q(D). ple 1.1. Moreover, there is no solution to the view side-
For a tuple ā ∈ V(D), the delete-propagation problem, in effect-free problem associated to this answer, which coin-
its most general form, is the task of deleting a set of tuples cides with the result obtained in Example 1.2, and confirms
from D, and so obtaining a subinstance D  of D, such that Proposition 3.3. 
ā ∈/ V(D ). It is natural to expect that the deletion of ā Now we show, the other way around, that actual causes,
from the view can be achieved through deletions from D most responsible causes, and VC causes can be ob-
of the causes for ā to be in the view extension. However, tained from solutions to different variants of the delete-
to obtain solutions to the different variants of this problem propagation problem.
introduced in Section 3.1, different sets of actual causes
must be considered. First, we show that actual causes for a query answer can be
obtained from the solutions to the corresponding minimal
First, we show that an actual cause for ā to be in V(D) source-side-effect problem.
forms, with any of its contingency sets, a solution to the
minimal source-side-effect problem (cf. Definition 3.1). Proposition 3.4. Consider an instance D, a view V defined
by a monotone query Q, and ā ∈ V(D): Tuple t is an
Proposition 3.1. Consider an instance D, a view V defined
actual cause for ā iff there is a D  ⊆ D with t ∈ (D 
by a monotone query Q, and ā ∈ V(D): D  ⊆ D is
D ) ⊆ Dn and (D, D  , ā) ∈ MSSEP s(Q). 
a solution to the minimal source-side-effect problem, i.e.
(D, D , ā) ∈ MSSEP s(Q), iff there is a t ∈ D  D  ,
such that t ∈ Causes(D, Q(ā)) and D  (D  ∪ {t}) ∈ 10
Since this proposition does not involve contingency sets, the
Cont (D, Q(ā), t).  existential problem in Definition 3.2(b) is the right one to con-
sider.
8
Similarly, most-responsible causes for a query answer can As mentioned in Section 1.1, responsibility computation
be obtained from solutions to the corresponding minimum (more precisely the RDP problem in Definition 1.3) is
source-side-effect problem. tractable for weakly linear queries. We can take advan-
Proposition 3.5. Consider an instance D, a view V defined tage of this result and obtain, via Proposition 3.2, a new
by a monotone query Q, and ā ∈ V(D): Tuple t is a most tractability result for the minimum source-side-effect prob-
responsible actual cause for ā iff there is a D  ⊆ D with lem, which has been shown to be NP-hard for general CQs
t ∈ (D  D ) ⊆ Dn and (D, D  , ā) ∈ MSSEP c(Q).  in (Buneman et al., 2002).

Finally, VC-causes for an answer can obtained from solu- Proposition 3.9. For weakly linear queries, the minimum
tions to the view side-effect-free problem. source-side-effect decision problem is tractable. 

Proposition 3.6. Consider an instance D, a view V defined The class of weakly linear queries generalizes that of linear
by a monotone query Q, and ā ∈ V(D): Tuple t is a VC- queries (cf. Section 1.1). So, Proposition 3.9 also holds for
cause for ā iff there is a D  ⊆ D with t ∈ (D  D  ) ⊆ Dn linear queries.
and D  is a solution to the view side-effect-free problem In (Buneman et al., 2002) it has been shown that the min-
associated to ā.  imum source-side-effect decision problem is tractable for
The partition of a database into endogenous and exoge- the class of project-join queries with chain joins. Now, a
nous tuples used in causality may also be of interest in the join on k atoms with different predicates, say R 1 , ..., Rk , is
context of delete propagation. It makes sense to consider a chain join if there are no attributes (variables) shared by
endogenous delete-propagation that are obtained through any two atoms Ri and Rj with j > i + 1. That is, only
deletions on endogenous tuples only. Actually, given an in- consecutive relations may share attributes. For example,
stance D = D n ∪ Dx , a view V defined by a monotone ∃xvyu(A(x) ∧ S1 (x, v) ∧ S2 (v, y) ∧ R(y, u) ∧ S3 (y, z)) is
query Q, and ā ∈ V(D), endogenous delete-propagations a project-join query with chain joins.
for ā (in all of its flavors) can be obtained from actual We observe that project-join queries with chain joins cor-
causes for ā from the partitioned instance. respond linear queries. Actually, the tractability results
Example 3.2. (ex. 3.1 cont.) Consider again that for these classes of queries are both obtained via a re-
tuple John, XML must be deleted from the query re- duction to maximum flow problem (Meliou et al., 2010a;
sult; and assume now the data in Journal is reliable. Buneman et al., 2002). As a consequence, the result in
Therefore, only deletions from Author make sense. This Proposition 3.9 extends that in (Buneman et al., 2002),
can be captured by considering Journal-tuples as exoge- from linear queries to weakly-linear queries. For exam-
nous and Author-tuples as endogenous. With this parti- ple, ∃xyz(R(x, y) ∧ S(y, z) ∧ T (z, x) ∧ V (x)) is not linear
tioning, only Author(John, TODS) and Author(John, TKDE) (then, nor with chain joins), but it is weakly linear (Meliou
are actual causes for John, XML , and each of them et al., 2010a).
forms a singleton and unique contingency set of the other
as a cause (See Exampleex:cfex1). Therefore, D  4 CONCLUSIONS
{Author(John, TODS), Author(John, TKDE)} is a solution to
the associated minimal- and minimum endogenous delete- We have related query causality to abductive diagnosis and
propagation of John, XML .  the view-update problem. Some connections between the
last two have been established before. More precisely, the
We now investigate the complexity of the view-conditioned view-update problem has been treated from the point of
causality problem (cf. Definition 1.6). For this, we take ad- view of abductive reasoning (Kakas & Mancarella, 1990;
vantage of the connection between VC-causality and the Console et al., 1995). The idea is to “abduce” the pres-
view side-effect-free problem. Actually, the following re- ence of tuples in the base tables that explain the presence
sult is obtained from the NP-completeness of view side- of those tuples in the view extension that one would like,
effect-free problem (Buneman et al., 2002) and Proposition e.g. to get rid of.
3.3.
In combination with the results reported in (Salimi &
Proposition 3.7. For CQs, the view-conditioned causality Bertossi, 2015), we can see that there are deeper and mul-
decision problem, VCP, is NP-complete.  tiple connections between the areas of query causality, ab-
Actually, this result also holds for UCQs. The next result is ductive and consistency-based diagnosis, view updates, and
obtained from the FP NP (log(n)) -completeness of comput- database repairs. Results for any of these areas can be prof-
ing the responsibility of the most responsible causes (ob- itably applied to the others. 11
tained in (Salimi & Bertossi, 2015)) and Proposition 3.2.
We point out that database repairs are related to the view-
Proposition 3.8. Computing the size of a solution to update problem. Actually, answer set programs (ASPs)
the minimum source-side-effect problem is FP NP (log(n)) -

11
hard. Connections between consistency-based and abductive diag-
nosis have been established, e.g. in (Console & Torasso, 1991).
9
(Brewka et al., 2011) for database repairs (Bertossi, 2011) Console, L., Sapino M. L., Theseider-Dupre, D. The Role of Ab-
implicity repair the database by updating conjunctive com- duction in Database View Updating. J. Intell. Inf. Syst., 1995,
binations of intentional, annotated predicates. Those logi- 4(3): 261-280.
Denecker, M., and Kakas A. C. Abduction in Logic Program-
cal combinations -views after all- capture violations of in-
ming. In Computational Logic: Logic Programming and Be-
tegrity constraints in the original database or along the (im- yond, 2002, LNCS 2407, pp. 402-436.
plicitly iterative) repair process (a reason for the use of an- Eiter, T. and Gottlob, G. The Complexity of Logic-Based Abduc-
notations). tion. J. ACM , 1995, 42(1): 3-42.
Eiter, T., Gottlob, G. and Leone, N. Abduction from Logic Pro-
Even more, in (Bertossi & Li, 2013), in order to protect grams: Semantics and Complexity. Theor. Comput. Sci., 1997,
sensitive information, databases are explicitly and virtually 189(1-2):129-177.
“repaired” through secrecy views that specify the informa- Friedrich, G., Gottlob. G. and Nejdl, W. Hypothesis Classifica-
tion that has to be kept secret. In order to protect infor- tion, Abductive Diagnosis and Therapy. Proc. Internat. Work-
mation, a user is allowed to interact only with the virtually shop on Expert Systems in Engineering, 1990, LNCS 462, pp.
69-78.
repaired versions of the original database that result from
Gottlob, G., Pichler, R. and Wei, F. Bounded Treewidth as a Key
making those views empty or contain only null values. Re- to Tractability of Knowledge Representation And Reasoning.
pairs are specified and computed using ASP, and an explicit Artificial Intelligence, 2010a, 174(1):105132.
connection to prioritized attribute-based repairs (Bertossi, Gottlob, G., Pichler, R. and Wei, F. Tractable Database Design
2011) is made (Bertossi & Li, 2013). and Datalog Abduction through Bounded Treewidth. Inf. Syst.,
2010b, 35(3):278-298.
Finally, we should note that abduction has also been ex- Halpern, J., and Pearl, J. Causes and Explanations: A Structural-
plicitly applied to database repairs (Arieli et al., 2004). Model Approach: Part 1 Proc. UAI, 2001, pp. 194-202.
The idea, again, is to “abduce” possible repair updates that Halpern, Y. J., Pearl, J. Causes and Explanations: A Structural-
bring the database to a consistent state. Model Approach: Part 1. British J. Philosophy of Science,
2005, 56:843-887.
Acknowledgments: Research funded by NSERC Discov- Halpern, J. A Modification of Halpern-Pearl Definition of Causal-
ery, and the NSERC Strategic Network on Business Intel- ity. To appear in Proc. IJCAI, 2015.
Halpern, J. Appropriate Causal Models and Stability of Causa-
ligence (BIN). tion. Proc. KR, 2014.
Kakas A. C. and Mancarella, P. Database Updates through Ab-
References duction. Proc. VLDB, 1990, pp. 650-661.
Kimelfeld, B. A Dichotomy in the Complexity of Deletion Prop-
Abiteboul, S. Hull R., and Vianu V. Foundations of Databases. agation with Functional Dependencies. Proc. PODS, 2012, pp.
Addison-Wesley, 1995. 191-202.
Arieli, O., Denecker, M., Van Nuffelen, B. and Bruynooghe, M. Kimelfeld, B., Vondrak, J. and Williams, R. Maximizing Con-
Coherent Integration of Databases by Abductive Logic Pro- junctive Views in Deletion Propagation. ACM TODS, 2012,
gramming. J. Artif. Intell. Res., 2004, 21:245-286. 7(4):24.
Bertossi, L. and Li, L. Achieving Data Privacy through Secrecy Meliou, A., Gatterbauer, W. Moore, K. F. and Suciu, D. The Com-
Views and Null-Based Virtual Updates. IEEE Transaction on plexity of Causality and Responsibility for Query Answers and
Knowledge and Data Engineering, 2013, 25(5):987-1000. Non-Answers. Proc. VLDB, 2010a, pp. 34-41.
Bertossi, L. Database Repairing and Consistent Query Answer- Meliou, A., Gatterbauer. W., Halpern, J. Y., Koch, C., Moore K. F.
ing. Morgan & Claypool, Synthesis Lectures on Data Manage- and Suciu, D. Causality in Databases. IEEE Data Eng. Bull,
ment, 2011. 2010b, 33(3):59-67.
Bertossi, L. and Salimi, B. Unifying Causality, Diagnosis, Meliou, A., Gatterbauer, S. Nath. and Suciu, D. Tracing Data Er-
Repairs and View-Updates in Databases. First International rors with View-Conditioned Causality. Proc. SIGMOD, 2011.
PODS-Workshop on Big Uncertain Data (BUDA 2014). Psillos., A. Ampliative Reasoning: Induction or Abduction. Proc.
http://www.sigmod2014.org/buda/papers/p5.pdf ECAI’96 Workshop on Abductive and Inductive Reasoning,
Brewka, G., Eiter, Th. and Truszczynski, M. Answer Set Pro- 1996.
gramming at a Glance. Communications of the ACM, 2011, Poole, D. Logic Programming, Abduction and Probability. Proc.
54(12):92-103. FGCS, 1992, pp. 530-538.
Buneman, P., Khanna, S. and Tan, W. C. On Propagation of Dele- Poole, D. Representing Diagnosis Knowledge. Annals of Mathe-
tions and Annotations Through Views. Proc. PODS, 2002, pp. matics and Artificial Intelligence, 1994, 11(1-4):33-50.
150-158. Reiter, R. A Theory of Diagnosis from First Principles. Artificial
Ceri, S., Gottlob, G. and Tanca, L. Logic Programming and Intelligence, 1987, 32(1):57-95.
Databases. Springer, 1989. Salimi, B. and Bertossi, L. Causality in Databases: The Diagnosis
Chockler, H. and Halpern, J. Y. Responsibility and Blame: A and Repair Connections. Proc. 15th International Workshop
Structural-Model Approach. J. Artif. Intell. Res., 2004, 22:93- on Non-Monotonic Reasoning (NMR 2014), 2014. Corr Arkiv
115. Paper cs.DB/1404.6857.
Salimi, B. and Bertossi, L. From Causes for Database Queries to
Console, L., and Torasso, P.,. A Spectrum of Logical Definitions
Repairs and Model-Based Diagnosis and Back. Proc. ICDT,
of Model-Based Diagnosis. Comput. Intell., 1991, 7:133-141.
2015.
Console, L., Theseider-Dupre, D. and Torasso, P. On the Rela- Struss, P. Model-based Problem Solving. In Handbook of Knowl-
tionship between Abduction and Deduction. J. Log. Comput., edge Representation, chap. 10. Elsevier, 2008.
1991, 1(5):661-690. 10