Introduction

When a database D is equipped with an ontology Σ, that is, a knowledge base consisting of constraints that express relevant properties of the underlying domain, queries are not answered merely against the database instance D, but against the logical theory D ∪ Σ. Several languages have been proposed for ontologies, with different computational properties. The DL-Lite family [2,15,23] has the advantage of a low (ac 0 , which is contained in logspace) data complexity of conjunctive query answering and of knowledge base satisfiability. The well-known Entity-Relationship (ER) [17] model has recently gained importance in ontology specification, due to the fact that it is comprehensible to theorists and practitioners, while having good expressive power. The ER ± family of ER-like languages [12], in particular, comprises several tractable (w.r.t. conjunctive query answering) ontology languages, which properly generalize the main languages of the DL-Lite family. Another relevant, more general class of ontology languages, is the Datalog ± family, that is, a family of rule-based languages derived from Datalog (see, e.g., [9] and references therein) whose rules are (function-free) Horn rules, possibly with existentially quantified variables in the head, called tuple-generating dependencies (TGDs), enriched with functionality constraints in the form of equality-generating dependencies (EGDs), and negative constraints, a form of denial constraints. The simplest and least expressive Datalog ± languages are able to properly capture the most prominent ontology languages, including most of the DL-lite family.

In this paper we focus on the interaction between TGDs and EGDs. A TGD is a first-order implication that forces the existence of tuples under certain conditions, and it is of the form ∀X∀Y ϕ(X, Y) → ∃Z ψ(X, Z), where ϕ(X, Y) and ψ(X, Z) are conjunctions of atoms over a relational schema. An EGD forces equality of values under certain conditions, and it is of the form ∀X ϕ(X) → X i = X j , where ϕ(X) is a conjunction of atoms over a relational schema, and {X i , X j } ⊆ X. To answer a query Q over an instance D and a set Σ of TGDs and EGDs, we could in principle expand D according to Σ, inferring all the entailed additional knowledge, and then evaluate Q against the obtained instance1 . In doing so, unknown values (those corresponding to the existentiallyquantified variables of TGDs) will be represented by labelled nulls, which are a sort of placeholder. EGDs play a role in answering as they can enforce equalities; if an equality between two distinct constants is enforced, the process fails as the theory is unsatisfiable.

Example 1. Consider the following set Σ of TGDs and EGDs (we omit universal quantifiers to avoid clutter):

σ 1 : r 1 (X) → ∃Y r 2 (X, Y ) σ 4 : r 4 (X, Y ) → r 5 (X, Y ) σ 2 : r 2 (X, Y ) → r 3 (X, Y ) σ 5 : r 5 (X, Y ) → r 2 (X, Y ) σ 3 : r 3 (X, Y ) → r 4 (X, Y ) η : r 3 (X, Y ), r 3 (X, Z) → Y = Z

Notice that η is a key dependency, imposing that atoms in r 3 have unique values on their first attribute. Now, let us take D = {r 1 (a), r 3 (a, b)} and the (ground) Boolean conjunctive query Q defined as q ← r 2 (a, b) (q is a propositional predicate), which simply asks whether r 2 (a, b) holds. Let us answer Q by expanding D according to Σ. We first obtain r 2 (a, ζ) from σ 1 , where ζ is a null. From σ 3 we get r 4 (a, b). We then add r 3 (a, ζ) from σ 2 ; at this point we need to apply η and enforce ζ = b, so that r 3 (a, ζ) becomes r 3 (a, b). Due to η, therefore, the query has positive answer, written D ∪ Σ |= Q. However, even in the absence of η, Q would be answered positively. In fact, if we proceed with the expansion we get r 5 (a, b) from σ 4 and finally r 2 (a, b) from σ 5 . Therefore we would have had the same result without η. This can be shown to hold for every query Q; therefore, provided that the theory D ∪ Σ is satisfiable (that is, the expansion does not fail), we can answer every query, for every D, by considering the TGDs only. This property is called separability, and it defines a form of lack of interaction (hence the name) between EGDs and TGDs in a certain set.

In this paper we provide the following contributions:

1. We illustrate the two notions of separability (the old and the new one) found in the literature, relating them to each other, and to the several syntactic conditions, sufficient to separability (one of the two notions), that have been proposed in the literature in the last decade or so. 2. We consider the problem of checking satisfiability of a theory consisting of an instance and a set of TGDs and EGDs. This can be done by answering suitable Boolean Conjunctive queries, and this has been shown in several cases. However, the proof that this technique works has always been ad hoc, depending on the particular class of TGDs and EGDs. Here, we show that this technique for the satisfiability check is sound and complete if a semantic condition, which we call deep separability, holds. We show that, fortunately, (new) separability implies deep separability. This way, we unify several known results under a single general theorem, and we also provide a useful tool for all separable classes that are yet to be discovered. 3. Finally, we mention, as an application, a syntactic condition which is sufficient for separability of sticky sets of TGDs [10] and EGDs, we hint at our preliminary experiment with a prototype system, and we discuss some open problems.

Preliminaries

In this section we recall some basics on databases, queries, tuple-generating dependencies, equality-generating dependencies, and the chase procedure.

General. We define the following pairwise disjoint (infinite) sets of symbols: (i) a set Γ of constants (constitute the "normal" domain of a database), (ii) a set Γ N of labeled nulls (used as placeholders for unknown values, and thus can be also seen as variables), and (iii) a set Γ V of variables (used in queries and dependencies). Different constants represent different values (unique name assumption), while different nulls may represent the same value. A lexicographic order is defined on Γ ∪ Γ N , such that every value in Γ N follows all those in Γ . Throughout the paper, we denote by X the sequence of variables X 1 , . . . , X k , where k 0. Also, let [n] be the set {1, . . . , n}, for any integer n 1.

A relational schema R (or simply schema) is a set of relational symbols (or predicates), each with its associated arity. A position r[i] (in a schema R) is identified by a predicate r ∈ R and its i-th argument (or attribute). A term t is a constant, null, or variable. An atomic formula (or simply atom) has the form r(t 1 , . . . , t n ), where r is an n-ary relation, and t 1 , . . . , t n are terms. Conjunctions of atoms are often identified with the sets of their atoms. A database (instance) D for a schema R is a (possibly infinite) set of atoms of the form r(t) (a.k.a. facts), where r is an n-ary predicate of R, and t ∈ (Γ ∪ Γ N ) n . We denote as r(D) the set {t | r(t) ∈ D}.

A substitution from one set of symbols S 1 to another set of symbols S 2 is a function h : S 1 → S 2 defined as follows: (i) ∅ is a substitution (empty substitution), (ii) if h is a substitution, then h ∪ {X → Y } is a substitution, where X ∈ S 1 and Y ∈ S 2 , and h does not already contain some X → Z with Y = Z. If X → Y ∈ h we write h(X) = Y . A homomorphism from a set of atoms A 1 to a set of atoms A 2 , both over the same schema R, is a substitution

h : Γ ∪ Γ N ∪ Γ V → Γ ∪ Γ N ∪ Γ V such that: (i) if t ∈ Γ , then h(t) = t, and (ii) if r(t 1 , . . . , t n ) is in A 1 , then h(r(t 1 , . . . , t n )) = r(h(t 1 ), . . . , h(t n )) is in A 2 .

If there are homomorphisms from A 1 to A 2 and vice-versa, then A 1 and A 2 are homomorphically equivalent. The notion of homomorphism naturally extends to conjunctions of atoms. Given a set of symbols S, two atoms a 1 and a 2 are Sisomorphic iff there exists a bijection h such that h(a 1 ) = a 2 , h −1 (a 2 ) = a 1 , and h(X) = X, for each X ∈ S.

Conjunctive Queries. A conjunctive query (CQ) Q of arity n over a schema R has the form q(X) ← ϕ(X, Y), where ϕ(X, Y) is a conjunction of atoms over R, X and Y are sequences of variables or constants in Γ , and q is an n-ary predicate that does not occur in R. ϕ(X, Y) is called the body of q, denoted as body(q). A Boolean CQ (BCQ) is a CQ of zero arity.

The answer to an n-ary CQ Q of the form q(X) ← ϕ(X, Y) over a database D, denoted as Q(D), is the set of all n-tuples t ∈ Γ n for which there exists a homomorphism h : X∪Y → Γ ∪Γ N such that h(ϕ(X, Y)) ⊆ D and h(X) = t. A BCQ has only the empty tuple as possible answer, in which case it is said that has positive answer. Formally, a BCQ Q has positive answer over D, denoted as

D |= Q, iff ∈ Q(D), or, equivalently, Q(D) = ∅.

Dependencies. Given a schema R, a tuple-generating dependency (TGD) σ over R is a first-order formula ∀X∀Y ϕ(X, Y) → ∃Z ψ(X, Z), where ϕ(X, Y) and ψ(X, Z) are conjunctions of atoms over R, called the body and the head of σ, denoted as body(σ) and head (σ), respectively. Henceforth, to avoid notational clutter, we will omit the universal quantifiers in TGDs. Such σ is satisfied by a database D for R iff, whenever there exists a homomorphism h such that h(ϕ(X, Y)) ⊆ D, there exists an extension h ′ of h (i.e., h ′ ⊇ h) where h ′ (ψ(X, Z)) ⊆ D.

Inclusion dependencies (IDs) are the simplest class of TGDs; they have just one body-atom and one head-atom, without repetition of variables neither in the body nor in the head. They are usually denoted as

r 1 [A] ⊆ r 2 [B],

where A and B are sets of attributes (arguments) of r 1 and r 2 respectively. Such an ID expresses that for each r 1 -atom, its values in A have to appear in B some r 2 atom. How this is represented by a TGD is obvious.

An equality-generating dependency (EGD) η over R is a first-order formula ∀X ϕ(X) → X i = X j , where ϕ(X) is a conjunction of atoms over R, called the body and denoted as body(η), and X i = X j is an equality among variables of X.

Henceforth, for brevity, we will omit the universal quantifiers in EGDs. Such η is satisfied by a database D for R iff, whenever there exists a homomorphism h such that h(ϕ(X)) ⊆ D, then h(X i ) = h(X j ). Special cases of EGDs are functional dependencies (FDs) of the form r : A → B, where A and B are sets of attributes of r; such a dependency is satisfied in an instance D if there are no two atoms in D that have the same values on A but different values on B. If the union of A and B is the whole set of attributes of r, the FD is said to be a key dependency (KD). How a FD is expressed by EGDs is obvious.

CQ Answering under Dependencies. We now define the notion of query answering under TGDs and EGDs. Given a database D for R, and a set Σ of TGDs and EGDs over R, the models of D w.r.t. Σ, denoted as mods(D, Σ), is the set of all databases B such that B |= D ∪ Σ, i.e., B ⊇ D and B satisfies Σ. The answer to a CQ Q w.r.t. D and Σ, denoted as ans(Q, D, Σ), is the set

{t | t ∈ Q(B), for each B ∈ mods(D, Σ)}. The answer to a BCQ Q w.r.t. D and Σ is positive, denoted as D ∪ Σ |= Q, iff ans(Q, D, Σ) = ∅.

Note that query answering under general TGDs and EGDs is undecidable. In fact, this is true even in extremely simple cases such as that of IDs and keys [16].

We recall that the two problems of CQ and BCQ answering under TGDs and EGDs are logspace-equivalent [6]. Moreover, it is easy to see that the query output tuple problem (as a decision version of CQ answering) and BCQ evaluation are ac 0 -reducible to each other. Thus, we henceforth focus only on the BCQ answering problem.

The Chase Procedure. The chase procedure (or simply chase) is a fundamental algorithmic tool introduced for checking implication of dependencies [21], and later for checking query containment [20]. Informally, the chase is a process of repairing a database w.r.t. a set of dependencies so that the resulted database satisfies the dependencies. We shall use the term chase interchangeably for both the procedure and its result. The chase works on an instance through the socalled TGD and EGD chase rules. The TGD chase rule comes in two different equivalent fashions: oblivious and restricted [6], where the restricted one repairs TGDs only when they are not satisfied. In the sequel, we focus on the oblivious one for better technical clarity. The chase rules follow. TGD Chase Rule. Consider a database D for a schema R, and a TGD σ of the form ϕ(X, Y) → ∃Z ψ(X, Z) over R. If σ is applicable to D, i.e., there exists a homomorphism h such that h(ϕ(X, Y)) ⊆ D, then: (i) define h ′ ⊇ h such that h ′ (Z i ) = z i , for each Z i ∈ Z, where z i ∈ Γ N is a "fresh" labeled null not introduced before, and following lexicographically all those introduced so far, and (ii) add to D the set of atoms h ′ (ψ(X, Z)), if not already in D.

EGD Chase Rule. Consider a database D for a schema R, and an EGD η of the form ϕ(X) → X i = X j over R. If η is applicable to D, i.e., there exists a homomorphism h such that h(ϕ(X)) ⊆ D and h(X i ) = h(X j ), then: (i) if h(X i ) and h(X j ) are both constants of Γ , then there is a hard violation of η, and the chase fails, otherwise (ii) replace each occurrence of h(X j ) with h(X i ), if h(X i ) precedes h(X j ) in the lexicographic order, or vice-versa otherwise.

Given a database D and a set of dependencies Σ = Σ T ∪ Σ E , where Σ T are TGDs and Σ E are EGDs, the chase algorithm for D and Σ consists of an exhaustive application of the chase rules in a breadth-first fashion, which leads to a (possibly infinite) database. Roughly, the chase of D w.r.t. Σ, denoted as chase(D, Σ), is the (possibly infinite) instance constructed by iteratively applying (i) the TGD chase rule once, and (ii) the EGD chase rule as long as it is applicable (i.e., until a fixed point is reached). A formal definition of the chase algorithm is given, e.g., in [10].

Example 2 (from [14]). Let R = {r, s}. Consider the set Σ of TGDs and EGDs over R constituted by the TGDs σ 1 = r(X, Y ) → ∃Z r(Z, X), s(Z) and σ 2 = r(X, Y ) → r(Y, X), and the EGD η = r(X, Y ), r(X ′ , Y ) → X = X ′ . Let D be the database for R consisting of the single atom r(a, b). During the construction of chase(D, Σ) we first apply σ 1 , and we add the atoms r(z 1 , a), s(z 1 ), where z 1 is a "fresh" null of Γ N . Moreover, σ 2 is applicable and we add the atom r(b, a). Now, the EGD η is applicable and we replace each occurrence of z 1 with the constant b; thus, we get the atom s(b). We continue by applying exhaustively the chase rules as explained above.

The (possibly infinite) chase of D w.r.t. Σ is a universal model of D w.r.t. Σ, i.e., for each database B ∈ mods(D, Σ), there exists a homomorphism from chase(D, Σ) to B [19,18]. Using this fact it can be shown that the chase is a formal tool for query answering under TGDs and EGDs. In particular, given a 3 What is separability?

BCQ Q, D ∪ Σ |= Q iff chase(D, Σ) |= Q, providing

In this section we provide a brief review of the interaction of TGDs and EGDs in ontological query answering.

It is well know that the interaction of TGDs and EGDs leads to undecidability of query answering; this happens even in simple sub-classes of constraints, such as key and inclusion dependencies [4,13]. It is therefore useful to identify classes of constraints which do not suffer from his "harmful" interaction. To this aim, a key condition is that of separability [12,11], which we give below.

Definition 1 (Separability). Consider a set Σ T of TGDs over a schema R, and a set Σ E of EGDs over R. We say that the set

Σ = Σ T ∪ Σ E is separable if, for every database D for R, either chase(D, Σ) fails, or, chase(D, Σ) |= Q iff chase(D, Σ T ) |= Q, for every BCQ Q over R.

Notably, there is another definition of separability in the literature, which is adopted in [4,13,8]. Such a definition is similar to the above Definition 1, but with a difference which makes it stronger. For the sake of completeness, we give such a definition below.

Definition 2 (Old separability). Consider a set Σ T of TGDs over a schema R, and a set Σ E of EGDs over R. We say that the set Σ = Σ T ∪Σ E is separable if, for every database D for R, (i) if the chase fails, then D |= Σ E (D does not satisfy Σ), and (ii) if the chase does not fail, we have chase(D, Σ)

|= Q iff chase(D, Σ T ) |= Q, for every BCQ Q over R.

The old separability is a special case of the new separability as it enforces condition (i) (Definition 2), which we reformulate below, calling it EGD-stability.

Definition 3 (EGD-stability). Consider a set Σ T of TGDs over a schema R, and a set Σ E of EGDs over R. We say that the set

Σ = Σ T ∪ Σ E is EGD-stable if, for every instance D for R, D |= Σ E implies that chase(D, Σ) does not fail.

EGD stability guarantees that the satisfiability of D ∪ Σ (i.e., the existence, or non-failure, of chase(D, Σ)) can be determined by merely checking whether D |= Σ E . In fact, the difference between the old and the new definitions of separability resides in the fact that under the new separability condition, a chase failure does not imply that the initial database D violates some EGD in Σ E , while this holds under the old definition. The satisfiability check is a fundamental step in query answering (see Section 3.2), and EGD stability guarantees it can be easily done. However, with a more sophisticated version of the satisfiability check (see Section 4), the old separability can be relaxed to the new separability, giving raise to the discovery of new (syntactic) classes that enjoy (new) separability. Section 3.1 below provides an overview of the most relevant syntactic classes in the literature.

Related Work

The notion of (old) separability was first introduced in [4,13], in the context of inclusion dependencies (IDs) and key dependencies (KDs) (see e.g. [1]). The general idea is to define a sufficient syntactic condition for separability, which can be efficiently checked. This was done while extending an early class of IDs and KDs (see e.g. [1]), called key-based. Key-based IDs and KDs were proposed in the milestone work by Johnson and Klug [20], and they are in fact separable, though not defined explicitly as such. Key-based IDs and KDs are defined as follows2 : (i) for each relational predicate r, there is only one KD defined on it;

(ii) for each ID r[X] ⊆ s[Y]

, where X and Y are set of attributes of r and s respectively (see [1] for the notation), (ii.a) X is disjoint from any key set of attributes for r, and (ii.b) Y is properly contained in the set of key attributes for s.

The more general class of non-key-conflicting (NKC) IDs, with respect to a set of KDs, is defined as follows: (i) for each relational predicate r, there is only one KD defined on it; (ii) for every ID r[X] ⊆ s[Y], Y is not a proper superset of the set of key attributes for s (if such set exists). The class of KDs and NKC IDs is separable, and it properly captures the well known class of foreign-key dependencies.

The class of KDs and non-key conflicting IDs was generalized in [8] to general TGDs, which are assumed to have a single atom in the head, without loss of generality. The idea is analogous, and the condition is as follows: (i) for each relational predicate r, there is only one KD defined on it; (ii) each existentially quantified variable in the head of a TGD must occur only once; (iii) for each TGD σ = ϕ(X, Y) → ∃Z r(X, Z), the set of X-attributes of r(X, Z) is not a proper superset of the set of key attributes of r.

In [10], the class of non-key-conflicting TGDs was straightforwardly extended to treat functional dependencies (FDs) rather than keys.

The literature so far discussed deals with sufficient syntactic conditions that guarantee, in fact, EGD-stability. However, there are classes of TGDs and EGDs such that EGDs are triggered in the chase, but which enjoy separability.

Example 3. Consider the set of TGDs and EGDs in Example 1. It is separable, but it is not EGD-stable. In fact, if we consider the instance D ′ = {r 3 (a, b), r 2 (a, c)}, we have that D ′ |= Σ E but D ∪ Σ E is unsatisfiable because the chase fails due to a hard violation. This leads in [12] to the definition of separability as in Definition 1 in this paper. This work deals with IDs and KDs which express an expressive variant of the Entity-Relationship model [17]. By means of graph-related properties, necessary and sufficient syntactic conditions for separability are provided, thus defining useful tractable classes of constraints.

The case of linear TGDs (TGDs with a single body-atom) and KDs was later considered in [14,11]. In these works, sufficient syntactic conditions are proposed that guarantee separability, without imposing non-egd-triggerability. The conditions are quite involved and they make use of backward-resolution. Interestingly, the complexity of checking the syntactic condition, called non-conflict condition, is the same as that of query answering, that is pspace-complete in combined complexity.

At this point, we considered separability but not the problem of satisfiability. While separability allows us to ignore EGDs in the case of satisfiable theories, the problem of deciding the satisfiability remains, as well as that of determining its complexity. This will be the subject of next section.

Query Answering under Separable Constraints

In the case of a set Σ = Σ T ∪ Σ E of separable TGDs and EGDs, such that BCQ answering under Σ T is decidable, given an instance D and a BCQ Q, to decide whether D ∪ Σ |= Q, the following steps are needed:

1. Check whether the chase fails, that is, whether

D ∪ Σ is satisfiable; if D ∪ Σ is unsatisfiable, then trivially D ∪ Σ |= Q ("Ex falso quodlibet"). 2. If D ∪ Σ is satisfiable, then by Definition 1 we know chase(D, Σ) |= Q iff chase(D, Σ T ) |= Q, therefore we check whether chase(D, Σ T ) |= Q.

Apart from the complexity of the satisfiability check, we have that the complexity of query answering is the same as that of answering under TGDs only, which is a highly desirable property. In the case of EGD-stable constraints, the satisfiability check amounts simply to checking whether D |= Σ E , which can be done in np, and in ptime (or better, in the even lower complexity class ac 0 ) if we consider Σ E fixed. However, in the cases of separable but not EGD-stable constraints, the problem is to be addressed differently; this will be the subject of Section 4.

Separability and Satisfiability

In this section we address the problem of deciding whether, given an instance D and a set Σ of separable TGDs and EGDs, D ∪ Σ is satisfiable. As seen in Section 3, this preliminary check is needed, in the case of separability, before one proceeds to answer a BCQ Q by taking into account the TGDs only.

The satisfiability check is done as in [8,12], by encoding hard violations of EGDs as a set Q V of Boolean conjunctive queries. Given a separable set Σ = Σ T ∪ Σ E , and an instance D, we have that satisfiability holds if and only if, for each Q ∈ Q V we have D ∪ Σ T |= Q or, equivalently, if and only if all queries in Q V have negative answer when evaluated against D and Σ T (TGDs only). The encoding is done as follows. First, we need to add auxiliary facts to D. For each pair of distinct constants c 1 , c 2 appearing in D as arguments, we add the facts neq(c 1 , c 2 ) and neq(c 2 , c 1 ) to D, where neq/2 is an auxiliary predicate expressing that two constants are distinct. Then, for each EGD η of the form φ(X) → X i = X j , with X i and X j in X, we construct the BCQ Q η as follows (quantifiers omitted for brevity): Q η : q ← φ(X), neq(X i , X j ), where q is a propositional predicate. The set Q V encoding hard violations is then defined as the set of of all Q η so constructed, or equivalently

Q V = η∈ΣE Q η . It is not difficult to prove that if D ∪ Σ |= Q η then chase(D, Σ

) fails, and therefore D ∪ Σ is unsatisfiable. However, it still remains to determine whether D ∪Σ |= Q η . Notice that in the case of non-egd-triggerable constraints we do not have this problem, as we merely need to check whether D |= Σ E . In principle, separability (see Definition 1) does not tell us anything about the cases when the chase fails. However, we are still in luck because we can evaluate the (Boolean) conjunctive queries in Q V against D ∪ Σ T rather than D ∪ Σ. This is proved, for instance, in [12,14], but ad hoc, by using the properties of the particular class of constraints involved. Here we show a general condition that allows us to perform the satisfiability check as above. We first need to introduce a preliminary condition, called deep separability, which is apparently more restrictive than separability (we shall then prove that it is implied by separability). We start by denoting by chase k (D, Σ) the result of the first k chase steps under Σ applied to an instance D, where a step is either an EGD or a TGD application. Definition 4. Let Σ be a set of TGDs and EGDs, with Σ = Σ T ∪ Σ E , where the dependencies in Σ T are TGDs and those in Σ E are EGDs. We say that Σ is deeply separable if, for each integer k ≥ 0, for each instance D with with values in Γ ∪ Γ N , and for each Boolean conjunctive query Q, the following holds: if

chase k (D, Σ) exists, then chase k (D, Σ) |= Q implies chase(D, Σ T ) |= Q.

The notion of deep separability, intuitively, guarantees that, at any step before a possible failure, the chase does not entail any atoms that are not entailed by the chase computed according to Σ T only. We now come to the main result about deeply separable TGDs and EGDs. The result states that in the case of deep separability the satisfiability check done by answering suitable queries as above is correct and complete. Notice that for the "If" direction we do not need deep separability nor separability; this direction of the implication holds for general TGDs and EGDs. Finally we show that, despite the appearances, deep separability is not a stricted condition than separability. In fact, separability implies deep separability.

Theorem 2. Let Σ be a set of TGDs and EGDs. If Σ is separable, then it is deeply separable.

Proof (sketch). We distinguish two cases. The following result immediately follows from the above.

Corollary 1. For every separable set Σ of TGDs and EGDs, for every instance D and for every BCQ Q:

checking unsatisfiability of D∪Σ has the same complexity as query answering under Σ T alone; -checking whether D ∪ Σ |= Q has the same complexity as query answering under Σ T alone.

Notice that we mention unsatisfiability rather than satisfiability because Theorem 1 shows a reduction from failure (unsatisfiability) to BCQ answering under TGDs alone.

Preliminary Experiments

We show here some preliminary experiments on the separability check in ontologies. First of all, let us describe the ontology language we have adopted. In [11], a sufficient condition for separability (in the "new" meaning) is provided for the case of EGDs and linear TGDs (which, we remind the reader, are TGDs with exactly one head-atom and one body-atom). We have extended such condition, with a rather straightforward adaptation, to the class of sticky sets of TGDs [10], a relevant class that allows for a form of joins in the body. The condition requires, as in the case of [11], a significant number of containment checks under sticky sets of TGDs in practical cases. More specifically, there is a first step, like in [11], where the body of each EGD is expanded via a (terminating) variant of backward resolution, and then for each obtained subgoal, a suitable containment check (under TGDs alone) is performed. We have built a prototype system which performs such a separability check which requiresas is obvious from this paper -also the satisfiability check. In the first tests, we considered a few known ontologies, including the GALEN medical ontology and the LUBM ontology (benchmark from Lehigh University, which describes the organizational structure of universities). The tests have been run on an Intel QuadCore I7 at 2.0 GHz and with 4 Gb of RAM; the operating system was Windows 7 Professional carrying Java Standard Edition Runtime Environment 1.7.0. The considered ontologies do not include any expressive functionality constraints, therefore we designed some ourselves, according to the semantics. In such cases, separability checks ran in extremely short time, confirming our idea that real-world functionality constraints can be efficiently checked for separability. We therefore moved on to test the system on near-worst-case schemata. We "artificially" designed some ad-hoc ontologies that, to be checked for separability, require a high number of containment checks (double exponential in the maximum predicate arity). Some values are shown in Figure 1 execution times are still reasonable for arities that are already too large to exist in practice. Given that the check is independent of queries, and therefore it is run only in case either the constraints or the instance change, we believe the first results are promising and the separability check is generally efficient in practice.

Discussion

In this paper we have given an overview of the problem of separability between TGDs and EGDs in the context of ontological query answering, where queries are (Boolean) conjunctive queries. We have reviewed the two main notions of separability found in the literature, the "old" one and the "new" one, and we have clarified the difference between them. We have then addressed the issue of checking satisfiability of a set of TGDs and EGDs together with an instance, and we have shown that this can be done by merely answering suitable queries in the case of deeply separable classes of constraints. We have shown the desirable property that all separable sets of constraints are also deeply separable.

We have therefore clarified and proved formally a satisfiability check which was already employed in the literature, but proved on a case-by-case basis [11,8,12], depending on the class of constraints. We believe that our generalisation provides a useful tool for future studies, and a better insight into the satisfiability problem. Then, we have shown some preliminary experimental results on a prototype system we have built. While the experimentation is still at an initial stage, the first results are promising, even in "pathological" cases where we designed ontologies that behave, with respect to the separability check, as the (asymptotically) worst case. Our research, given the broad variety of expressive ontology languages captured by the formalisms we considered, has broad applications in ontology-based data access, as we provide tools for the separability check. Notice that in the case of data exchange [19], where the chase is guaranteed to terminate for each instance, general EGDs can be easily treated, and the notion of separability has little significance.

Open problems. We currently have two main open problems at hand, which seem non-trivial. First, we would like to study the decidability of determining whether a given set of TGDs and EGDs is separable. This has been proved to be undecidable for the case of arbitrary TGDs and EGDs [22]; however, the proof relies on the fact that query answering under arbitrary TGDs (without EGDs) is undecidable [3]. It is not clear whether undecidability holds also in the cases where query answering is undecidable under TGDs and EGDs together, but decidable under TGDs alone; relevant cases are, for instance, IDs and KDs, sticky sets of TGDs and EGDs, or guarded TGDs and KDs [7]. We conjecture that determining separability is undecidable for these classes, but a proof is still to be devised. The second problem is more technical, and is determining the complexity of checking the syntactic condition for the separability of sticky sets of TGDs and EGDs. We have an obvious exptime lower bound, but the upper bound is currently unknown.