Generalized Deletion Propagation on Counting Conjunctive Query Answers

TL;DR

This paper studies the complexity of minimally removing input tuples to eliminate a specified number of output tuples in conjunctive query results, providing a structural characterization of tractable cases and approximation algorithms for hard cases.

Contribution

It offers a complexity dichotomy for deletion propagation in conjunctive queries, identifying structural conditions for polynomial solvability and developing approximation algorithms for NP-hard cases.

Findings

Dichotomy theorem classifies full conjunctive queries as either polynomial-time solvable or NP-hard.

Provides an exact algorithm for easy cases of the problem.

Develops approximation algorithms for the hard cases.

Abstract

We investigate the computational complexity of minimizing the source side-effect in order to remove a given number of tuples from the output of a conjunctive query. In particular, given a multi-relational database $D$, a conjunctive query $Q$, and a positive integer $k$ as input, the goal is to find a minimum subset of input tuples to remove from D that would eliminate at least $k$ output tuples from $Q(D)$. This problem generalizes the well-studied deletion propagation problem in databases. In addition, it encapsulates the notion of intervention for aggregate queries used in data analysis with applications to explaining interesting observations on the output. We show a dichotomy in the complexity of this problem for the class of full conjunctive queries without self-joins by giving a characterization on the structure of $Q$ that makes the problem either polynomial-time solvable or NP-hard. Our proof of this dichotomy result already gives an exact algorithm in the easy cases; we complement this by giving an approximation algorithm for the hard cases of the problem.

Equations

$$Q_1(\cdots )$$

$$Q_2(\cdots )$$

$$Q(\mathbb{A}):-R_1({\mathbb{A}}_1),R_2({\mathbb{A}}_2),\cdots ,R_p({\mathbb{A}}_p)$$

$${\mathbb{A}}_{ij}={\mathbb{A}}_i\cap {\mathbb{A}}_j$$

$$\begin{split}{\textsc{OptCost}}[i][s]=\min&\begin{cases}{\textsc{OptCost}}[i-1][s]\\ \min_{m=1}^{s-1}\Big{\{}{\textsc{OptCost}}[i-1][s-m]+c_{i,m}\Big{\}}\\ \end{cases}\end{split}$$

Full text

††journalyear: 2020††copyright: acmcopyright††conference: Woodstock ’18: ACM Symposium on Neural Gaze Detection; June 03–05, 2018; Woodstock, NY††booktitle: Woodstock ’18: ACM Symposium on Neural Gaze Detection, June 03–05, 2018, Woodstock, NY††price: 15.00††isbn: 978-1-4503-9999-9/18/06

1. Introduction

The problem of view update (e.g., (Bancilhon and Spyratos, 1981; Dayal and Bernstein, 1982)) – how to change the input to achieve some desired changes to a view or query output – is a well-studied problem in the database literature. This arises in contexts where the user is interested in tuning the output to meet her prior expectation, satisfy some external constraint, or examine different possibilities. In these cases, she would want to know whether and how the input can be changed to achieve the desired effect in the output.

One special case of view update that has been studied from a theoretical standpoint is deletion propagation, which was first analyzed by Buneman, Khanna, and Tan (Buneman et al., 2002). Given a database $D$ and a monotone query $Q$, and a designated output tuple $t\in Q(D)$, the goal is to remove $t$ from $Q(D)$ by removing input tuples from $D$ subject to two alternative optimization criteria. In the source side-effect version, the goal is to remove $t$ from $Q(D)$ by removing the smallest number of input tuples from $D$, whereas in the view side-effect version, the goal is to remove $t$ such that the number of other output tuples deleted from $Q(D)$ is minimized. The intuition is that if the user considers tuple $t$ to be erroneous, then she would want to remove it from the output in a way that is minimal in terms of her intervention on the input, or in terms of the disruption caused in the output.

In this paper, we study the Generalized Deletion Propagation problem (GDP), where given $Q$ and $D$, instead of removing a designated tuple $t$ from $Q(D)$, the goal is to remove at least $k$ tuples from $Q(D)$ for a given integer $k$. We are interested in studying this problem from the perspective of minimizing the source side-effect, i.e., we want to remove $k$ output tuples by removing the smallest number of input tuples from $D$.

Consider an example where an airline has flights from a set of northern locations to a set of central locations stored in a relation ${\tt R_{nc}(north,central)}$, and also from a set of central locations to a set of southern locations stored in ${\tt R_{cs}(central,south)}$. The conjunctive query (CQ) $Q_{\rm alltrips}(n,c,s):-R_{nc}(n,c),R_{cs}(c,s)$ shown in Datalog format finds all the north-central-south routes served by the airline. Now, consider a competitor that want to start new routes in a minimum number of these segments so as to affect at least $k$ of the routes being operated by the first airline. This can be exactly modeled by the GDP problem. More generally, the GDP problem can be used to analyze whether there is a small subset of input tuples with high impact on the output: if removal of a small number of input tuples causes a large change in the output, then there is significant dependence on this small subset which can be a potential source of vulnerability.

The other motivation for the GDP problem comes from the recent study of explaining aggregate query answers and outliers by intervention (Wu and Madden, 2013; Roy and Suciu, 2014; Roy et al., 2015). Here, given an aggregate query $Q$, possibly with group-by operations, the user studies the outputs and may ask questions like ‘why a value $q_{1}$ is high’, or, ‘why a value $q_{1}$ is higher or lower than another value $q_{2}$’. A possible explanation is a set of input tuples, compactly expressed using predicates, such that by removing these subsets we can change the selected values in the opposite direction, e.g., if the user thinks $q_{1}(D)$ is high, then a good explanation with high score capturing a subset $S$ of input tuples will make $q_{1}(D\setminus S)$ as low as possible. One example given in (Roy and Suciu, 2014) was on the DBLP publication data, where it is observed that there was a peak in SIGMOD papers coauthored by researchers in industry around year 2000 (and then it gradually declined), which is explained by some top industrial research labs that had hiring slow-down or shut down later (i.e., if the papers by these labs did not exist in the database, the peak will be lower). Although this line of work studies more general SQL aggregate queries with group-by and aggregates, it aims to change the output by deleting the input tuples (if the question is on a single output, it can only reduce for monotone queries). In this work, we study the complexity of the reverse direction of this problem in a simpler setting, where we only consider counts and conjunctive queries, and aim to find the minimum number of input tuples that would reduce the output by a desired amount.

The GDP problem is also related to the partial vertex cover (Caskurlu et al., 2017) or partial set cover problems (Gandhi et al., 2004), that are generalizations of the classical vertex cover or set cover problems, where instead of covering all edges or all elements, the goal is to select a minimum cost set of vertices or sets so that at least $k$ edges or $k$ elements are covered. These partial coverage problems are useful when the goal is to cover a certain fraction of the elements or edges, e.g., to build facilities to provide service to a certain fraction of the population (Gandhi et al., 2004). The GDP problem is a special case of the partial set cover problem where each element is an output tuple of a CQ and each input tuple represents a set containing all the output tuples that would be removed on deleting it from the input (see Section 4).

**Our contributions. ** We propose the GDP problem, and analyze its complexity for the class of full conjunctive queries without self-join111The class of full CQ without self-join is a natural sub-class of CQs. Full CQs have been studied in contexts like the worst-case optimal join algorithms (Ngo et al., 2012; Veldhuizen, 2014), AGM bounds (Atserias et al., 2008), and parallel evaluation of CQs (Koutris and Suciu, 2011) (without self-joins). Self-join free queries have been studied in most of the related papers on deletion propagation. The complexity of GDP for larger classes of queries is interesting future work (see Section 5).. Given a conjunctive query (CQ) $Q$ that outputs the natural join of the input relation based on common attributes, a database instance $D$, and an integer $k$, the goal is to remove at least $k$ tuples from the output by removing the smallest number of input tuples from the database. GDP for arbitrary monotone queries $Q$ generalizes the source side-effect version of the deletion propagation problem for single or multiple output tuples, since we can add a selection operation to keep only these tuples in the output, and then run the GDP problem for $k=all$, to remove all tuples in the output.

First we give a dichotomy result that completely resolves the complexity of the GDP problem for the class of full CQ without self-joins (Section 3). We assume the standard data complexity for our complexity results where the complexity is given in terms of the size of the input instance and the query and schema are assumed to be of constant size (Vardi, 1982). We give an algorithm that only takes the query $Q$ as input, and decides in time that is polynomial in the size of the query (i.e., in time that is constant in data complexity), whether GDP can be solved in time that is polynomial in the data complexity for all instances $D$ and all values of $k$. If this algorithm returns true, then the problem is solvable in polynomial time for all $k$ and $D$. Moreover, if the algorithm returns false, the problem is NP-hard for some set of instances and some value of $k$. The problem we use to prove NP-hardness is partial vertex cover in bipartite graphs (PVCB) that intends to cover at least $k$ of the edges by minimizing the cost instead of covering all the edges in a bipartite graph. Unlike the vertex cover problem in bipartite graphs, this problem was shown to be NP-hard by Caskurlu et al. (Caskurlu et al., 2017). An example query where the reduction can be readily applied is the query for paths of length two: $Q_{2-path}(A,B):-R_{1}(A),R_{2}(A,B),R_{3}(B)$ (see Lemma B.1). Note that this path query was shown to be poly-time solvable for the deletion propagation problem (Buneman et al., 2002), not only for the full CQ $Q_{2-path}$ that belongs to the class $SJ$ and therefore is poly-time solvable for a designated tuple, but also if projections are involved by a reduction to the minimum $s-t$-cut problem (the class PJ is, in general, hard for deletion propagation). However, for arbitrary $k$, this problem becomes NP-hard for GDP.

The query $Q$ can have more complex patterns like (attributes in the head are not displayed)

[TABLE]

or, a complex combination of the above two possibly involving additional attributes (we discuss these examples in Section 3). We give a set of simplification steps such that if none of them can be applied to $Q$, there is a reduction from the PVCB problem even if there is no obvious path structure like $Q_{2-path}$. In addition, we argue that the hardness is preserved in all simplification steps. If the algorithm to check whether a query is poly-time solvable returns true, then we give an algorithm that returns an optimal solution in polynomial time using the same simplification steps. There can be scenarios when $Q$ can be decomposed into two or more connected components, or when there is a common attribute in all relations in $Q$, and the algorithm gives a solution for each such case by building upon smaller sub-problems.

Since the GDP problem is NP-hard even for simple queries like $Q_{2-path}$, we then study approximations to this problem (Section 4). We give an approximation algorithm by a reduction to the partial set cover problem. When $f$ is the maximum frequency of an element in the sets, Gandhi, Khuller, and Srinivasan (Gandhi et al., 2004) generalize the classic primal dual algorithm for the set cover problem to obtain an $f$-approximation for the partial set cover problem. Using this algorithm, we get a $p$-approximation for the GDP problem, where $p$ is the number of relations in the schema.

**Related Work. ** The classical view update problem has been studied extensively over the last four decades (e.g., (Bancilhon and Spyratos, 1981; Dayal and Bernstein, 1982)), although the special case of deletion propagation has gained more popularity in the last two decades starting with the seminal work by Buneman, Khanna, and Tan (Buneman et al., 2002). They showed that the class of monotone queries involving select-project-join-union (SPJU) operators can be divided into sub-classes for which finding the optimal source side-effect is NP-hard (e.g., queries with PJ or JU) or solvable in polynomial time (e.g., SPU or SJ). Recently, Friere et al. (Freire et al., 2015) studied the resilience problem, for the class of CQs without self-joins and with arbitrary functional dependency, and gave a dichotomy characterizing whether it is poly-time solvable or NP-hard. The input to the resilience problem is a Boolean CQ and a database instance $D$ such that $Q(D)$ is true, and the goal is to remove a minimum subset of tuples from the input that makes the query $Q$ evaluate to false. This is identical to the deletion propagation problem where all attributes are projected out.

In recent years, the complexity of deletion propagation for the view side-effect version has been extensively studied by Kimelfeld, Vondrak, and Williams in a series of papers (Kimelfeld et al., 2011; Kimelfeld, 2012; Kimelfeld et al., 2013). First, a dichotomy result was shown for CQs without self-joins (Kimelfeld et al., 2011), that if a ‘head-domination property’ holds, then the problem is poly-time solvable; otherwise, it is APX-hard. In addition, it was shown that self-joins affect the hardness further. Then a dichotomy result was shown by Kimelfeld (Kimelfeld, 2012) for the deletion propagation problem with functional dependency for CQs without self-join. The multi-tuple deletion propagation problem was studied in (Kimelfeld et al., 2013) where the goal is to remove a given set of output tuples, and a trichotomy result was shown (a query is poly-time solvable, APX-hard but constant approximation exists, or no non-trivial approximation exists). All these papers focus on the view side-effect version of deletion propagation and therefore the optimization goal is different from ours.

For the source side-effect version, the complexity of multi-tuple deletion propagation was studied by Cong, Fan, and Geerts (Cong et al., 2006). They show that for single tuple deletion propagation, key preservation makes the problem tractable for SPJ views; however, if multiple tuples are to be deleted, the problem becomes intractable for SJ, PJ, and SPJ views. In our work, we study deletion propagation where the count of tuples to be removed is specified, and give a complete characterization for the class of full CQs without self joins.

Beyond the context of deletion propagation, several dichotomy results have been obtained for problems motivated by data management, e.g., in the context of probabilistic databases (Dalvi and Suciu, 2012), computing responsibility (Meliou et al., 2010), or database repair (Livshits et al., 2018). Problems similar to GDP have also been studied as reverse data management (Meliou et al., 2011) where some action needs to be performed on the input data to achieve desired changes in the output. Toward this goal, Meliou and Suciu (Meliou and Suciu, 2012) studied how-to queries, where a suite of desired changes (e.g., modifying aggregate values, creating or removing tuples) can be specified by a Datalog-like language, and a possible world satisfying all constraints and optimizing on some criteria is returned. Although (Meliou and Suciu, 2012) considered a much more general class of queries and update operations, their focus was to develop an end-to-end system using provenance and mixed integer programming, and not on the complexity of this problem. As discussed before, GDP is also related to explanations by intervention (Wu and Madden, 2013; Roy and Suciu, 2014; Roy et al., 2015) where the goal is to find a set of input tuples captured by a predicate that changes an aggregate answer (or a function of multiple aggregate answers). For the class of simple predicates, this problem is poly-time solvable in data complexity, but complexity of the problem for more complex scenarios remains an open question.

**Roadmap. ** We define some preliminary concepts in Section 2, then give our main dichotomy result in Section 3 and the approximation results in Section 4, and conclude with directions of future work in Section 5.

2. Preliminaries

**Schema, instance, relations, attributes, tuples. ** We consider the standard setting of multi-relational databases and conjunctive queries. Let ${\mathbb{R}}$ be a database schema that contains $p$ tables $R_{1},\cdots,R_{p}$. Let ${\mathbb{A}}$ be the set of all attributes in the database ${\mathbb{R}}$. Each relation $R_{i}$ is defined on a subset of attributes ${\texttt{attr}}(R_{i})={\mathbb{A}}_{i}\subseteq{\mathbb{A}}$. We use $A,B,C,A_{1},A_{2},\cdots\in{\mathbb{A}}$ to denote the attributes in ${\mathbb{A}}$ and $a,b,c,\cdots$ etc. to denote their values. For each attribute $A\in{\mathbb{A}}$, ${\texttt{dom}}(A)$ denotes the domain of $A$ and ${\texttt{rels}}(A)$ denotes the set of relations that $A$ belongs to, i.e., ${\texttt{rels}}(A)=\{R_{i}:A\in{\mathbb{A}}_{i}\}$.

Given the database schema ${\mathbb{R}}$, let $D=D^{\mathbb{R}}$ be a given instance of ${\mathbb{R}}$, and the corresponding instances of $R_{1},\cdots,R_{p}$ be $D^{R_{1}},\cdots,D^{R_{p}}$. Where it is clear from the context, we will use $D$ instead of $D^{\mathbb{R}}$, and $R_{1},\cdots,R_{p}$ instead of $D^{R_{1}},\cdots,D^{R_{p}}$. Any tuple $t\in R_{i}$ is defined on ${\mathbb{A}}_{i}$. For any attribute $A\in{\mathbb{A}}_{i}$, $t.A\in{\texttt{dom}}(A)$ denotes the value of $A$ in $t$. Similarly, for a set of attributes ${\mathbb{B}}\subseteq{\mathbb{A}}_{i}$, $t.{\mathbb{B}}$ denotes the values of attributes in ${\mathbb{B}}$ for $t$ with an implicit ordering of the attributes. Let $n_{i}$ be the number of tuples in $R_{i}$ and $n=\sum_{i=1}^{p}n_{i}$ be the total number of tuples in $D$.

**Full conjunctive queries without self-joins. ** We consider the class of full conjunctive queries (CQ) without self-joins. Such a CQ represents the natural join among the given relations, and has the following form:

[TABLE]

We will call the above query $Q$ the full CQ on schema ${\mathbb{R}}$. Note that we do not have any projection in the body or in the head of the query, and each $R_{i}$ in $Q$ is distinct, i.e., the CQ does not have a self-join.

When this query is evaluated on an instance $D$, the result $Q(D)$ contains all tuples $t$ defined on ${\mathbb{A}}$ such that there are tuples $t_{i}\in R_{i}$ with $t_{i}.A=t.A$ for all attributes $A\in{\mathbb{A}}_{i}$, for all $i=1,\cdots,p$. Extending the notations, we use ${\texttt{rels}}(Q)$ to denote all the relations that appear in the body of $Q$ (initially, ${\texttt{rels}}(Q)={\mathbb{R}}$), and ${\texttt{attr}}(Q)$ to denote all the attributes that appear in the body of $Q$ (initially, ${\texttt{attr}}(Q)={\mathbb{A}}$).

Example 2.1.

In Figure 1, we show an example database schema ${\mathbb{R}}$ with three relations $R_{1},R_{2},R_{3}$, where ${\mathbb{A}}=\{A,B,C,E\}$, ${\mathbb{A}}_{1}=\{A,B\}$, ${\mathbb{A}}_{2}=\{B,C\}$, and ${\mathbb{A}}_{3}=\{C,E\}$. Further, ${\texttt{rels}}(A)=\{R_{1}\}$, ${\texttt{rels}}(B)=\{R_{1},R_{2}\}$, ${\texttt{rels}}(C)=\{R_{2},R_{3}\}$, and ${\texttt{rels}}(E)=\{R_{3}\}$. It also shows an instance $D$ and the result $Q(D)$ of the CQ $Q(A,B,C,E):-R_{1}(A,B),R_{2}(B,C),R_{3}(C,E)$. Here $n=11$ and $p=4$.

**Generalized Deletion Propagation problem GDP). ** Below we define the generalized deletion propagation problem in terms of the count of output tuples of a CQ:

Definition 2.2.

Given a database schema ${\mathbb{R}}$ with $p$ relations $R_{1},\cdots,R_{p}$, a CQ $Q$ on ${\mathbb{R}}$, an instance $D$, and a positive integer $k\geq 1$, the generalized deletion propagation problem (GDP) aims to remove at least $k$ tuples from the output $Q(D)$ by removing the minimum number of input tuples from $D$.

Given $Q$, $k$, and $D$, we denote the above problem by ${\texttt{GDP}}(Q,k,D)$ (note that the schema is implicit in $Q$).

Example 2.3.

Suppose $k=4$ for the input in Example 2.1. Then, given the instance in Figure 1, the solution of GDP will include a single tuple $R_{2}(b1,c1)$ since by removing this tuple we would remove the first four output tuples in $Q(D)$.

For arbitrary CQs, GDP generalizes the deletion propagation problem (both single- and multi-tuple versions), since we can only select the intended tuple(s) for deletion by a selection operation at the end, and then run GDP for $k=all$.

**GDP for full CQ without self-joins. ** In this paper we study the complexity of GDP for the class of full CQ without self-joins. Note that the problem is trivial if $k=1$: since we do not allow projection, any output tuple can be removed by removing any one input tuple that has been used to produce the output tuple. This is observed in (Buneman et al., 2002), who identified the class of SJ queries as poly-time solvable for single-tuple deletion propagation.

**Data complexity. ** In this paper we assume standard data complexity (Vardi, 1982), where the size of the input instance $n$ is considered variable, but the size of the query and schema is assumed to be constant, i.e., $p,|{\mathbb{A}}|$ are constants.

3. Dichotomy

In this section, we give the following dichotomy result that characterizes the complexity of GDP on the full CQ of any input schema ${\mathbb{R}}$ with $p$ relations $R_{1},\cdots,R_{p}$.

Theorem 3.1.

If the algorithm ${\textsc{IsPtime}}(Q)$ given in Algorithm 1 returns true, then for all values of integer $k$ and for all instances $D$, the problem ${\texttt{GDP}}(Q,k,D)$ is poly-time solvable in data complexity. Moreover, an optimal solution can be computed in poly-time. Otherwise the problem ${\texttt{GDP}}(Q,k,D)$ is NP-hard.

The algorithm has seven simplification steps as written next to each condition, and some simplification steps call the algorithm IsPtime recursively222It may be noted that Algorithm 1 has a correspondence with hierarchical queries, where for any two attributes $A,B$, either one of ${\texttt{rels}}(A),{\texttt{rels}}(B)$ is a subset of the other, or they are disjoint. Hierarchical queries have been used in the seminal dichotomy results of efficient query evaluations in probabilistic databases by Dalvi and Suciu (e.g., (Dalvi and Suciu, 2012)) that classify queries either as poly-time solvable or #P-hard. Our problem is an optimization problem instead of a counting-like problem of query evaluation in probabilistic databases, and the proof techniques for both hardness and algorithmic results are different.. The first four steps check if the query is empty, has one or two relations, or there is a relation whose all attributes appear in all other relations; then the algorithm returns true. The fifth step looks for a common attribute present in all relations, and the sixth step checks whether two attributes co-occur in all relations. The last simplification step decomposes the query $Q$ into two or more maximal connected components (if possible), which can be achieved by a standard procedure. We form a graph $G_{Q}$ on ${\texttt{rels}}(Q)$ as the vertices. For any two relations $R_{i},R_{j}\in{\texttt{rels}}(Q)$, if there is an attribute $A\in{\texttt{attr}}(R_{i})\cap{\texttt{attr}}(R_{j})$, then we add an edge between $R_{i}$ and $R_{j}$ in $G_{Q}$. Then we decompose $G_{Q}$ into maximal connected components using standard graph-traversal-based algorithms (Cormen et al., 2009) and call the components as $Q^{1},\cdots,Q^{s}$. For instance, if $Q(A,B,C,E,F,G):-R_{1}(A,B),R_{2}(F),R_{3}(B,C),R_{4}(G),R_{5}(C,E)$, then $Q$ can be decomposed into $s=3$ maximal connected components $Q^{1}(A,B,C):-R_{1}(A,B),R_{3}(B,C),R_{5}(C,E)$, $Q^{2}(F):-R_{2}(F)$, and $Q^{3}(G):-R_{4}(G)$.

Before we prove Theorem 3.1, we give some examples illustrating the application of the theorem (we omit the attributes in the head of the queries).

Example 3.2.

• •

Consider $Q_{0}(\cdots):-$ $R_{1}(A,B)$, $R_{2}(F,G)$, $R_{3}(B,C,E)$, $R_{4}(C,E)$, $R_{5}(G,H)$ (also see Figure 2). Observe that the first four simplifications cannot be applied to $Q_{0}$. Since $rels(C)=rels(E)$, CoOccurrence-6 gives $Q_{0\hskip 2.84526ptC,E\rightarrow K}$. Next, Decomposition-7 is applied which gives $Q^{1}$ (with $R_{1},R_{3},R_{4}$) and $Q^{2}$ (with $R_{2},R_{5}$). The query $Q^{2}$ has two relations so it returns true. However, All simplifications fail for $Q^{1}$, so it returns false. In turn, IsPtime for $Q_{0\hskip 2.84526ptC,E\rightarrow K}$ and $Q_{0}$ return false. Therefore $Q_{0}$ is a hard query.

• •

Consider the queries $Q_{1}$ and $Q_{2}$ given in the introduction. None of the simplification steps can be applied to both these queries, so these two queries are NP-hard (albeit the NP-hardness for these two queries are shown by two different proof techniques as shown Lemma 3.6 and Lemma 3.7).

• •

Consider $Q_{3}(\cdots)$ $:-$ $R_{1}(A,P)$, $R_{2}(A,P,M)$, $R_{3}(A,P,G)$, $R_{4}(A,B,C)$, $R_{5}(A,C,E)$, $R_{6}(F)$. Here first we apply Decomposition-7 to separate $R_{6}$, which is a single relation, and therefore returns true. For $R_{1},\cdots,R_{5}$, first CommonAttribute-5 is applied to remove $A$. Then Decomposition-7 is again applied to partition into $R_{1},R_{2},R_{3}$ and $R_{4},R_{5}$. The intermediate query for $R_{4},R_{5}$ returns true as there are two relations. For $R_{1},R_{2},R_{3}$, Subset-4 is applied and returns true as $P$ is the only remaining attribute in $R_{1}$ and it belongs both $R_{2}$ and $R_{3}$. In turn, all the intermediate queries and the original query return true. By Theorem 3.1, this query is poly-time solvable, and an optimal solution can be obtained by applying Algorithm 2 in Section 3.2.

In our hardness proofs and in our algorithms, we use the recursion-tree of query $Q_{0}$ capturing the repeated use of ${\textsc{IsPtime}}(Q)$ for intermediate queries $Q$ within ${\textsc{IsPtime}}(Q_{0})$, which is defined as follows.

Definition 3.3.

Let $Q_{0}$ be the query that is given as the initial input to Algorithm 1. The recursion-tree of $Q_{0}$ is a tree $T$ where the non-leaf nodes denote intermediate CQs $Q$ for which ${\textsc{IsPtime}}(Q)$ has been invoked during the execution of ${\textsc{IsPtime}}(Q_{0})$. The leaves in $T$ are true or false. The root is $Q_{0}$.

If one of the first four steps is applied to an intermediate query $Q$, we add a single leaf child to $Q$ and assign true. If no simplifications can be applied, we add a leaf node with value false as the child of query $Q$. If CoOccurrence-6 is applied in Algorithm 1, we add a single child $Q_{A,B\rightarrow C}$ of $Q$ (see Algorithm 1). If CommonAttribute-5 is applied, we add a single child $Q_{-A}$ of $Q$. If Decomposition-7 is applied, we add $s$ children $Q^{1},\cdots,Q^{s}$ where $s$ is the number of connected components.

We prove Theorem 3.1 in the next two subsections. First, in Section 3.1 we show that if Algorithm 1 returns false for a query $Q$, then ${\texttt{GDP}}(Q,k,D)$ is NP-hard for $Q$. Then in Section 3.2 we give algorithms to solve the ${\texttt{GDP}}(Q,k,D)$ problem in polynomial time for all $k$ and $D$ when ${\textsc{IsPtime}}(Q)$ returns true.

3.1. Hardness

The proof of hardness is divided into two parts. In the first part we argue that for the last three simplification steps that call the IsPtime algorithm recursively, hardness of the query is preserved (proved in Appendix A due to space constraints). In particular, the last step Decomposition-7 needs a careful construction here to ensure a poly-time reduction, which we prove in two steps. First we show that an immediate application of Decomposition-7 gives a poly-time reduction showing NP-hardness, but it leads to a polynomial increase in the instance size. Then we show how the NP-hardness can be obtained up to the original query $Q_{0}$ still incurring a polynomial increase in the problem size. In the first four simplification steps the algorithm returns true, so we do not need to consider them.

In the second part we argue that if all the simplification steps fail, then the problem is NP-hard, which we discuss below.

The NP-hard problem that we use to prove the NP-hardness of GDP is the partial vertex cover problem for bipartite graphs (PVCB) defined as follows.

Definition 3.4.

The input to the PVCB problem is an undirected bipartite graph $G(U,V,E)$ where $E$ is the set of edges between two sets of vertices $U$ and $V$, and an integer $k$. The goal is to find a subset $S\subseteq U\cup V$ of minimum size such that at least $k$ edges from $E$ have at least one endpoint in $S$. The PVCB problem has been shown to be NP-hard ((Caskurlu et al., 2017))333The value of $k$ in the hard instance of PVCB in (Caskurlu et al., 2017) is not a constant, hence the complexity of GDP for constant $k>1$ remains open..

We use a reduction from the PVCB problem when all the simplification steps fail in Algorithm 1. An example, proved in Appendix B, is the query $Q_{2-path}(A,B):-R_{1}(A),R_{2}(A,B),R_{3}(B)$ for paths of length two, where $A,B$ can correspond to $U,V$ for an easy reduction. However, the relations and attributes can form a more complex pattern like $R_{1}(A,B),R_{2}(B,H),R_{3}(C,E,B),R_{4}(E,H,A)$. The goal is to show that when the algorithm return false, there is a way to assign edges and vertices to the relations in $Q$.

Lemma 3.5.

If none of the simplification steps in Algorithm 1 can be applied for an intermediate query $Q$, all the following hold:

• (1)

$Q$* has at least three relations, all with at least one attribute.*

• (2)

There are no common attributes in all relations.

• (3)

For any two attributes $A,B\in{\texttt{attr}}(Q)$, ${\texttt{rels}}(A)\neq{\texttt{rels}}(B)$, i.e., two attributes cannot belong to the exact same set of relations.

• (4)

The relations form a single connected components in terms of their attributes.

Proof.

If these properties do not hold, simplification steps TwoRelations-3 (and SingleRelation-2), CommonAttribute-5, CoOccurrence-6, and Decomposition-7 can still be applied. ∎

Next we argue that if none of the simplification steps can be applied, there is a reduction from the partial vertex cover (PVCB) problem described in Lemma B.1. We divide the proof in two cases. First in Lemma 3.6 we show that if there are two relations in $Q$ that do not share any attribute, then GDP is NP-hard for $Q$. Then in Lemma 3.7 we show that if this condition does not hold, i.e., if for any two relations in $Q$ there is a common attribute, even then GDP is NP-hard for $Q$.

Lemma 3.6.

If none of the simplification steps in Algorithm 1 can be applied for an intermediate query $Q$, and if there are two relations $R_{i},R_{j}$ in ${\texttt{rels}}(Q)$ such that ${\texttt{attr}}(R_{i})\cap{\texttt{attr}}(R_{j})=\emptyset$, then ${\texttt{GDP}}(Q,k,D)$ is NP-hard for some $k,D$.

Proof.

Consider two relations $R_{i},R_{j}$ in ${\texttt{rels}}(Q)$ such that ${\texttt{attr}}(R_{i})\cap{\texttt{attr}}(R_{j})=\emptyset$. We give a reduction from the PVCB problem (Definition 3.4). Let $G(U,V,E)$ and $k$ be the input to the PVCB problem. The value of $k$ remains the same and we create instance $D$ as follows. For every vertex $u\in U$, we include a tuple $t_{u}=(u,u,\cdots,u)$ to $R_{i}$ such that for every attribute $A\in{\texttt{rels}}(R_{i})$, $t_{u}.A=u$. Similarly, for every vertex $v\in V$, we include a tuple $t_{v}=(v,v,\cdots,v)$ to $R_{j}$ such that for every attribute $B\in{\texttt{rels}}(R_{j})$, $t_{v}.B=v$.

Now we grow two connected components of relations $C_{i}$ and $C_{j}$ starting with $C_{i}=\{R_{i}\}$ and $C_{j}=\{R_{j}\}$. We do the following until no more relations can be added to either $C_{i}$ or $C_{j}$. Consider any relation $R_{\ell}$ that has not been added to $C_{i}$ or $C_{j}$. (a) If $R_{\ell}$ shares an attribute $S$ with some relation in $C_{i}$ and an attribute $T$ with some relation in $C_{j}$, it gets tuples $t_{uv}$ for every edge $(u,v)\in E$, where $t_{uv}.S=u$ and $t_{uv}.T=v$; for any other attribute $C\notin{\texttt{attr}}(C_{i})\cup{\texttt{attr}}(C_{j})$, it gets $t_{uv}.C=u$. (b) Otherwise, if $R_{\ell}$ shares an attribute only with some relation in $C_{j}$ but no attributes with any relation in $C_{i}$, it gets tuples $t_{v}$ for every vertex $v\in V$ where $t_{v}.S=v$ for all attributes $S$ in $R_{\ell}$; further we add $R_{\ell}$ to $C_{j}$. (c) Otherwise, if $R_{\ell}$ shares an attribute only with some relation in $C_{i}$ (but not with any relation in $C_{j}$), then $R_{\ell}$ gets tuples $t_{u}$ for every vertex $u\in U$ where $t_{u}.S=u$ for all attributes $S$ in $R_{\ell}$; further, we add $R_{\ell}$ to $C_{i}$.

An example construction is shown in Figure 3.

Note that every relation in $Q$ corresponds to either vertices in $U$ or $V$, or edges in $E$. Clearly at least $R_{i}$ corresponds to $U$ and $R_{j}$ corresponds to $V$. We argue that at least one table $R_{\ell}$ has tuples $t_{uv}$ corresponding to the vertices: this holds from Lemma 3.5 since there are at least three relations, and the relations form a single connected components, otherwise relations that belong to $C_{i}$ and the ones that belong to $C_{j}$ would form two separate connected components.

Now we claim that $PVCB$ has a solution of size $M$ if and only if ${\texttt{GDP}}(Q,k,D)$ has a solution of size $M$. Note that the output tuples in $Q(D)$ correspond to the edges in $E$.

(only if) If $PVCB$ has a solution of size $M$, we can remove the corresponding tuples from $R_{i}$ and $R_{j}$, and remove at least $k$ output tuples corresponding to the edges.

(if) If GDP has a solution of size $M$, we can assume wlog. that the input tuples are only chosen from $R_{i}$ and $R_{j}$: if an input tuple $t_{u}$ is chosen from $R_{\ell}\in C_{i}$ (respectively, $C_{j}$), we replace it with the corresponding tuple in $R_{i}$ (respectively, $R_{j}$). If an input tuple $t_{uv}$ is chosen from a relation that shares attributes with both $C_{i}$ and $C_{j}$, we replace it with the corresponding $t_{u}$ from $R_{i}$. This removes at least the original tuples as before without increasing the cost. Now tuples from $R_{i}$ and $R_{j}$ corresponds to a solution of the PVCB problem that removes at least $k$ edges corresponding to the output tuples removed in ${\texttt{GDP}}(Q,k,D)$. ∎

Next, we show the NP-hardness for the other case when any two relations share at least one attribute. We again give a reduction from the PVCB problem, where the input is a bipartite graph $G(U,V,E)$ and integer $k$. Given the relations in $Q$, we identify three relations where the tuples can correspond to $U,V,$ and $UV$ respectively. However, unlike the reduction in Lemma 3.6, we may assign a constant value $*$ to all the tuples for some attributes in some tables. Due to the problem stated before Lemma A.3, we will ensure that no table in $Q$ receives such a constant value for all attributes. Otherwise this table will have a single tuple $(*,*,\cdots,*)$, and removing this tuple, will remove all output tuples from $Q(D)$ with only cost 1. We aim to identify the following (the relation names are chosen wlog.): (i) a relation $R_{1}$ corresponding to $U$, where attributes correspond to $U$ or $*$ (and not $V$), and at least one attribute corresponds to $U$, (ii) a relation $R_{3}$ corresponding to $V$, where attributes correspond to $V$ or $*$ (and not $U$), and at least one attribute corresponds to $V$, and (iii) a relation $R_{2}$ corresponding to $E$, where attributes correspond to $U,V$ or $*$, and there are at least two attributes corresponding to $U$ and $V$ that together capture the edges in $E$. The other relations can have attributes corresponding to $U,V,$ or $*$, but no relation can have only attributes that take the constant value $*$. We give the formal reduction below by proving the following lemma.

Lemma 3.7.

If none of the simplification steps in Algorithm 1 can be applied for an intermediate query $Q$, and if for any two relations $R_{i},R_{j}$ in ${\texttt{rels}}(Q)$ it holds that ${\texttt{attr}}(R_{i})\cap{\texttt{attr}}(R_{j})\neq\emptyset$, then ${\texttt{GDP}}(Q,k,D)$ is NP-hard for some $k,D$.

Proof.

We give a reduction from the PVCB problem, where the input is a bipartite graph $G(U,V,E)$ and integer $k$ (see Definition 3.4).

We first observe the following property in addition to the properties $(1)-(4)$ in Lemma 3.5.

• (P1)

Any relation in $Q$ has at least two attributes.

Suppose not, i.e., there is only one attribute $A$ in $R_{i}$. Since $R_{i}$ shares attributes with all relations in $Q$, $A$ appears in all relations in $Q$, violating property (2) from Lemma 3.5.

Recall that ${\mathbb{A}}_{i}={\texttt{attr}}(R_{i})$ denotes the attributes in $R_{i}$. We also use

[TABLE]

to denote the the common attributes in $R_{i}$ and $R_{j}$, where $i<j$. Note that by property (1) of Lemma 3.5, there are at least three relations in $Q$.

• (P2)

There exist three relations, wlog., $R_{1},R_{2},R_{3}$, and two attributes $A,B$ in $Q$ such that $A\in{\mathbb{A}}_{12}\setminus{\mathbb{A}}_{23}$ and $B\in{\mathbb{A}}_{23}\setminus{\mathbb{A}}_{12}$. In other words, $A$ belongs to $R_{1},R_{2}$ but not in $R_{3}$, and $B$ belongs to $R_{2},R_{3}$ but not in $R_{1}$.

To see (P2), start with the relation with the smallest number of attributes as $R_{1}$, breaking ties arbitrarily. Consider its intersection with all other relations (all are non-empty by assumption), and let $R_{2}$ be the relation with smallest number of attributes in the intersection ${\mathbb{A}}_{12}$ with $R_{1}$. If any attribute in ${\mathbb{A}}_{12}$ belongs to ${\mathbb{A}}_{2j}$ for all $j>2$, then it violates property (2) in Lemma 3.5. Therefore, for all $A\in{\mathbb{A}}_{12}$, there is a relation $R_{j}$ such that $A\notin{\mathbb{A}}_{2j}$. Pick any such $A$ and the corresponding $R_{j}$. Now consider ${\mathbb{A}}_{2j}$. We claim that there exists $B\in{\mathbb{A}}_{2j}\setminus{\mathbb{A}}_{12}$. Suppose not. Then ${\mathbb{A}}_{2j}\subseteq{\mathbb{A}}_{12}$. Combining with the fact that there is an $A\in{\mathbb{A}}_{12}\setminus{\mathbb{A}}_{2j}$, ${\mathbb{A}}_{2j}\subset{\mathbb{A}}_{12}$ (a proper subset). This violates the assumption that $R_{2}$ is the relation with smallest number of attributes in the intersection of ${\mathbb{A}}_{12}$ with $R_{1}$. For simplicity, we assume $R_{j}=R_{3}$ wlog.

Next we give the reduction from the PVCB problem by creating an instance $D$ for the same $k$ of GDP. $R_{1},R_{3}$ correspond to $U,V$ respectively, whereas $R_{2}$ corresponds to the edges in $E$.

• •

*We include a tuple $t_{u}$ for each $u\in U$ to $R_{1}$ in $D$, where (i) for all $C\in{\mathbb{A}}_{13}$, $t_{u}.C=*$ (all attributes in ${\mathbb{A}}_{13}$ are constant attributes), and (ii) for all $C\in{\mathbb{A}}_{1}\setminus{\mathbb{A}}_{13}$, $t_{u}.C=u$. *

• •

*We include a tuple $t_{v}$ for each $v\in V$ to $R_{3}$ in $D$, where (i) for all $C\in{\mathbb{A}}_{13}$, $t_{v}.C=*$, and (ii) for all $C\in{\mathbb{A}}_{3}\setminus{\mathbb{A}}_{13}$, $t_{v}.C=v$. *

Note that the assignment of values $U,V$ to attributes above is consistent, i.e., no attribute can get both $U$ and $V$. The above assignment is propagated to all other relations $R_{j},j\neq 1,3$, including $R_{2}$ (and by assigning any non-assigned attributes to $U$) as follows. For any other $R_{j}$, where $j\neq 1,3$,

• •

If ${\mathbb{A}}_{j}$ includes an attribute $C\in{\mathbb{A}}_{13}$, it gets constant values in all tuples.

• •

If ${\mathbb{A}}_{j}$ includes an attribute $C\in{\mathbb{A}}_{1}\setminus{\mathbb{A}}_{13}$, it gets values corresponding to $U$.

• •

If ${\mathbb{A}}_{j}$ includes an attribute $C\in{\mathbb{A}}_{3}\setminus{\mathbb{A}}_{13}$, it gets values corresponding to $V$.

• •

If ${\mathbb{A}}_{j}$ includes an attribute $C\notin{\mathbb{A}}_{1}\cup{\mathbb{A}}_{3}$, it gets values corresponding to $U$.

After this assignment, if attributes in ${\mathbb{A}}_{j}$ are assigned to only constant and $U$, we insert tuples of the form $t_{u}$ as in $R_{1}$. If attributes in ${\mathbb{A}}_{j}$ are assigned to only constant and $V$, we insert tuples of the form $t_{v}$ as in $R_{3}$. If attributes in ${\mathbb{A}}_{j}$ are assigned to both $U$ and $V$ (and possibly some constant attributes), we insert tuples of the form $t_{u,v}$ for each edge $(u,v)\in E$ in the same way. Hence at least $R_{2}$ gets tuples of the form $t_{uv}$ corresponding to the edges. The output $Q(D)$ of the query corresponds to the edges in $E$, but there can be multiple attributes for the vertices $u,v$ of an edge $(u,v)$.

An example construction is shown in Figure 4.

Now we argue that PVCB has a solution of size $P$ if and only if GDP has a solution of size $P$.

(only if) If PVCB has a solution $S$ of size $P$ that covers $\geq k$ edges in $G$, we remove the corresponding tuples $t_{u},t_{v}$ from $R_{1}$ and $R_{3}$, which will remove the set of $\geq k$ tuples corresponding to these edges in the output.

(if) If GDP has a solution of size $P$ that removes at least $k$ output tuples, we argue that wlog., we can assume that the tuples are removed only from $R_{1}$ and $R_{3}$. This holds because of the following property:

• (P3)

No relation $R_{j}$ in $Q$ can have all attributes assigned to constant value $*$.

Otherwise, by construction, ${\mathbb{A}}_{j}\subseteq{\mathbb{A}}_{13}\subset{\mathbb{A}}_{1}$ (since at least $A\in{\mathbb{A}}_{1}\setminus{\mathbb{A}}_{13}$). Therefore $R_{j}$ has fewer attributes than $R_{1}$ violating the assumption that $R_{1}$ is the relation with the smallest number of attributes. Hence, we have the following property:

• (P4)

All relations in $Q$ have tuples of the form $t_{u}$ for $U$, $t_{v}$ for $V$, or $t_{uv}$ for $E$.

If any tuple is removed from a $R_{j}$ that has $t_{u}$-s, we replace it with the corresponding tuple from $R_{1}$, and if any tuple is removed from a $R_{j}$ that has $t_{v}$-s, we replace it with the corresponding tuple from $R_{3}$. If any tuple of the form $t_{uv}$ is removed, we replace it with $t_{u}$ from $R_{1}$ that removes at least the same number of output tuples as before without increasing the cost. Hence, in any solution of GDP, we can assume that tuples are removed only from $R_{1},R_{3}$, which corresponds to a solution of the PVCB problem where we remove the corresponding vertices to cover the edges corresponding to the output tuples. ∎

Combining the above results, we get the following lemma:

Lemma 3.8.

If Algorithm 1 returns false for a query $Q_{0}$, i.e., ${\textsc{IsPtime}}(Q_{0})={\texttt{false}}$, there exists $k$ and $D$ such that ${\texttt{GDP}}(Q_{0},k,D)$ is NP-hard.

Proof.

Consider the recursion-tree $T$ of $Q_{0}$. Note that the leaves of $T$ are true or false. Note that if ${\textsc{IsPtime}}(Q)={\texttt{false}}$ for any intermediate query $Q$, there must exist a path from $Q$ to a false leaf and vice versa. We apply induction on the length of the shortest path from an intermediate node to a leaf. For the base case, i.e., when the length = 1, the intermediate query $Q$ at the node has a false child. If there are two relations in ${\texttt{rels}}(Q)$ that do not share any attribute, by Lemma 3.6, GDP for $Q$ is NP-hard. Otherwise, i.e., if no such two relations exist, then by Lemma 3.7, GDP for $Q$ is NP-hard.

Now consider the path from an NP-hard query $Q$ with a false child to the root $Q_{0}$. If at least one node along this path has $\geq 2$ children, i.e., if at least once Decomposition-7 has been invoked, $Q_{0}$ is NP-hard by Lemma A.4.

Otherwise, the path from $Q_{0}$ to a false leaf is unique, and the parent of the false leaf is NP-hard by the base case. Suppose the induction hypothesis holds for the intermediate node $Q$, i.e., $Q$ is NP-hard, where the shortest path length to a false leaf is $\ell$, and consider the intermediate node $Q^{\prime}$ that is parent of $Q$, and for which the shortest path length to a is $\ell+1$. If $Q$ is formed from $Q^{\prime}$ by CommonAttribute-5, then by Lemma A.1 $Q^{\prime}$ is NP-hard. Otherwise, $Q$ is formed from $Q^{\prime}$ by CoOccurrence-6, and by Lemma A.2 $Q^{\prime}$ is NP-hard, proving the hypothesis. Repeating this argument, $Q_{0}$ is again NP-hard. ∎

3.2. Algorithms

If Algorithm 1 returns true for a query $Q$, we can find an optimal solution of ${\texttt{GDP}}(Q,k,D)$ by running Algorithm 2. For each of the simplification step except the trivial case of empty query, we give a procedure that optimally solves that case, possibly using subsequent calls to ComputeOpt. Note that the first trivial case can never be reached if the original query is non-empty, for instance, if $Q(A):-R_{1}(A),R_{2}(A),R_{3}(A)$, before CommonAttribute-5 is applied, instead Subset-4 will be invoked, directly returning true in Algorithm 1 and returning an optimal solution in Algorithm 2. In Section 3.2.1, we discuss the helper procedures used in Algorithm 2. The pseudocodes of these procedures may suggest that ComputeOpt is invoked recursively within these procedures. However, to ensure polynomial data complexity, we solve the problem bottom-up, and instead of recursive calls, use look ups from these pre-computed values, which is discussed in Section 3.2.2. Due to space constraints, all the pseudocodes of Section 3.2.1 are given in the appendix.

3.2.1. Details of the procedures in Algorithm 2

**1. Procedure ${\textsc{SingleRelation}}(Q,k,D)$. ** Suppose $Q({\mathbb{A}}_{i}):-R_{i}({\mathbb{A}}_{i})$ be the query. We return any $k$ tuples from relation $R_{i}$ as the solution. Since there is no joins, each output tuple corresponds to a unique input tuple, and we can remove any $k$ input tuples to remove $k$ output tuples.

**2. Procedure ${\textsc{TwoRelations}}(Q,k,D)$. ** Suppose $Q({\mathbb{A}}_{1}\cup{\mathbb{A}}_{2}):-R_{i}({\mathbb{A}}_{1}),R_{j}({\mathbb{A}}_{2})$ be the query (wlog.). The pseudocode is given in Algorithm 3. There can be two cases.

(a) If $R_{1},R_{2}$ do not share any attribute, i.e., ${\mathbb{A}}_{1}\cap{\mathbb{A}}_{2}=\emptyset$, all tuples from $R_{1}$ join with all tuples from $R_{2}$ to form $Q(D)$. Let $n_{1},n_{2}$ be the number of tuples from $R_{1},R_{2}$ respectively. Suppose $n_{1}\leq n_{2}$. Then any tuple in $R_{1}$ removes exactly $n_{2}$ tuples from the output, which is higher than the number of tuples that a tuple from $R_{1}$ removes. In particular, consider any optimal solution $OPT$ and suppose it includes $s_{1}$ tuples from $R_{1}$ and $s_{2}$ tuples from $R_{2}$ that together remove at least $k$ output tuples. Removing the overlaps, we have, $N_{OPT}=s_{1}n_{2}+s_{2}n1-s_{1}s_{2}$. Consider another solution $S$ that replaces all $s_{2}$ of $R_{2}$-tuples from $OPT$ by $s_{2}$ tuples from $R_{1}$ that have not been chosen yet. Now the number of output tuples deleted $N_{S}=(s_{1}+s_{2})n_{2}=N_{OPT}+(n_{2}-n_{1})s_{2}+s_{1}s_{2}\geq N_{OPT}$ since $n_{2}\geq n_{1}$. Hence we always get an optimal solution by removing tuples from $R_{1}$, and any ${\lceil\frac{k}{n_{1}}\rceil}$ of $R_{1}$-tuples remove at least $k$ output tuples.

(b) Otherwise, let ${\mathbb{A}}_{12}={\mathbb{A}}_{1}\cap{\mathbb{A}}_{2}$ be the common attributes in $R_{1},R_{2}$. Let ${\mathbb{a}}_{1},{\mathbb{a}}_{2},\cdots,{\mathbb{a}}_{g}$ be all the distinct value combinations of ${\mathbb{B}}_{12}$ in $D$. We partition $R_{1}$ and $R_{2}$ into $G_{1},\cdots,G_{g}$ and $H_{1},\cdots,H_{g}$ respectively based on these values of ${\mathbb{B}}_{12}$. Hence, when we fix any ${\mathbb{a}}_{i}$, all $R_{1}$-tuples in $G_{i}$ join by a cross product with all $R_{2}$-tuples in $H_{i}$. Therefore, the number of output tuples in $Q(D)$ is $\sum_{i=1}^{g}m_{i}.n_{i}$, where $m_{i}=|G_{i}|,n_{i}=|H_{i}|$ for $i=1$ to $g$. First we sort all these groups in decreasing order of ‘profits’ $p_{i}=\max(m_{i},n_{i})$, which is the maximum number of output tuples removed by removing only tuple from each group. wlog., assume $p_{1}\geq p_{2}\geq\cdots\geq p_{g}$. Consider any group $i$: if $m_{i}\leq n_{i}$, we call $R_{1}$ the better relation of group $i$, else $R_{2}$ is better. We get profit $p_{i}$ by removing tuples from the better relation of group $i$. Following the argument in case (a), it is more beneficial to remove from the better relation. Furthermore, in any optimal solution $OPT$ if a tuple $t_{j}$ has been chosen from group $j>i$ skipping a tuple $t_{i}$ from the better relation of group $i$, $t_{j}$ can be replaced by $t_{i}$ without increasing the cost and removing no fewer than the original number of output tuples. Hence we can assume wlog., that the optimal solution greedily chooses from the better relation of the groups $1,2,\cdots,g$ in this order, which is implemented in the algorithm.

3. Procedure ${\textsc{OneSubset}}(Q,k,D,R_{i})$. Here the attributes in $R_{i}$ form a subset of all other relations in $Q$. The pseudocode is given in Algorithm 4. For every tuple in $R_{i}$, we compute the number of output tuple it contributes to, and choose greedily from a decreasing order on these numbers until $k$ output tuples are chosen.

The algorithm returns optimal solution since given any optimal solution of GDP in this case, we can assume wlog. that all the tuples in the optimal solution belong to $R_{i}$. If any tuple $t$ is chosen from $R_{\ell}\neq R_{i}$, we can choose the corresponding tuple $t^{\prime}=t.{\mathbb{A}}_{i}$ from $R_{i}$ instead, without increasing the cost and decreasing the number of output tuples deleted. Therefore the procedure always chooses from this sorted list, in decreasing order on $m_{j}$.

4. Procedure ${\textsc{CommonAttrPartition}}(Q,k,D,A)$. Here the attribute $A$ belongs to all relations in $Q$. The pseudocode is given in Algorithm 5. First we partition the instance $D$ into $D_{1},\cdots,D_{g}$, corresponding to $a_{1},\cdots,a_{g}$, which are the all possible values of $A$ in $D$. All tuples $t$ in all relations in $D_{i}$ have $t.A=a_{i}$. Note that $Q(D)$ is a disjoint union of $Q(D_{1}),\cdots,Q(D_{i})$.

Here we run a dynamic program to compute the optimal solution OptSol and its cost OptCost. Here ${\textsc{OptCost}}[i][s]$ denotes the minimum number of input tuples to remove at least $s$ output tuples from $Q(D)$ where the input tuples can only be chosen from $D_{1}$ to $D_{i}$. This problem shows an optimal sub-structure property and can be solved with the following dynamic program:

[TABLE]

where $c_{i,m}$ denotes the minimum number of input tuples only from $D_{i}$ that would remove at least $m$ output tuples from $Q(D_{i})$. In other words, the above rules say that, to remove at least $s$ output tuples from $Q(D)$ where the input tuples can only be chosen from $D_{1},\cdots,D_{i}$, we can either choose input tuples from $D_{1},\cdots,D_{i-1}$ that achieve this goal, or we can remove at least $m$ tuples $Q(D_{i})$ by removing $c_{i,m}$ tuples only from $D_{i}$, and take its union with the optimal solution for the rest of the $s-m$ output tuples that have to be removed from $Q(D)$ by only removing tuples from $D_{1},\cdots,D_{i-1}$.

Since $k$ is bounded by the number of output tuples in $Q(D)$ (polynomial in data complexity) and $g$ is bounded by the number of input tuples, the number of cells in OptCost and OptSol is polynomial in data complexity. However, the procedure ${\textsc{CommonAttrPartition}}(Q,k,D,A)$ is invoked in combination with other procedures in Algorithm 2, which makes the total complexity non-obvious. In Section 3.2.2 we discuss how the entire Algorithm 2 can be implemented in polynomial data complexity.

**5. Procedure ${\textsc{CoOccurrence}}(Q,k,D,A,B)$. ** Here ${\texttt{rels}}(A)={\texttt{rels}}(B)$. The pseudocode is given in Algorithm 6. We simply replace both $A,B$ with a new attribute $C$ in all these relations, and assign values $t.C=(a,b)$ where $t.A=a,t.B=b$ in all such relations. Then we call the ComputeOpt procedure to get the optimal solution for this new query and instance. Since the inputs and outputs of the new query $Q_{AB\rightarrow C}$ and instance $D^{\prime}$ have a one-to-one correspondence with the inputs and outputs of the original query $Q$ and instance $D$, an optimal solution (if it exists) of the latter gives an optimal solution to the former by changing the tuples back to their original form.

6. Procedure ${\textsc{DecompCrossProduct}}(Q,k,D,Q^{1},\cdots$, $Q^{s})$. Here $Q^{1},\cdots,Q^{s}$ form maximal connected components, i.e., no relation in $Q^{i}$ share any attribute with any relation in $Q^{j}$ for $i\neq j$. The pseudocode is given in Algorithm 7, which generalizes the first part of Algorithm 3 when two relations combine by a cross-product. The main difference is that, when the sub-queries are arbitrary and not a single relation, then the optimal solution may be required to select tuples from both sides of a partition. Although the output tuples from both partitions still join by cross-product, we do not know apriori how many output tuples to remove from each partition. Consider two disjoint components $Q_{1},Q_{2}$, and let $m_{1},m_{2}$ be the size of $Q_{1}(D)$ and $Q_{2}(D)$ respectively. Note that if an optimal solution $OPT$ removes $k_{1}$ tuples from $Q_{1}(D)$ and $k_{2}$ tuples from $Q_{2}(D)$, the total number of tuples removed from the join of $Q_{1},Q_{2}$ is $k_{1}m_{2}+k_{2}m_{1}-k_{1}k_{2}$, taking into account the tuples removed in the overlap. Algorithm 7 takes two components at a time and aims to find the optimal solution for an arbitrary $s\leq k$, therefore we go over all possible requirements $k_{1},k_{2}$ from $Q_{1}(D)$ and $Q_{2}(D)$ that satisfy $k_{1}m_{2}+k_{2}m_{1}-k_{1}k_{2}\geq s$. The overall polynomial data complexity of Algorithm 2 is discussed in Section 3.2.2.

3.2.2. Poly-time implementation of Algorithm 2

Algorithm 2 recursively calls itself through the helper procedures, and calls ${\textsc{ComputeOpt}}(Q^{\prime},k^{\prime},D^{\prime})$ for many intermediate queries and values of $k^{\prime}\leq k$. Suppose Algorithm 2 is invoked for ${\textsc{ComputeOpt}}(Q_{0},k,D)$. To ensure polynomial running time in data complexity, we first build the recursion-tree $T$ of $Q_{0}$ using Algorithm 1 as defined in Definition 3.3. Since Algorithm 1 runs on the schema of $Q$, it is trivially polynomial in data complexity. If there is a leaf with value false we know that the query $Q$ is NP-hard, and Algorithm 2 would return fail. Otherwise, using this tree and instance $D$, we solve ${\textsc{ComputeOpt}}(Q^{\prime},s,D)$ for each intermediate query $Q^{\prime}$ and value $s=1\cdots k$ in a bottom-up pass. These solutions and their sizes are simply looked up in Algorithms 5, 6, and 7 instead of running ComputeOpt recursively. Since there are a constant number of nodes in the recursion-tree (in data complexity, depends only on the number of relations and attributes), the maximum value of $k$ is $|Q_{0}(D)|$ (polynomial data complexity), and given these values all the algorithms run in polynomial time. Hence, we get a polynomial running time of Algorithm2.

Together with Lemma 3.8, this proves Theorem 3.1.

4. Approximations

In this section, we discuss approximations for optimal solutions to ${\texttt{GDP}}(Q,k,D)$, where full CQ $Q$ contains $p$ relations in its body, $D$ is a given instance of the schema and $k$ is the number of output tuples we want to intervene on. In particular, we give a $p$-approximation for a general setting of our problem.

Recall from Lemma 3.8 that all the simplification steps in Algorithm 1 fail when ${\texttt{GDP}}(Q,k,D)$ is NP-hard. In such cases, we can model the problem as an instance of the Partial Set Cover problem ($k^{\prime}$-PSC).

Definition 4.1.

Given a set of elements $U$, a collection of subsets $\mathcal{S}\subseteq 2^{U}$, a cost function on sets $c:\mathcal{S}\rightarrow\mathcal{Q}^{+}$ and a positive integer $k^{\prime}$, the goal of the Partial Set Cover problem ($k^{\prime}$-PSC) is to pick the minimum cost collection of sets from $\mathcal{S}$ that covers at least $k$ elements in $U$.

Observe the similarity between ${\texttt{GDP}}(Q,k,D)$ and $k^{\prime}$-PSC in that we want to pick the smallest number of input tuples that intervene on at least $k$ output tuples. If there is a cost associated with deleting a specific input tuple, the cost function $c$ can be used to reflect this. Thus, sets correspond to input tuples from relations in the body of CQ $Q$ and elements to output tuples in $Q(D)$. Also, $k^{\prime}=k$.

In (Gandhi et al., 2004), Gandhi et al. give a primal-dual algorithm for partial set cover that generalizes the classic primal dual algorithm for set cover. If every element appears in at most $p$ sets in $\mathcal{S}$, they obtain a $p$-approximation for the problem (see Theorem 2.1 in (Gandhi et al., 2004)). Via a simple approximation preserving reduction given below, we also obtain a $p$-approximation for ${\texttt{GDP}}(Q,k,D)$ (proof in Appendix C).

Theorem 4.2.

${\texttt{GDP}}(Q,k,D)$* has a $p$-approximation, which can be computed via an approximation preserving reduction to $k^{\prime}$-PSC in poly-time.*

5. Conclusions

In this paper, we studied the generalized deletion propagation (GDP) problem for full CQs without self-joins, gave a dichotomy to decide whether GDP for a query is poly-time solvable for all $k$ and instance $D$, and also gave approximation results. Several open questions remain. First, it would be good to study the complexity for larger classes of queries involving projections and/or self-joins, other classes of aggregates like sum, and also instances with arbitrary weights on the input and output tuples. Another interesting direction is to understand the approximability of this problem even for the restricted class of full CQs without self-join. We showed that a $p$-approximation exists where $p$ is the number of tables in the query, but our study of this problem suggests that this bound is not tight. Whether a poly-time algorithm exists giving an absolute constant independent of the schema as the approximation factor remains an interesting open problem.

Appendix A Hardness propagation for simplification steps

In this section we show that for the last three simplification steps in Algorithm 1 that calls the IsPtime function recursively, if the new query $Q^{\prime}$ (or one of the new queries) is NP-hard, then the query $Q$ is NP-hard. While the proofs for the fifth and sixth steps are more intuitive, the proof for the seventh step needs a careful construction.

**Hardness propagation CommonAttribute-5. ** The following lemma shows the hardness propagation for the fifth simplification step in Algorithm 1.

Lemma A.1.

Let $\exists A\in{\texttt{attr}}(Q)$ such that for all relations $R_{i}\in{\texttt{rels}}(Q)$, $A\in{\texttt{attr}}(R_{i})$, and let $Q^{\prime}=Q_{-A}$ be the query formed by removing $A$ from each relation in ${\texttt{rels}}(Q)$. If ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$ is NP-hard, then ${\texttt{GDP}}(Q,k,D)$ is NP-hard.

Proof.

Given an instance of ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$, we construct an instance of ${\texttt{GDP}}(Q,k,D)$ as follows.

First, we claim that no relation $R_{i}$ in $Q^{\prime}$ can have empty set of attributes. Otherwise, $A$ was the single attribute in $R_{i}$, which also appeared in all other relations in $Q$, i.e., $\forall R_{j},~{}{\texttt{attr}}(R_{i})\subseteq{\texttt{attr}}(R_{j})$. Therefore, the condition for Subset-4 is satisfied, which is checked before CommonAttribute-5, and would have returned true. Therefore, all relations in $Q^{\prime}$ has at least one attribute.

For any relation $R_{i}^{\prime}\in{\texttt{rels}}(Q^{\prime})$, if a tuple $t^{\prime}$ appears in $D^{\prime R_{i}^{\prime}}$, create a new tuple $t$ in $D^{R_{i}}$ such that $t.A=*$ (a fixed value for all tuples and all relations in attribute $A$), and for all other attributes $E$, $t.E=t^{\prime}.E$ (there is at least one such $E$). Hence there is a one-to-one correspondence between the tuples in the output $Q(D)$ and $Q^{\prime}(D^{\prime})$, and also in the input $D$ and $D^{\prime}$. Therefore, a solution to ${\texttt{GDP}}(Q,k,D)$ of size $C$ corresponds to a solution to ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$, and vice versa. ∎

**Hardness propagation for CoOccurrence-6. ** Next we show the hardness propagation for the sixth simplification step in Algorithm 1.

Lemma A.2.

Let $A,B\in{\texttt{attr}}(Q)$ such that ${\texttt{rels}}(A)={\texttt{rels}}(B)$. Let $Q^{\prime}=Q_{AB\rightarrow C}$ be the query by replacing $A,B$ with a new attribute $C\notin{\texttt{attr}}(Q)$ in all relations. If ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$ is NP-hard, then ${\texttt{GDP}}(Q,k,D)$ is NP-hard.

Proof.

Given an instance of ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$, we construct an instance of ${\texttt{GDP}}(Q,k,D)$ as follows. Consider any relation $R_{i}^{\prime}\in{\texttt{rels}}(Q^{\prime})$ such that $C\in{\texttt{attr}}(R_{i}^{\prime})$, the corresponding relation $R_{i}$ in $Q$ has both attributes $A,B$ instead of $C$. If a tuple $t^{\prime}$ appears in $D^{\prime R_{i}^{\prime}}$, create a new tuple $t$ in $D^{R_{i}}$ such that $t.A=t.B=t^{\prime}.C$, and for all other attributes $E$, $t.E=t^{\prime}.E$ (i.e., both $A,B$ attributes get the value of attribute $C$ in $D$). Hence there is a one-to-one correspondence between the tuples in the output $Q(D)$ and $Q^{\prime}(D^{\prime})$, and also in the input $D$ and $D^{\prime}$. Therefore, a solution to ${\texttt{GDP}}(Q,k,D)$ of size $C$ corresponds to a solution to ${\texttt{GDP}}(Q^{\prime},k,D^{\prime})$, and vice versa. ∎

**Hardness propagation for Decomposition-7. ** Now we show the hardness propagation for the seventh simplification step. Unlike the above two steps, this step requires a careful construction. For instance, consider a query $Q(A,B,E):-R_{1}(A),R_{2}(A,B),R_{3}(B),R_{4}(E)$, which can be decomposed into two connected components $Q^{1}(A,B):-R_{1}(A),R_{2}(A,B),R_{3}(B)$ and $Q^{2}(E):-R_{4}(E)$. As we show later in Lemma B.1, ${\texttt{GDP}}(Q^{1},k^{\prime},D^{\prime})$ is NP-hard for some $k^{\prime},D^{\prime}$, so although $Q^{2}$ is easy (see Section 3.2), ${\texttt{GDP}}(Q,k,D)$ should be NP-hard for some $k,D$. An obvious approach is to assign a dummy value for $E$ in $R_{4}(E)$ similar to Lemma A.1 above. However, if the number of tuples in $R_{4}$ is one or small in $D$, ${\texttt{GDP}}(Q,k,D)$ gains advantage by removing tuples from $R_{4}$, thereby completely bypassing $Q^{1}$. Therefore, a possible solution is to use a large number of tuples in $R_{4}$ that do not give a high benefit to delete from $R_{4}$, e.g., if it has more than the number of tuples in the output of $Q^{1}$ on $D$ restricted to $R_{1},R_{2},R_{3}$. First, we show the hardness propagation for a single application of Decomposition-7.

Lemma A.3.

Let $Q$ is decomposed into maximal connected components $Q^{1},\cdots,Q^{s}$ where $s\geq 2$. without loss of generality (wlog.), suppose ${\texttt{GDP}}(Q^{1},k^{\prime},D^{\prime})$ is NP-hard. Then, ${\texttt{GDP}}(Q,k,D)$ is NP-hard.

Proof.

Given $Q^{1},k^{\prime},D^{\prime}$, we create $k,D$ as follows. In $D$, all relations in $Q^{1}$ retain the same tuples. For all relations $R_{i}\in\bigcup_{j=2}^{s}{\texttt{rels}}(Q^{j})$, we create $L$ tuples as follows: let us fix $R_{i}$, and let $A_{1},\cdots,A_{u}$ be the attributes in $R_{i}$. $R_{i}$ in $D$ contains $L$ tuples of the form $t_{\ell}=(a_{1,\ell},a_{2,\ell},\cdots,a_{u,\ell})$, for $\ell=1$ to $L$. Similarly, we populate the other relations. Note that in all the relations $R_{i}$ that an attribute $A_{h}$ appears in, it has $L$ values $a_{h,1},\cdots,a_{h_{L}}$. Therefore, any connected component $Q^{2},\cdots,Q^{s}$ except $Q^{1}$ has $L$ output tuples (the components are maximally connected) and each input tuple of a relation participates in exactly one output tuple within the connected component. Since $Q^{1},\cdots,Q^{s}$ are disjoint in terms of attributes, in the output of $Q$, the outputs of each connected component will join in cross products. Suppose $Q^{1}(D^{\prime})$ has $P$ output tuples. Then the number of output tuples in $Q(D)$ is $P\cdot L^{s-1}$. We set $k=k^{\prime}\cdot L^{s-1}$ and $L=P+1$. The size of $D$ is $|D^{\prime}|+L(s-1)$. Since $P\leq|D^{\prime}|^{p^{\prime}}$ (where $p^{\prime}$ is the number of relations in $Q^{1}$), the increase in size of the inputs in this reduction is still polynomial in data complexity. Now we argue that ${\texttt{GDP}}(Q^{1},k^{\prime},D^{\prime})$ has a solution of size $C$ if and only if ${\texttt{GDP}}(Q,k,D)$ has a solution of size $C$.

(only if) If by removing $C$ tuples from ${\texttt{rels}}(Q^{1})$ we remove $k^{\prime}$ tuples from $Q^{1}(D^{\prime})$, then by removing the same $C$ tuples we will remove $k^{\prime}\cdot L^{s-1}$ output tuples from $Q(D)$ by construction as the output tuples from the connected components join by cross product, and each connected component has $L$ output tuples.

(if) Consider a solution to ${\texttt{GDP}}(Q,k,D)$ that removes at least $k=k^{\prime}.L^{s-1}$ tuples from $Q(D)$. Note that any tuple from any relation $R_{i}\in{\texttt{rels}}(Q^{j})$, $j\geq 2$, can remove exactly 1 output tuple from the output of connected component $Q^{j}$ that it belongs to. Therefore, it removes exactly $o_{2}=P.L^{s-2}$ tuples from the output. On the other hand, since we do not have any projection, any tuple from any relation $R_{i}\in{\texttt{rels}}(Q^{1})$ removes at least one output tuple from $Q^{1}(D^{\prime})$, therefore at least $o_{1}=L^{s-1}$ output tuples from $Q(D)$. Since $L=P+1$, $o_{2}<o_{1}$. Therefore, if the assumed solution to ${\texttt{GDP}}(Q,k,D)$ removes any input tuple from any relation belonging to $Q^{2},\cdots,Q^{s}$, we can replace it by any input tuple from the relations in $Q^{1}$ that has not been removed yet without increasing the cost or decreasing the number of output tuples removed. Therefore, wlog. all removed tuples appear in relations in $Q^{1}$. Since $k=k^{\prime}.L^{s-1}$ tuples are removed from $Q(D)$, each tuple in $Q^{1}(D^{\prime})$ removes exactly $L^{s-1}$ tuples from $Q(D)$, and the set of tuples removed from $Q(D)$ by tuples from $Q^{1}(D^{\prime})$ are disjoint, at least $k^{\prime}$ tuples must be removed from $Q^{1}(D^{\prime})$ which gives a solution of cost at most $C$. ∎

Although the above proof requires an exponential blow-up in the size of the query and not the data, there may be multiple application of Decomposition-7 in Algorithm 1 in combination with the other simplification steps. Therefore, we need to ensure that the size of the instance $D$ that we create from $D^{\prime}$ is still polynomial in data complexity for the original query that we started with.

Using ideas from Lemmas A.1, A.2, and A.3, below we argue if any application of Decomposition-7 yields a hard query in one of the components, then the query we started with (say $Q_{0}$) is hard. Such an argument was not needed for CommonAttribute-5 and CoOccurrence-6 since in Lemma A.1 and A.2 the reductions do not yield an increase in the size of database instance.

Lemma A.4.

Let $Q_{0}$ be the query that is given as the initial input to Algorithm 1. For any intermediate query $Q^{\prime}$ in the recursion-tree of $Q_{0}$, if ${\texttt{GDP}}(Q^{\prime},k^{\prime},D^{\prime})$ is NP-hard, then ${\texttt{GDP}}(Q_{0},k,D)$ is NP-hard.

Proof.

Consider the recursion-tree  $T$ in which the simplification steps have been applied from $Q_{0}$ to $Q^{\prime}$. Now consider the node $Q^{\prime}$ in $T$ such that ${\texttt{GDP}}(Q^{\prime},k^{\prime},D^{\prime})$ is NP-hard. The instance $D^{\prime}$ is defined on the relations and attributes in $Q^{\prime}$. From $D^{\prime}$, we need to construct an instance $D$ on the relations and attributes in $Q_{0}$.

Consider the path from $Q^{\prime}$ to the root $Q_{0}$. The relations in $Q^{\prime}$ can lose attributes from the corresponding relations in $Q_{0}$ only by steps CommonAttribute-5 and CoOccurrence-6 along this path. For the the attributes that were lost on the path from $Q_{0}$ to $Q^{\prime}$, we populate the values bottom-up from $Q^{\prime}$ to $Q_{0}$ as follows. The relations appearing in $Q^{\prime}$ have the same number of tuples in $D$ and $D^{\prime}$. Moreover, (i) if two variables $A,B$ are replaced by a variable $C$ by CoOccurrence-6, both $A$ and $B$ get the same values of $C$ in the corresponding tuples, (ii) if a variable $A$ is removed by CommonAttribute-5, we replace it by a constant value $*$ in all tuples. Let $Q$ be the query formed by extending the relations in $Q^{\prime}$ with attributes by this process at the root.

Note that the relations in any non-descendant and non-ancestor node $Q_{nad}$ will be disjoint from those in $Q^{\prime}$, but they can share some attributes with $Q$ only by CommonAttribute-5: CommonAttribute-5 is applied before CoOccurrence-6 so multiple attributes co-occurring in all relations will be removed by CommonAttribute-5 not by CoOccurrence-6; further before CoOccurrence-6 can be applied, the decomposition step Decomposition-7 must be called at least once. We take all the relations that do not appear in the ancestors and descendants of $Q^{\prime}$, and do a maximal connected component decomposition on them excluding the attributes that are common with $Q$. Let $s$ be the number of connected components. The tables in the connected components each get $L$ tuples as in the construction of Lemma A.3: consider a relation $R_{i}\notin{\texttt{rels}}(Q)$. (a) if there is an attribute $A\in{\texttt{attr}}(R_{i})\cap{\texttt{attr}}(Q)$, assign $A=*$ in all $L$ tuples, (b) for all other attributes say $(A_{1},\cdots,A_{u})\in{\texttt{attr}}(R_{i})\setminus{\texttt{attr}}(Q)$, $R_{i}$ in $D$ contains $L$ tuples of the form $t_{\ell}=(a_{1,\ell},a_{2,\ell},\cdots,a_{u,\ell})$, for $\ell=1$ to $L$. Therefore, the number of output tuples in each connected component is $L$ and each input tuple from each connected component can remove exactly one output tuple from the component.

An example reduction is shown in Figure 5.

Eventually, $Q_{0}$ is formed by joining $Q$ with the relations in the $s$ connected components. The attribute values $*$ or repeated values due to CommonAttribute-5 and CoOccurrence-6 are not going to impact the number of output tuples.

Now the same reduction as in Lemma A.3 works: we set $k=k^{\prime}.L^{s}$ where $L=P+1$, and $P=$ the number of tuples in $Q^{\prime}(D^{\prime})$. We again argue that ${\texttt{GDP}}(Q^{\prime},k^{\prime},D^{\prime})$ has a solution of size $C$ if and only if ${\texttt{GDP}}(Q_{0},k,D)$ has a solution of size $C$.

(only if) If by removing $C$ tuples from ${\texttt{rels}}(Q^{\prime})$ we remove $k^{\prime}$ tuples from $Q^{\prime}(D^{\prime})$, then by removing the corresponding $C$ tuples from $Q$, we will remove $k^{\prime}\cdot L^{s}$ output tuples from $Q_{0}(D)$, by construction. The output tuples from the $s$ connected components join by cross product, and each connected component has $L$ output tuples.

(if) Consider a solution to ${\texttt{GDP}}(Q_{0},k,D)$ that removes at least $k=k^{\prime}.L^{s}$ tuples from $Q_{0}(D)$. Note that any tuple from any relation $R_{i}\notin{\texttt{rels}}(Q)$, can remove exactly 1 output tuple from the output of connected component that it belongs to. Therefore, it removes exactly $o_{2}=P.L^{s-1}$ tuples from the output. On the other hand, since we do not have any projection, any tuple from any relation $R_{i}\in{\texttt{rels}}(Q)$ removes at least one output tuple from $Q^{\prime}(D^{\prime})$, therefore at least $o_{1}=L^{s}$ output tuples from $Q_{0}(D)$. Since $L=P+1$, $o_{2}<o_{1}$. Therefore, if the assumed solution to ${\texttt{GDP}}(Q_{0},k,D)$ removes any input tuple from any relation belonging to the relations $\notin{\texttt{rels}}(Q)$, we can replace it by any input tuple from the relations in $Q$ that has not been removed yet without increasing the cost or decreasing the number of output tuples removed. Therefore, wlog. all removed tuples appear in relations in $Q$. Since $k=k^{\prime}.L^{s}$ tuples are removed from $Q_{0}(D)$, each tuple in the relations from $Q$ removes exactly $L^{s}$ tuples from $Q_{0}(D)$. Since the set of tuples removed from $Q_{0}(D)$ by tuples from $Q$ are disjoint, and the extension of attributes from relations in $Q^{\prime}$ to those in $Q$ by repeating values or by using a constant $*$ does not have an effect on the number of output tuples, at least $k^{\prime}$ tuples must be removed from $Q^{\prime}(D^{\prime})$, giving a solution of cost at most $C$. ∎

Appendix B GDP for Paths of Length-2 is NP-Hard

Lemma B.1.

For the query $Q_{2-path}(A,B):-R_{1}(A),R_{2}(A,B),R_{3}(B)$, the problem ${\texttt{GDP}}(Q,k,D)$ is NP-hard.

Proof.

We give a reduction from PVCB problem that takes as input $G=(U,V,E)$ and $k$.

Given an instance of the PVCB problem, we construct an instance $D$ of GDP as follows for $Q_{2-path}(A,B):-R_{1}(A),R_{2}(A,B),R_{3}(B)$. For every vertex $u\in U$, we include a tuple $t_{u}=(u)$ in $R_{1}(A)$; similarly, for every vertex $v\in V$, we include a tuple $t_{v}=(v)$ in $R_{3}(B)$. For every edge $(u,v)\in E$ where $u\in U,v\in V$, we include a tuple $t_{uv}=(u,v)$ in $R_{2}(A,B)$. Therefore the output tuples in $Q_{2-path}(D)$ corresponds to the edges in $E$.

We can see that PVCB has a solution of size $C$ if and only if ${\texttt{GDP}}(Q_{2-path},k,D)$ has a solution of size $C$ for the same $k$. The only if direction is straightforward. For the other direction, note that by removing a tuple of the form $t_{uv}$ exactly one tuple from the output can be removed. Hence if any such tuple is chosen by the solution of GDP, it can be replaced by either $t_{u}$ or $t_{v}$ without increasing cost or decreasing the number of output tuples deleted. ∎

Appendix C Proof of Theorem 4.2

Proof.

We prove that the reduction preserves the approximation guarantee in two steps: 1) given an instance of ${\texttt{GDP}}(Q,k,D)$, how to construct an instance of $k^{\prime}$-PSC, and 2) given a solution to $k^{\prime}$-PSC, how to recover a solution to ${\texttt{GDP}}(Q,k,D)$.

Given the full CQ $Q$ containing $p$ relations in its body, namely $R_{1},R_{2},\cdots,R_{p}$, we create a set per input tuple in the $p$ relations, and an element per output tuple in $Q(D)$. Each set contains elements that correspond to the output tuples resulting from the join between the associated input tuple and tuples from other relations in $Q$. It is well-known that the natural join on $R_{1},R_{2},\cdots,R_{p}$ can be computed in poly-time. Moreover, exactly one tuple in each of the $p$ relations participates in the join operation that produces a particular output tuple. Therefore, each element in the $k^{\prime}$-PSC instance belongs to exactly $p$ sets. As a result, the size of the $k^{\prime}$-PSC instance that we create is polynomial in the data complexity of ${\texttt{GDP}}(Q,k,D)$. Moreover, there is a one-on-one correspondence between instances of the two problems.

Lastly, given a $p$-approximate solution to $k^{\prime}$-PSC, we recover a solution to ${\texttt{GDP}}(Q,k,D)$ by picking the tuples associated with the sets in the solution, say $I$. Observe that the sets in $I$ cover $k^{\prime}=k$ elements in $U$. Thus, removing the corresponding input tuples from ${\texttt{GDP}}(Q,k,D)$ will intervene on at least $k$ output tuples. ∎