On the Enumeration Complexity of Unions of Conjunctive Queries

TL;DR

This paper investigates the enumeration complexity of unions of conjunctive queries (UCQs), extending the concept of free-connexity to identify tractable UCQs, including some with intractable components, under various database constraints.

Contribution

It generalizes free-connexity from CQs to UCQs, revealing new tractable classes and providing techniques applicable under dependencies and disequalities.

Findings

Some unions of intractable CQs are tractable.

Free-connexity characterizes tractability in several UCQ classes.

Techniques extend to databases with dependencies and disequalities.

Abstract

We study the enumeration complexity of Unions of Conjunctive Queries(UCQs). We aim to identify the UCQs that are tractable in the sense that the answer tuples can be enumerated with a linear preprocessing phase and a constant delay between every successive tuples. It has been established that, in the absence of self-joins and under conventional complexity assumptions, the CQs that admit such an evaluation are precisely the free-connex ones. A union of tractable CQs is always tractable. We generalize the notion of free-connexity from CQs to UCQs, thus showing that some unions containing intractable CQs are, in fact, tractable. Interestingly, some unions consisting of only intractable CQs are tractable too. We show how to use the techniques presented in this article also in settings where the database contains cardinality dependencies (including functional dependencies and key constraints) or when the UCQs contain disequalities. The question of finding a full characterization of the tractability of UCQs remains open. Nevertheless, we prove that for several classes of queries, free-connexity fully captures the tractable UCQs.

Equations

$$Q_1(x,y)$$

$$Q_2(x,y)$$

$$Q_1(x,y,w)$$

$$Q_2(x,y,w)$$

$$Q_1(x,y,w)$$

$$Q_2(x,y,w)$$

$$Q_1(x,y,v,u)\leftarrow$$

$$Q_2(x,y,v,u)\leftarrow$$

$$Q_3(x,y,v,u)\leftarrow$$

$$Q_1(x,y)$$

$$Q_2(x,y)$$

$$Q_3(x,y)$$

$$Q_1({\vec{v}}_1)$$

$$Q_2({\vec{v}}_2)$$

$$Q_1(h^{-1}({\vec{v}}_1)),Q_2({\vec{v}}_2)\leftarrow R_1({\vec{w}}_1),\dots ,R_n({\vec{w}}_n)$$

$$Q_1(x,y,v)$$

$$Q_2(x,y,v)$$

$$Q_1(w,y,z),Q_2(x,y,v)$$

$$Q_1(w,y,x,z),Q_2(x,y,w,v)\leftarrow R_1(w,v),R_2(v,y),R_3(y,z),R_4(z,x)$$

$$Q_1^{+}(w,y,x,z)\leftarrow R_1(w,v),R_2(v,y),R_3(y,z),R_4(z,x),P_1(v,w,y),$$

$$Q_2^{+}(x,y,w,v)\leftarrow R_1(w,v),R_2(v,y),R_3(y,z),R_4(z,x),P_2(x,y,z).$$

$$Q_1(x,y,u),Q_2(x,y,z)\leftarrow R_1(x,u,z),R_2(y,u,z).$$

$$\tau_{(a,b,c)}(v)=\left\{\begin{array}[]{ll}a&\text{ if }v\in V_{a},\\ b&\text{ if }v\in V_{b},\\ c&\text{ if }v\in V_{c},\\ \bot&\text{ otherwise,}\end{array}\right.$$

$$\tau_{a,b,c}(v)=\left\{\begin{array}[]{ll}a&\text{ if }v\in\{z_{0},z_{2}\},\\ b&\text{ if }v=z_{1},\\ c&\text{ if }v=u,\\ \bot&\text{ otherwise.}\end{array}\right.$$

$$Q_1(x,y,w)$$

$$Q_2(x,y,w)$$

$$Q_1(x_1,x_2,x_3),Q_2(x_1,x_2,z),Q_3(x_1,x_3,z),Q_4(x_2,x_3,z)\leftarrow R_1(x_1,z),R_2(x_2,z),R_3(x_3,z).$$

$$Q_1(x,y,z,w)\leftarrow$$

$$Q_2(x,y,z,w)\leftarrow$$

$$Q_1(x,y,v)$$

$$Q_2(x,y,v)$$

$$Q_1(x,z,y,v)$$

$$Q_2(x,z,y,v)$$

$$Q_1(x_2,x_3,x_4)$$

$$Q_2(x_2,x_3,x_4)$$

$$Q_1(x_2,\dots ,x_k)\leftarrow$$

$$Q_2(x_2,\dots ,x_k)\leftarrow$$

$$Q_1(x,w,u)\leftarrow$$

Full text

1. Introduction

Evaluating a query $Q$ over a database instance $D$ is a fundamental and well-studied problem in database management systems. Most of the complexity results dealing with query evaluation so far aim to solve a decision or counting variant of it. Starting with Durand and Grandjean in 2007 (Durand:constantdelay), there has been a renewed interest in examining the enumeration problem of all answers to a query, focusing on fine-grained complexity (DBLP:conf/pods/SchweikardtSV18; DBLP:conf/pods/NiewerthS18; DBLP:conf/pods/FlorenzanoRUVV18; DBLP:conf/icdt/CarmeliK18). When evaluating a non-Boolean query over a database, the number of results may be larger than the size of the database itself. Enumeration complexity offers specific measures for the hardness of such problems. In terms of data complexity, the best time guarantee we can hope for is to output all answers with a constant delay between consecutive answers. In the case of query evaluation, this enumeration phase comes after a linear preprocessing phase required to read the database and decide the existence of a first answer. The enumeration class achieving these time bounds is denoted by ${\sf DelayC_{lin}}$. Hereafter, we refer to queries in ${\sf DelayC_{lin}}$ as tractable, and queries outside of this class as intractable.

Results by Bagan et al. (bdg:dichotomy) and Brault-Baron (bb:thesis) form a dichotomy that fully classifies which self-join-free Conjunctive Queries (CQs) are in the class ${\sf DelayC_{lin}}$ based on the structure of the query: the class of free-connex queries is exactly the class that admits tractable enumeration. In the years following this dichotomy, much work has been conducted to achieve similar results for other classes of queries (Segoufin:survey). Unions of CQs (UCQs) are a natural extension of CQs, as they describe the union of the answers to several CQs. UCQs form an important class of queries, as it captures the positive fragment of relational algebra. Previous work which implies results on the enumeration complexity of UCQs imposes strong restrictions on the underlying database (segoufin_et_al:LIPIcs:2017:7060; DBLP:conf/pods/SchweikardtSV18). We aim to understand the enumeration complexity of UCQs without such restrictions and based solely on their structure.

Using known methods (strozecki:thesis), it can be shown that a union of tractable problems is again tractable. However, what happens if some CQs of a union are tractable while others are not? Intuitively, one might be tempted to expect a union of enumeration problems to be harder than a single problem within the union, making such a UCQ intractable as well. As we will show, this is not necessarily the case.

Example 1.1.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

Even though $Q_{1}$ is hard while $Q_{2}$ is easy, a closer look shows that $Q_{2}$ contains $Q_{1}$. This means that $Q_{1}$ is redundant, and the entire union is equivalent to the easy $Q_{2}$.

To avoid cases like these, where the UCQ can be translated to a simpler one, it makes sense to consider non-redundant unions. It was claimed that in all cases of a non-redundant union containing an intractable CQ, the UCQ is intractable too (DBLP:conf/icdt/BerkholzKS18). The following is a counter example which refutes this claim.

Example 1.2.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

According to the dichotomy of Bagan et al. (bdg:dichotomy), the enumeration problem for $Q_{2}$ is in ${\sf DelayC_{lin}}$, while $Q_{1}$ is intractable. Yet, it turns out that $Q$ is in fact in ${\sf DelayC_{lin}}$. The reason is that, since $Q_{1}$ and $Q_{2}$ are evaluated over the same database $I$, we can use $Q_{2}(I)$ to find $Q_{1}(I)$. We can compute $Q_{2}(I)$ efficiently, and try to extend every such solution to solutions of $Q_{1}$ with a constant delay: for every new combination $(a,c)$ of an output $(a,b,c)\in Q_{2}(I)$, we find all $d$ values with $(b,d)\in R_{3}^{I}$ and then output the solution $(a,c,d)\in Q_{1}(I)$. The new combinations $(a,c)$ can be detected by storing a lookup table containing $(a,c)$ for every answer $(a,b,c)\in Q_{2}(I)$ generated. This table can be accessed in constant time in the RAM model. Avoiding duplicates in case $Q_{1}$ and $Q_{2}$ share answers requires also storing the previously seen answers, and it is discussed in more details in Section 3. Intuitively, the source of intractability for $Q_{1}$ is the join of $R_{1}$ with $R_{2}$ as we need to avoid duplicates that originate in different $z$ values. The union is tractable since $Q_{2}$ returns exactly this join. ∎

As the example illustrates, to compute the answers to a UCQ in an efficient way, it is not enough to view it as a union of isolated instances of CQ enumeration. In fact, this task requires an understanding of the interaction between several queries. Example 1.2 shows that the presence of an easy query within the union may give us enough time to compute auxiliary data structures, which we can then add to the hard queries in order to enumerate their answers as well. In Example 1.2, we can assume we have a ternary relation holding the result of $Q_{2}$. Then, adding the auxiliary atom $R_{Q_{2}}(x,z,y)$ to $Q_{1}$ results in a tractable structure. We generalize this observation and introduce the concept of union-extended queries. We then use union extensions as a central tool for evaluating the enumeration complexity of UCQs, as the structure of such queries has implications on the tractability of the UCQ.

Interestingly, this approach can be taken a step further: We show that the concept of extending the union by auxiliary atoms can even be used to efficiently enumerate the answers of UCQs that only contain hard queries. By lifting the concept of free-connex queries from CQs to UCQs via union-extensions, we show that free-connex UCQs are always tractable. This gives us a sufficient global condition for membership in ${\sf DelayC_{lin}}$ beyond any classification of individual CQs.

Finding a full characterization of the tractability of UCQs with respect to ${\sf DelayC_{lin}}$ remains an open problem. Nevertheless, we prove that for several classes of queries, free-connexity fully captures the tractable UCQs. A non-free-connex union of two CQs is intractable in the following cases: both CQs are intractable, or they both represent the same CQ up to a different projection. The hardness results presented here use problems with well-established assumptions on the lower bounds, such as Boolean matrix-multiplication (MatrixMultiplication) or finding a clique or a hyperclique in a graph (DBLP:conf/soda/LincolnWW18).

Why is establishing lower bounds on UCQ evaluation, even when it contains only two CQs, a fundamentally more challenging problem than the one for CQs? In the case of CQs, hardness results are often shown by reducing a computationally hard problem to the task of answering a query. The reduction encodes the hard problem to the relations of a self-join-free CQ, such that the answers of the CQ correspond to an answer of this problem (bdg:dichotomy; bb:thesis; DBLP:conf/pods/BerkholzKS17; DBLP:conf/icdt/CarmeliK18). However, using such an encoding for CQs within a union does not always work. Similarly to the case of CQs with self-joins, relational symbols that appear multiple times within a query can interfere with the reduction. Indeed, when encoding a hard problem to an intractable CQ within a union, a different CQ in the union evaluates over the same relations, and may also produce answers. A large number of such supplementary answers, with constant delay per answer, accumulates to a long delay until we obtain the answers that correspond to the computationally hard problem. If this delay is larger than the lower bound we assume for the hard problem, we cannot conclude that the UCQ is intractable.

The lower bounds presented in this article are obtained either by identifying classes of UCQs for which we can use similar reductions to the ones used for CQs, or by introducing alternative reductions. As some cases remain unclassified, we devote a section to inspecting such UCQs, and describing the challenges that will need to be resolved in order to achieve a full classification.

Most of the results in this work refer to the classification of the hardness of UCQs over general database instances with respect to the time it takes to answer them with no space restrictions. Nonetheless, we also discuss the implications of these results when the settings are slightly modified. The first modification we consider is when the database instances are not general, as they are restricted by the schema. Cardinality dependencies are commonly given as part of the database schema to capture the fact that, since we know what our database represents, we know of restrictions on the combinations of values that the relations may hold. Functional Dependencies and key constraints are a special case of cardinality dependencies. In the presence of cardinality dependencies, additional CQs are tractable (DBLP:conf/icdt/CarmeliK18). We show that by combining the approach introduced in this article with the one for identifying tractable CQs in the presence of cardinality dependencies, we can also find additional tractable UCQs over such schemas.

We also inspect UCQs with disequalities. In the case of CQs with disequalities, the disequalities have no effect on the enumeration complexity (bdg:dichotomy). That is, one can simply ignore the disequalities, and the remaining CQ is free-connex if and only if the query is tractable (under the same assumptions used for the hardness of CQs). This irrelevance of disequalities to the enumeration complexity holds also in the case that there are cardinality dependencies in the schema (DBLP:conf/icdt/CarmeliK18). A natural question is: does this happen also with UCQs? We show that the answer is no: a tractable UCQ may become intractable when adding disequalities. We then show how to identify easy UCQs with disequalities using the same techniques we introduce for UCQs without them.

The final modification we consider is that of restricted space. We introduce the time complexity measure of linear partial time, which is more relaxed compared to linear preprocessing and constant delay, and discuss the connection between the two measures. We argue that from a theoretical point of view, when given access to enough space, the two time complexity measures are equivalent, and that from a practical point of view, an algorithm with only the relaxed requirements is sometimes preferable. We discuss the space consumption used in our approach, and demonstrate that in some cases it can be reduced to constant additional space. The question of when exactly this can be done remains open, but we claim in favor of using the measure of linear partial time as an intermediate step for future research.

This article is organized as follows: In Section 2 we provide definitions and state results that we use. Section 3 formalizes how CQs within a union can make each other easier, defines free-connex UCQs, and proves that free-connex UCQs are in ${\sf DelayC_{lin}}$. In Section 4 we prove conditional lower bounds and conclude a dichotomy for some classes of UCQs. Section 5 discusses the future steps required for a full classification, and demonstrates examples of queries of unknown complexity. Section 6 inspects the implications of this work with modified settings: in the presence of cardinality dependencies, with disequalities and with restricted space. Concluding remarks are given in Section 7.

A short version of this article appeared in the 38th ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems (PODS19) (DBLP:conf/pods/CarmeliK19). This article has the following additions. First, it closes some gaps by presenting full proofs to the results stated in the conference version. Second, it includes Section 6, which discusses the implications of this work in additional settings.

2. Preliminaries

In this section we provide preliminary definitions as well as state results that we will use throughout this article.

Unions of Conjunctive Queries

A schema ${\mathcal{S}}$ is a set of relational symbols $\{R_{1},\ldots,R_{n}\}$. We denote the arity of a relational symbol $R_{i}$ as $\operatorname{arity}(R_{i})$. Let ${\it dom}$ be a finite set of constants. A database $I$ over schema ${\mathcal{S}}$ is called an instance of ${\mathcal{S}}$, and it consists of a finite relation $R_{i}^{I}\subseteq{\it dom}^{\operatorname{arity}(R_{i})}$ for every relational symbol $R_{i}\in{\mathcal{R}}$.

Let ${\it var}$ be a set of variables disjoint from ${\it dom}$. A Conjunctive Query (CQ) over schema ${\mathcal{S}}$ is an expression of the form $Q(\vec{p})\leftarrow R_{1}(\vec{v}_{1}),\dots,R_{m}(\vec{v}_{m})$, where $R_{1},\ldots,R_{m}$ are relational symbols of ${\mathcal{S}}$, the tuples $\vec{p},\vec{v}_{1},\ldots,\vec{v}_{m}$ hold variables, and every variable in $\vec{p}$ appears in at least one of $\vec{v}_{1},\ldots,\vec{v}_{m}$. We often denote this query as $Q$. Define the variables of $Q$ as ${\it var}(Q)=\bigcup_{i=1}^{m}\vec{v}_{i}$, and define the free variables of $Q$ as $\operatorname{free}(Q)=\vec{p}$. The variables of $Q$ that are not free are called existential. We call $Q(\vec{p})$ the head of $Q$, and the atomic formulas $R_{i}(\vec{v}_{i})$ are called atoms. We further use $\operatorname{atoms}(Q)$ to denote the set of atoms of Q. We denote by $\operatorname{full}(Q)$ the full version of a CQ $Q$ obtained by adding all variables to the head of $Q$. A CQ is said to be self-join-free if no relational symbol appears in more than one atom.

The evaluation $Q(I)$ of a CQ $Q$ over a database $I$ is the set of all mappings $\mu|_{\operatorname{free}(Q)}$ such that $\mu$ is a homomorphism from $R_{1}(\vec{v}_{1}),\dots,R_{m}(\vec{v}_{m})$ into $I$, and $\mu|_{\operatorname{free}(Q)}$ is the restriction (or projection) of $\mu$ to the variables $\operatorname{free}(Q)$. We refer to such mappings as answers to $Q$ over $I$. To ease notation, we sometimes specify an answer as a tuple $\vec{u}$, and mean that the answer is the mapping that maps $\operatorname{free}(Q)$ to $\vec{v}$. A CQ $Q_{1}$ is contained in a CQ $Q_{2}$, denoted $Q_{1}\subseteq Q_{2}$, if for every instance $I$, $Q_{1}(I)\subseteq Q_{2}(I)$. A homomorphism from $Q_{2}$ to $Q_{1}$ is a mapping $h:{\it var}(Q_{2})\rightarrow{\it var}(Q_{1})$ such that: (1) for every atom $R(\vec{v})$ of $Q_{2}$, $R(h(\vec{v}))$ is an atom in $Q_{1}$; (2) $h(\operatorname{free}(Q_{2}))=\operatorname{free}(Q_{1})$.

A Union of Conjunctive Queries (UCQ) $Q$ is a finite set of CQs, denoted $Q=\bigcup_{i=1}^{\ell}Q_{i}$, where $\operatorname{free}(Q_{i_{1}})=\operatorname{free}(Q_{i_{2}})$ for all $1\leq{i_{1}},{i_{2}}\leq\ell$. Semantically, $Q(I)=\bigcup_{i=1}^{\ell}Q_{i}(I)$. We say that $Q$ is non-redundant if there are no two different CQs $Q_{1}$ and $Q_{2}$ in $Q$ such that there is a homomorphism from $Q_{2}$ to $Q_{1}$. We assume that UCQs are non-redundant; otherwise, an equivalent non-redundant UCQ can be obtained by removing the redundant CQs. Given a UCQ $Q$ and a database instance $I$, we denote by $\text{\sc Decide}\langle Q\rangle$ the problem of deciding whether $Q(I)\neq\emptyset$.

Hypergraphs

A hypergraph ${\mathcal{H}}=(V,E)$ is a set $V$ of vertices and a set $E$ of non-empty subsets of $V$ called hyperedges (sometimes edges). A join tree of a hypergraph ${\mathcal{H}}=(V,E)$ is a tree $T$ where the nodes are the hyperedges of ${\mathcal{H}}$, and the running intersection property holds, namely: for all $u\in V$ the set $\{e\in E\mid u\in e\}$ forms a connected subtree in $T$. A hypergraph ${\mathcal{H}}$ is acyclic if there exists a join tree for ${\mathcal{H}}$.

Two vertices in a hypergraph are neighbors if they appear in a common edge. A cycle in a hypergraph is a sequence of vertices that starts and ends in the same vertex and every two consecutive vertices are neighbors. A hypergraph is chordal if every cycle with at least four distinct vertices has an edge connecting two nonconsecutive vertices of the cycle. Every acyclic graph is chordal (beeri1983desirability).

A clique of a hypergraph is a set of vertices, which are pairwise neighbors in ${\mathcal{H}}$. If every edge in ${\mathcal{H}}$ has exactly $k$ vertices, we call ${\mathcal{H}}$ $k$-uniform. An $l$-hyperclique in a $k$-uniform hypergraph ${\mathcal{H}}$ is a set $V^{\prime}$ of $l>k$ vertices, such that every subset of $V^{\prime}$ of size $k$ forms a hyperedge.

A hypergraph ${\mathcal{H}}^{\prime}$ is an inclusive extension of ${\mathcal{H}}$ if every edge of ${\mathcal{H}}$ appears in ${\mathcal{H}}^{\prime}$, and every edge of ${\mathcal{H}}^{\prime}$ is a subset of some edge in ${\mathcal{H}}$. A tree $T$ is an ext-$S$-connex tree for a hypergraph ${\mathcal{H}}$ if: (1) $T$ is a join-tree of an inclusive extension of ${\mathcal{H}}$, and (2) there is a subtree $T^{\prime}$ of $T$ that contains exactly the variables $S$  (bdg:dichotomy) (see Figure 1).

Classes of CQs

We associate a hypergraph ${\mathcal{H}}(Q)=(V,E)$ to a CQ $Q$ where the vertices are the variables of $Q$, and every hyperedge is a set of variables occurring in a single atom of $Q$. That is, $E=\{\{v_{1},\ldots,v_{n}\}\mid R_{i}(v_{1},\ldots,v_{n})\in\operatorname{atoms}(Q)\}$. With a slight abuse of notation, we identify atoms of $Q$ with edges of ${\mathcal{H}}(Q)$. A CQ $Q$ is said to be acyclic if ${\mathcal{H}}(Q)$ is acyclic

A CQ $Q$ is $S$-connex if ${\mathcal{H}}(Q)$ has an ext-$S$-connex tree, and it is free-connex if it has an ext-$\operatorname{free}(Q)$-connex tree (bdg:dichotomy). Equivalently, $Q$ is free-connex if both $Q$ and $(V,E\cup\{\operatorname{free}(Q)\})$ are acyclic (bb:thesis). A free-path in a CQ $Q$ is a sequence of variables $(x,z_{1},\ldots,z_{k},y)$ with $k\geq 1$, such that: (1) $\{x,y\}\subseteq\operatorname{free}(Q)$ (2) $\{z_{1},\ldots,z_{k}\}\subseteq V\setminus\operatorname{free}(Q)$ (3) It is a chordless path in ${\mathcal{H}}(Q)$: that is, every two succeeding variables are neighbors in ${\mathcal{H}}(Q)$, but no two non-succeeding variables are neighbors. An acyclic CQ has a free-path iff it is not free-connex (bdg:dichotomy).

Computational Model

In this article, we adopt the Random Access Machine (RAM) model with uniform-cost measure and word length $\Theta(\log(n))$ on input of size $n$. Operations such as addition of the values of two registers or concatenation can be performed in constant time. In contrast to the Turing model of computation, the RAM model with uniform-cost measure can retrieve the content of any register via its unique address in constant time.

The input to our problems is a database instance $I$. We denote by $||o||$ the size of an object $o$ (i.e., the number of integers required to store it), whereas $|o|$ is its cardinality. Let $I$ be a database over a schema ${\mathcal{S}}=({\mathcal{R}},\Delta)$. We assume the input database is given by the reasonable encoding suggested by Flum et al. (DBLP:journals/jacm/FlumFG02). Thus, the input is of size $||I||=1+|{\it dom}|+|{\mathcal{R}}|+\sum_{R\in{\mathcal{R}}}{\operatorname{arity}(R)|R^{I}|}$ over integers bounded by $\max\{|{\it dom}|,max_{R\in{\mathcal{R}}}{|R^{I}|}\}$.

As we assume that the word length is $\Theta(\log(||I||))$, the values stored in registers are at most $||I||^{c}$ for some fixed integer $c$. As a consequence, and since we assume that the values may correspond to addresses, the amount of available memory is polynomial in $||I||$. Note that even in more restrictive variants of the RAM model, the size of the registers and the available memory depend on the size of the input (DBLP:journals/amai/Grandjean96). In particular, since we assume that the input fits in memory and each address fits in a register, the registers must contain at least $\log(n)$ bits for an input that requires $n$ registers.

The RAM model enables the construction of large lookup tables that can be queried within constant time. If the available memory is as large as the number of different possible keys, the lookup table can be as simple as initializing the memory to False, and setting the addresses matching the keys to be True. Note that the time for initialization is not an issue due to constant time initialization techniques (MoretShapiro). Solutions such as binary search trees and hash tables can reduce the memory consumption significantly. For example, a lookup table based on a binary search tree only requires linear memory in its content at the cost of a logarithmic factor to the time. In this work, we wish to identify what can and cannot be done within certain time bounds without restrictions on the memory consumption. Thus, we assume in our analysis that the available memory is very large and that we can access lookup tables of polynomial size in constant time.

Enumeration Complexity

Given a finite alphabet $\Sigma$ and binary relation $R\subseteq\Sigma^{*}\times\Sigma^{*}$, the enumeration problem $\text{\sc Enum}\langle R\rangle$ is: given an instance $x\in\Sigma^{*}$, output all $y\in\Sigma^{*}$ such that $(x,y)\in R$. Such $y$ values are often called solutions or answers to $\text{\sc Enum}\langle R\rangle$. An enumeration algorithm ${\mathcal{A}}$ for $\text{\sc Enum}\langle R\rangle$ is a RAM that solves $\text{\sc Enum}\langle R\rangle$ without repetitions. We say that ${\mathcal{A}}$ enumerates $\text{\sc Enum}\langle R\rangle$ with delay $d(|x|)$ if the time before the first output, the time between any two consecutive outputs, and the time between the last output and termination are each bounded by $d(|x|)$. Sometimes we wish to relax the requirements of the delay before the first answer, and specify a preprocessing time $p(|x|)$. In this case, the time before the first output is only required to be bounded by $p(|x|)$. The enumeration class ${\sf DelayC_{lin}}$ is defined as the class of all enumeration problems $\text{\sc Enum}\langle R\rangle$ which have an enumeration algorithm ${\mathcal{A}}$ with preprocessing $p(|x|)\in O(|x|)$ and delay $d(|x|)\in O(1)$. Note that we do not impose a restriction on the memory used. In particular, such an algorithm may use additional constant memory for writing between two consecutive answers.

Let $\text{\sc Enum}\langle R_{1}\rangle$ and $\text{\sc Enum}\langle R_{2}\rangle$ be enumeration problems. There is an exact reduction from $\text{\sc Enum}\langle R_{1}\rangle$ to $\text{\sc Enum}\langle R_{2}\rangle$, denoted as $\text{\sc Enum}\langle R_{1}\rangle\leq_{e}\text{\sc Enum}\langle R_{2}\rangle$, if there exist mappings $\sigma$ and $\tau$ such that: (1) for every $x\in\Sigma^{*}$, $\sigma(x)$ is computable in $O(|x|)$ time; (2) for every $y$ such that $(\sigma(x),y)\in R_{2}$, $\tau(y)$ is computable in $O(1)$ time; and (3) in multiset notation, $\{\tau(y)\mid(\sigma(x),y)\in R_{2}\}=\{y^{\prime}\mid(x,y^{\prime})\in R_{1}\}$. Intuitively, $\sigma$ maps instances of $\text{\sc Enum}\langle R_{1}\rangle$ to instances of $\text{\sc Enum}\langle R_{2}\rangle$, and $\tau$ maps solutions of $\text{\sc Enum}\langle R_{2}\rangle$ to solutions of $\text{\sc Enum}\langle R_{1}\rangle$. If $\text{\sc Enum}\langle R_{1}\rangle\leq_{e}\text{\sc Enum}\langle R_{2}\rangle$ and $\text{\sc Enum}\langle R_{2}\rangle\in{\sf DelayC_{lin}}$, then $\text{\sc Enum}\langle R_{1}\rangle\in{\sf DelayC_{lin}}$ as well (bdg:dichotomy).

Computational Hypotheses

We use the following well-known hypotheses for lower bounds on certain computational problems:

**mat-mul:: **

two Boolean $n\times n$ matrices cannot be multiplied in time $O(n^{2})$. This problem is equivalent to the evaluation of the query $\Pi(x,y)\leftarrow A(x,z),B(z,y)$ over the schema $\{A,B\}$ where $A,B\subseteq\{1,\ldots,n\}^{2}$. It is conjectured that this problem cannot be solved in $O(n^{2})$ time, and the best algorithms today require $O(n^{\omega})$ time, where $2.37<\omega<2.38$ is the matrix multiplication exponent (MatMulLimits).

Remark: mat-mul is the assumption originally used by Bagan et al. (bdg:dichotomy) to show the hardness for CQs. It was later suggested to use a sparse variant of this hypothesis to show the same results (berkholz2020tutorial). Here, we use the original variant, as the sparse variant is not enough to handle cases like Lemma 4.12.

hyperclique**:: **

for all $k\geq 3$, finding a $k$-hyperclique in a $(k-1)$-uniform hypergraph with $n$ vertices is not possible in time $O(n^{k-1})$. When $k=3$, this is the assumption that we cannot detect a triangle in a graph in $O(n^{2})$ time (cycles). When $k>3$, this is a special case of the $(\ell,k)-$ Hyperclique Hypothesis (DBLP:conf/soda/LincolnWW18), which states that, in a $k$-uniform hypergraph of $n$ vertices, $n^{k-o(1)}$ time is required to find a set of $\ell$ vertices such that each of it subsets of size $k$ forms a hyperedge. The hyperclique hypothesis is sometimes called Tetra$\langle k\rangle$ (bb:thesis).

**4-clique:: **

it is not possible to determine the existence of a $4$-clique in a graph with $n$ nodes in time $O(n^{3})$. This is a special case of the $k$-Clique Hypothesis (DBLP:conf/soda/LincolnWW18), which states that detecting a clique in a graph with $n$ nodes requires $n^{\frac{\omega k}{3}-o(1)}$ time, where $\omega$ is again the matrix multiplication exponent.

Enumerating Answers to UCQs

Given a UCQ $Q$ over some schema ${\mathcal{S}}$, we denote by $\text{\sc Enum}\langle Q\rangle$ the enumeration problem $\text{\sc Enum}\langle R\rangle$, where $R$ is the binary relation between instances $I$ over ${\mathcal{S}}$ and sets of mappings $Q(I)$. We consider the size of the query as well as the size of the schema to be fixed. In the case of CQs, Bagan et al. (bdg:dichotomy) showed that a self-join-free acyclic CQ is in ${\sf DelayC_{lin}}$ iff it is free-connex. In addition, Brault-Baron (bb:thesis) showed that self-join-free cyclic queries are not in ${\sf DelayC_{lin}}$. In fact, the existence of a single answer to a cyclic CQ cannot be determined in linear time. We call a CQ difficult if it is self-join-free and not free-connex. Difficult CQs are intractable according to the following dichotomy.

Theorem 2.1 ((bdg:dichotomy; bb:thesis)).

Let $Q$ be a self-join-free CQ.

1. (1)

If $Q$ is free-connex, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$. 2. (2)

If $Q$ is acyclic and not free-connex, then $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, assuming mat-mul. 3. (3)

If $Q$ is cyclic, then $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, as $\text{\sc Decide}\langle Q\rangle$ cannot be solved in linear time, assuming hyperclique.

The positive case of this dichotomy can be shown using the Constant Delay Yannakakis (CDY) algorithm (CDY). It uses an ext-$\operatorname{free}(Q)$-connex tree $T$ for $Q$. First, it performs the classical Yannakakis preprocessing (Yannakakis) over $T$ to obtain a relation for each node in $T$, where all tuples can be used for some answer in $Q(I)$. Then, it considers only the subtree of $T$ containing $\operatorname{free}(Q)$, and joins the relations corresponding to this subtree with constant delay.

3. Upper Bounds via Union Extensions

In this section, we identify tractable UCQs. Section 3.1 discusses unions that contain only tractable CQs. Section 3.2 inspects the requirements from UCQs in ${\sf DelayC_{lin}}$ and proves the Cheater’s Lemma: a tool that allows us to compile several enumeration algorithms into one. In Section 3.3, we introduce the concepts of union extensions and variable sets that a CQ can supply in order to help the evaluation of another CQ in the union. We generalize the notion of free-connexity to UCQs and show that such queries are in ${\sf DelayC_{lin}}$ in Section 3.4.

3.1. Unions of Tractable CQs

Using known techniques (strozecki:thesis, Proposition 2.38) a union of tractable CQs is also tractable.

Theorem 3.1.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ for some fixed $n\geq 1$. If all CQs in $Q$ are free-connex, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

Proof.

Algorithm 1 evaluates a union of two CQs. In case of a union $Q=\bigcup_{i=1}^{\ell}Q_{i}$ of more CQs, we can use this recursively by treating the second query as $Q_{2}\cup\ldots\cup Q_{\ell}$.

By the end of the run, the algorithm prints $Q_{1}(I)\setminus Q_{2}(I)$ over all iterations of line 3, and it prints $Q_{2}(I)$ in lines 5 and 7. Line 5 is called $Q_{1}(I)\cap Q_{2}(I)$ times, so the command $Q_{2}(I).next()$ always succeeds there. For free-connex CQs after linear preprocessing time, the answers can be enumerated in constant delay, and testing whether a given mapping is an answer can be done in constant time (berkholz2020tutorial). Thus, this algorithm runs within the required time bounds. ∎

The technique presented in the proof of Theorem 3.1 has the advantage that it does not require more than constant memory available for writing in the enumeration phase. Alternatively, this theorem is a consequence of the following lemma, which we prove next and gives us a general approach to compile several enumeration algorithms into one.

3.2. The Cheater’s Lemma

In this section, we prove a lemma that is useful to show upper bounds for UCQs even in cases not covered by Theorem 3.1. To get a clearer notion of what it means for a problem to be in the class ${\sf DelayC_{lin}}$, we first define linear partial time.

Definition 3.2 (Linear Partial Time).

An algorithm runs in linear partial time if, for every input $x$, the time before the $n$th output is $O(|x|+n)$.

We claim next that if we relax the requirement of linear preprocessing and constant delay to allow a constant number of linear delay steps, we get linear partial time.

Proposition 3.3.

Let ${\mathcal{A}}$ be an algorithm. If there exist constants $a$, $b$ and $c$ such that, on any input $x$, the time between successive outputs of ${\mathcal{A}}$ is bounded by $a(|x|+n)$ at most $b$ times, where $n$ is the number of answers printed up to that point, and bounded by $c$ otherwise, then ${\mathcal{A}}$ runs in linear partial time.

Proof.

Before the $n$th answer, there are at most $b$ steps with delay larger than constant, and in these cases the delay is bounded by $a(|x|+n)$. Thus, the time in which the $n$th answer is produced is bounded by $ba(|x|+n)+cn\leq(ab+c)(|x|+n)$ for every $n$. ∎

If space is not restricted (as in our case), this relaxation in the phrasing of the requirements does not change the requirements themselves, as we show that any algorithm that runs in linear partial time can be modified to achieve linear preprocessing and constant delay. This can be done using the known technique (CAPELLI2018, Proposition 12) of delaying the results to regularize the delay. In fact, we can further relax the phrasing by allowing a constant number of duplicates per answer.

Lemma 3.4 ((The Cheater’s Lemma)).

Let $P$ be an enumeration problem. The following are equivalent:

1. (1)

$P\in{\sf DelayC_{lin}}$. 2. (2)

*There exist an algorithm ${\mathcal{A}}$ and constants $c$ and $d$ such that: ${\mathcal{A}}$ outputs the solutions to $P$, the time before the *$n$th answer is bounded by $c(|x|+n)$, and every result is produced at most $d$ times.

Proof.

As any algorithm that runs in linear preprocessing and constant delay also runs in linear partial time, the direction 1$\Rightarrow$2 is trivial. We now show the opposite direction.

We describe an algorithm ${\mathcal{A}}^{\prime}$ that simulates ${\mathcal{A}}$, stores all generated results to prevent duplicates and holds back generated results to regularize the delay. ${\mathcal{A}}^{\prime}$ maintains a lookup table containing the results that ${\mathcal{A}}$ generated and a queue containing those that were not yet printed. Both are initialized as empty. ${\mathcal{A}}^{\prime}$ calls ${\mathcal{A}}$. When ${\mathcal{A}}$ returns a result, ${\mathcal{A}}^{\prime}$ checks the lookup table to determine whether it was found before. If it was not, the result is added to both the lookup table and the queue. Otherwise, it is ignored. Since ${\mathcal{A}}$ runs in linear partial time, there exists a constant $c$ such that the $n$th answer to ${\mathcal{A}}$ is obtained after $c(|x|+n)$ operations. ${\mathcal{A}}^{\prime}$ first performs $c|x|$ computation steps, and then after every $cd$ computation steps, it outputs a result from the queue. The queue is never empty when used: ${\mathcal{A}}^{\prime}$ returns its $i$th result after $c|x|+(cd)i=c(|x|+di)$ computation steps; At this time, ${\mathcal{A}}$ produced at least $di$ results, which contain at least $i$ unique results. When it is done simulating ${\mathcal{A}}^{\prime}$, ${\mathcal{A}}$ outputs all remaining results in the queue. By definition, ${\mathcal{A}}^{\prime}$ operates with linear preprocessing time and constant delay. It outputs all results of ${\mathcal{A}}$ with no duplicates since, due to the lookup table, every result enters the queue exactly once. ∎

The Cheater’s Lemma formalizes how much we are allowed to “cheat” in order to show that a problem can be solved with linear preprocessing and constant delay by only showing an algorithm with relaxed requirements. To show that a problem is in ${\sf DelayC_{lin}}$, it suffices to find an algorithm for this problem where the delay is usually constant, but it may be linear a constant number of times, and the number of times every result is produced is bounded by a constant. The allowed linear delay is not only with respect to the input, but also with respect to the already produced answers.

3.3. Union Extensions

As Example 1.2 shows, Theorem 3.1 does not cover all tractable UCQs. We now define union extensions and address the other cases. We first define body-homomorphisms between CQs to have the standard meaning of homomorphism, but without the restriction on the heads of the queries.

Definition 3.5.

Let $Q_{1},Q_{2}$ be CQs.

• •

A body-homomorphism from $Q_{2}$ to $Q_{1}$ is a mapping $h:{\it var}(Q_{2})\rightarrow{\it var}(Q_{1})$ such that for every atom $R(\vec{v})$ of $Q_{2}$, $R(h(\vec{v}))\in Q_{1}$.

• •

If there exists a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$ and vice versa, we say that $Q_{1}$ and $Q_{2}$ are body-homomorphically equivalent.

• •

A body-isomorphism from $Q_{2}$ to $Q_{1}$ is a bijective mapping $h$ such that $h$ is a body-homomorphism from $Q_{2}$ to $Q_{1}$ and $h^{-1}$ is a body-homomorphism from $Q_{1}$ to $Q_{2}$.

• •

If there is a body-isomorphism between $Q_{2}$ and $Q_{1}$, we say that $Q_{1}$ and $Q_{2}$ are body-isomorphic.

The standard definition of a homomorphism from $Q_{2}$ to $Q_{1}$ is then a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$ such that $h(\operatorname{free}(Q_{2}))=\operatorname{free}(Q_{1})$. To demonstrate the definition of a body-homomorphism, consider the UCQ $Q=Q_{1}\cup Q_{2}$ from Example 1.2 with the CQs $Q_{1}(x,y,w)\leftarrow R_{1}(x,z),R_{2}(z,y),R_{3}(y,w)$ and $Q_{2}(x,y,w)\leftarrow R_{1}(x,y),R_{2}(y,w)$. There is a body-homomorphism $h:Q_{2}\rightarrow Q_{1}$ with $h(x)=x$, $h(y)=z$, and $h(w)=y$. However, this is not a body-isomorphism. Body-isomorphic CQs have the same body up to variable renaming (and the renaming is given by the body-isomorphism). Note that body-isomorphic CQs are necessarily body-homomorphically equivalent. The opposite direction holds for self-join-free CQs; that is, if two CQs are self-join-free and body-homomorphically equivalent, then they are necessarily body-isomorphic. We now formalize the way that one CQ can help with evaluating another CQ in the union by supplying variables.

Definition 3.6.

We say that a CQ $Q$ supplies a set $V$ of variables if there exists $S$ such that $V\subseteq S\subseteq\operatorname{free}(Q)$ and $Q$ is $S$-connex. 111The conference version of this article contains a definition of providing variables instead of that of supplying variables. The difference is that the supplied variables are specified in terms of the giving CQ, while the providing variables are specified in terms of the receiving CQ. We need the terminology to refer to the giving CQ to be able to specify a variable set that one CQ supplies and several CQs use, and so we introduced this minor change of naming with respect to the previous version in order to avoid confusion.

When considering again Example 1.2, the query $Q_{2}$ supplies $\{x,y,w\}\subseteq\operatorname{free}(Q_{2})$ as $Q_{2}$ is $\{x,y,w\}$-connex. The following lemma shows why body-homomorphisms and supplying variables play an important role in UCQ enumeration. In case of a body-homomorphism from a supplying CQ $Q_{2}$ to another CQ $Q_{1}$, we can produce an auxiliary relation that contains all possible value combinations of the matching variables in $Q_{1}$. This can be done efficiently while producing some answers to $Q_{2}$. 222The version of Lemma 3.7 as it was phrased in the conference version of this article was incorrect. In fact, it was too strong, and the slightly weaker version given here describes more accurately what we need.

Lemma 3.7.

Let $Q_{2}$ be a CQ that supplies the variables $\vec{v}_{2}$. Given an instance $I$, one can compute with linear time preprocessing and constant delay a set of mappings $M$ from $\operatorname{free}(Q_{2})$ to the domain such that:

• •

$M\subseteq Q_{2}(I)$**

• •

$M$* can be translated in time $O(|M|)$ to a relation $R^{M}$ such that: for every CQ $Q_{1}$ with a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$ and for every answer $\mu_{1}\in\operatorname{full}(Q_{1})(I)$, there is the tuple $\mu_{1}(h(\vec{v}_{2}))\in R^{M}$.*

Proof.

According to Definition 3.6, there exists $\vec{v}_{2}\subseteq S\subseteq\operatorname{free}(Q_{2})$ such that $Q_{2}$ is $S$-connex. Take an ext-$S$-connex tree $T$ for $Q_{2}$, and perform the CDY algorithm (CDY) on $Q_{2}$ while treating $S$ as the free variables. This results in a set $N$ of mappings from the variables of $S$ to the domain such that $N=Q_{2}(I)|_{S}$. Note that, as we mentioned following Theorem 2.1, the CDY algorithm has a preprocessing stage that removes dangling tuples and guarantees that, at its end, there is a relation for each vertex of the tree such that each tuple of such a relation can be used for some answer.

For every mapping $\mu\in N$, we extend it once to obtain a mapping from all variables of $Q_{2}$ as follows. Go over all vertices of $T$ starting from the connected subtree containing $S$ and treating a neighbor of an already treated vertex at every step. Consider a step where in its beginning $\mu$ is a homomorphism from a set $S_{1}$, and we are treating an atom $R(\vec{v},\vec{u})$ where $\vec{v}\subseteq S_{1}$ and $\vec{u}\cap S_{1}=\emptyset$. We take some tuple in $R$ of the form $(\mu(\vec{v}),\vec{t})$ and extend $\mu$ to also map $\mu(\vec{u})=\vec{t}$. Such a tuple exists since the dangling tuples were removed. This extension takes constant time, and in its end we have that $\mu|_{\operatorname{free}(Q_{2})}\in Q_{2}(I)$. Using these extensions, we set $M=\{\mu^{+}|_{\operatorname{free}(Q_{2})}\mid\mu^{+}\text{ is an extension of }\mu\in N\}$. We have that $M\subseteq Q_{2}(I)$. We also have that $M|_{S}=N=Q_{2}(I)|_{S}$, and since $\vec{v}_{2}\subseteq S$, this means that $M|_{\vec{v}_{2}}=Q_{2}(I)|_{\vec{v}_{2}}$. The mappings $M$ are computed with linear preprocessing and constant delay as this is the complexity of the CDY algorithm and the manipulations we describe only require constant time per answer.

We define $R^{M}=\{\mu^{+}(\vec{v}_{2})\mid\mu^{+}\in M\}$. Since $M|_{\vec{v}_{2}}=Q_{2}(I)|_{\vec{v}_{2}}$, this is the same as $\{\mu_{2}(\vec{v}_{2})\mid\mu_{2}\in Q_{2}(I)\}$. Let $Q_{1}$ be a CQ such that there is a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$, and let $\mu_{1}\in\operatorname{full}(Q_{1})(I)$. Since $h$ is a body-homomorphism, for every atom $R(\vec{v})$ in $Q_{2}$, $R(h(\vec{v}))$ is an atom in $Q_{1}$. Since $\mu_{1}$ forms an answer to the full $Q_{1}$, for every such atom $\mu_{1}(h(\vec{v}))\in R^{I}$. This means that $\mu_{1}\circ h|_{\operatorname{free}(Q_{2})}$ is an answer to $Q_{2}$, so there exists $\mu_{2}\in Q_{2}(I)$ such that $\mu_{1}\circ h|_{\operatorname{free}(Q_{2})}=\mu_{2}$. By construction, $\mu_{1}(h(\vec{v}_{2}))=\mu_{2}(\vec{v}_{2})\in R^{M}$. ∎

Note that if the mapping $h$ is not a body-homomorphism, Lemma 3.7 does not hold in general.

Example 3.8.

Consider $Q=Q_{1}\cup Q_{2}$, which is a slight modification of Example 1.2, with

[TABLE]

Since $R_{4}$ is not a relational symbol in $Q_{1}$, there is no body-homomorphism from $Q_{2}$ to $Q_{1}$. If, $R_{4}^{I}={\it dom}$, then we can take the same approach as in Example 1.2, as the answers of $Q_{2}$ form $Q_{1}(I)|_{\{x,z,y\}}$. However, if $R_{4}^{I}$ is smaller, this extra atom may filter the answers to $Q_{2}$, and we do not obtain all of $Q_{1}(I)|_{\{x,z,y\}}$ in general. ∎

During evaluation, a set of supplied variables can form an auxiliary relation, accessible by an auxiliary atom. We call the query with its auxiliary atoms a union extension.

Definition 3.9.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ. An extension sequence for $Q$ is a sequence $Q^{1},\ldots,Q^{N}$ where $Q=Q^{1}$ and for all $1<j\leq N$, $Q^{j}$ is a UCQ of the form $Q_{1}^{j}\cup\ldots\cup Q_{n}^{j}$ such that the following holds. For some relational symbol $R_{j}$ that does not appear in $Q_{j-1}$ and a sequence $\vec{v}_{j}$ of variables supplied by a previous $Q_{p(j)}^{\ell}$ (i.e., $\ell\leq j$ and $1\leq p(j)\leq n$) we have the following for all $i=1,\dots,n$:

• •

$Q_{i}^{j}=Q_{i}^{j-1}$; or

• •

there is a body-homomorphism $h_{{p(j)},i}$ from $Q_{p(j)}^{1}$ to $Q_{i}^{1}$, and $Q_{i}^{j}$ is obtained by adding the atom $R_{j}(h_{{p(j)},i}(\vec{v}_{j}))$ to $Q_{i}^{j-1}$.

If such an extension sequence exists, we call $Q^{N}$ a union extension of $Q^{1}$. Atoms that appear in $Q^{N}$ but not in $Q^{1}$ are called virtual atoms.

Consider Example 1.2 again. We already established that $Q_{2}$ supplies $\{x,y,w\}\subseteq\operatorname{free}(Q_{2})$ and that there is a body-homomorphism $h:{\it var}(Q_{2})\rightarrow{\it var}(Q_{1})$ with $h((x,y,w))=(x,z,y)$. Thus, $Q$ has the union extension that contains $Q_{2}$ and $Q_{1}^{+}(x,y,w)\leftarrow R_{1}(x,z),R_{2}(z,y),R_{3}(y,w),R^{\prime}(x,z,y)$, where $Q_{1}^{+}$ is obtained by adding the virtual atom $R^{\prime}(x,z,y)$ to $Q_{1}$.

3.4. Extension-Based Tractability

Union extensions can transform an intractable query to a free-connex one.

Definition 3.10.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ.

• •

$Q_{1}$ is said to be union-free-connex with respect to $Q$ if it has a free-connex union extension.

• •

$Q$ is free-connex if all CQs in $Q$ are union-free-connex.

Note that the term free-connex for UCQs is a generalization of that for CQs: If a UCQ $Q$ contains only one CQ, then $Q$ is free-connex iff the CQ it contains is free-connex. We next show that tractability of free-connex queries also carries over to UCQs.

Theorem 3.11.

Let $Q$ be a UCQ. If $Q$ is free-connex, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

Proof.

We begin by sketching the proof. For answering $Q$, we describe an algorithm ${\mathcal{A}}$ which is comprised of two phases: a provision phase and a final results phase. In the provision phase, a free-connex union-extension is instantiated for each CQ in the union. In the final results phase, the answers of every CQ in the union are enumerated via their free-connex union-extensions. These answers can be enumerated efficiently using the CDY algorithm (see Theorem 2.1). We will use Lemma 3.7 to generate some answers to $Q$ during the provision phase; this permits us to use more than linear time before the final results phase while still achieving an enumeration algorithm with only linear preprocessing time. We will use the Cheater’s Lemma (Lemma 3.4) to remove duplicates and obtain the time bounds we want.

Initial Algorithm.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$, and take an extension sequence $Q^{1},\ldots,Q^{N}$ where $Q^{1}=Q$ and $Q^{N}$ comprises of free-connex CQs. The provision phase consists of $N-1$ provision steps. Let $I=I^{1}$ be the input database instance. During the $j$th provision step (with $1<j\leq N$), we extend the database instance $I_{j-1}$ into an instance $I_{j}$ that matches $Q^{j}$. We use Lemma 3.7 to generate a set of answers $M_{j}\subseteq Q_{p(j)}^{j-1}(I_{j-1})$ while also computing a relation $R^{M_{j}}$. We set $(R_{j})^{I_{j}}:=R^{M_{j}}$. The other relations remain as they were; that is, $R^{I_{j}}=R^{I_{j-1}}$ for every relational symbol in the UCQ except for $R_{j}$. By the end of the provision phase, the algorithm computes an instance $I_{N}$ that matches $Q^{N}$. Finally, we perform the final results phase where we compute $Q_{i}^{N}(I_{N})$ for every $Q_{i}$ in the union using the CDY algorithm.

Correctness.

We prove that for all $1\leq i\leq n$ and $1\leq j\leq N$ we have that $Q_{i}(I)=Q_{i}^{j}(I_{j})$ by induction on $j$. The base case trivially holds as $Q_{i}(I)=Q_{i}^{1}(I_{1})$ by definition. Now consider the $j$th provision step. Intuitively, answers to an extended CQ are by definition all answers to its previous version that agree with some tuple in the new atom. Since the new atom contains a projection of the answers, the extension has exactly the same answers as its previous version. More formally, let $Q_{e(j)}$ be a CQ extended in step $j$. For every mapping $\mu$, by definition of the extension we have that $\mu\in Q_{e(j)}^{j}(I_{j})$ if and only if both $\mu\in Q_{e(j)}^{j-1}(I_{j-1})$ and $\mu(h(\vec{v}_{j}))\in R_{j}^{I_{j}}$, and these two conditions hold if and only if $\mu\in Q_{e(j)}^{j-1}(I_{j-1})$ since for all $\mu\in Q_{e(j)}^{j-1}(I_{j-1})$ we have that $\mu(h(\vec{v}_{j}))\in R_{j}^{I_{j}}$. This proves that $Q_{e(j)}^{j}(I_{j})=Q_{e(j)}^{j-1}(I_{j-1})$. This shows that for every $Q_{i}$ in the union, $Q_{i}^{j}(I_{j})=Q_{i}^{j-1}(I_{j-1})$. By the induction hypothesis, $Q_{i}^{j-1}(I_{j-1})=Q_{i}(I)$. This concludes the proof that $Q_{i}^{j}(I_{j})=Q_{i}(I)$ for all $j\leq N$, and in particular, $Q^{N}(I_{N})=Q(I)$. Since $Q^{N}(I_{N})=Q(I)$, the final results phase computes all answers to $Q$. Since $Q_{i}(I)=Q_{i}^{j}(I_{j})$ for all $i$ and $j$, the mappings generated by Lemma 3.7 during the provision phase are also answers to $Q$.

The algorithm ${\mathcal{A}}$ we presented so far produces the results we want, but it is not a constant delay enumeration algorithm. It is left to show that ${\mathcal{A}}$ conforms to the conditions of the Cheater’s lemma. This would mean that we can apply the lemma, and conclude that $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

Duplicates.

Overall the algorithm produces results in $N$ provision steps during the provision phase and in $n$ CQ evaluation steps during the final results phase. The results produced at each individual step contain no duplicates. Therefore, every result appears at most $N+n$ times. Since $N$ and $n$ are constants, this is a constant number of duplicates per value.

Delay.

Consider the $j$th provision step. It starts with a preprocessing of time ${\mathcal{O}}(|I_{j-1}|)$ followed by a constant delay enumeration of a set $M_{j}$ of answers. At its end, ${\mathcal{O}}(|M_{j}|)$ time is required to compute the new relation. This means that the delay before the first answer of the $j$th provision step is $O(|I_{j-1}|+|M_{j-1}|)$, and the delay before answers in the provision phase that are not first in their step is constant. During the final results phase, we have $n$ steps in which we apply the CDY algorithm on an extended CQ. Each such step starts with $O(|I_{N}|)$ preprocessing time followed by constant delay. Thus, during the final results phase, there are $n$ times where the delay is $O(|I_{N}|)$, and in other times the delay is constant.

We have that $|I_{j}|=|I_{j-1}|+|R_{j}^{M_{j}}|\leq|I_{j-1}|+|M_{j}|$ for all $1<j\leq N$, and $|I_{1}|=|I|$. By induction, this shows that $|I_{j}|\leq|I|+\sum_{i=2}^{j}{|M_{i}|}$. This means that whenever the delay is not constant, it is linear in the input size plus the number of (not necessarily unique) answers produces thus far. Since there are $n+N$ such times where the delay is not constant, according to Proposition 3.3, the algorithm ${\mathcal{A}}$ runs in linear partial time, and the requirements of the Cheater’s Lemma on the delay are met. ∎

We can now conclude the tractability of Example 1.2. In Section 3.3, we saw that $Q_{1}$ has the union extension $Q_{1}^{+}(x,y,w)\leftarrow R_{1}(x,z),R_{2}(z,y),R_{3}(y,w),R^{\prime}(x,z,y)$. Since $Q_{1}^{+}$ is free-connex (see Figure 2), the CQ $Q_{1}$ is union-free-connex. Since every query in $Q$ is union-free-connex, we have that $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$ by Theorem 3.11.

Remark 1**.**

Example 1.2 is a counter example to a past made claim (DBLP:conf/icdt/BerkholzKS18, Theorem 4.2b). The claim is that if a UCQ contains an intractable CQ and does not contain redundant CQs (a CQ contained in another CQ in the union), then the union is intractable. In contrast, none of the CQs in Example 1.2 is redundant, $Q_{1}$ is intractable, and yet the UCQ is tractable.

The intuition behind the proof of the past claim is reducing the hard CQ $Q_{1}$ to $Q$. This can be done by assigning each variable of $Q_{1}$ with a different and disjoint domain (e.g., by concatenating the variable names to the values in the relations corresponding to the atoms), and leaving the relations that do not appear in the atoms of $Q_{1}$ empty. It is well known that $Q_{1}\subseteq Q_{2}$ iff there exists a homomorphism from $Q_{2}$ to $Q_{1}$ (homomorphism/redundancy). The claim is that since there is no homomorphism from another CQ in the union to $Q_{1}$, then there are no answers to the other CQs with this reduction. However, it is possible that there is a body-homomorphism from another CQ to $Q_{1}$ even if it is not a full homomorphism (the free variables do not map to each other). Therefore, in cases of a body-homomorphism, the reduction from $Q_{1}$ to $Q$ does not work. In such cases, the union may be tractable, as we show in Theorem 3.11. In Lemma 4.3, we use the same proof described here, but restrict it to UCQs where there is no body-homomorphism from other CQs to $Q_{1}$. ∎

The tractability result in Theorem 3.11 is based on the structure of the union-extended queries. This means that the intractability of any query within a UCQ can be resolved as long as another query can supply the right variables. The following example shows that this can even be the case for a UCQ only consisting of non-free-connex CQs. It also illustrates why the definition of union extensions needs to be recursive.

Example 3.12.

Let $Q=Q_{1}\cup Q_{2}\cup Q_{3}$ with

[TABLE]

Each of three CQs is difficult on its own: $Q_{1}$ has the free-path $(x,z_{1},z_{2},z_{3},y)$, while $Q_{2}$ has the free-path $(v,z_{1},u)$, and $Q_{3}$ has the free-path $(x,z_{1},y)$. The CQ $Q_{2}$ supplies $\{x,y,v\}$ as $Q_{2}$ is $\{x,y,v\}$-connex and $\{x,y,v\}$ are free in $Q_{2}$. Since there is a body-homomorphism $h_{2,3}$ from $Q_{2}$ to $Q_{3}$ with $h_{2,3}((x,y,v))=(x,z_{1},y)$, we can extend the body of $Q_{3}$ by the virtual atom $R^{\prime}(x,z_{1},y)$, which yields a free-connex extension $Q_{3}^{+}$ of $Q_{3}$. Similarly, we have that $Q_{3}$ supplies $\{y,v,u\}$, and there is a body-homomorphism $h_{3,2}$ from $Q_{3}$ to $Q_{2}$ with $h_{3,2}((y,v,u))=(v,z_{1},u)$. Extending $Q_{2}$ by $R^{\prime\prime}(v,z_{1},u)$ yields the free-connex extension $Q_{2}^{+}$. Since $Q_{2}^{+}$ and $Q_{3}^{+}$ each supply $\{x,y,v,u\}$, we can add virtual atoms with the variables $(x,z_{1},z_{2},y)$ and $(x,z_{2},z_{3},y)$ to $Q_{1}$. This results in a free-connex extension $Q_{1}^{+}$. The UCQ $Q_{1}^{+}\cup Q_{2}^{+}\cup Q_{3}^{+}$ is a free-connex union extension of $Q$. By Theorem 3.11, $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$. ∎

4. Lower Bounds

In this section, we prove lower bounds for evaluating UCQs within the time bounds of ${\sf DelayC_{lin}}$. Since for CQs we currently only have hardness result when they are self-join free, we focus on unions of self-join-free CQs. We begin with some general observations regarding cases where a UCQ is at least as hard as a single CQ it contains, and then continue to handle other cases. In Section 4.1 we discuss unions containing only difficult CQs, and in Section 4.2 we discuss unions containing two body-isomorphic CQs. In both cases such UCQs may be tractable, and in case of such a union of size two, we show that our results from Section 3 capture all tractable unions.

In order to provide some intuition for the choices we make throughout this section, we first explain where the approach used for proving the hardness of single CQs fails. Consider Example 1.2. The original proof that shows that $Q_{1}$ is hard describes a reduction from Boolean matrix multiplication (bdg:dichotomy, Lemma 26). Let $A$ and $B$ be binary representations of Boolean $n\times n$ matrices, i.e. $(a,b)\in A$ corresponds to a $1$ in the first matrix at index $(a,b)$. Define a database instance $I$ as $R_{1}^{I}=A$, $R_{2}^{I}=B$, and $R_{3}^{I}=\{1,\ldots,n\}\times\{\bot\}$. One can show that $Q_{1}(I)$ corresponds to the answers of $AB$. If $\text{\sc Enum}\langle Q_{1}\rangle\in{\sf DelayC_{lin}}$, we can solve matrix multiplication in time ${\mathcal{O}}(n^{2})$, in contradiction to mat-mul. Since $Q_{2}$ evaluates over the same relations, $Q_{2}$ also produces answers over this construction. Since the number of results for $Q_{2}$ might reach up to $n^{3}$, evaluating $Q$ in constant delay does not necessarily compute the answers to $Q_{1}$ in $O(n^{2})$ time, and does not contradict the complexity assumption.

So in general, whenever we show a lower bound to a UCQ by computing a hard problem through answering one CQ in the union, we need to ensure that the other CQs cannot have too many answers over this construction. The following lemma formalizes the idea that by assigning variables of a CQ with different domains, we can restrict the answers obtained by other CQs.

Lemma 4.1.

Given a CQ $Q_{1}$ over a schema ${\mathcal{S}}$, there exist mappings $\sigma_{\neq}$ and $\tau_{\neq}$ such that for every database instance $I$ over ${\mathcal{S}}$:

• •

$Q_{1}(I)=\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))$* in multiset notation.*

• •

$\sigma_{\neq}(I)$* can be computed in linear time.*

• •

For every CQ $Q_{i}$ over ${\mathcal{S}}$:

• –

$\tau_{\neq}(\mu)$* can be computed in constant time for every answer $\mu\in Q_{i}(\sigma_{\neq}(I))$.*

• –

If there is no body-homomorphism from $Q_{i}$ to $Q_{1}$, $Q_{i}(\sigma_{\neq}(I))=\emptyset$.

• –

If there is no homomorphism from $Q_{i}$ to $Q_{1}$, given $\mu\in Q_{1}(\sigma_{\neq}(I))\cup Q_{i}(\sigma_{\neq}(I))$, it is possible to determine in constant time whether $\mu\in Q_{1}(\sigma_{\neq}(I))$.

Proof.

We define $\sigma_{\neq}$ to assign each variable of $Q_{1}$ with a different and disjoint domain by concatenating the variable names to the values in their corresponding relations. For every atom $R(v_{1},\cdots,v_{m})$ in $Q_{1}$ and tuple $(c_{1},\cdots,c_{m})\in R^{I}$, we add the tuple $((c_{1},v_{1}),\ldots,(c_{m},v_{m}))$ to $R^{\sigma_{\neq}(I)}$. All relations that do not appear in $Q_{1}$ are left empty. We claim that the results of $Q_{1}$ over the original instance are exactly the same as over our construction if we omit the variable names. That is, we define $\tau_{\neq}:{\it dom}\times{\it var}(Q_{1})\rightarrow{\it dom}$ as $\tau_{\neq}((c,v))=c$, and show that $Q_{1}(I)=\tau_{\neq}(Q(\sigma_{\neq}(I)))$. Note the $\sigma_{\neq}$ and $\tau_{\neq}$ can be computed in linear and constant time respectively.

We first prove that $Q_{1}(I)=\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))$. The first direction is trivial: if $\nu|_{\operatorname{free}(Q_{1})}\in Q_{1}(\sigma_{\neq}(I))$, then for every atom $R(\vec{v})$ in $Q_{1}$, $\nu(\vec{v})\in R^{\sigma_{\neq}(I)}$. By construction, $\tau_{\neq}(\nu(\vec{v}))\in R^{I}$, and therefore $\tau_{\neq}\circ\nu|_{\operatorname{free}(Q_{1})}\in Q_{1}(I)$. We now show the opposite direction. If $\mu|_{\operatorname{free}(Q_{1})}\in Q_{1}(I)$, then for every atom $R(v_{1},\cdots,v_{m})$ in $Q_{1}$, $(\mu(v_{1}),\ldots,\mu(v_{m}))\in R^{I}$. By construction, $((\mu(v_{1}),v_{1}),\ldots,(\mu(v_{m}),v_{m}))\in R^{\sigma_{\neq}(I)}$. By defining $f_{\mu}:{\it var}(Q_{1})\rightarrow{\it dom}\times{\it var}(Q_{1})$ as $f_{\mu}(u)=(\mu(u),u)$, we have $f_{\mu}\in Q_{1}(\sigma_{\neq}(I))$. Since $\tau_{\neq}\circ f_{\mu}=\mu$, we have that $\mu|_{\operatorname{free}(Q_{1})}\in\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))$, and this concludes that $Q_{1}(I)\subseteq\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))$.

We now show that $Q_{i}(\sigma_{\neq}(I))=\emptyset$ if there is no body-homomorphism from $Q_{i}$ to $Q_{1}$. Assume by contradiction that there exists such $\mu|_{\operatorname{free}(Q_{i})}\in Q_{i}(\sigma_{\neq}(I))$. This means that for every atom $R(\vec{v})$ in $Q_{i}$, $\mu(\vec{v})\in R^{\sigma_{\neq}(I)}$. By construction, $\mu(\vec{v})$, like all tuples in $R^{\sigma_{\neq}(I)}$, is of the form $((c_{1},v_{1}),\ldots,(c_{m},v_{m}))$ such that $R(v_{1},\ldots,v_{m})$ is an atom in $Q_{1}$. Define $\eta:{\it dom}\times{\it var}(Q_{1})\rightarrow{\it var}(Q_{1})$ as $\eta(c,v)=v$. We have that for every atom $R(\vec{v})$ in $Q_{i}$, $R(\eta(\mu(\vec{v})))$ is an atom in $Q_{1}$. This means that $\eta\circ\mu$ is a body-homomorphism from $Q_{i}$ to $Q_{1}$, which is a contradiction.

It is left to show that, if there is no homomorphism from $Q_{i}$ to $Q_{1}$, given $\mu\in Q_{1}(\sigma_{\neq}(I))\cup Q_{i}(\sigma_{\neq}(I))$, it is possible to determine in constant time whether $\mu\in Q_{1}(\sigma_{\neq}(I))$. As we showed, $Q_{i}$ has answers over $\sigma_{\neq}(I)$ only if there is a body-homomorphism $h$ from it to $Q_{1}$. Since this is not a full homomorphism, $h(\operatorname{free}(Q_{i}))\neq\operatorname{free}(Q_{1})$. Note that by definition of UCQs, the free variables are the same for all CQs in the union, and in particular $\operatorname{free}(Q_{i})=\operatorname{free}(Q_{1})$. If $\mu$ is an answer to $Q_{1}$, then applying $\eta\circ\mu$ on $\operatorname{free}(Q_{1})$ will result in $\operatorname{free}(Q_{1})$. Otherwise (if $\mu$ is an answer to $Q_{i}$), then applying $\eta\circ\mu$ on $\operatorname{free}(Q_{1})=\operatorname{free}(Q_{i})$ will result in $h(\operatorname{free}(Q_{i}))$. Since $h(\operatorname{free}(Q_{i}))\neq\operatorname{free}(Q_{1})$, this helps us distinguish the answers: apply $\eta\circ\mu$ on the $\operatorname{free}(Q_{1})$; if this results in $\operatorname{free}(Q_{1})$, then $\mu$ is an answer to $Q_{1}$; otherwise, $\mu$ is an answer to $Q_{i}$. ∎

Example 4.2.

Consider the union of $Q_{1}(x)\leftarrow R(x,y)$ with $Q_{2}(x)\leftarrow R(y,x)$ and $Q_{3}(x)\leftarrow R(x,x)$. If the input database $I$ has $R^{I}=\{(a,a),(a,b)\}$, then all three queries have $a$ as an answer, and $Q_{2}$ also has $b$. Applying the construction from Lemma 4.1 results in $R^{\sigma_{\neq}(I)}=\{((a,x),(a,y)),((a,x),(b,y))\}$. Then, we have that $Q_{3}(\sigma_{\neq}(I))=\emptyset$ as there is no body-homomorphism from $Q_{3}$ to $Q_{1}$. There is a body-homomorphism from $Q_{2}$ to $Q_{1}$ but no such full homomorphism. We have that $Q_{2}(\sigma_{\neq}(I))=\{(a,y),(b,y)\}$ and $Q_{1}(\sigma_{\neq}(I))=\{(a,x)\}$, and so the answers can be distinguished by the concatenated variable name. Thus, if we are interested only in answers to $Q_{1}$ but we only have the ability to compute the entire UCQ, we can use this construction, ignore the answers containing $y$, and project out the variable names. This will result in the answer $a$ alone.

The following lemma identifies cases where we can encode any arbitrary instance of a CQ to an instance of the union containing it, such that no other CQ in the union returns results.

Lemma 4.3.

Let $Q$ be a UCQ, and let $Q_{1}\in Q$ such that for all $Q_{i}\in Q\setminus\{Q_{1}\}$ there is no body-homomorphism from $Q_{i}$ to $Q_{1}$. Then $\text{\sc Enum}\langle Q_{1}\rangle\leq_{e}\text{\sc Enum}\langle Q\rangle$.

Proof.

This reduction can be performed using the mappings $\sigma_{\neq}$ and $\tau_{\neq}$ defined in Lemma 4.1. For every $Q_{i}\in Q\setminus\{Q_{1}\}$, there is no body-homomorphism from $Q_{i}$ to $Q_{1}$, and therefore $Q_{i}(\sigma_{\neq}(I))=\emptyset$. We now have that $\tau_{\neq}(Q(\sigma_{\neq}(I)))=\bigcup_{Q_{i}\in Q}{\tau_{\neq}(Q_{i}(\sigma_{\neq}(I)))}=\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))$. Since we also know that $\tau_{\neq}(Q_{1}(\sigma_{\neq}(I)))=Q_{1}(I)$, this concludes our reduction. ∎

The lemma above implies that if there is an intractable CQ in a union where no other CQ maps to it via a body-homomorphism, then the entire union is intractable. This also captures cases such as a union of CQs where one of them is hard, and the others contain a relation that does not appear in the hard CQ.

Using the same reduction, a similar statement with relaxed requirements can be made in case it is sufficient to consider the decision problem.

Lemma 4.4.

Let $Q$ be a UCQ, and let $Q_{1}\in Q$ such that for all $Q_{i}\in Q$, either there exists no body-homomorphism from $Q_{i}$ to $Q_{1}$, or $Q_{1}$ and $Q_{i}$ are body-isomorphic. Then $\text{\sc Decide}\langle Q_{1}\rangle\leq\text{\sc Decide}\langle Q\rangle$ via a linear-time many-one reduction.

Proof.

We use the encoding from Lemma 4.1. We know that $Q_{i}(\sigma_{\neq}(I))=\emptyset$ for every CQ $Q_{i}$ with no body-homomorphism to $Q_{1}$. We claim now that a CQ $Q_{j}$ which is body-isomorphic to $Q_{1}$ has an answer iff $Q_{1}$ has an answer. Therefore $Q(\sigma_{\neq}(I))\neq\emptyset$ iff $Q_{1}(\sigma_{\neq}(I))\neq\emptyset$. We know that $Q_{1}$ retains the same answers under this encoding, so in particular $Q_{1}(\sigma_{\neq}(I))=\emptyset$ if and only if $Q_{1}(I)=\emptyset$. Overall this shows that $Q(\sigma_{\neq}(I))\neq\emptyset$ if and only if $Q_{1}(I)\neq\emptyset$.

We now show formally that for body-isomorphic CQs $Q_{1}$ and $Q_{2}$ and database $I$, $Q_{1}(I)\neq\emptyset$ iff $Q_{2}(I)\neq\emptyset$. Let $h$ be a body-homomorphism from $Q_{2}$ to $Q_{1}$. That is, for every atom $R(\vec{v})\in Q_{2}$, we have $R(h(\vec{v}))\in Q_{1}$. If $Q_{1}(I)\neq\emptyset$, then there exists $\mu|_{\operatorname{free}(Q_{1})}\in Q_{1}(I)$, and for every atom $R(h(\vec{v}))\in Q_{1}$, we have $\mu(h(\vec{v}))\in R^{I}$. This means that $\mu\circ h$ is a homomorphism from $Q_{2}$ to $I$, and $\mu\circ h|_{\operatorname{free}(Q_{2})}\in Q_{2}(I)$. So, $Q_{2}(I)\neq\emptyset$. Since there is also a body-homomorphism from $Q_{1}$ to $Q_{2}$, we can show in the same way that if $Q_{2}(I)\neq\emptyset$ then $Q_{1}(I)\neq\emptyset$. ∎

From Theorem 2.1 it follows that deciding whether a cyclic CQ has any answers cannot be done in linear time (assuming hyperclique). Following Lemma 4.4, if a UCQ $Q$ contains a cyclic $Q_{1}$, and the conditions of Lemma 4.4 are satisfied with respect to this CQ, then the entire union cannot be decided in linear time, and thus $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$.

4.1. Unions of Intractable CQs

We now discuss unions containing only CQs classified as hard according to Theorem 2.1. Recall that these are called difficult CQs, and they are self-join-free CQs and not free-connex. The following lemma can be used to identify a CQ on which we can apply Lemma 4.3 or Lemma 4.4.

Lemma 4.5.

Let $Q$ be a UCQ. There exists a query $Q_{1}\in Q$ such that for all $Q_{i}\in Q$ either there is no body-homomorphism from $Q_{i}$ to $Q_{1}$ or $Q_{1}$ and $Q_{i}$ are body-homomorphically equivalent.

Proof.

Consider a longest sequence $(Q^{1},\ldots,Q^{m})$ of CQs from $Q$ such that for every $2\leq j\leq m$ there is a body-homomorphism from $Q^{j}$ to $Q^{j-1}$, but no body-homomorphism in the opposite direction. We claim that $Q_{1}=Q^{m}$ satisfies the conditions of the lemma.

First we show that such a sequence exists. We denote the body-homomorphism from $Q^{j}$ to $Q^{j-1}$ by $\mu^{j}$. It is not possible that the same query appears twice in the sequence: if $Q^{i}=Q^{j}$ where $j>i$, then there is a mapping $\mu^{i+2}\circ\ldots\circ\mu^{j}$ from $Q^{j}=Q^{i}$ to $Q^{i+1}$, in contradiction to the definition of the sequence. Therefore, $m\leq|Q|$, and a longest sequence exists. We now show that $Q^{m}$ satisfies the requirements. First consider some $Q^{j}\in\{Q^{1},\ldots,Q^{m-1}\}$. There is a body-homomorphism from $Q^{m}$ to $Q^{j}$ which is the composition $\mu^{j+1}\circ\ldots\circ\mu^{m}$. Therefore, either there is no body-homomorphism from $Q^{j}$ to $Q^{m}$, or $Q^{m}$ and $Q^{j}$ are body-homomorphically equivalent. In addition, $Q^{m}$ is body-homomorphically equivalent to itself with the identity mapping serving as the body-homomorphisms. It is left to consider CQs that are not on the sequence. Let $Q_{i}\in Q\setminus\{Q^{1},\ldots,Q^{m}\}$. If there is no body-homomorphism from $Q_{i}$ to $Q^{m}$, then we are done. Otherwise, if there is also no body-homomorphism from $Q_{1}$ to $Q^{m}$, then $(Q^{1},\ldots,Q^{m},Q_{i})$ is a longer sequence, contradicting the maximality of the sequence we started with. Therefore, in this case $Q^{m}$ and $Q_{i}$ are body-homomorphically equivalent. Overall we showed that for each query in $Q$ either there is no body-homomorphism from this query to $Q^{m}$ or these two CQs are body-homomorphically equivalent. ∎

Using the results obtained so far, we deduce a characterization of all cases of a union of difficult CQs, except those that contain a pair of body-isomorphic acyclic CQs.

Theorem 4.6.

Let $Q$ be a UCQ of difficult CQs that does not contain two body-isomorphic acyclic CQs. Then, $Q\not\in{\sf DelayC_{lin}}$, assuming mat-mul and hyperclique.

Proof.

Let $Q_{1}$ be a CQ in $Q$ given by Lemma 4.5. By definition, difficult CQs are self-join-free, and so if two CQs in $Q$ are body-homomorphically equivalent, they are also body-isomorphic. We treat the two possible cases of the structure of $Q_{1}$. In case $Q_{1}$ is acyclic, since we know that $Q$ does not contain body-isomorphic acyclic CQs, then for all $Q_{i}\in Q\setminus\{Q_{1}\}$ there is no body-homomorphism from $Q_{i}$ to $Q_{1}$. According to Lemma 4.3, $\text{\sc Enum}\langle Q_{1}\rangle\leq_{e}\text{\sc Enum}\langle Q\rangle$. Since $Q_{1}$ is self-join-free acyclic non-free-connex, we have that $\text{\sc Enum}\langle Q_{1}\rangle\not\in{\sf DelayC_{lin}}$ assuming mat-mul. Therefore $\text{\sc Enum}\langle Q\rangle$ is not in ${\sf DelayC_{lin}}$ either. In case $Q_{1}$ is cyclic, we use Lemma 4.4 to conclude that $\text{\sc Decide}\langle Q_{1}\rangle\leq\text{\sc Decide}\langle Q\rangle$. According to Theorem 2.1, since $Q_{1}$ is self-join-free cyclic, $\text{\sc Decide}\langle Q_{1}\rangle$ cannot be solved in linear time assuming hyperclique. Therefore $\text{\sc Decide}\langle Q\rangle$ cannot be solved in linear time either, and $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$. ∎

In the next example, we demonstrate how the reductions described in Lemma 4.4 and Theorem 2.1 combine in Theorem 4.6.

Example 4.7.

Consider the UCQ $Q=Q_{1}\cup Q_{2}\cup Q_{3}$ with

[TABLE]

The queries $Q_{1}$ and $Q_{2}$ are cyclic, and $Q_{3}$ is acyclic but not free-connex. This union is intractable according to Theorem 4.6. Note that $Q_{1}$ and $Q_{2}$ are body-isomorphic, but there is no body-homomorphism from $Q_{3}$ to $Q_{1}$. The proof of Theorem 2.1 states the following: If $\text{\sc Enum}\langle Q_{1}\rangle\in{\sf DelayC_{lin}}$, then given an input graph $G$, we can use $Q_{1}$ to decide the existence of triangles in $G$ in time $O(n^{2})$, in contradiction to hyperclique. The same holds true for $\text{\sc Enum}\langle Q\rangle$. For every edge $(u,v)$ in $G$ with $u<v$ we add $((u,x),(v,y))$ to $R_{1}^{I}$, $((u,y),(v,z))$ to $R_{2}^{I}$ and $((u,x),(v,z))$ to $R_{3}^{I}$. The query detects triangles: for every triangle $a,b,c$ in $G$ with $a<b<c$, the query $Q_{1}$ returns $((a,x),(b,y))$. The union only returns answers corresponding to triangles:

• •

For every answer $((d,x),(e,y))$ to $Q_{1}$, there exists some $f$ such that $d,e,f$ is a triangle in $G$ with $d<e<f$.

• •

For every answer $((g,z),(h,x))$ to $Q_{2}$, there exists some $i$ such that $g,h,i$ is a triangle in $G$ with $h<i<g$.

• •

The query $Q_{3}$ returns no answers over $I$. ∎

Theorem 4.6 does not cover the case of a UCQ containing acyclic non-free-connex queries with isomorphic bodies. Since this requires a more intricate analysis, we first restrict ourselves to such unions of size two.

4.2. Unions of Two Body-Isomorphic CQs

Consider a set of body-isomorphic CQs. As all of them have the same structure, either every CQ in this set is cyclic, or every CQ is acyclic. In the case of a union of two cyclic CQs, the UCQ is intractable according to Theorem 4.6. So in this section, we discuss the union of body-isomorphic acyclic CQs. Note that, unlike the previous section, we allow a CQ in the union to be free-connex. We first introduce a new notation for body-isomorphic UCQs that we use hereafter in order to simplify the discussion on the query structure.

Consider a UCQ of the form $Q_{1}\cup Q_{2}$, where there exists a body-isomorphism $h$ from $Q_{2}$ to $Q_{1}$. That is, the CQs have the structure:

[TABLE]

By applying $h^{-1}$ to the variables of $Q_{1}$, we can rewrite $Q_{1}$ as $Q_{1}(h^{-1}(\vec{v}_{1}))\leftarrow R_{1}(\vec{w}_{1}),\ldots,R_{n}(\vec{w}_{n})$. Every mapping $\mu$ that is an answer to $Q_{1}$ in its new form can easily be converted to an answer to the original $Q_{1}$ by composing it with $h$. So for simplicity we can assume that $Q_{1}$ is given in the modified form. Since now the two CQs have exactly the same body, we can treat the UCQ as a query with one body and two heads:

[TABLE]

We use this notation from now on for UCQs containing only body-isomorphic CQs. Note that when treating a UCQ as one CQ with several heads, we can use the notation $\operatorname{atoms}(Q)$, as the atoms are the same for all CQs in the union, and the notation $\operatorname{free}(Q_{i})$, as the free variables may differ between different queries $Q_{i}$ in the union. With this notation at hand, we now inspect some examples of two body-isomorphic acyclic CQs.

Example 4.8.

Consider $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

Since $Q_{1}$ and $Q_{2}$ are body-isomorphic, $Q$ can be rewritten as

[TABLE]

In this case we can use the same approach used for single CQs in Theorem 2.1, and show that this UCQ is not in ${\sf DelayC_{lin}}$ assuming mat-mul. Let $A$ and $B$ be binary representations of Boolean $n\times n$ matrices as explained in the beginning of this section. Define a database instance $I$ with $R_{1}^{I}=A$, $R_{2}^{I}=B$, $R_{3}^{I}=\{1,\ldots,n\}\times\{\bot\}$ and $R_{4}^{I}=\{(\bot,\bot)\}$. $Q_{1}(I)$ corresponds to the answers of $AB$, and $|Q_{2}(I)|={\mathcal{O}}(n^{2})$. Assume by contradiction that $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$. Then we find $Q(I)$ in ${\mathcal{O}}(n^{2})$ time. We can distinguish the answers of $Q_{1}$ from those of $Q_{2}$ since the possible assignments to the variables in different queries are from disjoint domains: given an answer $\mu\in Q(I)$, we have that $\mu\in Q_{1}(I)$ if and only if $\mu(v)=\bot$. This means we can solve matrix multiplication in time ${\mathcal{O}}(n^{2})$, which is a contradiction to mat-mul. ∎

A union of two difficult body-isomorphic acyclic CQs may also be tractable. In fact, by adding a single variable to the heads in Example 4.8, we obtain a tractable UCQ.

Example 4.9.

Let $Q$ be the UCQ

[TABLE]

Both CQs are acyclic non-free-connex. As $Q_{2}$ supplies the variables $\{v,w,y\}$ and $Q_{1}$ supplies $\{x,y,z\}$, both CQs have free-connex union extensions:

[TABLE]

By Theorem 3.11 it follows that $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$. ∎

Intuitively, the reason why the reduction of Example 4.8 fails in Example 4.9 is the fact that all the variables of the free-paths in one CQ, which are used to encode matrix multiplication, are free in the other CQ. Indeed, if we encode matrices $A$ and $B$ to the relations of the free path $w,v,y$ in $Q_{1}$, there can be $n^{3}$ answers to $Q_{2}$. The answer set in this case is too large to contradict the assumed lower bound for matrix multiplication. As it turns out, there are cases where we cannot reduce matrix multiplication to a union in this manner, and yet we can show that it is intractable using an alternative problem.

Example 4.10.

Let $Q$ be the UCQ

[TABLE]

This union is intractable under the 4-clique assumption. For a given graph $G=(V,E)$ with $|V|=n$, we compute the set $T$ of all triangles in $G$ in time $O(n^{3})$. Define a database instance $I$ as $R_{1}^{I}=R_{2}^{I}=T$. For every output $\mu|_{\operatorname{free}(Q_{i})}$ in $Q(I)$ with $i\in\{1,2\}$, we know that $(\mu(x),\mu(u),\mu(z))$ and $(\mu(y),\mu(u),\mu(z))$ are triangles. If $\mu(x)\neq\mu(y)$, this means that $\mu((x,y))\in E$ if and only if $(\mu(x),\mu(y),\mu(u),\mu(z))$ forms a 4-clique (see Figure 3). Moreover, for every 4-clique $(a,b,c,d)$ in the graph, we have $(a,b,c)\in Q_{1}(I)$, so this will detect all 4-cliques. Since there are $O(n^{3})$ answers to $Q$, if $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$, we can check whether $\mu((x,y))\in E$ for every answer in $Q(I)$, and determine whether a $4$-clique appears in $G$ in time ${\mathcal{O}}(n^{3})$. ∎

Note that we can use the 4-clique assumption in Example 4.10, since, in addition to the free-path variables, there is another variable in both free-path relations. We now generalize the observations from the examples.

Definition 4.11.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ where $Q_{1}$ and $Q_{2}$ are body-isomorphic.

• •

$Q_{1}$ is said to be free-path guarded if for every free-path $P$ in $Q_{1}$, we have that ${\it var}(P)\subseteq\operatorname{free}(Q_{2})$.

• •

Consider a path $P=(u_{1},\ldots u_{k})$ in $Q_{1}$. Two atoms $R_{1}(\vec{v}_{1})$ and $R_{2}(\vec{v}_{2})$ of $Q_{1}$ are called subsequent $P$-atoms if $\{u_{i-1},u_{i}\}\subseteq\vec{v}_{1}$ and $\{u_{i},u_{i+1}\}\subseteq\vec{v}_{2}$ for some $1<i<k$.

• •

$Q_{1}$ is said to be bypass guarded if for every free-path $P$ in $Q_{1}$ and variable $u$ that appears in two subsequent $P$-atoms, we have that $u\in\operatorname{free}(Q_{2})$.

Note that every free-connex CQ is trivially free-path guarded and bypass guarded.

Let us demonstrate the definitions on the recent examples. The CQ $Q_{1}$ of Example 4.9 is both free-path guarded and bypass guarded. The only free-path it contains is $P=(w,v,y)$, and $Q_{1}$ is free-path guarded since $\{w,v,y\}\subseteq\operatorname{free}(Q_{2})$. The only subsequent $P$-atoms are $R_{1}(w,v)$ and $R_{2}(v,y)$, and $Q_{1}$ is bypass guarded since $v\in\operatorname{free}(Q_{2})$. The query $Q_{1}$ of Example 4.8 is not free-path guarded as the variables of the free-path $P^{\prime}=(w,v,y)$ of $Q_{1}$ are not contained in $\operatorname{free}(Q_{2})$. The query $Q_{1}$ of Example 4.10 is not bypass guarded. Consider the free-path $P^{\prime\prime}=(x,z,y)$ of $Q_{1}$. The atoms $R_{1}(x,u,z)$ and $R_{2}(y,u,z)$ are subsequent $P^{\prime\prime}$ atoms. Since $u$ is contained in both atoms but not in $\operatorname{free}(Q_{2})$, we have that $Q_{1}$ is not bypass guarded.

In the following two lemmas, we prove that if some CQ in a union is either not free-path guarded or bypass guarded, then the UCQ is intractable. As in the characterization for CQs in Theorem 2.1, our lower bounds apply only when the CQs are self-join-free; with this restriction, we can assign different atoms with different relations. The next lemma shows that the reduction in Example 4.8, where we can use the fact that $Q_{1}$ is not free-path guarded to compute matrix multiplication, can be constructed in the general case as well.

Lemma 4.12.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ of self-join-free body-isomorphic acyclic CQs. If $Q_{1}$ is not free-path guarded, then $\text{\sc Enum}\langle Q\rangle$ is not in ${\sf DelayC_{lin}}$, assuming mat-mul.

Proof.

Let $A$ and $B$ be Boolean $n\times n$ matrices represented as binary relations, i.e. $A\subseteq\{1,\ldots,n\}^{2}$, where $(a,b)\in A$ means that the entry in the $a$th row and $b$th column is $1$. Further let $P=(z_{0},\ldots,z_{k+1})$ be a free-path in $Q_{1}$ that is not guarded, and let $i$ be the minimal index such that $z_{i}\not\in\operatorname{free}(Q_{2})$. We assign the path variables to three roles as follows. If $0<i<k+1$, we define $V_{a}=\{z_{0},\ldots,z_{i-1}\}$, $V_{b}=\{z_{i}\}$ and $V_{c}=\{z_{i+1}\ldots,z_{k+1}\}$. Otherwise (if $i$ is [math] or $k+1$), we define $V_{a}=\{z_{0}\}$, $V_{b}=\{z_{1},\ldots,z_{k}\}$ and $V_{c}=\{z_{k+1}\}$. Note that, in both cases, there exists some $\alpha\in\{a,b,c\}$ such that $V_{\alpha}\cap\operatorname{free}(Q_{2})=\emptyset$. Intuitively that means that some role is not guarded. Note also that since $P$ is chordless and $k\geq 1$, there is no atom in $Q$ that contains both a variable from $V_{a}$ and a variable from $V_{c}$. Thus we can partition the atoms into nonempty sets ${\mathcal{R}}_{A}=\{R(\vec{v})\in\operatorname{atoms}(Q)\mid V_{c}\cap\vec{v}=\emptyset\}$ and ${\mathcal{R}}_{B}=\operatorname{atoms}(Q)\setminus{\mathcal{R}}_{A}$, and we have that the atoms of ${\mathcal{R}}_{A}$ do not contain variables of $V_{c}$, and the atoms of ${\mathcal{R}}_{B}$ do not contain variables of $V_{a}$.

Given three values $(a,b,c)$ we define a function $\tau_{(a,b,c)}:{\it var}(Q)\rightarrow\{a,b,c,\bot\}$ that assigns every variable with the value corresponding to its role:

[TABLE]

For a vector $\vec{v}$, we denote by $\tau_{(a,b,c)}(\vec{v})$ the vector obtained by element-wise application of $\tau_{(a,b,c)}$. We define a database instance $I$ over $Q$ as follows: For every atom $R(\vec{v})$, if $R(\vec{v})\in{\mathcal{R}}_{A}$ we set $R^{I}=\{\tau_{(a,b,\bot)}(\vec{v})\mid(a,b)\in A\}$, and if $R(\vec{v})\in{\mathcal{R}}_{B}$ we set $R^{I}=\{\tau_{(\bot,b,c)}(\vec{v})\mid(b,c)\in B\}$. Note that every relation is defined only once since ${\mathcal{R}}_{A}$ and ${\mathcal{R}}_{B}$ are disjoint and $Q$ is self-join-free.

Consider an answer $\mu\in Q(I)$. In the case that $0<i<k+1$, we have that $\mu(z_{0})=\cdots=\mu(z_{i-1})=a$, $\mu(z_{i})=b$ and $\mu(z_{i+1})=\cdots=\mu(z_{k+1})=c$ for some $(a,b)\in A$ and $(b,c)\in B$, and in case that $i\in\{0,k+1\}$, we have that $\mu(z_{0})=a$, $\mu(z_{1})=\cdots=\mu(z_{k})=b$ and $\mu(z_{k+1})=c$ for some $(a,b)\in A$ and $(b,c)\in B$. This is since the variables $z_{i}$ are connected via the path in both CQs. In either case, $\mu(\operatorname{free}(Q_{1}))$ is a tuple only containing the values $a,c$ and $\bot$. So the answers to $Q_{1}$ represent the answer to the matrix multiplication task we started with. We now need to verify that the answers to $Q_{2}$ do not interfere with the reduction. If $0<i<k+1$, $\mu(\operatorname{free}(Q_{2}))$ is a tuple only containing the values $\{a,c,\bot\}$; if $i=0$, it only contains $\{b,c,\bot\}$; and if $i=k+1$, it only contains $\{a,b,\bot\}$. Thus the number of answers to $Q$ is at most of size $2n^{2}$. Assume by contradiction that we can enumerate the solutions of $Q(I)$ with linear preprocessing and constant delay. To distinguish the answers of $Q_{1}$ from those of $Q_{2}$, we can concatenate the variable names to the values, as described in Lemma 4.1. That way, we can ignore the answers that correspond to the values $(a,b)$ or $(b,c)$, and use the $(a,c)$ pairs as the answers to matrix multiplication. This solves matrix multiplication in $O(n^{2})$ time, in contradiction to mat-mul. ∎

In Example 4.10, we encounter a UCQ where both CQs are free-path guarded, but $Q_{1}$ is not bypass guarded. We can encode 4-clique in every UCQ with this property.

Lemma 4.13.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ of self-join-free body-isomorphic acyclic CQs. If $Q_{1}$ and $Q_{2}$ are free-path guarded and $Q_{1}$ is not bypass guarded, then $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, assuming 4-clique.

Proof.

Let $G=(V,E)$ be a graph with $|V|=n$. We show how to solve the 4-clique problem on $G$ in time ${\mathcal{O}}(n^{3})$ if $\text{\sc Enum}\langle Q\rangle$ is in ${\sf DelayC_{lin}}$. Let $P$ be a free-path in $Q_{1}$ and let $u\not\in\operatorname{free}(Q_{2})$ such that $u$ appears in two subsequent P-atoms.

We first claim that, under the conditions of this lemma, $P$ is of length $2$. Let $P=(z_{0},\ldots,z_{k+1})$ and $1\leq i\leq k$ such that $\{u,z_{i-1},z_{i}\}$ and $\{u,z_{i},z_{i+1}\}$ are contained in edges of ${\mathcal{H}}(Q)$. As $P$ is chordless, there is no edge containing $\{z_{i-1},z_{i+1}\}$ , thus the path $(z_{i-1},u,z_{i+1})$ is a chordless path. As $Q_{1}$ is free-path guarded, $z_{i-1},z_{i+1}\in\operatorname{free}(Q_{2})$ and since $u\not\in\operatorname{free}(Q_{2})$, this is a free-path of $Q_{2}$. Since $Q_{2}$ is free-path guarded we have that $z_{i-1},z_{i+1}\in\operatorname{free}(Q_{1})$. Since $P$ is a free-path in $Q_{1}$, the only variables of $P$ that are free in $Q_{1}$ appear in the edges of the path, and so $i=k=1$, and $P$ is of the form $(z_{0},z_{1},z_{2})$. Therefore, there exist atoms $R_{1}$ and $R_{2}$ with $\{z_{0},z_{1},u\}\subseteq{\it var}(R_{1})$ and $\{z_{1},z_{2},u\}\subseteq{\it var}(R_{2})$.

Given three values $(a,b,c)$ we define a function $\tau_{(a,b,c)}:{\it var}(Q)\rightarrow\{a,b,c\}$ as follows:

[TABLE]

For every atom $R(\vec{v})\in\operatorname{atoms}(Q)$, we define $R^{I}=\{\tau_{a,b,c}(\vec{v})\mid(a,b,c)\text{ a triangle in }G\}$. Every relation is defined only once since $Q$ is self-join-free. Note that $|R^{I}|\in{\mathcal{O}}(n^{3})$, as there are at most $n^{3}$ triangles in $G$, and that we can construct $I$ with ${\mathcal{O}}(n^{3})$ time.

Consider an answer $\mu|_{\operatorname{free}(Q_{1})}\in Q_{1}(I)$. Since $R_{1}$ and $R_{2}$ are atoms in $Q_{1}$, we are guaranteed that $(\mu(z_{0}),\mu(z_{1}),\mu(u))$ and $(\mu(z_{1}),\mu(z_{2}),\mu(u))$ form triangles in $G$. Therefore, the graph contains a 4-clique if and only if there is an edge $(\mu(z_{0}),\mu(z_{2}))$. As $z_{0},z_{2}\in\operatorname{free}(Q_{1})$ it suffices to check every $\mu|_{\operatorname{free}(Q_{1})}\in Q_{1}(I)$ for this property. Since $Q_{1}$ is free-path guarded, we know that $z_{1}$ is existential in $Q_{1}$ but free in $Q_{2}$. This means that $\operatorname{free}(Q_{1})\neq\operatorname{free}(Q_{2})$ and so there is no homomorphism from $Q_{2}$ to $Q_{1}$. We can therefore use the mappings from Lemma 4.1 in order to distinguish the answers of $Q_{1}$ from those of $Q_{2}$. We have that $\{z_{0},z_{1},z_{2},u\}$ is neither contained in $\operatorname{free}(Q_{1})$ nor in $\operatorname{free}(Q_{2})$. Thus, $|Q(I)|\in{\mathcal{O}}(n^{3})$. If $\text{\sc Enum}\langle Q\rangle$ is in ${\sf DelayC_{lin}}$, we can construct the database instance, compute $Q$, and check every answer to $Q_{1}$ for an edge of the form $(\mu(z_{0}),\mu(z_{2}))$ in total time ${\mathcal{O}}(n^{3})$, which contradicts 4-clique. ∎

In the next section, we show that Lemma 4.12 and Lemma 4.13 cover all intractable cases of the UCQs discussed in this section.

4.3. Complete Classification of Fragments of UCQs

We show next that the hardness proofs given above complete our tractability results into a dichotomy for the fragments of UCQs we examined. We first establish this for unions of two body-isomorphic acyclic CQs, and then conclude the same for unions of two intractable CQs.

To prove that any union of two body-isomorphic acyclic CQs that is not covered by Lemma 4.12 and Lemma 4.13 has a free-connex union extension, we need some observations regarding the place of appearance of relevant variables in join-trees. Recall that we call $(v_{1},\ldots,v_{n})$ a path of variables in a query $Q$ if for all $1\leq i<n$, there exists an atom $R(\vec{u_{i}})$ in $Q$ such that $\{v_{i},v_{i+1}\}\subseteq\vec{v}$.

Proposition 4.14.

Let $(v_{1},\ldots,v_{n})$ be a path of variables in an acyclic query $Q$, and let $A_{s}$ and $A_{t}$ be atoms containing $\{v_{1},v_{2}\}$ and $\{v_{n-1},v_{n}\}$ respectively. For all $1\leq i<n$, the simple path between $A_{s}$ and $A_{t}$ on a join-tree of $Q$ contains an atom $R_{i}(\vec{u_{i}})$ such that $\{v_{i},v_{i+1}\}\subseteq\vec{u_{i}}$.

Proof.

We prove this by induction on $n$. If $n=3$, this trivially holds as the endpoints, $A_{s}$ and $A_{t}$, contain the required variables. We now assume this proposition holds for paths of length $n-1$ and show that it also holds for paths of length $n$ where $n\geq 4$. Consider the simple path between $A_{s}$ and a node containing $\{v_{n-2},v_{n-1}\}$. Let $A_{m}$ be the first node on that path that contains $\{v_{n-2},v_{n-1}\}$. Denote by $P_{s}$ the simple path between $A_{s}$ and $A_{m}$. Note that $A_{m}$ is the only node on $P_{s}$ that contains $\{v_{n-2},v_{n-1}\}$. By the induction assumption, $P_{s}$ contains $\{v_{i},v_{i+1}\}$ for all $1\leq i<n-1$, and in particular it contains $\{v_{n-3},v_{n-2}\}$. Denote by $P_{t}$ the simple path between $A_{m}$ and $A_{t}$, and denote by $P$ the concatenation of $P_{s}$ and $P_{t}$. The path $P$ goes between $A_{s}$ and $A_{t}$ and contains $\{v_{i},v_{i+1}\}$ for all $1\leq i<n$. We claim that $P$ is a simple path. Assume by contradiction that $P$ is not simple. This means that there is a node $A_{v}$ that $P_{s}$ and $P_{t}$ share other than $A_{m}$. Due to the running intersection property, since $A_{v}$ is on the simple path between $A_{m}$ and $A_{t}$, $A_{v}$ contains $v_{n-1}$. Denote by $A_{m-1}$ the node preceding $A_{m}$ on $P_{s}$. Due to the running intersection property, since $A_{m-1}$ is on the simple path between $A_{v}$ and $A_{m}$, $A_{m-1}$ contains $v_{n-1}$ too. Since a node containing $\{v_{n-3},v_{n-2}\}$ is on $P_{s}$, and since $A_{m-1}$ is on the simple path between this node and $A_{m}$, we have that $A_{m-1}$ contains $v_{n-2}$. Overall, we have that $A_{m-1}$ contains $\{v_{n-2},v_{n-1}\}$, which is a contradiction to the fact that $A_{m}$ is the only such node on $P_{s}$. ∎

Proposition 4.15.

Let $(v_{1},\ldots,v_{n})$ be a path of variables in an acyclic query $Q$, and let $A_{s}$ and $A_{t}$ be atoms containing $\{v_{1},v_{2}\}$ and $\{v_{n-1},v_{n}\}$ respectively. If $A_{1}$ and $A_{2}$ are two subsequent nodes on the simple path $P$ between $A_{s}$ and $A_{t}$ on a join-tree of $Q$, then there exists some $1\leq i\leq n$ such that $v_{i}\in A_{1}\cap A_{2}$.

Proof.

Denote the subpath of $P$ between $A_{s}$ and $A_{1}$ by $P_{s}$, and the subpath between $A_{2}$ and $A_{t}$ by $P_{t}$. Denote by $i$ the maximal index such that $v_{i}\in{\it var}(P_{s})$. If $i=n$, note that an atom in $P_{s}$ and an atom in $P_{t}$ both contain $v_{i}$. Otherwise, $i<n$. According to Proposition 4.14 and since all atoms of $P$ appear in either $P_{s}$ or $P_{t}$, an atom containing the variables $\{v_{i},v_{i+1}\}$ must appear in $P_{s}$ or $P_{t}$. It does not appear in $P_{s}$ because of the maximality of $i$, so it appears in $P_{t}$. In this case too, an atom in $P_{s}$ and an atom in $P_{t}$ both contain $v_{i}$. Since $A_{1}$ and $A_{2}$ are on the path between these atoms, due to the running intersection property, $v_{i}\in A_{1}\cap A_{2}$.

∎

Using this proposition, we can prove the structural property that we need.

Lemma 4.16.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ of body-isomorphic acyclic CQs, where $Q_{1}$ and $Q_{2}$ are free-path guarded, and $Q_{1}$ is bypass guarded, and let $P=(z_{0},\ldots,z_{k+1})$ be a free-path in $Q_{1}$. There exists a join-tree $T$ for $Q$ with a subtree $T_{P}$ such that:

• •

${\it var}(P)\subseteq{\it var}(T_{P})$.

• •

For every variable $u$ that appears in two different atoms of $T_{P}$:

• –

$u\in\operatorname{free}(Q_{2})$.

• –

There is an atom $R(\vec{v})$ in $T_{P}$ such that $u,z_{i}\in\vec{v}$ for some $0<i<k+1$.

Proof.

Recall that according to our notation, we assume that body-isomorphic CQs have exactly the same body. Thus, $T$ is also a join-tree for $Q_{2}$. In the following, we refer to the body of $Q$ when we make statements that apply to the bodies of both $Q_{1}$ and $Q_{2}$.

Consider a path $P_{A}=(A_{1},\ldots,A_{s})$ between two atoms on a join tree. We define a contraction step for a path of length $2$ or more: if there exists $j$ such that $A_{j}\cap A_{j+1}\subseteq A_{1}\cap A_{s}$, then remove the edge $(A_{j},A_{j+1})$ and add the edge $(A_{1},A_{s})$. A path on a join-tree is said to be fully-contracted if none of its subpaths can be contracted. Given any two atoms on a join-tree, it is possible to fully contract the path between them by performing any arbitrary sequence of contraction steps until it is no longer possible: the process will end as every contraction step reduces the length of the path.

We now claim that the graph $T^{\prime}$ obtained from such a contraction step of a path $P_{A}$ on a join-tree $T$, remains a join-tree. It is still a tree since it remains connected and with the same number of edges as before. It is left to show the running intersection property. We start with some observations regarding $T$. Since the running intersection property holds in $T$, for all $1\leq i\leq s$, $A_{1}\cap A_{s}\subseteq A_{i}$. Since $A_{j}\cap A_{j+1}\subseteq A_{1}\cap A_{s}$, we also have that $A_{j}\cap A_{j+1}\subseteq A_{i}$. Now consider two nodes $B$ and $C$. We need to show that every node on the simple path between them in $T^{\prime}$ contains $B\cap C$. If it is the same path as in $T$, then we are done. Otherwise, a path between $B$ and $C$ in $T^{\prime}$ can be obtained by using the simple path between them in $T$ and replacing the edge $(A_{j},A_{j+1})$ with $(A_{j+1},\ldots,A_{s},A_{1},\ldots,A_{j})$. The simple path between $B$ and $C$ is contained in this path. This means that atoms on the simple path between $B$ and $C$ in $T^{\prime}$ are either: (1) on the simple path between $B$ and $C$ in $T$, and therefore contain $B\cap C$; (2) on the path $P_{A}$ and therefore contain $A_{j}\cap A_{j+1}$. Since $A_{j}$ and $A_{j+1}$ are on the path between $B$ and $C$ in $T$, we have that $B\cap C\subseteq A_{j}\cap A_{j+1}$, so in this case too, the atoms contain $B\cap C$. This proves that the contracted graph is indeed a join-tree. By induction, if we fully contract a path on a join-tree, we still have a join-tree.

Now let $T$ be a join-tree of $Q$. We consider some path in $T$ between an atom containing $\{z_{0},z_{1}\}$ and an atom containing $\{z_{k},z_{k+1}\}$. Take the unique subpath of it containing only one atom with $\{z_{0},z_{1}\}$ and one atom with $\{z_{k},z_{k+1}\}$, and fully contract it. We denote this fully contracted subpath as $T_{P}=(A_{1},\ldots,A_{s})$. Due to Proposition 4.14, ${\it var}(P)\subseteq{\it var}(T_{P})$.

First, we claim that every variable $u$ that appears in two or more atoms of $T_{P}$ is part of a chordless path from $z_{0}$ to $z_{k+1}$. We first show a chordless path from $u$ to $z_{k+1}$. Denote the last atom on $T_{P}$ containing $u$ by $A_{i}$. If $A_{i}$ contains $z_{k+1}$, we have found the chordless path $(u,z_{k+1})$, and we are done. Otherwise, $A_{i}$ is not the last atom on $T_{P}$. It is also not the first atom on $T_{P}$, as another atom contains $u$. Consider the subpath $A_{i-1},A_{i},A_{i+1}$. Since it is fully contracted, $A_{i}\cap A_{i+1}\not\subseteq A_{i-1}\cap A_{i+1}$. This means that there is a variable $u_{+1}$ in $A_{i}$ and in $A_{i+1}$ that does not appear in $A_{i-1}$. Now consider the last atom containing $u_{+1}$, and continue with the same process iteratively until reaching $z_{k+1}$. This results in a chordless path $u,u_{+1},\ldots,u_{+m}=z_{k+1}$ with $m\geq 1$. Do the same symmetrically to find a chordless path $z_{0}=u_{-n},\ldots,u_{-1},u$ with $n\geq 1$. We now claim that the concatenation $P_{u}=(u_{-n},\ldots,u_{-1},u,u_{+1},\ldots,u_{+m})$ is chordless. We prove that $u_{-t}$ and $u_{+\ell}$ are not neighbors for all $1\leq t\leq n$ and $1\leq\ell\leq m$ by induction on $\ell+t$. Out of the atoms containing $u$, the variable $u_{+1}$ only appears in the last atom by construction: if $u_{+1}=z_{k+1}$ this is true since $z_{k+1}$ appears only in one atom, and otherwise it is true because this is how we chose $u_{+1}$. Similarly $u_{-t}$ only appears in the first. Since there are at least two atoms of the path containing $u$, we have that $u_{-1}$ and $u_{+1}$ are not neighbors, and this proves the induction base. Next, assume by way of contradiction that $u_{-t}$ and $u_{+\ell}$ are neighbors. By using the induction assumption, we have that $u_{-t},\ldots,u_{-1},u,u_{+1},\ldots,u_{+\ell},u_{-t}$ is a chordless cycle of length four or more, contradicting the fact that $Q$ is acyclic and therefore chordal. This proves that $u$ is part of the chordless path $P_{u}$ from $z_{0}$ to $z_{k+1}$.

Assume by contradiction that a variable $u\not\in\operatorname{free}(Q_{2})$ appears in two distinct atoms of $T_{P}$. There is a chordless path from $z_{0}$ to $z_{k+1}$ that contains $u$. Denote this path $P_{u}$. Take a subpath of $P_{u}$ starting with the last variable on $P_{u}$ before $u$ that is in $\operatorname{free}(Q_{2})$, and ending with the first variable on $P_{u}$ after $u$ that is in $\operatorname{free}(Q_{2})$. Such variables exist on this path because $z_{0},z_{k+1}\in\operatorname{free}(Q_{2})$. This subpath is a free-path in $Q_{2}$, and since $Q_{2}$ is free-path guarded, $u\in\operatorname{free}(Q_{1})$. Next consider two neighboring atoms on $T_{P}$ that contain $u$. According to Proposition 4.15, there exists some $z_{i}$ that appears in both atoms. Note that $i>0$ and $i<k+1$ since the path only contains one atom with $z_{0}$ and one atom with $z_{k+1}$. Since $Q_{1}$ is bypass guarded and $u\not\in\operatorname{free}(Q_{2})$, it is not possible that there is both an atom with $\{z_{i-1},z_{i},u\}$ and an atom with $\{z_{i},z_{i+1},u\}$ in $Q$. Without loss of generality, assume there is no atom with $\{z_{i},z_{i+1},u\}$. Since the query is acyclic, this means that $u$ and $z_{i+1}$ are not neighbors (if the three variables $z_{i},z_{i+1},u$ are pairwise neighbors in an acyclic graph, then necessarily they all appear in the same hyperedge). Then, there is a chordless path $(u,z_{i},z_{i+1},\ldots,z_{k+1})$. Since $u\in\operatorname{free}(Q_{1})$, it is a free-path. This contradicts the fact that $Q_{1}$ is free-path guarded since $u\not\in\operatorname{free}(Q_{2})$.

It is left to show that there is an atom $R(\vec{v})$ in $T_{P}$ such that $u,z_{i}\in\vec{v}$ for some $0<i<k+1$. Since $u$ appears in two distinct atoms of $T_{P}$, and since $T_{P}$ is a join-tree, $u$ also appears in two adjacent atoms of $T_{P}$. According to Proposition 4.15, there exists $0\leq i\leq k+1$ such that $z_{i}$ is in those atoms. This cannot be [math] or $k+1$ because they appear only in one atom in $T_{P}$. ∎

We are now ready to show that the properties free-path guardedness and bypass guardedness imply free-connexity.

Lemma 4.17.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ of body-isomorphic acyclic CQs. If $Q_{1}$ and $Q_{2}$ are both free-path guarded and bypass guarded, then $Q$ is free-connex.

Proof.

We describe how to iteratively build a union extension for each CQ. In every step, we take one free-path among the queries in $Q$ and add a virtual atom in order to eliminate this free-path. More specifically, let $P=(z_{0},\ldots,z_{k+1})$ be a free-path in $Q_{1}$. Take $T_{P}$ according to Lemma 4.16, and denote by $V_{P}$ the variables of $P$ and all variables that appear in more than one atom of $T_{P}$. We add the atom $R(V_{P})$ to both $Q_{1}$ and $Q_{2}$ and obtain $Q_{1}^{+}$ and $Q_{2}^{+}$ respectively. We will show that repeatedly applying such steps eventually leads to free-connex union extensions for $Q_{1}$ and $Q_{2}$.

First, we claim that $Q_{2}$ supplies $V_{P}$. It is guaranteed that $V_{P}\subseteq\operatorname{free}(Q_{2})$ since $P$ is guarded and due to Lemma 4.16. We now show that $Q_{2}$ is acyclic $V_{P}$-connex. We know that $T_{P}$ is a subtree of $T$ that contains $V_{P}$, but it may contain additional variables, each appearing in only atom, so we need to modify the tree. For every vertex $A_{i}$ in $T_{P}$, add another vertex with $A_{i}^{\prime}={\it var}(A_{i})\cap V_{P}$ and an edge $(A_{i},A_{i}^{\prime})$. Then, for every edge $(A_{i},A_{j})$ in $T_{P}$, replace it with the edge $(A_{i}^{\prime},A_{j}^{\prime})$. The new graph is a tree since it is connected and the number of added vertices is equal to the number of added edges (hence, after the modification, the number of edges remains equal to the number of vertices minus one). We next show that the running intersection property is maintained. For every edge $(A_{i},A_{j})$ removed, ${\it var}(A_{i})\cap{\it var}(A_{j})\subseteq V_{P}$, and so by definition of the new vertices, ${\it var}(A_{i})\cap{\it var}(A_{j})={\it var}(A_{i}^{\prime})\cap{\it var}(A_{j}^{\prime})$. Given two nodes $B$ and $C$ of the join-tree, the path between them in the modified join-tree is similar to the path in the original join-tree, except it may contain the node $(A_{i}^{\prime},A_{j}^{\prime})$ if it contained the node $(A_{i},A_{j})$ before. Since the running intersection property holds in $T$, every node on the path between $B$ and $C$ contains ${\it var}(B)\cap{\it var}(C)$. Since ${\it var}(A_{i})\cap{\it var}(A_{j})={\it var}(A_{i}^{\prime})\cap{\it var}(A_{j}^{\prime})$, the running intersection property also holds in the modified tree. As the variables of the subtree that consists of the new vertices are exactly $V_{P}$, this concludes the proof that $Q_{2}$ supplies $V_{P}$.

After the extension step we described, there are no free-paths that start in $z_{0}$ and end in $z_{k+1}$ since these variables are now neighbors. If both of the CQs are now free-connex, then we are done. Otherwise, we use the extension recursively. We can apply the extension again as we show next that the UCQ $Q_{1}^{+}\cup Q_{2}^{+}$ conforms to the conditions of this lemma. Note that after a free-path from $z_{0}$ to $z_{k+1}$ is treated, and even after future extension, there will be no free-path from $z_{0}$ to $z_{k+1}$ since they are now neighbors. Since there is a finite number of variable pairs, after a finite number of such steps, all pairs that have a free-path between them are resolved. At this point, we have an acyclic extension with no free-paths, so it is free-connex. It is left to prove that the conditions of this lemma are maintained after the extension steps as long as at least one of the extended CQs is not free-connex. We show that in the following three claims.

Claim 1**.**

$Q^{+}_{1}$* and $Q^{+}_{2}$ are body-isomorphic acyclic.*

Proof of Claim 1.

First recall that we assume that the CQs are given in the notation defined in the beginning of Section 4.2, so the two CQs have exactly the same body. Since we add the same atom to both CQs, the extensions also have the same body. We show a join-tree $T^{+}$ for the extension. Take the join-tree $T$ according to Lemma 4.16, and add the vertex $R(V_{P})$. Remove all edges in $T_{P}$ and add an edge between $R(V_{P})$ and every atom in $T_{P}$. This construction results in a connected graph with no cycles, and so it is a tree. We claim that the running intersection property is preserved. Let $B$ and $C$ be two nodes in $T^{+}$. We first handle the case that none of $B$ and $C$ are $R(V_{P})$. We need to show that every node on the path between them in $T^{+}$ contains $B\cap C$. Since this property holds in $T$, every node on the path between them in $T^{+}$ that also appears on the path between them in $T$ preserves this property. By construction, the only new node that may appear on this path is $R(V_{P})$. In this case, the two nodes before and after $R(V_{P})$ on this path contain $B\cap C$. By definition, $V_{P}$ contains all variables that appear in more that one atom in $T_{P}$, so $R(V_{P})$ contains every variable that appears in more than one of its neighbors, and it also contains $B\cap C$. It is left to handle the second case. Assume without loss of generality that $C=R(V_{P})$. We need to handle the path between $R(V_{P})$ and $B$. Let $v\in V_{P}\cap B$. Since $v\in V_{P}$, there exists some node $A_{v}$ in $T_{P}$ that contains it. Consider the simple path in $T$ between $A_{v}$ and $B$, and let $A_{v}^{\prime}$ be the last node on this path which is in $T_{P}$. Due to the running intersection property, every node on this path contains $A_{v}\cap B$, and so it also contains $v$. The edge from $V_{P}$ to $A_{v}^{\prime}$ and the simple path from $A_{v}^{\prime}$ to $B$ is therefore a simple path in $T^{+}$ from $V_{P}$ to $B$ that contains $v$. ∎

Claim 2**.**

$Q^{+}_{1}$* and $Q^{+}_{2}$ are free-path guarded.*

Proof of Claim 2.

Since the original CQs are free-path guarded, every free-path in the extension that is also a free-path in the original query is guarded. According to our construction, the only atom that was added in the extension contains exactly $V_{P}$. Thus, a new free-path $(v_{0},\ldots,v_{m+1})$ contains $v_{j},v_{j+1}\in V_{P}\subseteq\operatorname{free}(Q_{2})=\operatorname{free}(Q_{2}^{+})$. In particular, since the variables in the center of a free-path must be existential, $Q_{2}^{+}$ does not contain new free-paths. It is left to handle free-paths that appear in $Q_{1}^{+}$ but not in $Q_{1}$.

Let $P^{\prime}=(v_{0},\ldots,v_{m+1})$ be a free-path in $Q^{+}_{1}$ but not in $Q_{1}$, and let $v_{j},v_{j+1}\in V_{P}$. We need to show that $v_{i}\in\operatorname{free}(Q_{2}^{+})$ for all $0\leq i\leq m+1$. First note that $v_{j},v_{j+1}\in V_{P}\subseteq\operatorname{free}(Q_{2})=\operatorname{free}(Q_{2}^{+})$. We next prove the same for $v_{0}$ and $v_{m+1}$.

We first claim that there is a path $P_{\text{mid}}$ between $v_{j}$ and $v_{j+1}$ that goes only through existential variables in $Q_{1}$. We prove that every variable in $V_{P}$ is either of the form $z_{i}$ such that $0<i<k+1$ (recall that these are the variables in the center of the eliminated free-path) or it has a neighbor of that form. Let $v\in V_{P}$. By definition of $V_{P}$, either there exists $0\leq i\leq k+1$ such that $v=z_{i}$ or $v$ appear in two atoms or more in $T_{P}$. In the first case, if $0<i<k+1$, then it is of the required form. Otherwise, if $i=0$, it has the neighbor $z_{1}$, and if $i=k+1$, it has the neighbor $z_{k}$. In the second case (if $v$ appear in two atoms or more in $T_{P}$), according to Lemma 4.16, $v$ has a neighbor of the required form. Since $v_{j},v_{j+1}\in V_{P}$, this proves that each of $v_{j}$ and $v_{j+1}$ is either of the form $z_{i}$ such that $0<i<k+1$ or it has a neighbor of that form. Since all $z_{i}$ such that $0<i<k+1$ are connected through $P$, there is a path $P_{\text{mid}}$ between $v_{j}$ and $v_{j+1}$ that goes only through existential variables in $Q_{1}$.

Since $P^{\prime}$ is chordless, no variable in $P^{\prime}$ other than $v_{j}$ and $v_{j+1}$ is in $V_{P}$. One consequence of this is that $P_{s}=(v_{0},\ldots,v_{j})$ and $P_{t}=(v_{j+1},\ldots,v_{m+1})$ are also paths in $Q_{1}$. Another consequence is that $v_{0}$ and $v_{m+1}$ are not both in $V_{P}$. Since $P^{\prime}$ is chordless and $m\geq 1$, we have that $v_{0}$ and $v_{m+1}$ are not neighbors in $Q^{+}$. Since they are not both on the new atom, $v_{0}$ and $v_{m+1}$ are not neighbors in $Q$ either. By concatenating $P_{s}$, $P_{\text{mid}}$ and $P_{t}$, we obtain a path in $Q$ from $v_{0}$ to $v_{m+1}$ that goes only through existential variables in $Q_{1}$. Take a simple chordless path $P_{\ell}$ contained in it. Since $v_{0}$ and $v_{m+1}$ are not neighbors, the path $P_{\ell}$ is of length two at least, and so it is a free-path in $Q_{1}$. Since $Q_{1}$ is free-path guarded, we conclude that $v_{0},v_{m+1}\in\operatorname{free}(Q_{2})$.

So far we have that $v_{0},v_{j},v_{j+1},v_{m+1}\in\operatorname{free}(Q_{2})$. Assume by contradiction that there exists $0<i<j$ such that $v_{i}\not\in\operatorname{free}(Q_{2})$, and consider the subpath of $P_{s}$ beginning with the last variable before $v_{i}$ on $P_{s}$ that is in $\operatorname{free}(Q_{2})$ and ending with the first after $v_{i}$ on $P_{s}$ that is in $\operatorname{free}(Q_{2})$. This is a free-path in $Q_{2}$ containing $v_{i}$. We know that $v_{i}\not\in\operatorname{free}(Q_{1})$ as it is in the center of the free-path $P^{\prime}$, but this contradicts the fact that $Q_{2}$ is free-path guarded. In the same way, we can show that $v_{i}\in\operatorname{free}(Q_{2})$ for all $j+1<i<m+1$. Overall we have seen that $v_{i}\in\operatorname{free}(Q_{2})=\operatorname{free}(Q_{2}^{+})$ for all $0\leq i\leq m+1$ as required. ∎

Claim 3**.**

$Q_{1}^{+}$* and $Q_{2}^{+}$ are bypass guarded.*

Proof of Claim 3.

First let $P^{\prime}=(t_{0},\ldots,t_{m+1})$ be a free-path in $Q^{+}_{2}$, and assume by contradiction that there exists some $u\not\in\operatorname{free}(Q_{1}^{+})$ that appears in two subsequent $P^{\prime}$-atoms. This means that there exists $i$ such that $Q^{+}_{2}$ has an atom containing $\{t_{i-1},t_{i},u\}$ and an atom containing $\{t_{i},t_{i+1},u\}$. As explained in the previous claim, $Q^{+}_{2}$ has no new free-paths, so $P^{\prime}$ is a free-path in $Q_{2}$ as well. Since $Q_{2}$ is bypass guarded, $u$ does not appear in two subsequent $P^{\prime}$-atoms in $Q_{2}$, so one of these atoms is new in $Q^{+}_{2}$. Assume without loss of generality that it is $\{t_{i},t_{i+1},u\}$. Then, $\{t_{i},t_{i+1},u\}\subseteq V_{P}\subseteq\operatorname{free}(Q_{2})$. This contradicts the fact that $t_{i}\not\in\operatorname{free}(Q_{2})$ since $P^{\prime}$ is a free-path.

Now let $P^{\prime}=(t_{0},\ldots,t_{m+1})$ be a free-path in $Q^{+}_{1}$. Assume by contradiction that there exists some $u\not\in\operatorname{free}(Q_{2}^{+})$, that appears in two subsequent $P^{\prime}$-atoms. This means that $Q^{+}$ has an atom containing $\{t_{i-1},t_{i},u\}$ and an atom containing $\{t_{i},t_{i+1},u\}$. Since $P^{\prime}$ is chordless, $t_{i-1}$ and $t_{i+1}$ are not neighbors, and so $(t_{i-1},u,t_{i+1})$ is a chordless path as well. According to Claim 2, ${\it var}(P^{\prime})\subseteq\operatorname{free}(Q_{2}^{+})$, and so $(t_{i-1},u,t_{i+1})$ is a free-path in $Q_{2}^{+}$. According to Claim 2 again, $\{t_{i-1},u,t_{i+1}\}\subseteq\operatorname{free}(Q_{1}^{+})$. Since the only free variables on a free-path are at its ends, this means that $P^{\prime}$ is of length two, and $i=m=1$. Since $u\not\in\operatorname{free}(Q_{2})$ and ${V_{P}}\subseteq\operatorname{free}(Q_{2})$, we have that the atoms containing $\{t_{0},t_{1},u\}$ and $\{t_{1},t_{2},u\}$ are not the added atom, and so they appear also in $Q_{2}$ and in $Q_{1}$. This means that $P^{\prime}$ is a free-path in $Q_{1}$, and $u\not\in\operatorname{free}(Q_{2})$ appears in two subsequent atoms of $P^{\prime}$ in $Q_{1}$. Thus, $Q_{1}$ is not bypass guarded, in contradiction to the conditions of this lemma.

∎

This proves that the lemma can be applied iteratively. ∎

Since Lemma 4.12, Lemma 4.13 and Lemma 4.17 cover all cases of a union of two self-join-free body-isomorphic acyclic CQs, we have a dichotomy that characterizes the fragment of UCQs we discuss.

Theorem 4.18.

Let $Q=Q_{1}\cup Q_{2}$ be a UCQ of self-join-free body-isomorphic CQs.

• •

If $Q_{1}$ and $Q_{2}$ are acyclic free-path guarded and bypass guarded, then $Q$ is free-connex and $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

• •

Otherwise, $Q$ is not free-connex and $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, under the assumptions hyperclique, mat-mul and 4-clique*.*

Proof.

Since the CQs are body-isomorphic, they are either both acyclic or both cyclic. First assume that the CQs are acyclic. By Lemma 4.17, if $Q_{1}$ and $Q_{2}$ are both free-path guarded and bypass guarded, then $Q$ is free-connex, and $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$ by Theorem 3.11. Otherwise, either one of $Q_{1}$ and $Q_{2}$ is not free-path guarded, or they both are but one of them is not bypass guarded. In these cases, by Lemma 4.12 and Lemma 4.13, $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$ assuming mat-mul and 4-clique. By Theorem 4.6, if the CQs are cyclic, $\text{\sc Enum}\langle Q\rangle$ is not in ${\sf DelayC_{lin}}$ assuming hyperclique. In all cases where $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, we know that $Q$ is not free-connex by Theorem 3.11. ∎

By combining Theorem 4.18 with Theorem 4.6, we have the following dichotomy for the case of unions containing exactly two intractable CQs.

Theorem 4.19.

Let $Q=Q_{1}\cup Q_{2}$ be a union of difficult CQs.

• •

If $Q$ is free-connex, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

• •

If $Q$ is not free-connex, then $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, assuming mat-mul, hyperclique and 4-clique*.*

Proof.

If $Q$ is free-connex, Theorem 3.1 proves that it is tractable. If $Q_{1}$ and $Q_{2}$ are acyclic and body-isomorphic but $Q$ is not free-connex, then Theorem 4.18 proves that $Q$ is intractable. Otherwise, $Q$ is a union of difficult CQs that does not contain body-isomorphic acyclic CQs, and Theorem 4.6 proves that it is intractable. ∎

5. Towards a Dichotomy

In this section we examine the next steps that are required to fully characterize which UCQs are in ${\sf DelayC_{lin}}$. We pinpoint some of the difficulties that must be tackled when formulating such a dichotomy, accompanied by examples. In Section 5.1 we discuss unions containing only acyclic CQs, and in Section 5.2 we discuss those that contain at least one cyclic CQ.

5.1. Unions of Acyclic CQs

We inspect two ways of extending the results of Section 4.2. The first such extension is to a union of two CQs that are not body-isomorphic. If there is a difficult CQ $Q_{1}$ in the union where for every other CQ $Q_{i}$ in the union there is no body-homomorphism from $Q_{i}$ to $Q_{1}$, we can reduce $Q_{1}$ to the union as described in Lemma 4.3. Since $Q_{1}$ is difficult, the union is intractable too. In case there is a body-homomorphism to the hard queries, one might think that it is sufficient for intractability to have unguarded difficult structures similarly to the previous section. This is incorrect.

Example 5.1 (Unresolved UCQ with CQs that are not body-isomorphic).

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

The query $Q_{1}$ is acyclic non-free-connex, while $Q_{2}$ is free-connex. Further $Q_{1}$ is not contained in $Q_{2}$ but there is a body-homomorphism from $Q_{2}$ to $Q_{1}$. The variable $z$ is part of the free-path $(x,z,y)$ in $Q_{1}$, but the variables $t_{1}$ and $t_{2}$ that map to it via the body-homomorphism are not free in $Q_{2}$. If we extend the notion of guarding to non-body-isomorphic CQs in the natural way, the free-path $(x,z,y)$ is not guarded. Nevertheless, we cannot compute matrix multiplication in $O(n^{2})$ time by encoding it to the free-path $(x,z,y)$ like before. Over such a construction, there can be $n^{3}$ many results to $Q_{2}$ as $w$ and $y$ are not connected in $Q_{2}$ so they can have distinct values. This is not an issue when discussing body-isomorphic CQs. We do not know whether this example is in ${\sf DelayC_{lin}}$. ∎

A future characterization of the union of CQs that are not body-isomorphic would need an even more careful approach than the one used in Section 4.2 in order to handle the case that variables mapping to the free-path are not connected via other variables mapping to the free-path.

A second way of extending Section 4.2 is to consider more than two body-isomorphic acyclic CQs. This case may be tractable or intractable, and for some queries of this form, we do not have a classification yet. Example 3.12 shows a tractable union of such form, while the following example shows that free-paths that share edges can be especially problematic within a union.

Example 5.2 (Unresolved UCQ with more than two body-isomorphic CQs).

Let $k\geq 4$ and consider the UCQ $Q$ containing $k$ body-isomorphic CQs, with an atom $R_{i}(x_{i},z)$ for every $1\leq i\leq k-1$. The heads are all possible combinations of $k-1$ out of the $k$ variables of the query, $\{z,x_{1},\ldots,x_{k-1}\}$. In the case of $k=4$ we have the following UCQ:

[TABLE]

The query $Q_{1}$ has free-paths $(x_{i},z,x_{j})$ between all possible pairs of $i$ and $j$. In this case, enumerating the solutions to the UCQ is not in ${\sf DelayC_{lin}}$ assuming 4-clique: Encode each relation with all edges in the input graph, and concatenate the variable names. That is, for every edge $(u,v)$ in the graph, add $((u,x_{1}),(v,z))$ to $R_{1}$. By concatenating variable names, we can identify which solutions come from which CQ as described in Lemma 4.1 and ignore the answers to all CQs other than $Q_{1}$. The answers to $Q_{1}$ give us $3$ vertices that have a common neighbor. We can check in constant time if every pair of the $3$ vertices are neighbors, and if so, we found a $4$-clique. As there can be $O(n^{3})$ solutions to the UCQ, we solve $4$-clique in $O(n^{3})$ time. This proves that this UCQ when $k=4$ is intractable assuming 4-clique.

If we apply the same strategy for a general $k$, we get that tractability of this UCQ implies solving $k$-clique in time $O(n^{k-1})$. However, this does not result in a lower bound for large $k$ values: It is assumed that one can not find a $k$-clique in time $n^{\frac{\omega k}{3}-o(1)}$, which does not contradict an $O(n^{k-1})$ algorithm. In fact, for sufficiently large $k$, algorithms for $k$-clique detection that require time $O(n^{k-1})$ do exist (eisenbrand2004complexity). However, this reduction does not seem to fully capture the hardness of this query, as it encodes all relations with the same set of edges. We do not know if queries of the structure given here are hard in general, or if they become easy for larger $k$ values, as any current approach that we know of for constant delay enumeration fails for them. ∎

We now describe some classification we can achieve when we exclude cases like Example 5.2.

5.1.1. Lower bound for isolated free-paths

When generalizing the notion of guarding free-paths to unions of several CQs, a free-path does not have to be guarded by a single CQ. We formalize this in the following definition.

Definition 5.3.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a union of body-isomorphic CQs, and let $P=(z_{0},\ldots,z_{k+1})$ be a free-path in $Q_{1}$. We say that a set ${\mathcal{U}}\subseteq 2^{{\it var}(P)}$ is a union guard for $P$ if:

• •

$\{z_{0},z_{k+1}\}\in{\mathcal{U}}$.

• •

For every $\{z_{a},z_{c}\}\subseteq u\in{\mathcal{U}}$ with $a+1<c$, we have that $\{z_{a},z_{b},z_{c}\}\in{\mathcal{U}}$ for some $a<b<c$.

• •

For every $u\in{\mathcal{U}}$, we have $u\subseteq\operatorname{free}(Q_{i})$ for some $1\leq i\leq n$.

We sometimes refer to the set $\{z_{a},z_{b},z_{c}\}$ with $a<b<c$ as $(z_{a},z_{b},z_{c})$.

Note that, when $n=2$, if a UCQ is free-path guarded by Definition 4.11, every free-path $P$ it contains has the union guard ${\mathcal{U}}=\{{\it var}(P)\}$. Definition 5.3 allows several variable sets in the union guard, and different sets are allowed to be free in different CQs. We now show that if a UCQ contains a free-path with no union guard, then the entire union is intractable.

Theorem 5.4.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ of body-isomorphic acyclic CQs. If there exists a free-path in $Q_{1}$ that is not union guarded, then $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$, assuming mat-mul.

Proof.

Let $P=(z_{0},\ldots,z_{k+1})$ be a free-path of $Q_{1}$ that is not union guarded. We know that $\{z_{0},z_{k+1}\}\subseteq\operatorname{free}(Q_{1})$. Since $P$ is not union guarded, there exist some $a$ and $c$ such that $a+1<c$, and $\{z_{a},z_{c}\}\subseteq\operatorname{free}(Q_{r})$ for some $Q_{r}\in Q$, but for all $Q_{s}\in Q$ and for all $a<b<c$ we have $\{z_{a},z_{b},z_{c}\}\not\in\operatorname{free}(Q_{s})$. Note that $P^{\prime}=(z_{a},z_{a+1},\ldots,z_{c})$ is a free-path of $Q_{r}$. We define $V_{a}=\{z_{a}\}$, $V_{b}=\{z_{a+1},\ldots,z_{c-1}\}$ and $V_{c}=\{z_{c}\}$. Since $P^{\prime}$ is a free-path, there is no atom in $Q$ that contains both $z_{a}$ and $z_{c}$ as variables.

The rest of the proof is similar to Lemma 4.12. We partition the atoms into nonempty sets ${\mathcal{R}}_{A}=\{R(\vec{v})\in\operatorname{atoms}(Q)\mid V_{c}\cap\vec{v}=\emptyset\}$ and ${\mathcal{R}}_{B}=\operatorname{atoms}(Q)\setminus{\mathcal{R}}_{A}$, and we have that the atoms of ${\mathcal{R}}_{A}$ do not contain the variable of $V_{c}$, and the atoms of ${\mathcal{R}}_{B}$ do not contain the variable of $V_{a}$. Let $A$ and $B$ be Boolean $n\times n$ matrices represented as binary relations. We define a database instance $I$ over $Q$ as follows: For every atom $R(\vec{v})$, if $R(\vec{v})\in{\mathcal{R}}_{A}$ we set $R^{I}=\{\tau_{(a,b,\bot)}(\vec{v})\mid(a,b)\in A\}$, and if $R(\vec{v})\in{\mathcal{R}}_{B}$ we set $R^{I}=\{\tau_{(\bot,b,c)}(\vec{v})\mid(b,c)\in B\}$. Here, $\tau_{(a,b,c)}$ is the function defined in Lemma 4.12.

Consider an answer $\mu\in Q(I)$. Since the variables $z_{i}$ are connected via the path in all CQs, we have that $\mu(z_{a})=a$, $\mu(z_{a+1})=\cdots=\mu(z_{c-1})=b$ and $\mu(z_{c})=c$ for some $(a,b)\in A$ and $(b,c)\in B$. Since $\{z_{a},z_{c}\}\subseteq\operatorname{free}(Q_{r})$, the product $AB$ is encoded in $Q_{r}(I)$. Since for all $Q_{s}\in Q$ and for all $a<b<c$ we have $\{z_{a},z_{b},z_{c}\}\not\in\operatorname{free}(Q_{s})$, every $Q_{s}(I)$ is of size at most ${\mathcal{O}}(n^{2})$. Thus there are $O(n^{2})$ answers to $Q$. Assume by contradiction that we can enumerate the solutions of $Q(I)$ with linear preprocessing and constant delay. To distinguish the answers of $Q_{r}$ from those of the other CQs, we can concatenate the variable names to the values, as described in Lemma 4.1. That way, we can ignore the answers that correspond to the values $(a,b)$ or $(b,c)$, and use the $(a,c)$ pairs as the answers to matrix multiplication. This solves matrix multiplication in $O(n^{2})$ time, in contradiction to mat-mul. ∎

As we do not know of a classification for Example 5.2, we restrict the UCQs we consider to cases where the free-paths within each CQ do not share variables. Then, we manage to obtain a similar characterization to that of Section 4.2.

Definition 5.5.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a union of body-isomorphic CQs, and let $P$ be a free-path of $Q_{1}$. We say that $P$ is isolated if the following two conditions hold:

• •

$Q$ is ${\it var}(P)$-connex and

• •

${\it var}(P^{\prime})\cap{\it var}(P)=\emptyset$ for all free-paths $P^{\prime}\neq P$ in $Q_{1}$ .

Note that isolated is a stronger property than bypass-guarded. Given a free-path $P$, A bypass-guarded query can have a variable in two subsequent $P$-atoms as long as this variable is free in another CQ. An isolated free-path cannot have such a variable at all. If all free-paths in a union of body-isomorphic acyclic CQs are union guarded and isolated, we can show that the union is tractable. To achieve this result, we first need to show a structural property given in the following lemma.

Lemma 5.6.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ, $P=(z_{0},\ldots,z_{k+1})$ a free-path of $Q_{1}$ and ${\mathcal{U}}$ a union guard of $P$. There exists some ${\mathcal{U}}^{\prime}\subseteq{\mathcal{U}}$ such that:

• •

$\{z_{0},z_{k+1}\}\subseteq v\in{\mathcal{U}}^{\prime}$.

• •

for all $1\leq i\leq m$, $\{z_{i-1},z_{i}\}\subseteq v\in{\mathcal{U}}^{\prime}$.

• •

there exists a join-tree $T_{P}$ for ${\mathcal{H}}=({\it var}(P),{\mathcal{U}}^{\prime})$.

Proof.

We use the inductive definition of a union guard to define ${\mathcal{U}}^{\prime}$ and $T_{P}$. Moreover, for the ease of explanations, we define $T_{P}$ with a parent-child relation. By the first two points of Definition 5.3, $\{z_{0},z_{k+1}\}\in{\mathcal{U}}$ and thus we have $(z_{0},z_{\ell},z_{k+1})\in{\mathcal{U}}$ for some $1\leq\ell\leq k$. We set $(z_{0},z_{\ell},z_{k+1})$ as a root vertex of $T_{P}$. The second condition of Definition 5.3 defines the parent-child condition of $T_{P}$ with at most two children per vertex: If $v=(z_{a},z_{b},z_{c})\in V(T_{P})$, then

• •

if $b>a+1$, there exists some $\{z_{a},z_{j},z_{b}\}\in{\mathcal{U}}$ with $a<j<b$. Add one such vertex to the set of children of $v$.

• •

if $c>b+1$, there exists some $\{z_{b},z_{j},z_{c}\}\in{\mathcal{U}}$ with $b<j<c$. Add one such vertex to the set of children of $v$.

Note that given ${\mathcal{U}}$, the choice of $T_{P}$ might not be unique, and the vertices in $T_{P}$ correspond to a subset ${\mathcal{U}}^{\prime}$ of ${\mathcal{U}}$.

Claim 4**.**

$T_{P}$* is a join tree of ${\mathcal{H}}$.*

Proof of the Claim.

For every $v\in V(T_{P})$, denote by $T_{P}(v)$ the maximal subtree of $T_{P}$ rooted in $v$. Note that for $v=(z_{a},z_{b},z_{c})$, we have ${\it var}(T_{P}(v))\subseteq\{z_{a},\ldots,z_{c}\}$ by construction.

We first prove that for every $v_{p},v_{c}\in V(T_{P})$, if $v_{c}$ is a descendent of $v_{p}$ and $z_{i}\in v_{c}\cap v_{p}$, then $z_{i}$ is contained in every vertex on the path between $v_{p}$ and $v_{c}$. Let $v_{c}\in T_{P}(v_{p})$, and by way of contradiction let $v_{q}$ be the first vertex the path not containing $z_{i}$. Then by construction of $T_{P}$, the parent of $v_{q}$ must either be of the form $(z_{i},z_{a},z_{b})$, or $(z_{a},z_{b},z_{i})$. In both cases, $v_{q}$ is of the form $(z_{a},z_{j},z_{b})$, and ${\it var}(T_{P}(v_{q}))\subseteq\{z_{a},\ldots,z_{b}\}$. In the first case $a>i$, and in the second case $b<i$. In either case $z_{i}\not\in T_{P}(v_{q})$, which is a contradiction to the fact that $z_{i}\in v_{c}$.

Let $v_{1},v_{2}$ be two distinct vertices in $T_{P}$ and $z_{i}\in v_{1}\cap v_{2}$ for some $0\leq i\leq k+1$. Let $v_{3}$ be a vertex on the unique path from $v_{2}$ to $v_{1}$. We make a case distinction by how $v_{1}$ and $v_{2}$ are connected. In case either $v_{1}\in T_{P}(v_{2})$ or $v_{2}\in T_{P}(v_{1})$, we already showed that $v_{3}$ contains $z_{i}$. So assume that $v_{1}\not\in T_{P}(v_{2})$ and $v_{2}\not\in T_{P}(v_{1})$. This means that there is some $v_{p}\in V(T_{P})\setminus\{v_{1},v_{2}\}$ with $v_{1},v_{2}\in T_{P}(v)$, and distinct children $u_{1},u_{2}$ of $v_{p}$ such that $v_{1}\in T_{P}(u_{1})$ and $v_{2}\in T_{P}(u_{2})$. For $v_{p}=(z_{a},z_{b},z_{c})$ we have that ${\it var}(T_{P}(u_{1}))\cap{\it var}(T_{P}(u_{2}))=\{z_{b}\}$ by construction, and since $z_{i}\in v_{1}\cap v_{2}$ it follows that $z_{b}=z_{i}$. Thus, either $v_{3}$ is on the unique path from $v_{p}$ to $v_{1}$ or from $v_{p}$ to $v_{2}$. Since $v_{1}$ and $v_{2}$ are descendents of $v_{p}$, we already showed that $z_{b}\in v_{3}$. ∎

Claim 5**.**

For every $1\leq i\leq k+1$, the set $\{z_{i-1},z_{i}\}$ is contained in a vertex of $T_{P}$.

Proof of the Claim.

We describe a path from the root to a vertex containing $\{z_{i-1},z_{i}\}$. We start with the root, and at each step we consider a vertex $v=(z_{a},z_{b},z_{c})$ such that $a\leq i-1,i\leq c$. We have that either $i\leq b$ or $i-1\geq b$. Assume that $i\leq b$. If $b=a+1$, we have that $a=i-1$ and $b=i$, so we found the vertex we need. Otherwise, $v$ has a child $(z_{a},z_{t},z_{b})$ with $a\leq i-1,i\leq b$. We consider this child next. The case that $i-1\geq b$ is symmetrical. Since the tree is finite, the process will end and we will find such vertex. ∎

This concludes the proof of the Lemma. ∎

With this structural property at hand, we can show a union-extension for CQs in which every free-path is union guarded and isolated.

Theorem 5.7.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a union of body-isomorphic acyclic CQs. If every free-path in $Q$ is union guarded and isolated, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

Proof.

Let $Q_{1}\in Q$. We use the fact that every free-path in $Q_{1}$ is union guarded and isolated to show that $Q_{1}$ is union-free-connex with respect to $Q$. Since this is true for every CQ in the union, $Q$ is free-connex, and according to Theorem 3.11, $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

We show how to eliminate a free-path in $Q_{1}$ by adding virtual atoms. This process can be applied repeatedly to treat all free-paths in $Q_{1}$. Let $P=(z_{0},\ldots,z_{k+1})$ be a free-path in $Q_{1}$, and consider a join-tree $T_{P}$ given by Lemma 5.6. We extend every CQ $Q_{j}$ in $Q$ to a union extension $Q_{j}^{+}$ as follows: For every $v\in T_{P}$, add the atom $R_{v}(\vec{v})$ to $\operatorname{atoms}(Q)$, where $R_{v}$ is a fresh relational symbol. In Claim 7 we show that these variables sets are supplied, so this is indeed a valid union extension. In Claim 8 we show that extension eliminates $P$ without introducing new free-paths. As the proof of Claim 7 uses a bottom-up induction on $T_{P}$, we will need to use Claim 6 regarding the subtrees of $T_{P}$. We use the same notation as in the proof of Lemma 5.6: For every vertex $v\in V(T_{P})$, we denote by $T_{P}(v)$ the subtree of $T_{P}$ rooted in $v$. Note that $V(T_{P}(v))$ is a subset of ${\mathcal{U}}^{\prime}$.

Claim 6**.**

Let $v\in V(T_{P})$. There exists an ext-${\it var}(T_{P}(v))$-connex tree $T^{\prime}$ for the hypergraph ${\mathcal{H}}^{\prime}=({\it var}(Q),E({\mathcal{H}}(Q))\cup V(T_{P}(v)))$.

Proof of the Claim.

Let $v=(z_{a},z_{b},z_{c})$. By construction of $T_{P}$, we have that ${\it var}(T_{P}(v))=\{z_{a},z_{a+1},\ldots,z_{c}\}$. Denote by $R$ the subpath $(z_{a},z_{a+1},\ldots,z_{c})$ of $P$. It is possible to show that since $P$ is a chordless path, for every subpath of $P$, we have that $Q$ is ${\it var}(R)$-connex. Let $T$ be an ext-${\it var}(R)$-connex tree for ${\mathcal{H}}(Q)$, and let $T_{R}\subseteq T$ be a connected subtree of $T$ with ${\it var}(T_{R})={\it var}(R)$. We construct a new tree $T^{\prime}$ by first removing the edges among vertices of $T_{R}$, adding the tree $T_{P}(v)$ and then reconnecting the vertices of $T_{R}$ to $T_{P}(v)$ as fellows: Let $u\in V(T_{R})$. Since $R$ is a chordless path, we have that $u=\{z_{s}\}$ for some $a\leq s\leq c$ or $u=\{z_{s},z_{s+1}\}$ for some $a\leq s\leq c-1$. Thus there exists some vertex $w\in T_{P}(v)$ with $u\subseteq w$. Chose some arbitrary $w\in T_{P}(v)$ with this property and add an edge $(u,w)$.

Since $T$ is a tree, removing the edges of $T_{R}$ results in a forest. For every $u\in V(T_{R})$, the connected component of this forest that contains $u$ does not contain any other vertices in $V(T_{R})$. Thus in every step of adding an edge, we attach a new tree to $T_{P}(v)$, and no such tree is attached to $T_{P}(v)$ more then once. Thus $T^{\prime}$ is again a tree and acyclic. ∎

Claim 7**.**

$Q_{1}^{+}$* is a union-extension.*

Proof.

We prove via a bottom-up induction on $T_{P}$ that every vertex $v\in V(T_{P})$ is supplied by some union-extension of a CQ in $Q$.

For the base case, note that the leaves of $T_{P}$ are triples of the form $(z_{i},z_{i+1},z_{i+2})$ for $0\leq i\leq k-1$. Since $P$ is a chordless path, for every subpath of $P$ we have that $Q$ is ${\it var}(R)$-connex. Therefore, $Q$ is $\{z_{i},z_{i+1},z_{i+2}\}$-connex. Since also $(z_{i},z_{i+1},z_{i+2})$ is contained in some $\operatorname{free}(Q_{j})$, all leaves are supplied.

Consider some vertex $v=(z_{a},z_{b},z_{c})$ of $T_{P}$ that is not a leaf, and assume that for every child $v^{\prime}$ of $v$, we have that every vertex in $T(v^{\prime})$ is supplied. We need to show that $v$ is supplied. Consider the ext-${\it var}(T_{P}(v))$-connex tree $T^{\prime}$ of the hypergraph $({\it var}(Q),E({\mathcal{H}}(Q))\cup V(T_{P}(v)))$, that was constructed in the proof for Claim 6. In this tree, we replace the node $v$ by the two nodes $v_{1}=\{z_{a},z_{b}\}$ and $v_{2}=\{z_{b},z_{c}\}$, and then add the edge $(v_{1},v_{2})$. For every edge $e=(u,v)$ that was lost when deleting $v$, we do the following: If $u$ contains the variable $z_{c}$, add an edge $(u,v_{2})$, otherwise add the edge $(u,v_{1})$. Since no vertex in $T^{\prime}$ besides $v$ contains both $z_{a}$ and $z_{c}$, this is again a valid join tree. Moreover, both $\{z_{a},z_{b}\}$ and $\{z_{b},z_{c}\}$ are contained in vertices of $T^{\prime}\setminus\{v_{1},v_{2}\}$: If $v$ has two children, then the children contain $\{z_{a},z_{b}\}$ and $\{z_{b},z_{c}\}$. Otherwise, if $v$ has only one child node, we have that either $b=a+1$ or $c=a+1$. In both such cases, $\{z_{a},z_{b}\}$ or $\{z_{b},z_{c}\}$ is an edge of the path $P$ and thus contained in a vertex in $T^{\prime}$. Thus we have that $T^{\prime}$ is ext-$\{z_{a},z_{b},z_{c}\}$-connex acyclic. Let $Q_{j}\in Q$ such that $\{z_{a},z_{b},z_{c}\}\subseteq\operatorname{free}(Q_{j})$. Since every vertex in $T^{\prime}$ is supplied, there exists a union-extension $Q_{j}^{+}$ with $Q_{j}^{+}(\operatorname{free}(Q))\leftarrow R_{v_{1}}(\vec{v_{1}}),\ldots,R_{v_{N}}(\vec{v_{N}})$ and $\{v_{1},\ldots,v_{N}\}=V(T^{\prime})$. Therefore, $Q_{j}^{+}$ supplies $v$. ∎

Claim 8**.**

The set of free-paths in $Q_{1}^{+}$ equals the set of free-paths in $Q_{1}$ minus $P$.

Proof of the claim.

Since $\{z_{0},z_{k+1}\}$ is contained in a vertex of $T$ by Lemma 5.6, it is also contained in the variables of some added atom $R_{v}(\vec{v})$, thus $P$ is not a free-path of $Q_{1}^{+}$. For the sake of a contradiction, assume that there is some new free-path $P^{\prime}=(z_{0}^{\prime},\ldots,z_{m+1}^{\prime})$ in $Q_{1}^{+}$. The only new edges in ${\mathcal{H}}(Q_{i}^{+})$ are between variables in ${\it var}(P)$, thus $|var(P)\cap{\it var}(P^{\prime})|\geq 2$. Let $z_{s}$ and $z_{t}$ be the first and last elements in $P^{\prime}$ that are also in $P$. Note that the $z_{s}$ and $z_{t}$ are not neighbors in $P$. Replacing the path between $z_{s}$ and $z_{t}$ in $P^{\prime}$ with the path between $z_{s}$ and $z_{t}$ in $P$, we get the path $P^{\prime\prime}=(z_{0}^{\prime},\ldots,z_{s},z_{s+1},\ldots,z_{t-1},z_{t},\ldots,z_{m+1}^{\prime})$, which is a path in ${\mathcal{H}}(Q)$. This path contains a chordless sub-path $P^{\prime\prime\prime}$ between $z_{0}^{\prime}$ and $z_{m+1}^{\prime}$ containing at least one element in $\{z_{s},z_{s+1},\ldots,z_{t-1},z_{t}\}$. Thus $P^{\prime\prime\prime}$ is a free-path in $Q_{1}$ with a non-empty intersection with $P$, which is a contradiction to the assumption that every free-path is isolated. ∎

If $Q_{1}^{+}$ is free connex, then we are done. Otherwise, by Claim 8, every free-path $P^{\prime}$ in $Q_{1}^{+}$ is a free-path in $Q_{1}$ and thus union guarded and isolated in $Q_{1}$. Since the added atoms only contain variables of ${\it var}(P)$ and ${\it var}(P)\cap{\it var}(P^{\prime})=\emptyset$, we have that $P^{\prime}$ is also union guarded and isolated in $Q_{1}^{+}$. The tree-structure from Claim 6 over the root is a join-tree for the union extension. Since the extension consists of body-isomorphic acyclic queries, we can iteratively apply this process until $Q_{1}$ becomes free-connex. ∎

Theorem 5.4 and Theorem 5.7 form a dichotomy for unions of body-isomorphic acyclic CQs where all free-paths are isolated: if all free-paths are are guarded, the UCQ is in ${\sf DelayC_{lin}}$; otherwise, it is not in ${\sf DelayC_{lin}}$ assuming mat-mul. It is still left to handle cases like Example 5.2, of unions containing body-isomorphic acyclic CQs where some free-path is union guarded but not isolated. After solving this case, and regarding unions of difficult CQs, we should also explore unions containing body-isomorphic acyclic CQs but also other difficult CQs.

5.2. Unions Containing Cyclic CQs

We now discuss UCQs containing at least one cyclic query. We first mention that many of the observations we have regarding acyclic CQs also apply here. In the following examples, $Q_{1}$ is cyclic while $Q_{2}$ is free-connex. Example 5.8 shows that unions containing cyclic CQs may be tractable and covered by Theorem 3.11. Example 5.9 demonstrates that it is not enough to resolve the cyclic structures in CQs, but that we should also handle free-paths. Finally, Example 5.10 shows that, much like Example 5.1 in the acyclic case, even if all difficult structures are unguarded, the original reductions showing the intractability of single CQs may not work.

Example 5.8 (A tractable UCQ containing a cyclic CQ).

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

The CQ $Q_{2}$ is free-connex, and $\{y,x,z,w\}\subseteq\operatorname{free}(Q_{2})$. Thus, $Q_{2}$ supplies $V_{1}$ to $Q_{1}$. The body-homomorphism from $Q_{2}$ to $Q_{1}$ maps $V_{2}=\{y,x,z,w\}$ to $V_{1}=\{t,y,z,w\}$. Adding the virtual atom $R^{\prime}(t,y,z,w)$ to $Q_{1}$ results in a free-connex union-extension, so $\text{\sc Enum}\langle Q_{1}\cup Q_{2}\rangle\in{\sf DelayC_{lin}}$ according to Theorem 3.11. ∎

Example 5.9 (An intractable UCQ with guarded cycles).

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

The union $Q_{1}\cup Q_{2}$ is intractable despite the fact that $Q_{2}$ guards the cycle variables $\{v,y,z\}$. This is due to the unguarded free-path $(x,z,y)$ in $Q_{1}$. Similarly to Example 4.8, we can encode matrix multiplication to $x,z,y$ and conclude that $\text{\sc Enum}\langle Q\rangle\not\in{\sf DelayC_{lin}}$ assuming mat-mul. ∎

Example 5.10 (An unresolved UCQ with unguarded difficult structures).

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

We do not know the complexity of this example. As $Q_{2}$ does not have a free variable that maps to $y$ via a homomorphism, $Q_{1}$ is not union-free-connex, so we cannot conclude using Theorem 3.11 that $Q_{1}\cup Q_{2}$ is tractable. The only difficult structure in $Q_{1}$ is the cycle $x,y,z$, but encoding the triangle finding problem to this cycle in $Q_{1}$, like we did in Example 4.7, could result in $n^{3}$ answers to $Q_{2}$. This means that if the input graph has triangles, we are not guaranteed to find one in $O(n^{2})$ time by evaluating the union efficiently. ∎

In addition to these issues, in the cyclic case, even if the original difficult structures are resolved, the extension may introduce new ones. Resolving the following example in general is left for future work.

Example 5.11 (An unresolved UCQ with guarded difficult structures).

We start with a specific UCQ that we later generalize into a family of UCQs. Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

There is a body-homomorphism from $Q_{2}$ to $Q_{1}$, but $Q_{1}$ is not contained in $Q_{2}$. $Q_{1}$ is cyclic, as it has the cycle $(x_{1},x_{2},x_{3})$. This is the only difficult structure in $Q_{1}$, i.e. ${\mathcal{H}}(Q_{1})$ does not contain a hyperclique or a free-path. The query $Q_{2}$ is both free-connex and $\{x_{2},x_{3},x_{4}\}$-connex, and so it supplies $\{x_{2},x_{3},x_{4}\}$. These variables are mapped to $\{x_{1},x_{2},x_{3}\}$ via the body-homomorphism to $Q_{1}$. Nevertheless, extending $Q_{1}$ with a virtual atom $R(x_{1},x_{2},x_{3})$ does not result in a free-connex CQ. Even though the extension “removes” all difficult structures from $Q_{1}$, it is intractable as it introduces a new difficult structure, namely the hyperclique $\{x_{1},x_{2},x_{3},x_{4}\}$.

In this case, we have $\text{\sc Enum}\langle Q_{1}\cup Q_{2}\rangle\not\in{\sf DelayC_{lin}}$ assuming 4-clique, with a reduction similar to that of Example 4.10: Given an input graph, compute all triangles and encode them to the three relations. For every triangle $\{a,b,c\}$, add the tuple $((a,x_{2}),(b,x_{3}),(c,x_{4}))$ to $R_{1}$, $((a,x_{1}),(b,x_{3}),(c,x_{4}))$ to $R_{2}$ and $((a,x_{1}),(b,x_{2}),(c,x_{4}))$ to $R_{3}$. By concatenating variable names, we can identify which solutions correspond to which CQ as described in Lemma 4.1, and thus are able to ignore the answers to $Q_{2}$. The answers to $Q_{1}$ represent $3$ vertices that appear in a $4$-clique: For every answer $((b,x_{2}),(c,x_{3}),(d,x_{4}))$ to $Q_{1}$, we know that $((b,x_{2}),(c,x_{3}),(d,x_{4}))\in R_{1}$, and there exists some $a$ with $((a,x_{1}),(c,x_{3}),(d,x_{4}))\in R_{2}$ and $((a,x_{1}),(b,x_{2}),(d,x_{4}))\in R_{3}$. This means that $\{a,b,c,d\}$ is a $4$-clique. In the opposite direction, for every $4$-clique $\{a,b,c,d\}$ we have that $\{b,c,d\}$, $\{a,c,d\}$ and $\{a,b,d\}$ are triangles. By construction, the tuple $((b,x_{2}),(c,x_{3}),(d,x_{4}))$ is an answer to $Q_{1}$. As there are $O(n^{3})$ triangles and there can be at most $O(n^{3})$ solutions to $Q_{2}$, we solve $4$-clique in $O(n^{3})$ time. This proves that the UCQ is intractable assuming 4-clique.

This example can be generalized to higher orders. There, we do not have a similar lower bound. Consider the union of the following:

[TABLE]

Again, the query $Q_{1}$ is cyclic and $Q_{2}$ is free-connex. Even though $Q_{2}$ supplies variables that map to $\{x_{1},\ldots,x_{k-1}\}$ via a body-homomorphism, adding a virtual atom with these variables does not result in a free-connex extension, as this extension is again cyclic. As in Example 5.2, we can encode $k$-clique to this example in general, but this does not imply a lower bound for large $k$ values. ∎

6. Modified Settings

We devote this section to discussing the implications of this work when the settings are slightly different than the ones assumed so far: in Section 6.1 we discuss the common case that there are cardinality dependencies in the database schema; in Section 6.2 we discuss unions of conjunctive queries with disequalities; and in Section 6.3 we discuss the case where we want to restrict the space requirements of our algorithm. Reaching complete results regarding the tractability of UCQs in these settings is beyond the scope of this work, but we do discuss some insights we can conclude regarding these settings following our work.

6.1. Cardinality Dependencies

In this work, we inspect the complexity of answering UCQs when we cannot assume anything on the database instance given as input. Nevertheless, usually we do know what the database we have at hand represents, and this implies restrictions on the combinations of values that the relations may hold. One way of formalizing such restrictions is through Cardinality Dependencies (CDs), also known as degree bounds (abo2017shannon), given as part of the schema. Cardinality dependencies are of the form $(R:A\rightarrow B,c)$ where $A,B\subseteq\{1,\ldots,\operatorname{arity}(R)\}$ and $c$ is a positive natural number. This dependency means that for every database instance of this schema, the number of tuples in $R$ with the same values in the $A$ indices but distinct values in the $B$ indices is at most $c$. Functional Dependencies (FDs) are a special case of cardinality dependencies where $c=1$, and keys are a special case of FDs where $A\cup B=\{1,\ldots,\operatorname{arity}(R)\}$.

As we know, the tractable CQs over general instances are the ones with a free-connex structure. In the presence of cardinality dependencies, additional CQs are tractable. The tractable CQs can be identified by treating the dependencies as between variables and “chasing” the dependencies: the variables of the right-hand side of a dependency are added to any atom that contains the variables of its left-hand side; this extension is applied to the head of the CQ in addition to the atoms. Applying any such number of extension steps generates a CD-extended CQ, and if this CQ is free-connex, the original CQ is tractable (DBLP:conf/icdt/CarmeliK18). This resembles the technique used in this article to show the tractability of a UCQ where we extend the CQs of the union with additional atoms to reach a tractable (free-connex) structure. Following is the formal definition of CD-Extended CQs.

Definition 6.1 (CD-Extended CQ (DBLP:conf/icdt/CarmeliK18)).

Let $Q(\vec{p})\leftarrow R_{1}(\vec{v_{1}}),\dots,R_{m}(\vec{v_{m}})$ be a CQ over a schema with the dependencies $\Delta$. There are two possible types of extension steps:

• •

The extension of an atom $R_{i}(\vec{v_{i}})$ according to an CD $R_{j}\colon A\rightarrow b$.

Prerequisites: $\vec{v_{j}}[A]\subseteq\vec{v_{i}}$ and $\vec{v_{j}}[b]\notin\vec{v_{i}}$.

Effect: The arity of $R_{i}$ increases by one, $R_{i}(\vec{v_{i}})$ is replaced by $R_{i}(\vec{v_{i}},\vec{v_{j}}[b])$. In addition, every $R_{k}(\vec{v_{k}})$ such that $R_{k}$=$R_{i}$ and $k\neq i$ is replaced with $R_{k}(\vec{v_{k}},t_{k})$, where $t_{k}$ is a fresh variable in every such step.

• •

The extension of the head $Q(\vec{p})$ according to an CD $R_{j}\colon A\rightarrow b$.

Prerequisites: $\vec{v_{j}}[A]\subseteq\vec{p}$ and $\vec{v_{j}}[b]\notin\vec{p}$.

Effect: The head is replaced by $Q(\vec{p},\vec{v_{j}}[b])$.

The CD-extension of $Q$ is the CQ obtained by performing all possible extension steps on $Q$ according to CDs of $\Delta$ until a fixpoint is reached.

We devote this section to discussing whether there is a need to combine these two techniques and how this can be done. First, we discuss the need to combine the two techniques.

Example 6.2.

Consider the UCQ $Q=Q_{1}\cup Q_{2}$ with:

[TABLE]

over a schema with the FD $R_{3}:2\rightarrow 1$.

The CQ $Q_{1}$ in itself is not free-connex, as it contains the free-path $(x,y,z,w)$. Even if we take the FD into account, $Q_{1}$ is not tractable. The FD-extension of $Q_{1}$ is obtained by ”chasing” the FD $w\rightarrow z$, and adding $z$ to the query head.

[TABLE]

$Q_{1}^{+}$ is not free-connex as it contains the free-path $(x,y,z)$. This means that by using the FD techniques alone, $Q$ does not become tractable. If we take the union into account but ignore the FD, $Q_{2}$ can supply $\{x,w,u\}$, which map to $\{x,y,z\}$ in $Q_{1}$ via a body-homomorphism, but adding atoms with any subset of these variables cannot make $Q_{1}$ tractable, because it cannot prevent the appearance of a free-path between $x$ and $w$. It can only shorten it from $(x,y,z,w)$ to $(x,z,w)$. This means that by using the union techniques alone, $Q$ does not become tractable. Nonetheless, if we combine the extensions, we both add $z$ to the head and add an atom with $\{x,y,z\}$, we get the following tractable extension:

[TABLE]

Practically, this means that $Q$ can be solved efficiently by first solving $Q_{2}$, then using its results as another atom $R^{\prime}$, then solving $Q_{1}^{++}$ with the help of $R^{\prime}$, and translating every answer to $Q_{1}^{++}$ to an answer to $Q_{1}$ by projecting out $z$. The FD guarantees that the translation phase does not result in duplicates. If we had a cardinality dependency instead of an FD, we would have a constant number of duplicates per answer to $Q_{1}$, and the duplicates could be ignored efficiently using the Cheater’s Lemma (Lemma 3.4).

Example 6.2 shows that if we have UCQs over a schema with CDs, we can identify additional tractable cases by combining the two techniques. The two types of extensions can easily be combined in any order. To show this, we just need to modify the definitions of a free-connex union to account for CDs, and use the same proof as before.

Definition 6.3.

Let $Q=Q_{1}\cup\ldots\cup Q_{n}$ be a UCQ over a schema with cardinality dependencies.

• •

A CD-extension for $Q$ is of the form $Q=Q_{1}^{\prime}\cup\ldots\cup Q_{n}^{\prime}$ such that for all $i=1,\dots,n$ either $Q_{i}^{\prime}=Q_{i}$ or $Q_{i}^{\prime}$ is the CD-extension of $Q_{i}$.

• •

A CD-union extension sequence for $Q$ is a sequence $Q^{1},\ldots,Q^{N}$ where $Q=Q^{1}$ and for all $1<j\leq N$, it holds that $Q^{j}$ is either a union extension or a CD-extension of $Q^{j-1}$.

Note that a CD-extension of a CQ may result in an increase in the arity of the head. Therefore, a CD-extension of a UCQ may not be a valid UCQ in terms of the standard definitions, as these require all CQ heads to have the same arity. However, as the algorithms we use in this article for the evaluation of UCQs do not rely on the size of the heads, we can evaluate such a union as usual.

Theorem 6.4.

Let $Q$ be a UCQ over a schema with cardinality dependencies. If $Q$ has a CD-union extension sequence ending in a UCQ containing only free-connex CQ, then $\text{\sc Enum}\langle Q\rangle\in{\sf DelayC_{lin}}$.

Proof.

Consider an extension sequence $Q^{1},\ldots,Q^{N}$. First, we inductively build an instance for $Q^{N}$. The instance for $Q^{1}$ is given as input. If $Q^{i+1}$ is a union-extension of $Q^{i}$, use the construction given in this article for CQs without CDs (i.e., follow the provision phase described in Theorem 3.11) to obtain the instance for $Q^{i+1}$. Otherwise, $Q^{i+1}$ is a CD-extension of $Q^{i}$, and so use the construction for CD-extensions (DBLP:conf/icdt/CarmeliK18, Theorem 2 (Claim 1)) instead. Then, evaluate every CQ in $Q^{N}$ using the CDY algorithm. For every answer produced during the construction or in the final evaluation, translate it back to an answer to $Q^{1}$ by projecting out any extra variables (these were possibly introduced due to CD-extensions). The correctness follows from the correctness of the individual extensions. The desired time complexity is achieved using the Cheater’s Lemma: since $N$ (the length of the extension sequence) is constant with respect to the input database, the number of times every answer is produced is bound by a constant. ∎

Note that in Example 6.2 the order of applying the extension does not matter. That is, first adding $R^{\prime}$ and then adding $z$ wherever $w$ appears results in the same query as first adding $z$ and then adding $R^{\prime}$. This is not always the case. Consider the same UCQ as before but with the FD $R_{3}:1\rightarrow 2$ instead of the reverse FD. When we treat the FD as between variables in $Q_{1}$, we get $z\rightarrow w$, and we can add $w$ wherever $z$ appears in $Q_{1}$ as an FD-extension. The individual extensions are still not enough: adding $w$ to $R_{2}$ results in the free-path $(x,y,w)$, and adding an atom with $\{x,y,z\}$ or a subset of these variables does not help as before. The combination of the two extensions is enough if we first use the union and only then use the FD. We get the following free-connex CQ.

[TABLE]

If we apply the extensions in the opposite order, we do not have $w$ in $R^{\prime}$, and we have the free-path $(x,z,w)$, so the extension is not tractable.

Overall we saw that the two techniques can and should be combined to find more tractable cases. However, one should be aware that it is not enough to first take the CD-extensions of all CQs in the union and then perform union-extensions. The order in which the different extensions are combined matters.

6.2. Disequalities

In this section we discuss the enumeration complexity of unions of CQs with disequalities. In the case of individual CQs with disequalities, the disequalities have no effect on the enumeration complexity (bdg:dichotomy). That is, one can simply ignore the disequalities, and the remaining CQ is free-connex if and only if the query is tractable (under the same assumptions as in Theorem 2.1). A natural question is whether this happens also with UCQs. We next show that it does not, and some tractable UCQs become intractable with the addition of disequalitites.

Example 6.5.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

We can show this union is hard by encoding triangle detection to the cycle in $Q_{1}$ as usual. Due to the disequality, $Q_{2}$ has no answers over this construction, so finding an answer to the UCQ in linear time detects a triangle in linear time. If there was no disequality, $Q_{2}$ would supply variables that map to the cycle in $Q_{1}$ via a body-homomorphism, and the UCQ would become tractable.

This example shows that (unlike with CQs) the positive results presented in this article for UCQs do not hold when we ignore disequalities. Nevertheless, a simple adjustment of the proofs of Section 3 reveals cases where a UCQ with disequalities containing hard CQs is easy.

Definition 6.6.

Let $Q_{1},Q_{2}$ be CQs with disequalities.

• •

A body-homomorphism from $Q_{2}$ to $Q_{1}$ is a mapping $h:{\it var}(Q_{2})\rightarrow{\it var}(Q_{1})$ such that:

• –

for every atom $R(\vec{v})$ of $Q_{2}$, $R(h(\vec{v}))\in Q_{1}$.

• –

for every disequality $v\neq u$ of $Q_{2}$, $h(v)\neq h(u)$ is in $Q_{1}$.

• •

We say that $Q_{2}$ supplies a set $V$ of variables if $Q_{2}$ is free-connex and $V\subseteq\operatorname{free}(Q_{2})$.

Note that the definition of a body-homomorphism now takes the disequalities into account. Note also that the definition of supplying variables here is simpler than before as we require the supplying CQ to be free-connex.333This is a restriction we impose for simplicity, and it is possible that a more refined condition may lead to additional tractable cases. However, this seems to require going into the details of the algorithm for CQs with disequalities, and it is left for future work. We set the definition of a union extension as in Section 3 (but using the new definition of supplied variables and body-homomorphisms). Using these definitions, we can get a result similar to that of Theorem 3.11. We first prove the equivalent of Lemma 3.7 in our settings.

Lemma 6.7.

Let $Q_{2}$ be a CQ with disequalities that supplies the variables $\vec{v}_{2}$. Given an instance $I$, one can compute with linear time preprocessing and constant delay $M=Q_{2}(I)$, and $M$ can be translated in time $O(|M|)$ to a relation $R^{M}$ such that: for every CQ $Q_{1}$ with a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$ and for every answer $\mu_{1}\in\operatorname{full}(Q_{1})(I)$, there is the tuple $\mu_{1}(h(\vec{v}_{2}))\in R^{M}$.

Proof.

Let $Q_{2}$ be a CQ with disequalities that supplies the variables $\vec{v}_{2}$. Since $Q_{2}$ is free-connex, it can be answered with linear preprocessing and constant delay (bdg:dichotomy). We define $R^{M}=\{\mu_{2}(\vec{v}_{2})\mid\mu_{2}\in Q_{2}(I)\}$. Let $Q_{1}$ be a CQ such that there is a body-homomorphism $h$ from $Q_{2}$ to $Q_{1}$, and let $\mu_{1}\in\operatorname{full}(Q_{1})(I)$. Since $h$ is a body-homomorphism, for every atom $R(\vec{v})$ in $Q_{2}$, $R(h(\vec{v}))$ is an atom in $Q_{1}$, and for every disequality $v\neq u$ of $Q_{2}$, $h(v)\neq h(u)$ is in $Q_{1}$. Since $\mu_{1}$ is an answer to $\operatorname{full}(Q_{1})$, for such atoms and disequalities $\mu_{1}(h(\vec{v}))\in R^{I}$ and $\mu_{1}(h(v))\neq\mu_{1}(h(u))$. This means that $\mu_{1}\circ h|_{\operatorname{free}(Q_{2})}$ is an answer to $Q_{2}$, so there exists $\mu_{2}\in Q_{2}(I)$ such that $\mu_{1}\circ h|_{\operatorname{free}(Q_{2})}=\mu_{2}$. By construction, $\mu_{1}(h(\vec{v}_{2}))=\mu_{2}(\vec{v}_{2})\in R^{M}$. ∎

With Lemma 6.7 at hand, we can apply the proof of Theorem 3.11 as is. We only need to use Lemma 6.7 instead of Lemma 3.7. This proves the following result.

Theorem 6.8.

Let $Q$ be a union of CQ with disequalities. If $Q$ is free-connex, then $\text{\sc Enum}\langle Q\rangle$ is in ${\sf DelayC_{lin}}$.

Example 6.9.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

This is the same as Example 1.2 except for the added disequalities. Without the disequalities this union is easy as $Q_{2}$ supplies $\{x,y,w\}$, and adding a virtual atom with a union extension to $Q_{1}$ results in a free-connex form. Since $Q_{2}$ is free-connex and the disequality of $Q_{2}$ maps to that of $Q_{1}$ using the body-homomorphism, this union is easy even with the disequalities according to Theorem 6.8.

Theorem 6.8 can be used also to show the tractability of UCQs that are not naturally of that form. For example, in the case of the last example, the union is easy even without the disequality in $Q_{1}$.

Example 6.10.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

We can partition the answers to $Q_{1}$ to those that assign the same values to $x$ and $z$ and those that do not. $Q$ is equivalent to $Q^{\prime}=Q_{1}^{\neq}\cup Q_{1}^{=}\cup Q_{2}$ with

[TABLE]

Here, $Q_{2}$ and $Q_{1}^{=}$ are free-connex, and $Q_{1}^{\neq}$ has a free-connex union-extension as explained in Example 6.9.

Unlike in the case of individual CQs, the complexity of answering unions of CQs changes with the addition of disequalities. We proved the tractability of some unions with disequalities that can be easily concluded from the results of this article, but identifying all of the tractable cases is left for future work.

6.3. Restricted Space

In this article, we only considered time bounds. The class ${\sf CD\!\circ\!Lin}$ describes the problems that can be solved with the same time bounds, but with the additional restriction that the available space for writing during the enumeration phase is constant. Evaluating free-connex CQs is in ${\sf CD\!\circ\!Lin}$, and Kazana offers a comparison between ${\sf DelayC_{lin}}$ and ${\sf CD\!\circ\!Lin}$ (kazana:thesis, Section 8.1.2). All lower bounds presented in this article naturally hold for ${\sf CD\!\circ\!Lin}$ as we know that, by definition of the classes, ${\sf CD\!\circ\!Lin}\subseteq{\sf DelayC_{lin}}$. The tractability of unions containing only free-connex CQs, as explained in Theorem 3.1, also holds for this class. However, in our techniques for the tractable UCQs that do not contain only tractable CQs, the memory to which we write during the enumeration phase may increase in size by a constant with every new answer. An interesting question is whether we can achieve the same time bounds when restricting the memory according to ${\sf CD\!\circ\!Lin}$.

The first reason we use polynomial space is to regularize the delay and avoid duplicates. This is achieved in the Cheater’s Lemma (Lemma 3.4) by storing all results we produce. We should mention in that context that regularizing the delay is arguably not of practical importance. In practice, once we have an answer, we will probably want to use it immediately. For this reason, one might be satisfied with simply using a relaxed complexity measure which captures the fact that an algorithm performs ”just as good” as linear preprocessing and constant delay when given enough space: linear partial time (see Definition 3.2). The Cheater’s Lemma shows that, whenever we have an algorithm ${\mathcal{A}}$ that runs in linear partial time, there is a linear preprocessing and constant delay algorithm ${\mathcal{A}}^{\prime}$ that uses additional space and computes the same results, where every result in ${\mathcal{A}}$ is returned no later than the same result in ${\mathcal{A}}^{\prime}$. In fact, if we denote by ${\sf Lin_{Partial}}$ the class of enumeration problems that can be solved by a linear partial time algorithm, ${\sf Lin_{Partial}}={\sf DelayC_{lin}}$. Please note that this does not imply ${\sf Lin_{Partial}}={\sf CD\!\circ\!Lin}$, as we currently do not know whether ${\sf DelayC_{lin}}={\sf CD\!\circ\!Lin}$.

The other reason that we use large amounts of space is that we need to store the generated relations that correspond to the virtual atoms in order to evaluate the union extension as specified in Theorem 3.11. The discussion above implies that it makes sense to focus on eliminating this fundamental reason. As the next example demonstrates, this seems to require a different approach than the one presented in this article.

Example 6.11.

Let $Q=Q_{1}\cup Q_{2}$ with

[TABLE]

$Q_{1}$ is cyclic, so it is not possible to find an answer to it in linear time. However, since $Q_{2}$ is free-connex and supplies variables that map to the cycle $\{x,y,z\}$ in $Q_{1}$ via a body-homomorphism, and since $Q_{1}$ becomes free connex when adding an atom with these variables, the union is solvable in linear preprocessing time and constant delay by saving the results of $Q_{2}$ as a relation as suggested in Section 3. In this case, there is also a way of solving it with no additional space: use CDY to solve $Q_{2}$ efficiently; for every answer $(a,b,c,d)$ to $Q_{2}$, check if $a=d$, $(a,b)\in R_{1}$, $(b,c)\in R_{2}$ and $(c,a)\in R_{3}$; if all these conditions are met, go over all tuples $(a,e)\in R_{4}$ and output $(a,b,c,e)$. These checks can be done in constant time per answer in the RAM model by constructing lookup tables for each relation during preprocessing. This finds all answers to $Q_{1}\cup Q_{2}$ with constant time per answer. However, if an answer belongs to both CQs, we print it twice. The duplicates can easily be avoided by replacing $R_{4}$ in $Q_{1}$ with a modified version, lacking the tuples that cause duplicates. During preprocessing, compute $R_{4}^{\prime}=R_{4}\setminus\{(a,e)\in R_{4}\mid\exists{t}\text{ s.t. }(e,t)\in R_{4}\}$. During enumeration, for every qualifying answer $(a,b,c,d)$ to $Q_{2}$, go over all tuples $(a,e)\in R_{4}^{\prime}$ and output $(a,b,c,e)$.

Example 6.11 shows that reducing the space requirements is sometimes possible. We do not know however whether this is the case for all free-connex UCQs. Consider Example 1.2. The same approach would mean that for every answer $(a,b,c)$ to $Q_{2}$ we go over all tuples $(c,d)\in R_{3}$ and print $(a,c,d)$. The problem here is that we will print many duplicates: every answer $(a,c,d)$ will be produced as many times as there are different $b$ values with $(a,b,c)\in Q_{2}(I)$.

In conclusion, UCQs that contain intractable CQs can sometimes be made easy by using virtual atoms. In this article, we proposed instantiating a relation that corresponds to each virtual atom during enumeration. This instantiation can sometimes be avoided, but it requires a different approach, and it is left for future work to find when this can be done. The discussion above also gives rise to a possible relaxation that can be considered a first step: can we evaluate such UCQs efficiently with only constant writing memory available during enumeration, when we allow for linear partial time and a constant number of duplicates per answer? Note that in Example 6.11 we do not need this relaxation, so another interesting question is whether this relaxation is useful for our task or can all UCQs that can be answered with this relaxed measure also be answered with linear preprocessing and constant delay without extra space.

7. Conclusions

In this article we study the enumeration complexity of UCQs with respect to ${\sf DelayC_{lin}}$. We formalized how CQs within a union can make each other easier by supplying variables, and we introduced union extensions. Then, we defined free-connex UCQs, and showed that these are tractable. In particular, we demonstrated that UCQs containing only intractable CQs may be tractable.

We showed that in case of a union of two difficult CQs or two acyclic body-isomorphic CQs, free-connexity fully captures the tractable cases. Nevertheless, achieving a full classification of UCQs remains an open problem. Section 5 discusses the next steps that are required to fully characterize which UCQs are in ${\sf DelayC_{lin}}$ and provides examples with unknown complexity. Resolving Examples 5.1, 5.2, 5.10 and 5.11 is a necessary step on the way to a future dichotomy.

In addition to the general settings, we also showed that in three other variations: cardinality dependencies in the schema, UCQs with disequalities and restricted space, we can identify tractable UCQs that contain intractable CQs. Section 6 offers a preliminary idea on how the results of the article can be applied in these variations, and leaves substantial room for future exploration of this topic. For example, Theorem 6.8 in Section 6.2 shows the tractability of free-connex UCQs with disequalities, but as Example 6.10 demonstrates, additional such queries are tractable. Can we find a characterization that captures all such tractable UCQs with disequalities?

Most of this article ignores space consumption in order to concentrate on time. An interesting question is how much space is required to achieve the time bounds described here. As Example 6.11 shows, sometimes we can solve UCQs with only constant memory available for writing during the enumeration phase. It is left open whether all free-connex UCQs can be solved under this restriction, and in general whether ${\sf DelayC_{lin}}={\sf CD\!\circ\!Lin}$ (see the discussion in Section 6.3).

Acknowledgements.

The authors are greatly thankful to Benny Kimelfeld for his advice. The work of Nofar Carmeli was supported by the Irwin and Joan Jacobs Fellowship and by the Google PhD Fellowship. The work of Markus Kröll was supported by the Austrian Science Fund (FWF): P30930-N35, W1255-N23.