Specifying and computing causes for query answers in databases via database repairs and repair-programs

Abstract

There is a recently established correspondence between database tuples as causes for query answers in databases and tuple-based repairs of inconsistent databases with respect to denial constraints. In this work, answer-set programs that specify database repairs are used as a basis for solving computational and reasoning problems around causality in databases, including causal responsibility. Furthermore, causes are introduced also at the attribute level by appealing to an attribute-based repair semantics that uses null values. Corresponding repair-programs are introduced, and used as a basis for computation and reasoning about attribute-level causes. The answer-set programs are extended in order to capture causality under integrity constraints.

Appendices

A. Examples of tuple-based causes with DLV-complex

In this section, we show in detail how the examples and repairs-programs extended with causality elements of Sect. 5 can be specified and executed in the DLV-Complex system [17, 18].

Example A.1

(Example 2.3, 3.1, 5.1–5.3 cont.) The first fragment of the DLV program below, in its non-disjunctive version, shows facts for database D, and the three repair rules for the DC $\kappa ({\mathcal {Q}})$. In it, and in the rest of this section, predicates +R+, +S+ stand for ${ Receives}$ and ${ Store}$, resp.; and $\texttt {R}_\texttt {a}$, $\texttt {S}_\texttt {a}$,...+ stand for ${ Receives}', { Store}',\ldots$ used before, with the subscript $_\texttt {a}$ for “auxiliary.” We recall that the first attribute of a predicate holds a variable or a constant for a tid; and the last attribute of $\texttt {R}_\texttt {a}$, etc. holds an annotation constant, +d+ or +s+, for “deleted” (from the database) or “stays” in a repair, resp.

This is the non-disjunctive version of the repair-program given in disjunctive form in Example 5.1, which in DLV takes the following form: (we will keep using the non-disjunctive versions of these programs)

DLV returns the stable models of the program, as follows:

These three stable models (that do not show here the original EDB) are associated to the S-repairs $D_1, D_2, D_3$ in Example 3.1, resp. As expected from Example 2.3, only tuples with tids 1, 3, 4, 6 are at some point deleted. In particular, the last model corresponds to the C-repair     $D_1 = \{{ Receives}(s_4,s_3), { Receives}(s_2,s_1), { Receives}(s_3,s_3),$ ${ Store}(s_4), { Store}(s_2)\}$.

Now, to compute causes and their accompanying deleted tuples we add to the program the rules defining ${ Cause}$, in (14) and (15), and ${ CauCont}$, in Example 5.2:

Next, contingency sets can be computed by means of DLV-Complex, on the basis of the rules defining predicates ${ cause}$ and ${ cauCont}$ above:

The last two rules play the role of rules (16) and (17), that associate the empty contingency set to counterfactual causes.

The three stable models obtained above will now be extended with ${ cause}$- and ${ cont}$-atoms, among others (unless otherwise stated, ${ preCont}$-, ${ tmpCont}$-, and ${ HoleIn}$-atoms will be filtered out from the output); as follows:

The first two models above show tuple 3 as an actual cause, with one contingency set per each of the models where it appears as a cause. The last line of the third model shows that cause (with tid) 6 is the only counterfactual cause (its contingency set is empty).

The responsibility $\rho$ can be computed via predicate ${ preRho}(T,N)$, defined in (22), that returns $N = \frac{1}{\rho }$, that is the inverse of the responsibility, for each tuple with tid T and local to a model that shows T as a cause. We concentrate on the computation of ${ preRho}$ in order to compute with integer numbers, as supported by DLV-Complex, which requires setting an upper integer bound by means of maxint, in this case, at least as large as the largest tid:

where the local (pre)responsibility of a cause (with tid) T within a repair is obtained by counting how many instances of ${ cauCont}(T,?)$ exist in the model, which is the size of the local contingency set for T plus 1. We obtain the following (filtered) output:

The first model shows causes 3 and 4 with a pre-rho value of 2. The second one, causes 3 and 1 with a pre-rho value of 2. The last model shows cause 6 with a pre-rho value of 1. This is also a maximum-responsibility cause, actually associated with a C-repair. Inspecting the three models, we can see that the overall pre-responsibility of cause 3 (the minimum of its pre-rho values) is 2, similarly for cause 1. For cause 6 the overall pre-responsibility value is 1.

Now, if we want only maximum-responsibility causes, we add weak program constraints to the program above, to minimize the number of deletions:

DLV shows only repairs with the least number of deletions, in this case:

As expected, only repair $D_1$ is obtained, where only ${ Store}(6,s_3)$ is a cause, and with responsibility 1, making it a maximum-responsibility cause.

Example A.2

(Example 5.4 cont.) We proceed as in Example A.1, with the repair-program being: (again, in non-disjunctive form, but DLV accepts disjunction)

Now, we define the contingency sets and the local (pre)responsibilities for every cause in each model:

We obtain the following output, showing four S-repairs, with the last three being C-repairs:

Cause 5, for example, appears in the first and third repairs, which are an S-repair and C-repair, resp. If we do not want to start inspecting the kinds of repairs where a cause appears, and we haven’t pruned non-C-repairs, then we may pose a query of the form ${ preRho}(5,N)?$ against this program under. This is done by inserting the query at the end of the program (in file +file+), as +preRho(5,N)?+. Then in the command line, one types: +dlv -brave file+, obtaining as expected:

The least of the returned values will give us the global pre-responsibility value, which can be used to compute tuple 5’s (global) responsibility: $\frac{1}{2}$. If we want all causes with their local pre-responsibilities, we pose instead the query: preRho(T,N)?.

If, as in Example A.1, we impose weak constraints to obtain only C-repairs:

we obtain:

As expected for C-repairs, the local pre-responsibilities for a cause coincide.

B. An example of null-based causes with DLV

Example B.1

(Example 4.2 and 4.6 cont.) In this DLV program S stands for ${ Store}$, and R, for ${ Receives}$. The tuples already contain tuple-ids. The program is similar to that in Example 6.2.

The query S(T1,X), R(T2,X,Y)? to the program under the brave semantics returns tuples of the form T1 X T2 Y, showing that tuples (with tids) 2,3,4,5 are responsible for the violation of the DC:

Two stable models are returned, corresponding to two attribute-based repairs: