arX

iv:1

512.

0389

9v1

[cs.

DB

] 12

Dec

201

5

Query Answering over Contextualized RDF/OWLKnowledge with Forall-Existential Bridge Rules:Decidable Finite Extension Classes (Post Print)

Mathew Joseph1,2, Gabriel Kuper2, Till Mossakowski3, and Luciano Serafini1

1 DKM, FBK-IRST, Trento, Italy2 DISI, University Of Trento, Trento, Italy

3 Faculty of Computer Science, Otto-von-Guericke University of Magdeburg, 39016,Magdeburg, Germany

{joseph, kuper}@disi.unitn.it, {serafini}@fbk.eu,{mossakow}@iws.cs.uni-magdeburg.de

Abstract. The proliferation of contextualized knowledge in the Semantic Web(SW) has led to the popularity of knowledge formats such asquadsin the SWcommunity. A quad is an extension of an RDF triple with contextual informa-tion of the triple. In this paper, we study the problem of query answering overquads augmented with forall-existential bridge rules thatenable interoperabilityof reasoning between triples in various contexts. We call a set of quads togetherwith such expressive bridge rules, a quad-system. Query answering over quad-systems is undecidable, in general. We derive decidable classes of quad-systems,for which query answering can be done using forward chaining. Sound, completeand terminating procedures, which are adaptations of the well known chase algo-rithm, are provided for these classes for deciding query entailment. Safe, msafe,and csafe class of quad-systems restrict the structure of blank nodes generatedduring the chase computation process to be directed acyclicgraphs (DAGs) ofbounded depth. RR and restricted RR classes do not allow the generation of blanknodes during the chase computation process. Both data and combined complexityof query entailment has been established for the classes derived. We further showthat quad-systems are equivalent to forall-existential rules whose predicates arerestricted to ternary arity, modulo polynomial time translations. We subsequentlyshow that the technique of safety, strictly subsumes in expressivity, some of thewell known and expressive techniques, such as joint acyclicity and model faithfulacyclicity, used for decidability guarantees in the realm of forall-existential rules.

Keywords: Contextualized Query Answering, Contextualized RDF/OWL knowledgebases, Multi-Context Systems, Quads, Query answering, forall-existential rules, Knowl-edge Representation, Semantic Web

1 Introduction

As the Semantic Web (SW) is getting more and more ubiquitous and its constellationof interlinked ontologies, the web of data, is seamlessly proliferating at a steady rate,

more and more applications have started using SW as a back end, providing their usersmanifold services, leveraging semantic technologies. Oneof the main reasons why SWenjoys such admirable hospitality from its mammoth geographically disparate usersis its “simple” and “open” model. The model is simple, as the only intricacy that acreator/consumer of a SW application needs to be equipped with is that of a (RDF)triple. A triple t = (s, p, o) represents the most basic piece of knowledge in the SW,wheres, called thesubject, is an identifier for a person, place, thing, value, or a resourcein general, about which the creator oft intended to express his/her knowledge usingt.p, called thepredicate, is an identifier for a property, attribute, or in general a binaryrelation that relatess with the componento, called the object, that is also an identifierfor a resource similar tos. The model is called open, as it allows anybody, anywherearound the world to freely create their RDF/OWL ontologies about a domain of theirchoice, and publish them in (embedded) RDF/OWL formats in their web portals, alsolinking via URIs to the concepts in other similarly published ontologies. Thus the openmodel, in order to promote reuse and freedom, imposes no arbitration mechanism forthe ontologies users publish on the SW.

A problem caused by this open model is that any piece of knowledge which a personpublishes is often his/her own perspective about a particular domain, which largely isrelative to this person. As a consequence, the truth value ofa piece of knowledge in theSW is context-dependent. Recently, as a solution to the aforementioned problem, theSW community adopts the use of quads, an extension of triples, as the primary carrierof knowledge. A quadc : (s, p, o) thus adds a fourth component of the contextc tothe triple(s, p, o), explicating the identifier of the context in which the triple holds. Asa result, more and more triple-stores are becoming quad-stores. Some of the popularquad-stores are 4store1, Openlink Virtuoso2, and some of the currently popular triple-stores like Sesame3, Allegrograph4 internally keep track of the contexts of triples. Someof the recent initiatives in this direction have also extended existing formats like N-Triples to N-Quads, which the RDF 1.1 has introduced as a W3C recommendation. Thelatest Billion triple challenge datasets have all been released in the N-Quads format.

Other benefits of quads over triples are that they allow knowledge creators to specifyvarious attributes of meta-knowledge that further qualifyknowledge [2], and also allowusers to query for this meta knowledge [3]. These attributes, which explicate the vari-ous assumptions under which knowledge holds, are also called context dimensions[4].Examples of context dimensions are provenance, creator, intended user, creation time,validity time, geo-location, and topic. Having defined knowledge that is contextualized,as inc1 : (Renzi, primeMinsiterOf, Italy), one can now declare in a meta-contextmc,statements such asmc : (c1, creator, John), mc : (c1, expiryTime, “jun-2016”) thattalk about the knowledge in contextc1, in this case its creator and expiry time. Anotherbenefit of such a contextualized approach is that it opens possibilities of interestingways for querying a contextualized knowledge base. For instance, if contextc1 con-tains knowledge about football world cup 2014 and contextc2 about football euro cup

1 http://4store.org2 http://virtuoso.openlinksw.com/rdf-quad-store/3 http://www.openrdf.org/4 http://www.franz.com/agraph/allegrograph/

2012, then the query “who beat Italy in both world cup 2014 andeuro cup 2012” canbe formalized as the conjunctive query:

c1: (x, beat, Italy) ∧ c2: (x, beat, Italy),

wherex is a variable.When reasoning with knowledge in quad form, since knowledgecan be grouped

and divided context wise and simultaneously be fed to separate reasoning engines, thisapproach improves both efficiency and scalability [9]. Besides the above flexibility,bridge rules[5] can be provided for inter-operating the knowledge in different contexts.Such rules are primarily of the form:

c : φ→ c′ : φ′ (1)

whereφ, φ′ are both atomic concept (role) symbols,c, c′ are contexts. The semantics ofsuch a rule is that if, for anya, φ(a) holds in contextc, thenφ′(a) should hold in con-text c′, wherea is a unary/binary vector depending on whetherφ, φ′ are concept/rolesymbols. Although such bridge rules serve the purpose of specifying knowledge inter-operability from a source contextc to a target contextc′, in many practical situationsthere is the need of inter-operating multiple source contexts with multiple target con-texts, for which the bridge rules of the form (1) are inadequate. Besides, one would alsowant the ability of creating new values in target contexts for the bridge rules.

In this work, we study contextual reasoning and query answering over contextual-ized RDF/OWL knowledge bases in the presence offorall-existential bridge rulesthatallow conjunctions and existential quantifiers in them, andhence are more expressivethan those in DDL [5] and McCarthy et al. [6]. We provide a basic semantics for contex-tual reasoning based on which we provide procedures for conjunctive query answering.For query answering, we use the notion of adistributed chase, which is an extensionof the standardchase[20, 21] that is widely used in the knowledge representation(KR)and Database (DB) settings for similar purposes. As far as the semantics for reasoning isconcerned, we adopt the approach given in works such as Distributed Description Log-ics [5], E-connections [22], and two-dimensional logic of contexts [23], to use a set ofinterpretation structures as a model for contextualized knowledge. In this way, knowl-edge in each context is separately interpreted in a different interpretation structure. Themain contributions of this work are:

1. We formulate a context-based semantics that reuses the standard RDF/OWL se-mantics, which can be used for reasoning over quad-systems.Studying conjunctivequery answering over quad-systems, it turns out that the entailment problem of con-junctive queries is undecidable for the most general class of quad-systems, calledunrestricted quad-systems.

2. We derive decidable subclasses of unrestricted quad-systems, namelycsafe, msafe,andsafequad-systems, for which we detail both data and combined complexitiesof conjunctive query entailment. These classes are based onthe constrained DAGstructure of Skolem blank nodes generated during the chase construction. We alsoprovide decision procedures to decide whether an input quad-system is safe (csafe,msafe) or not.

3. We further derive less expressive classes, RR and restricted RR quad-systems, forwhich no Skolem blank nodes are generated during the chase construction.

4. We show that the class of unrestricted quad-systems is equivalent to the class ofternary∀∃ rule sets. We compare the derived classes of quad-systems with wellknown subclasses of∀∃ rule sets, such as jointly acyclic and model faithful acyclicrule sets, and show that the technique of safety we propose, subsumes these othertechniques, in expressivity.

The paper is structured as follows. In section 2, we formalize the idea of contextualizedquad-systems, giving various definitions and notations forsetting the background. Insection 3, we formalize the problem of query answering for quad-systems, define no-tions such as distributed chase that are further used for query answering, and give theundecidability results of query entailment on unrestricted quad-systems. In section 4,we presentcsafe, msafe, andsafequad-systems and their computational properties. Insection 5, RR quad-systems and restricted RR quad-systems are introduced. In section6, we prove the equivalence of quad-systems with ternary∀∃ rule sets, and formallycompare a few well known decidable classes in the realm of∀∃ rules to the classesof quad-systems, we presented in section 4. We provide a detailed discussion to otherrelevant related works in section 7, and conclude in section8.

Note that parts of the contents of section 2 and section 3 has been taken from con-ference papers [11] and [12].

2 Contextualized Quad-Systems

In this section, we formalize the notion of a quad-system andits semantics. For anyvector or sequencex, we denote by‖x‖ the number of symbols inx, and by{x} theset of symbols inx. For any setsA andB,A→ B denotes the set of all functions fromsetA to setB.

Given the set of URIsU, the set of blank nodesB, and the set of literalsL, the setC = U ⊎ B ⊎ L is called the set of (RDF) constants. Any(s, p, o) ∈ C × C ×C iscalled a generalized RDF triple (from now on, just triple). Agraph is a set of triples.A quad is a tuple of the formc : (s, p, o), where(s, p, o) is a triple andc is a URI5,called thecontext identifierthat denotes the context of the RDF triple. Aquad-graphisdefined as a set of quads. For any quad-graphQ and any context identifierc, we denoteby graphQ(c) the set{(s, p, o)|c : (s, p, o) ∈ Q}. We denote byQC the quad-graphwhose set of context identifiers isC. The set of constants occurring inQC is given asC(QC) = {c, s, p, o | c : (s, p, o) ∈ QC}. The set of URIs inQC is given byU(QC) =C(QC) ∩ U. The set of blank nodesB(QC) and the set of literalsL(QC) are similarlydefined. LetV be the set of variables, any element of the setC

V = V ∪ C is a term.Any (s, p, o) ∈ C

V × CV × C

V is called atriple pattern, and an expression of theform c : (s, p, o), where(s, p, o) is a triple pattern,c a context identifier, is called aquadpattern. A triple patternt, whose variables are elements of the vectorx or elements ofthe vectory is written ast(x,y). For any functionf : A → B, therestrictionof f to

5 Although, in general a context identifier can be a constant, for the ease of notation, we restrictthem to be a URI

a setA′, is the mappingf |A′ from A′ ∩ A to B such thatf |A′(a) = f(a), for eacha ∈ A ∩ A′. For any triple patternt = (s, p, o) and functionµ from V to a setA,t[µ] denotes(µ′(s), µ′(p), µ′(o)), whereµ′ is an extension ofµ to C such thatµ′|C isthe identity function. For any set of triple patternsG, G[µ] denotes

⋃

t∈G t[µ]. For anyvector of constantsa = 〈a1, . . . , a‖a‖〉, and vector of variablesx of the same length,x/a is the functionµ such thatµ(xi) = ai, for 1 ≤ i ≤ ‖a‖. We use the notationt(a,y) to denotet(x,y)[x/a]. Similarly, the above notations are also extended to setsof quad-patterns. For instanceQ(x,y) denotes a set of quad-patterns, whose variablesare fromx ory, andQ(a,y) is written forQ(x,y)[x/a]. For the sake of interoperatingknowledge in different contexts, bridge rules need to be provided:

Bridge rules (BRs)Formally, a BR is of the form:

∀x∀z [c1: t1(x, z) ∧ ... ∧ cn: tn(x, z) → ∃y c′1: t′1(x,y) ∧ ... ∧ c′m: t′m(x,y)] (2)

wherec1, ..., cn, c′1, ..., c′m are context identifiers,x, y, z are vectors of variables such

that{x}, {y}, and{z} are pairwise disjoint.t1(x, z), ..., tn(x, z) are triple patternswhich do not contain blank-nodes, and whose set of variablesare fromx orz. t′1(x, y),...,t′m(x,y) are triple patterns, whose set of variables are fromx ory, and also does notcontain blank-nodes. For any BRr of the form (2),body(r) is the set of quad patterns{c1: t1(x, z),...,cn: tn(x, z)}, andhead(r) is the set of quad patterns{c′1: t

′1(x,y), ...

c′m: t′m(x, y)}, and the frontier ofr, fr(r) = {x}. Occasionally, we also note the BRrabove asbody(r)(x, z) → head(r)(x, y). The set of terms in a BRr is:

CV(r) = {c, s, p, o | c : (s, p, o) ∈ body(r) ∪ head(r)}

The set of terms for a set of BRsR isCV(R) =⋃

r∈R CV(r). The URIs, blank nodes,

literals, variables of a BRr (resp. set of BRsR) are similarly defined, and are denotedasU(r), B(r), L(r), V(r) (resp.U(R), B(R), L(R), V(R)), respectively.

Definition 1 (Quad-System).A quad-systemQSC is defined as a pair〈QC , R〉, whereQC is a quad-graph, whose set of context identifiers isC, andR is a set of BRs.

For any quad-system,QSC = 〈QC , R〉, the set of constants inQSC is given byC(QSC) =C(QC) ∪C(R). The setsU(QSC), B(QSC), L(QSC), andV(QSC) are similarly de-fined for any quad-systemQSC . For any quad-graphQC (BR r), its symbol size‖QC‖(‖r‖) is the number of symbols required to printQC (r). Hence,‖QC‖ ≈ 4 ∗ |QC |,where|QC | denotes the cardinality of the setQC . Note that|QC | equals the number ofquads inQC . For a BRr, ‖r‖ ≈ 4 ∗ k, wherek is the number of quad-patterns inr. Fora set of BRsR, ‖R‖ is given asΣr∈R‖r‖. For any quad-systemQSC = 〈QC , R〉, itssize‖QSC‖ = ‖QC‖+ ‖R‖.

SemanticsIn order to provide a semantics for enabling reasoning over aquad-system,we need to use a local semantics for each context to interpretthe knowledge pertainingto it. Since the primary goal of this paper is a decision procedure for query answeringover quad-systems based on forward chaining, we consider the following desiderata forthe choice of the local semantics and its deductive machinery:

– there exists an operationlclosure() that computes the deductive closure of a graphw.r.t to the local semantics using the local inference rulesin a set LIR,

– each inference rule in LIR isrange restricted, i.e. non value-generating,– given a finite graph as input, thelclosure() operation terminates with a finite graph

as output in polynomial time whose size is polynomial w.r.t.to the input set.

Some of the alternatives for the local semantics satisfyingthe above mentioned criterionare Simple, RDF, RDFS [31], OWL-Horst [27] etc. Assuming that a local semantics hasbeen fixed, for any contextc, we denote byIc = 〈∆c, ·c〉 an interpretation structure forthe local semantics, where∆c is the interpretation domain,·c the corresponding in-terpretation function. Also|=local denotes the local satisfaction relation between a localinterpretation structure and a graph. Given a quad graphQC , adistributed interpretationstructureis an indexed setIC = {Ic}c∈C, whereIc is a local interpretation structure,for eachc ∈ C. We define the satisfaction relation|= between a distributed interpretationstructureIC and a quad-systemQSC as:

Definition 2 (Model of a Quad-System).A distributed interpretation structureIC ={Ic}c∈C satisfies a quad-systemQSC = 〈QC , R〉, in symbolsIC |= QSC, iff all thefollowing conditions are satisfied:1. Ic |=local graphQC (c), for eachc ∈ C;2. aci = acj , for anya ∈ C, ci, cj ∈ C;3. for each BRr ∈ R of the form (2) and for eachσ ∈ V → ∆C , where∆C =

⋃

c∈C ∆c, if

Ic1 |=local t1(x, z)[σ], ..., Icn |=local tn(x, z)[σ],

then there exists a functionσ′ ⊇ σ, such thatIc

′1 |=local t

′1(x,y)[σ

′], ..., Ic′m |=local t

′m(x,y)[σ′].

Condition 1 in the above definition ensures that for any modelIC of a quad-graph, eachIc ∈ IC is a local model of the set of triples in contextc. Condition 2 ensures that anyconstantc is rigid, i.e. represents the same resource across a quad-graph, irrespectiveof the context in which it occurs. Condition 3 ensures that any model of a quad-systemsatisfies each BR in it. AnyIC such thatIC |= QSC is said to be a model ofQSC . Aquad-systemQSC is said to beconsistentif there exists a modelIC , such thatIC |=QSC , and otherwise said to beinconsistent. For any quad-systemQSC = 〈QC , R〉, itcan be the case thatgraphQC(c) is locally consistent, i.e. there exists anIc such thatIc |=local graphQC (c), for eachc ∈ C, whereasQSC is not consistent. This is becausethe set of BRsR adds more knowledge to the quad-system, and restricts the set ofmodels that satisfy the quad-system.

Definition 3 (Quad-system entailment).(a) A quad-systemQSC entails a quadc : (s,p, o), in symbolsQSC |= c : (s, p, o), iff for any distributed interpretation structureIC ,if IC |= QSC thenIC |= 〈{c : (s, p, o)}, ∅〉. (b) A quad-systemQSC entails a quad-graphQ′

C′ , in symbolsQSC |= Q′C′ iff QSC |= c : (s, p, o) for anyc : (s, p, o) ∈ Q′

C′ .(c) A quad-systemQSC entails a BRr iff for anyIC , if IC |= QSC thenIC |= 〈∅, {r}〉.(d) For a set of BRsR, QSC |= R iff QSC |= r, for everyr ∈ R. (e) Finally, a quad-systemQSC entails another quad-systemQS′

C′ = 〈Q′C′ , R′〉, in symbolsQSC |= QS′

C′

iff QSC |= Q′C′ andQSC |= R′.

We call the decision problems corresponding to the entailment problems (EPs) in (a),(b), (c), (d), and (e) asquad EP, quad-graph EP, BR EP, BRs EP, and quad-system EP,respectively.

3 Query Answering on Quad-Systems

In the realm of quad-systems, the classical conjunctive queries or select-project-joinqueries are slightly extended to what we callContextualized Conjunctive Queries(CCQs).A CCQCQ(x) is an expression of the form:

∃y q1(x,y) ∧ ... ∧ qp(x,y) (3)

whereqi, for i = 1, ..., p are quad patterns over vectors offree variablesx andquanti-fied variablesy. A CCQ is called a boolean CCQ if it does not have any free variables.With some abuse, we sometimes discard the logical symbols ina CCQ and consider itas a set of quad-patterns. For any CCQCQ(x) and a vectora of constants such that‖x‖ = ‖a‖,CQ(a) is boolean. A vectora is ananswerfor a CCQCQ(x) w.r.t. struc-tureIC , in symbolsIC |= CQ(a), iff there exists assignmentµ : {y} → B such thatIC |=

⋃

i=1,...,p qi(a,y)[µ]. A vectora is a certain answerfor a CCQCQ(x) overa quad-systemQSC , iff IC |= CQ(a), for every modelIC of QSC . Given a quad-systemQSC , a CCQCQ(x), and a vectora, decision problem of determining whetherQSC |= CQ(a) is called theCCQ EP. It can be noted that the other decision problemsover quad-systems, namely Quad/Quad-graph EP, BR(s) EP, Quad-system EP, are re-ducible to the CCQ EP (See Property 6). Hence, in this paper, we primarily focus onthe CCQ EP.

3.1 dChase of a Quad-System

In order to build a procedure for query answering over a quad-system, we employ whathas been called in the literature achase[20, 21]. Specifically, we adopt notions of therestricted chasein Fagin et al. [24] (also called non-oblivious chase). In order to fitthe framework of quad-systems, we extend the standard notion of chase to adistributedchase, abbreviateddChase. In the following, we show how the dChase of a quad-systemcan be constructed.

For a set of quad-patternsS and a set of termsT , we define the relationT -connectednessbetween quad-patterns inS as the least relation with:

– q1 andq2 areT -connected, ifCV(q1)∩CV(q2)∩T 6= ∅, for any two quad-patternsq1, q2 ∈ S,

– if q1 andq2 areT -connected, andq2 andq3 areT -connected, thenq1 andq3 arealsoT -connected, for any quad-patternsq1, q2, q3 ∈ S.

It can be noted thatT -connectedness is an equivalence relation and partitionsS intoa set ofT -components (similar notion is called apiecein Baget et al. [15]). Note thatfor two distinctT -componentsP1, P2 of S, CV(P1) ∩ C

V(P2) ∩ T = ∅. For anyBR r = body(r)(x, z) → head(r)(x,y), supposeP1, P2, . . . , Pk are the pairwisedistinct{y}-components ofhead(r)(x,y), thenr can be replaced by the semanticallyequivalent set of BRs{body(r)(x, z) → P1, . . . ,body(r)(x, z) → Pk} whose symbolsize is worst case quadratic w.r.t. the symbol size ofr. Hence, w.l.o.g. we assume thatfor any BRr, the set of quad-patternshead(r) is a single component w.r.t. the set ofexistentially quantified variables inr.

Considering the fact that the local semantics for contexts are fixed a priori (forinstance RDFS), both the number of rules in the set of local inference rules LIR and thesize of each rule in LIR can be assumed to be a constant. Note that each local inferencerule is range restricted and does not contain existentiallyquantified variables in its head.Any ir ∈ LIR is of the form:

∀x∀z [t1(x, z) ∧ . . . ∧ tk(x, z) → t′1(x)], (4)

whereti(x, z), for i = 1, . . . , n are triple patterns, whose variables are from{x} or{z}, andt′1(x) is a triple pattern, whose variables are from{x}. Hence, for any quad-systemQSC = 〈QC , R〉 in order to accomplish the effect of local inferencing in eachcontextc ∈ C, for eachir ∈ LIR of the form (4), we could augmentR with a BRirc ofthe form:

∀x∀z [c : t1(x, z) ∧ . . . ∧ c : tk(x, z) → c : t′1(x)]

Since‖LIR‖ is a constant and the size of the augmentation is linear in|C|, w.l.o.g weassume that the setR contains a BRirc, for eachir ∈ LIR, c ∈ C.

Given a quad-systemQSC , we denote byBsk ⊆ B, a set of blank nodes calledSkolem blank nodes, such thatBsk ∩ B(QSC) = ∅. For any BRr = body(r)(x, z)→ head(r)(x, y) and an assignmentµ : {x} ∪ {z} → C, theapplicationof µ on r isdefined as:

apply(r, µ) = head(r)[µext(y)]

whereµext(y) ⊇ µ such thatµext(y)(yi) = : b is a fresh blank node fromBsk, foreachyi ∈ {y}.

We assume that there exists an order≺l (for instance, lexicographic order) on the setof constants. We extend≺l to the set of quads such that for any two quadsc : (s, p, o)and c′ : (s′, p′, o′), c : (s, p, o) ≺l c

′ : (s′, p′, o′), iff c ≺l c′, or c = c′, s ≺l s

′, orc = c′, s = s′, p ≺l p

′, or c = c′, s = s′, p = p′, o ≺l o′. It can be noted that≺l is a

strict linear order over the set of all quads. For any finite quad-graphQC, the≺l-greatestquad ofQC , denoted greatestQuad≺l

(QC), is the quadq ∈ QC such thatq′ ≺l q, forevery otherq′ ∈ QC . Also, the order≺q is defined over the set of finite quad-graphs asfollows: for any two finite quad-graphsQC ,Q′

C′ ,

QC ≺q Q′C′ , if (i) QC ⊂ Q′

C′ ;QC ≺q Q′

C′ , if (i) does not hold and (ii) greatestQu--ad≺l

(QC \ Q′C′) ≺l greatestQuad≺l

(Q′C′ \ QC);

QC 6≺q Q′C′ , if both (i) and (ii) are not satisfied;

A relationR over a setA is called astrict linear order iff R is irreflexive, transitive,andR(a, b) orR(b, a) holds, for every distincta, b ∈ A.

Property 1. LetQ be the set of all finite quad-graphs;≺q is a strict linear order overQ.

Also, we now define in parallel the dChase of a quad systemQSC = 〈QC , R〉 and thelevel of a quad in the dChase ofQSC as follows: any quad inQC is of level 0. Thelevel of a set of quads is the largest among levels of quads in the set. The level of anyquad that results from the application of a BRr w.r.t. an assignmentµ is one more

than the level of the setbody(r)[µ], if it has not already been assigned a level. Let≺be an ordering on the quad-graphs such that for any two quad-graphsQ′

C′ andQ′′C′′ of

the same level,Q′C′ ≺ Q′′

C′′ , iff Q′C′ ≺q Q′′

C′′ . ForQ′C′ andQ′′

C′′ of different levels,Q′

C′ ≺ Q′′C′′ , iff level of Q′

C′ is less than level ofQ′′C′′ . It can easily be seen that≺

is a strict linear order over the set of quad-graphs. For any BRs r, r′ and assignmentsµ, µ′ overV(body(r)),V(body(r′)), respectively,(r, µ) ≺ (r′, µ′) iff body(r)[µ] ≺body(r′)[µ′]. For any quad-graphQ′

C′ , a set of BRsR, a BRr ∈ R, an assignmentµ ∈V(body(r)) → C, let applicableR be the least ternary predicate defined inductivelyas:

applicableR(r, µ,Q′C′) holds, if (a) body(r)[µ] ⊆ Q′

C′ , head(r)[µ′′] 6⊆ Q′C′ , ∀µ′′

⊇ µ, and(b) 6 ∃r′ ∈ R, 6 ∃µ′ such thatr′ 6= r or µ′ 6= µ with (r′, µ′) ≺ (r, µ) and

applicableR(r′, µ′, Q′

C′);

For any quad-systemQSC = 〈QC , R〉, letdChase0(QSC) = QC ;dChasei+1(QSC) = dChasei(QSC) ∪ apply(r, µ), if there existsr = body(r)(x,

z)→ head(r)(x, y) ∈R, assignmentµ : {x} ∪ {z} →C such thatapplicableR(r, µ,dChasei(QSC));

dChasei+1(QSC) = dChasei(QSC), otherwise; for anyi ∈ N. The dChase ofQSC , noteddChase(QSC), is given as:

dChase(QSC) =⋃

i∈N

dChasei(QSC)

Intuitively, dChasei(QSC) can be thought of as the state ofdChase(QSC) at theend of iterationi. It can be noted that, if there existsi such thatdChasei(QSC) =dChasei+1(QSC), thendChase(QSC) is equal todChasei( QSC). A modelIC ofa quad-systemQSC is calleduniversal[30], iff the following holds:IC is a model ofQSC , and for any modelI ′C of QSC there exists a homomorphism fromIC to I ′C .

Theorem 1. For any consistent quad-systemQSC, the following holds: (i)dChase(QSC)is a universal model ofQSC .6, and (ii) for any boolean CCQCQ(), QSC |= CQ() iffthere exists a mapµ : V(CQ) → C such that{CQ()}[µ] ⊆ dChase(QSC).

An anolog of the above theorem for DLs and Databases is statedand proved in [25].Since the proof in [25] can easily be adapted to our case, we refer the reader to [25]for the proof. We call the sequencedChase0(QSC), dChase1(QSC), ..., thedChasesequenceof QSC. It should be noted that at each iterationi, after the application of aBR, any new quad added is assigned a level, and as a result any subset of the set of quadsin dChasei(QSC) has a level. This assignment of levels guarantees thatapplicableR(r,µ, dChasei(QSC)) is either true or false, for anyr ∈ R, assignmentµ : V(body(r))→ C. The following lemma shows that in a dChase sequence of a quad-system, anydChase iteration can be performed in time exponential w.r.t. the size of the largest BR.

6 ThoughdChase(QSC) is not an interpretation in a strict model theoretic sense, one can easilycreate the corresponding interpretationIdChase(QSC) = {Ic = 〈∆c, .c〉}c∈C, s.t. for everyc ∈ C, ∆c is equal to set of constants ingraphdChase(QSC)(c), and .c is s.t (s, p, o) ∈graphdChase(QSC)(c) iff (sc, oc) ∈ pc.

Lemma 1. For a quad-systemQSC = 〈QC , R〉, for anyi ∈ N+, the following holds:(i) dChasei(QSC) can be computed in timeO( |R| ∗ ‖dChasei−1(QSC)‖rs), wherers = maxr∈R‖r‖, (ii) ‖dChasei(QSC)‖ = O(‖dChasei−1(QSC)‖+ ‖R‖).

Proof. (i) We can first find, if there exists anr among the set of BRsR, assignmentµsuch thatapplicableR(r, µ, dChasei−1(QSC)) holds, in the following naive way: (1)bind the set of variables in all rules inR with the set of constants indChasei−1(QSC).Let this set be calledS. Note that|S| = O(|R|∗‖dChasei−1(QSC )‖‖rs‖), wherers =maxr∈R‖r‖. Also, note that each of the binding inS is of the formbody(r)(x, z)(µ)→ head(r)(x, y)(µ′) (♥), wherer ∈ R. (2) From the setS we filter out every bindingof the form (♥) in which x[µ] 6= x[µ′]. Let S′ be the resulting set after the abovefiltering operation. (3) From the setS′, we now filter out all the bindings of the form(♥) with head(r)(x, y)(µ′)⊆ dChasei−1(QSC), with resulting setS′′. (4) If S′′ = ∅,then there is nor ∈ R, assignmentµ such thatapplicableR(r, µ, dChasei−1(QSC))is True. Otherwise ifS′′ 6= ∅, then note that each binding of the form (♥) in S′′ issuch that condition (a) of the trueapplicableR(r, µ, dChasei−1(QSC)) is satisfied.Now, we can sortS′′ w.r.t. ≺ and select the least bindingb of the form (♥), so thatcondition (b) in True condition ofapplicableR() is satisfied forb. It can easily be seenthat applicableR(r, µ, dChasei−1(QSC)) holds for ther, µ extracted fromb. Sincethe size of each binding is at most‖rs‖, the operations (1)-(4) can be performed intime O(|R| ∗ ‖dChasei−1(QSC)‖rs). SincedChasei(QSC) = dChasei−1(QSC) ∪head(r)[µ], for r, µ with applicableR(r, µ, dChasei−1(QSC)), dChasei(QSC) canbe computed in timeO(‖dChasei−1(QSC )‖rs).

(ii) Trivially holds, since at worstdChasei(QSC) = dChasei−1(QSC)∪ head(r)[µ],for r ∈ R.

Lemma 2. For any quad-systemQSC, If : b is a Skolem blank node indChase(QSC),generated by the application of assignmentµ onr = body(r)(x, z) → head(r)(x, y),with µext(y)(yj) = : b, yj ∈ {y}, then : b is unique for(r, yj ,x[µext(y)]).

Proof. By contradiction, suppose if: b is not unique for(r, yj ,x[µext(y)]), i.e. thereexists : b′ 6= : b in dChase(QSC), with : b′ generated byr such that : b′ = µ′ext(y)(yj)andx[µext(y)] = x[µ′ext(y)]. W.l.o.g. suppose: b was generated in an iterationl ∈ Nand : b′ in an iterationm > l. This means thathead(r)(x,y)[µext(y)]⊆ dChasel(QSC),and hencehead(r)(x, y)[µext(y)] ⊆ dChasem−1(QSC). Also, sinceµ|x = µ′|x, there∃µ′′ ⊇ µ′ s.t.head(r)(x, y)[µ′′] ⊆ dChasem−1(QSC). This means that (a) part of thefunctionapplicableR is false, forapplicableR(r, µ′, dChasem−1(QSC)) to be true,and henceapplicableR(r, µ′, dChasem−1(QSC)) is false. Hence, our assumption that: b′ = yj [µ

′ext(y)] is false. Hence,: b is unique for(r, yj, x[µext(y)]).

Although we now know how to compute the dChase of a quad-system, which can beused for deciding CCQ EP, the following proposition revealsthat for the class of quad-systems whose BRs are of the form (2), which we callunrestricted quad-systems, thedChase can be infinite.

Proposition 1. There exists unrestricted quad-systems whose dChase is infinite.

Proof. Consider an example of a quad-systemQSc = 〈Qc, r〉, whereQc = {c : (a,rdf:type, C)}, and the BRr = c : (x, rdf:type, C) → ∃y c : (x, P , y), c : (y,rdf:type, C). The dChase computation starts withdChase0(QSc) = {c : (a,rdf:type,C)}, now the ruler is applicable, and its application leads todChase1(QSc)= {c : (a,rdf:type,C), c : (a, P, : b1), c : ( : b1,rdf:type,C)}, where : b1 is afresh Skolem blank node. It can be noted thatr is yet again applicable ondChase1(QSc),for c : ( : b1, rdf:type, C), which leads to the generation of another Skolem blanknode, and so on. Hence,dChase(QSc) does not have a finite fix-point, anddChase(QSc)is infinite.

A classC of quad-systems is called afinite extension class(FEC), iff for every mem-berQSC ∈ C, dChase(QSC) is a finite set. Therefore, the class of unrestricted quad-systems is not a FEC. This raises the question if there are other approaches that canbe used, for instance, a similar problem of non-finite chase is manifested in descriptionlogics (DLs) with value creation, due to the presence of existential quantifiers, whereasthe approaches like the one in Glimm et al. [28] provides an algorithm for CQ entail-ment based on query rewriting. Theorem 2 below establishes the fact that the CCQ EPfor unrestricted quad-systems is undecidable. Despite this, the reader should note thatthe following undecidability result and its proof is only provided for the sake of selfcontainedness, and we do not claim the undecidability theorem nor its proof to be anovel contribution, as we will show in section 6, ternary∀∃ rule sets are polynomiallyreducible to unrestricted quad-systems. Hence, the undecidability results provided inBaget et al. [15], Krotzsch et al. [39], or Beeri et al. [14] can trivially be applied in oursetting to obtain the undecidability result for unrestricted quad-systems.

Theorem 2. The CCQ entailment problem over unrestricted quad-systemsis undecid-able.

Proof. (sketch) We show that the well known undecidable problem of non-emptinessof intersection of context-free grammars (CFGs) is reducible to the CCQ entailmentproblem. Given two CFGs,G1 = 〈V1, T, S1, P1〉 andG2 = 〈V2, T, S2, P2〉, whereV1, V2 are the set of variables,T such thatT ∩ (V1 ∪ V2) = ∅ is the set of terminals.S1 ∈ V1 is the start symbol ofG1, andP1 are the set of PRs of the formv → w, wherev ∈ V , w is a sequence of the formw1...wn, wherewi ∈ V1 ∪ T . s2, P2 are definedsimilarly. Deciding whether the language generated by the grammarsL(G1) andL(G2)have non-empty intersection is known to be undecidable [33].

Given two CFGsG1 = 〈V1, T, S1, P1〉 andG2 = 〈V2, T, S2, P2〉, we encode gram-marsG1, G2 into a quad-systemQSc = 〈Qc, R〉, with only a single context identifierc. Each PRr = v → w ∈ P1 ∪ P2, with w = w1w2w3..wn, is encoded as a BR ofthe form: c : (x1, w1, x2), c : (x2, w2, x3), ..., c : (xn, wn, xn+1) → c : (x1, v, xn+1),wherex1, .., xn+1 are variables. For each terminal symbolti ∈ T , R contains a BR ofthe form:c : (x,rdf:type, C) → ∃y c : (x, ti, y), c : (y, rdf:type, C) andQc isthe singleton:{ c : (a, rdf:type,C)}. It can be observed that:

QSc |= ∃y c : (a, S1, y) ∧ c : (a, S2, y) ⇔

L(G1) ∩ L(G2) 6= ∅

We refer the reader to Appendix for the complete proof.

Having shown the undecidability results of query answeringof unrestricted quad-systems,the rest of the paper focuses on defining subclasses of unrestricted quad-systems forwhich query answering is decidable, and establishing theirrelationships with similarclasses in the realm of∀∃ rules. While defining decidable classes for quad-systems, onemainly has two fundamentally distinct options: (i) is to define notions that solely usethe structure/properties of the BR part, ignoring the quad-graph part, or (ii) to define no-tions that takes into account both the BR and quad-graph part. The decidability notionswhich we define in section 4, namely safety, msafety, and csafety belong to type (ii), asthese techniques take into account the property of the dChase of a quad-system, whichis determined by both the quad-graph and BRs of the quad-system. Whereas the oneswhich we define in section 5, namely RR and restricted RR quad-systems fall into type(i), as the properties of BRs alone are used. With an analogy between a set of BRs anda set of∀∃ rules, and between a quad-graph and a set of∀∃ instances, the reader shouldnote that such distinctions can also be made for the decidability notions in the realm of∀∃ rule sets. Techniques such as Weak acyclicity [24], Joint acyclicity [38], and Acyclicgraph of rule dependencies [15] belong to type (ii), as thesenotions ignore the instancepart. Whereas techniques such as model faithful acyclicity[32] and model summarizingacyclicity [32] are of type (i) as both the rules and instancepart is considered.

4 Safe, Msafe and Csafe Quad-Systems: Decidable FECs

In the previous section, we saw that the query answering problem over unrestrictedquad-systems is undecidable, in general. We will also see insection 6 that any quad-system is polynomially translatable to a∀∃ rule set, which is also a first order logictheory. Hence, a possible solution approach is to translateto these more expressive lan-guages, and apply well known tests (see related work for details on such tests) availablein these languages to check if query answering is decidable.If the translated quad-system passes one of these tests, then query answering can beperformed on this trans-lation using available algorithms in these expressive languages. But such an approachis often discouraged, because of the non-applicability of the already available tools andtechniques available for reasoning over quads. Instead, wein the following define threeclasses of quad-systems, namelySAFE, MSAFE andCSAFE, that are FECs and for whichquery entailment is decidable. Finiteness/decidability is achieved by putting certain re-strictions (explained below) on the blank nodes generated in the dChase.

Recall that, for any quad-systemQSC, the set of blank-nodesB(dChase(QSC))in its dChase(QSC) not only contains blank nodes present inQSC, i.e.B(QSC), butalso contains Skolem blank nodes that are generated during the dChase constructionprocess. Note that the following holds:Bsk(dChase(QSC)) = B(dChase(QSC)) \B(QSC). We assume w.l.o.g. that for any set of BRsR, any BR inR has a unique ruleidentifier, and we often writeri for the BR inR, whose identifier isi.

Definition 4 (Origin RuleId/Vector). For any Skolem blank node: b, generated inthe dChase by the application of a BRri = body(ri)(x, z) → head(ri)(x,y) usingassignmentµ : {x} ∪ {z} → C, i.e. : b = µext(y)(yj), for someyj ∈ y, we say thatthe origin ruleId of : b is i, denotedoriginRuleId( : b) = i. Moreoverw = x[µ] issaid to be the origin vector of: b, denotedoriginV ector( : b) =w.

As we saw in Lemma 2, any such Skolem blank node: b, generated in the dChase canuniquely be represented by the expression(i, j,w), wherei is rule id,j is identifier ofthe existentially quantified variableyj in ri substituted by : b during the applicationof µ on ri. Also in the above case, we denote relation between each constant k =µext(y)(xh), xh ∈ {x}, and : b with the relationchildOf. Moreover, since children ofa Skolem blank node can be Skolem blank nodes, which themselves can have children,one can naturally define relationdescendantOf=childOf+ as the transitive closure ofchildOf. Note that according to the above definition, ‘descendantOf’ is not reflexive.In addition, we could keep track of the set of contexts in which a blank-node was firstgenerated, using the following notion:

Definition 5 (Origin-contexts). For any quad-systemQSC and for any Skolem blanknode : b ∈Bsk(dCha- se(QSC)), the set of origin-contexts of: b is given byorigin--Contexts( : b) = {c | ∃i. c:(s, p, o) ∈ dChasei(QSC), s = : b or p = : b or o =: b, and∄j < i with c′:(s′, p′, o′) ∈ dChasej(QSC), s′ = : b or p′ = : b or o′ =: b, for any c′ ∈ C}.

Intuitively, origin-contexts for a Skolem blank node: b is the set of contexts in whichtriples containing : b are first generated, during the dChase construction. Note thatthere can be multiple contexts in which: b can simultaneously be generated. By settingoriginRuleId(k) = n.d., (resp.originV ector(k) = n.d., resp.originContexts(k)= n.d.,) wheren.d. is an ad hoc constant,∀k 6∈ Bsk(dChase(QSC)), we extend thedefinition of origin ruleId, (resp. origin vector, resp. origin-contexts) to all the constantsin the dChase of a quad-system.

Example 1.Consider the quad-system〈QC , R〉, whereQC = {c1 : (a, b, c)}. SupposeR is the following set:

R =

c1 : (x11, x12, z1) → c2 : (x11, x12, y1) (r1)c2 : (a, z2, x22) → c3 : (a, x22, y2) (r2)c2 : (z3, b, x32) → c3 : (b, x32, y3) (r3)c3 : (a, z41, x41), c3 : (b, z42, x42)

→ c2 : (y4, x41, a), c2 : (y4, x42, b) (r4)

Suppose that for brevity quantifiers have been omitted, and variables of the formyi oryij are implicitly existentially quantified. Iterations during the dChase construction are:

dChase0(QSC) = {c1:(a, b, c)}

dChase1(QSC) = {c1 : (a, b, c), c2 : (a, b, : b1)}

dChase2(QSC) = {c1:(a, b, c), c2 : (a, b, : b1), c3 : (a, : b1, : b2)}

dChase3(QSC) = {c1:(a, b, c), c2 : (a, b, : b1), c3 : (a, : b1, : b2),

c3 : (b, : b1, : b3)}

dChase4(QSC) = {c1:(a, b, c), c2 : (a, b, : b1), c3 : (a, : b1, : b2), c3 : (b, : b1,

: b3), c2 : ( : b4, : b2, a), c2 : ( : b4, : b3, b)}

dChase5(QSC) = dChase4(QSC),

:b4

4, 〈 :b2, :b3〉, {c2}

:b3

3, 〈 :b1〉,{c3}

:b2

2, 〈 :b1〉,{c3}

:b1

1, 〈a, b〉,{c2}

a b

Fig. 1: descendance graph of:b4 in example 1. Note: n.d. labels not shown

Also note:originRuleId( : b1) = 1, originRuleId( : b2) = 2, originRuleId( : b3) = 3,originRuleId( : b4) = 4,originV ector( :b1) = 〈a, b〉, originV ector( :b2) = originV ector( :b3) = 〈 : b1〉,originV ector( :b4) = 〈 :b2, :b3〉,also originContexts( :b1) = {c2}, originConte- xts( : b2) = originContexts(: b3) = {c3}, origin- Contexts( : b4) = {c2},

also : b1 descendantOf: b3, : b1 descendantOf: b2, : b2 descendantOf: b4, : b3descendantOf: b4, : b1 descendantOf: b4.

For any Skolem blank node: b (in dChase), its descendant hierarchy can be analyzedusing adescendance graph〈V,E, λr, λv, λc〉, which is a labeled graph rooted at: b,whose set of nodesV are constants in the dChase, the set of edgesE is such that(k, k′) ∈ E, iff k′ is a descendant ofk. λr, λv, λc are node labeling functions, such thatλr(k) = originRuleId(k),λv(k) = originV ector(k), andλc(k) = originContexts(k),for anyk ∈ V . The descendance graph for:b4 of Example 1 is shown in Fig.1. Forany two vectors of constantsv,w, we notev ∼= w, iff there exists a bijectionµ : B(v)→ B(w) such thatw = v[µ].

Definition 6 (safe, msafe, csafe quad-systems).A quad-systemQSC is said to beun-safe(resp.unmsafe, resp.uncsafe), iff there exist Skolem blank nodes: b 6= : b′ indChase(QSC) such that : b is a descendant of: b′, with originRuleId( : b) =originRuleId( : b′) and originV ector( : b) ∼= originV ector( : b′) (resp.origin-RuleId( : b) = originRuleId( : b′), resp.originContexts( : b) = originConte-

xts( : b′)). A quad-system issafe(resp.msafe, resp.csafe) iff it is not unsafe (resp.unmsafe, resp. uncsafe).

Intuitively, safe, msafe and csafe quad-systems, does not allow repetitive generationof Skolem blank-nodes with a certain set of attributes in itsdChase. The containmentrelation between the class of safe, msafe, and csafe quad-systems are established by thefollowing theorem:

Theorem 3. Let SAFE,MSAFE, andCSAFE denote the class of safe, msafe, and csafequad-systems, respectively, then the following holds:

CSAFE⊂ MSAFE ⊂ SAFE

Proof. We first showMSAFE ⊆ SAFE, by showing the inverse inclusion of their com-pliments, i.e.UNSAFE⊆ UNMSAFE. Suppose a given quad-systemQSC is unsafe, thenby definition its dChase contains two distinct Skolem blank nodes : b, : b′ such that: b is a descendant of: b′, with originRuleId( : b) = originRuleId( : b′) andoriginV ector( : b) ∼= originV ector( : b′). But this will imply thatoriginRuleId(: b) = originRuleId( : b′). Hence, by definition,QSC is unmsafe. HenceUNSAFE⊆

UNMSAFE (†).Now, we show thatCSAFE⊆ MSAFE by showingUNMSAFE ⊆ UNCSAFE. Suppose

a given quad-systemQSC = 〈QC , R〉 is unmsafe, then by definition its dChase containstwo distinct Skolem blank nodes: b, : b′ such that : b is a descendant of: b′, withoriginRuleId( : b) = originRuleId( : b′). But this implies that there exists a BRri= body(ri)(x, z)→ head(ri)(x, y), assignmentµ, (resp.µ′,) s.t. : b (resp. : b′) wasgenerated indChase(QSC) as result of application ofµ (resp.µ′) onri. That is : b =yj [µ

ext(y)], and : b′ = yk[µ′ext(y)], whereyj , yk ∈ {y}. We have the following two

subcases (i)j = k, (ii) j 6= k. Suppose (i)j = k, then it immediately follows thatoriginContexts( : b) = originContexts( : b′). Hence,QSC is uncsafe. Suppose (ii)j 6= k, then by construction of dChase, on application ofµ′ to ri, along with : b′, theregets also generated a Skolem blank node: b′′ = yj [µ

′ext(y)], with yj ∈ {y}. Since: b and : b′′ are generated by substitutions of the same variableyj ∈ {y} of BR ri,originContexts( : b) = originContexts( : b′′). Also considering that childOf( : b′)= childOf( : b′′) = {x[µ′ext(y)]}, we can deduce that: b is a descendant of: b′′.Hence, by definition, it holds thatQSC is uncsafe. HenceUNMSAFE ⊆ UNCSAFE (‡).

From† and‡, it follows thatCSAFE⊆ MSAFE ⊆ SAFE. To show that the contain-ments are strict, consider the quad-systemQSC in example 1. By definition,QSC ismsafe, however uncsafe, as the Skolem blank nodes: b1, : b4, which have the sameorigin contexts are s.t.: b1 is a descendant of: b4. Hence,CSAFE ⊂ MSAFE. ForMSAFE ⊂ SAFE, the following example shows an instance of a quad-system that isunmsafe, yet is safe.

Example 2.Consider the quad-systemQSC = 〈QC , R〉, whereQC = {c1 : (a, b, c),c2 : (c, d, e)},R is given by:

c1 : (x11, x12, x13), c2 : (x13, x14, z1) → c3 : (y1, x11, x12), c4 : (x12, x13, x14) (r1)

c3 : (x21, a, x22), c4 : (x22, x23, x24) → c1 : (x21, a, x22), c2 : (x22, x23, x24) (r2)

c3 : (x21, x22, a), c4 : (a, x23, x24) → c1 : (x21, x22, a), c2 : (a, x23, x24) (r3)

c3 : (x21, x22, x23), c4 : (x23, a, x24) → c1 : (x21, x22, x23), c2 : (x23, a, x24) (r4)

c3 : (x21, x22, x23), c4 : (x23, x24, a) → c1 : (x21, x22, x23), c2 : (x23, x24, a) (r5)

Note that for brevity quantifiers have been omitted, and variables of the formyi or yijare implicitly existentially quantified. Iterations during the dChase construction are:

dChase0(QSC) = {c1:(a, b, c), c2:(c, d, e)}

dChase1(QSC) = dChase0(QSC) ∪ {c3 : ( : b1, a, b), c4 : (b, c, d)}

dChase2(QSC) = dChase1(QSC) ∪ {c1 : ( : b1, a, b), c2 : (b, c, d)}

dChase3(QSC) = dChase2(QSC) ∪ {c3 : ( : b2, : b1, a), c4 : (a, b, c)}

dChase4(QSC) = dChase3(QSC) ∪ {c1 : ( : b2, : b1, a), c2 : (a, b, c)}

dChase5(QSC) = dChase4(QSC) ∪ {c3 : ( : b3, : b2, : b1), c4 : ( : b1, a, b)}

dChase6(QSC) = dChase5(QSC) ∪ {c1 : ( : b3, : b2, : b1), c2 : ( : b1, a, b)}

dChase7(QSC) = dChase6(QSC) ∪ {c3 : ( : b4, : b3, : b2), c4 : ( : b2, : b1, a)}

dChase8(QSC) = dChase7(QSC) ∪ {c1 : ( : b4, : b3, : b2), c2 : ( : b2, : b1, a)}

dChase9(QSC) = dChase8(QSC) ∪ {c3 : ( : b5, : b4, : b3), c4 : ( : b3, : b2,

: b1)}

dChase(QSC) = dChase9(QSC)

It can be seen that: b1, : b2, : b3, : b4, : b5 form a descendant chain, since: bi de-scendantOf : bi+1, for eachi = 1, . . . , 4. Also, originRuleId( : bi) = originRule-Id( : bi+1), for eachi = 1, . . . , 4. Hence it turns out thatQSC is unmsafe. However, itcan be seen thatoriginV ector( : b1) = 〈a, b, c, d〉, andoriginV ector( : b2) = 〈 : b1,a, b, c〉, andoriginV ector( : b3) = 〈 : b2, : b1, a, b〉, andoriginV ector( : b4) =〈 : b3, : b2, : b1, a〉, andoriginV ector( : b5) = 〈 : b4, : b3, : b2, : b1〉, andoriginV ector( : bi) 6∼= originV ector( : bj), for 1 ≤ i 6= j ≤ 5, and hence, by defini-tion,QSC is safe with a terminating dChase. It can be noticed that during each distinctapplication ofr1, the vector of constants bound to the vector of variables〈x11, . . . , x14〉are different w.r.t∼=. Safe quad-systems in this way are capable of recognizing suchpositive cases of finite dChases (which are classified as negative cases by msafe quad-systems) by also keeping track of the origin vectors of Skolem blank-nodes in theirdChases.

The following property shows that for a safe quad-system, the descendance graph ofany Skolem blank node in its dChase is a directed acyclic graph (DAG):

Property 2 (DAG property).For a safe (csafe, msafe) quad-systemQSC, and for anyblank nodeb ∈ Bsk(dChase(QSC)), its descendance graph is a DAG.

Proof. By construction, as there exists no descendant for any constantk ∈ C(QSC),there cannot be any out-going edge from any suchk. Hence, no member ofC(QSC)can be involved in cycles. Therefore, the only members that can be involved in cyclesare the members ofC(dChase(QSC))−C(QSC) =Bsk(dChase(QSC)). But if thereexists : b ∈ Bsk(dChase(QSC)), such that there exists a cycle through: b, thenthis implies that : b is a descendant of: b. This would violate the prerequisites ofbeing safe (resp. csafe, resp. msafe), and imply thatQSC is unsafe (resp. uncsafe, resp.unmsafe), which is a contradiction.

Algorithm 1:UnRavel (Descendance GraphG)/* procedure to unravel, a descendance graph into a tree */

Input : descendance graphG = 〈V,E, λr , λv , λc〉Output : A labeled TreeGbegin

G = 〈V,E, λr, λv , λc〉 := RemoveTranstiveEdges(G);foreachNodevo ∈ preOrder(G) do

if (k = indegree(vo)) > 1 then{v1, ..., vk} :=getFreshNodes();/* each vi 6∈ V is fresh */

/* replace old node vo by the fresh nodes in V */

removeNodeFrom(vo, V );addNodesTo({v1, ..., vk}, V );foreach(vo, v′) ∈ E do

/* replace each outgoing edge from vo with a fresh outgoing

edges from each fresh node vi */

removeEdgeFrom((vo, v′), E);

addEdgesTo({(v1, v′), ..., (vk, v

′)}, E);

i := 1;foreach(v′, vo) ∈ E do

/* replace each incoming edge of vo with an incoming edge for

a unique vi */

removeEdgeFrom((v′, vo), E);addEdgeTo((v′, vi), E);i++;

/* restrict node labels to the updated set of nodes in V */

λr := λr |V , λv := λv |V , λc := λc|V ;return G;

Since the descendance graphG of any Skolem blank node: b ∈ Bsk(dChase(QSC))is such thatG is rooted at : b and is acyclic, any directed path from: b terminatesat some node. Hence, one can use a tree traversal technique, such as preorder (visit anode first and then its children) to sequentially traverse nodes inG. Algorithm 1 takesa descendance graphG and unravels it into a tree. The algorithm first removes all thetransitive edges fromG, i.e. if there arev, v′ ∈ V with (v, v′) ∈ E andG containsa path of length greater than 1 fromv to v′, then it removes(v, v′). Note that, in theresulting graph, the presence of a path fromv to v′′ still gives us the information thatv′′ is a descendant ofv. The algorithm then traverses the graph in preorder fashion, asit encounters a nodev, if v has an indegreek greater than one, it replacesv with k freshnodesv1, ..., vk, and distributes the set of edges incident tov acrossv1, ..., vk, such that(i) eachvi has at-most one incoming edge (ii) all the edges incident tov are incidentto somevi, i ∈ {1, . . . , k}. Outgoing edges ofv are copied for eachvi. Hence, afterthe above operation eachvi has an indegree1, whereas outdegree ofvi is same as theoutdegree ofv, i ∈ {1, . . . , k}. Hence, after all the nodes are visited, every node exceptthe root in the new graphG has an indegree1.G is still rooted, connected, acyclic, andis hence a tree. The algorithm terminates as there are no cycles in the graph, and at somepoint reaches a node with no children. For instance, the unraveling of the descendancegraph of :b4 in Fig. 1 is shown in Fig. 2. The following property holds for any Skolemblank node of a safe quad-system.

:b4

4, 〈 :b2, :b3〉, {c2}

:b3

3, 〈 :b1〉,{c3}

:b2

2, 〈 :b1〉,{c3}

:b1

1, 〈a, b〉,{c2}

:b1

1, 〈a, b〉,{c2}

a ba b

Fig. 2: Descendance graph of Fig.1 unraveled into a tree. Note: n.d. labels are not shown

Property 3. For a safe quad-systemQSC = 〈QC , R〉, and any Skolem blank node indChase(QSC), the unraveling (Algorithm 1) of its descendance graph results in a treet = 〈V , E, λr , λv, λc〉 s.t.:

1. any leaf node oft is from the setC(QSC),2. any non-leaf node oft is fromBsk(dChase(QSC)),3. order(t) ≤ w, wherew =maxr∈R|fr(r)|,4. there cannot be a path betweenb 6= b′ ∈ V , with λr(b) = λr(b

′) andλv(b) ∼=λv(b

′),5. there cannot be a path betweenb 6= b′ ∈ V , with λr(b) = λr(b

′), if QSC is alsomsafe,

6. there cannot be a path betweenb 6= b′ ∈ V , with λc(b) = λc(b′), if QSC is also

csafe.

Proof. 1. Any noden in the descendance graph is such thatn ∈ C(dChase(QSC)),andC(dChas- e(QSC)) = C(QSC) ⊎ Bsk(dChase(QSC)). Since any memberm ∈ Bsk(dChase(QSC)) is generated from an application of a BR with an as-signmentµ such that its frontier variables are assigned byµ with a set of constants,m has at-least one child. But, sincen is a leaf node,n ∈ C(QSC).

2. Since no memberm ∈ C(QSC) can have descendants and any non-leaf nodehas children,m cannot be a non-leaf node. Hence, non-leaf nodes must be fromBsk(dChase( QSC)).

3. The order oft is the maximal outdegree among the nodes oft, and outdegree of anode is the number of children it has. Since any node int with non-zero outdegreeis a Skolem blank-node: b generated by application of an assignmentµ to r =

body(r)(x, z)→ head(r)(x, y) ∈ R, the number of children: b has equals‖x‖.Hence the order oft is bounded byw.

4. Since any path fromb to b′ implies thatb′ is a descendant ofb, it must be thecase thatλr(b) 6= λr(b

′) or λv(b) 6∼= λv(b′), otherwise safety condition would be

violated.5. Similar as above, immediate by definition.6. Similar as above, immediate by definition.

The property above is exploited to show that there exists a finite bound in the dChasesize and its computation time.

Lemma 3. For any safe/msafe/csafe quad-systemQSC = 〈QC ,R〉, the following holds:

(i) the dChase size‖dChase(QSC)‖ = O(22‖QSC‖

), (ii) dChase(QSC) can be com-puted in2EXPTIME, (iii) if ‖R‖ and the set of schema triples inQC is fixed to aconstant, then‖dChase(QSC)‖ is a polynomial in‖QSC‖ and can be computed inPTIME.

Proof. The proofs are provided for safe quad-systems, but sinceCSAFE⊂ MSAFE ⊂SAFE and since we are giving upper bounds, they also propagate trivially to msafe andcsafe quad-systems.

(i) For any Skolem blank node indChase(QSC), the size of its originVector isupper bounded byw = maxr∈R|fr(r)|. If S is the set of all origin vectors of blank-nodes indChase(QSC), then cardinality of the setS′ = S\ ∼= is upper bounded by(|U(QSC)| + |L(QSC)| + w)w , which means that|S′| = O(2‖QSC‖). Also, since theset of origin ruleId labels,Rids, can at most be|R|, the cardinality of the setRids×S′

=O(2‖QSC‖). For the descendance treet of any Skolem blank node ofdChase(QSC),since there cannot be paths int between distinctb andb′, such thatoriginRuleId(b) =originRuleId(b′) andoriginV ector(b) ∼= originV ector(b′), the length of any suchpath is upper bounded by|Rids × S′| = O(2‖QSC‖). However, it turns out that theabove upper bound provided is loose, as there is the need of additional filter BRsto transform/back-propagate vectors of constants associated with Skolem blank nodesgenerated by repetitive application of the same BR. For instance, consider the set ofBRs in eg: 2. The BRr1 transforms the origin vector to a new vector each time dur-ing its application. BRsr2 - r5 deals with back propagation of these vectors back toinput origin vectors of BRr1. Such filter BRs rule out the case of a BR being appliedto a quad that contains a Skolem blank node that was generatedusing the same BR onan isomorphic origin vector, ensuring that the safety criteria for Skolem blank-nodesgenerated is not violated. It turns out that the number of such filter BRs required ispolynomial w.r.t. to the number of descendants with the samerule id, for a node int.Hence, it turns out the depth oft is polynomially bounded by‖R‖. (Note that depth oft is bounded by|R| for msafe quad-systems. Also since, the set of origin context labelsare bounded by the set of existential variables inR, depth oft is bounded by‖R‖ forcsafe quad-systems.) Also order of the tree is bounded byw. Hence, any such tree canhave at mostO(2‖QSC‖) leaf nodes,O(2‖QSC‖) inner nodes, andO(2‖QSC‖) nodes.Since each of the leaf nodes can only be fromC(QSC) and each of the inner nodescorrespond to an existential variable inR, the number of such possible trees are clearly

bounded double exponentially in‖QSC‖, hence bounds the number of Skolem blanknodes generated in the dChase.

(ii) From (i) ‖dChase(QSC)‖ is double exponential in‖QSC‖, and since eachiteration add at-least one quad to its dChase, the number of iterations are boundeddouble exponentially in‖QSC‖. Also, by Lemma 1 any iterationi can be done intimeO(‖dChasei−1(QSC)‖‖R‖). Hence, by using (i), we get‖dChasei−1(QSC)‖ =

O(22‖QSC‖

). Hence, we can infer that each iterationi can be done in timeO(2‖R‖∗2‖QSC‖

).Also since the number of iterations is at most double exponential, computingdChase(QSC)is in 2EXPTIME.

(iii) Since‖R‖ is fixed to a constant, the set of existential variables is also a constant.In this case, since the size of the frontier of anyr ∈ R is also a constant, the order anddepth of any descendant treet of a Skolem blank node is a constant. Hence, the numberof (leaf) nodes oft is bounded by a constant. Also in this setting, the label of inner nodesof t, which correspond to existential variables, is also a constant, and the leaf nodes oft can only be a constant inC(QSC). Hence, the number of descendant trees and conse-quentially, the number of Skolem blank nodes generated is bounded byO(|C(QSC)|z),wherez is a constant. Hence, the set of constants generated indChase(QSC) is a poly-nomial in‖QSC‖, and so is‖dChase(QSC)‖.

Since in any dChase iteration except the final one, at least one quad is added, andalso since the final dChase can have at mostO(‖QSC‖z) triples, the total number ofiterations are bounded byO(‖QSC‖

z) (†). By Lemma 1, since any iterationi can becomputed inO(‖dChasei−1(QSC)‖‖R‖) time, and since‖R‖ is a constant, the timerequired for each iteration is a polynomial in‖dChasei−1(QSC)‖, which is at mosta polynomial in‖QSC‖. Hence, any dChase iteration can be performed in polynomialtime in size ofQSC (‡). From (†) and (‡), it can be concluded that dChase can becomputed in PTIME.

Lemma 4. For any safe/msafe/csafe quad-system, the following holds: (i) data com-plexity of CCQ entailment is inPTIME, (ii) combined complexity of CCQ entailmentis in 2EXPTIME.

Proof. Note that the proofs are provided for safe quad-systems, butsinceCSAFE ⊂MSAFE ⊂ SAFE and since we are giving upper bounds, they also propagate trivially tomsafe and csafe quad-systems.

Given a safe quad-systemQSC = 〈QC , R〉, sincedChase(QSC) is finite, a booleanCCQCQ() can naively be evaluated by binding the set of constants in the dChase tothe variables in theCQ(), and then checking if any of these bindings are contained indChase(QSC). The number of such bindings can at most be‖dChase(QSC)‖‖CQ()‖

(†).(i) Since for data complexity, the size of the BRs‖R‖, the set of schema triples,

and‖CQ()‖ is fixed to a constant. From Lemma 3 (iii), we know that under the abovementioned settings the dChase can be computed in PTIME and ispolynomial in thesize ofQSC . Since‖CQ()‖ is fixed to a constant, and from (†), binding the set ofconstants indChase(QSC) onCQ() still gives a number of bindings that is worst casepolynomial in the size of‖QSC‖. Since membership of these bindings can checked inthe polynomially sized dChase in PTIME, the time required for CCQ entailment is inPTIME.

(ii) Since in this case‖dChase(QSC)‖ = O(22‖QSC‖

) (‡), from (†) and(‡), bindingthe set of constants indChase(QSC) toCQ() amounts toO(2‖CQ()‖∗2‖QSC‖

) numberof bindings. Since the dChase is double exponential in‖QSC‖, checking the mem-bership of each of these bindings can be done in 2EXPTIME. Hence, the combinedcomplexity is in 2EXPTIME.

Theorem 4. For any safe/msafe/csafe quad-system, the following holds: (i) The datacomplexity of CCQ entailment isPTIME-complete (ii) The combined complexity ofCCQ entailment is2EXPTIME-complete.

Proof. (i)(Membership) See Lemma 4 for the membership in PTIME.(Hardness) Follows from the PTIME-hardness of data complexity of CCQ entailmentfor Range-Restricted quad-systems (Theorem 8), which are contained in safe/msafe/csafequad-systems.(ii) (Membership) See Lemma 4.(Hardness) See following heading.

4.1 2EXPTIME-Hardness of CCQ Entailment

In this subsection, we show that the combined complexity of the decision problem ofCCQ entailment for context acyclic quad-systems is 2EXPTIME-hard. We show this byreduction of the word-problem of a 2EXPTIME deterministic turing machine (DTM)to the CCQ entailment problem. We notify the reader that the technique we follow is,similar to works such as [35, 36], to iteratively generate a doubly exponential numberof objects that represent the configurations and cells of thetape of the DTM, and thensimulate its working by appropriate BRs. A DTMM is a tupleM = 〈Q,Σ,∆, q0, qA〉,where

– Q is a set of states,– Σ is a finite set of letters that includes the blank symbol�,– ∆ : (Q ×Σ) → (Q×Σ × {+1,−1}) is the transition function,– q0 ∈ Q is the initial state.– qA ∈ Q is the accepting state.

W.l.o.g. we assume that there exists exactly one accepting state, which is also the lonehalting state. A configuration is a wordα ∈ Σ∗QΣ∗. A configurationα2 is a successorof the configurationα1, iff one of the following holds:

1. α1 = wlqσσrwr andα2 = wlσ′q′σrwr, if ∆(q, σ) = (q′, σ′, R), or

2. α1 = wlqσ andα2 = wlσ′q′�, if ∆(q, σ) = (q′, σ′, R), or

3. α1 = wlσlqσwr andα2 = wlq′σlσ

′wr, if ∆(q, σ) = (q′, σ′, L).

whereq, q′ ∈ Q, σ, σ′, σl, σr ∈ Σ, andwl,wr ∈ Σ∗. Since number of configurationscan at most be doubly exponential in the size of the input string, and since 2EXP-TIME ⊆ 2EXPSPACE, the number of tape cells traversed by the DTM tapehead is alsobounded double exponentially. A configurationc = wlqwr is an accepting configura-tion iff q = qA. A languageL ⊆ Σ∗ is accepted by a 2EXPTIME bounded DTMM ,iff for everyw ∈ L,M acceptsw in timeO(22

‖w‖

).

Simulating DTMs using Safe Quad-SystemsConsider a double exponential time boundedDTM M = 〈Q,Σ,∆, q0, qA〉, and a stringw, with ‖w‖ = m. Suppose thatM termi-nates in22

n

time, wheren =mk, k is a constant. In order to simulateM , we constructa quad-systemQSM

C = 〈QMC , R〉, whereC = {c0, c1, ..., cn}, whose various elements

represents the constructs ofM . LetQMC be initialized with the following quads:

c0 : (k0,rdf:type, R), c0 : (k1,rdf:type, R), c0 : (k0,rdf:type,min0),

c0 : (k1,rdf:type,max0), c0 : (k0, succ0, k1)

Now for each pair of elements of typeR in ci, a Skolem blank-node is generated inci+1, and hence follows the recurrence relationr(j +1) = [r(j)]2, with seedr(0) = 2,which aftern iterations yields22

n

. In this way, a doubly exponentially long chain ofelements is created incn using the following set of rules:

ci : (x0,rdf:type, R), ci : (x1,rdf:type, R) → ∃y ci+1 : (x0, x1, y),

ci+1 : (y,rdf:type, R) (eBr)

The combination of the minimal element with the minimal element (elements of typemini) in ci create the minimal element inci+1, and similarly the combination of themaximal element with the maximal element (elements of typemaxi) in ci create themaximal element ofci+1:

ci+1 : (x0, x0, x1), ci : (x0,rdf:type,mini) → ci+1 : (x1,rdf:type,mini+1)

ci+1 : (x0, x0, x1), ci : (x0,rdf:type,maxi) → ci+1 : (x1,rdf:type,maxi+1)

The successor relationsucci+1 is created inci+1 using the following set of rules, usingthe well-known integer counting technique:

ci : (x1, succi, x2), ci+1 : (x0, x1, x3), ci+1 : (x0, x2, x4) → ci+1 : (x3, succi+1, x4)

ci : (x1, succi, x2), ci+1 : (x1, x3, x5), ci+1 : (x2, x4, x6), ci : (x3,rdf:type,

maxi), ci : (x4,rdf:type,mini) → ci+1 : (x5, succi+1, x6)

Each of the above set of rules are instantiated for0 ≤ i < n, and in this way afterngenerating dChase iterations,cn has doubly exponential number of elements of typeR,that are ordered linearly using the relationsuccn. By virtue of the first rule below, eachof the objects representing the cells of the DTM are linearlyordered by the relationsucc. Also the transitive closure ofsucc is defined as the relationsucct

cn : (x0, succn, x1) → cn : (x0, succ, x1)

cn : (x0, succ, x1) → cn : (x0, succt, x1)

cn : (x0, succt, x1), cn : (x1, succt, x2) → cn : (x0, succt, x2)

Also using a similar construction, we can reuse the22n−1

linearly ordered elements incn−1 to create another linearly ordered chain of a doubly exponential number of objectsin cn that represents configurations ofM , whose minimal element is of typeconInit,and the linear order relation beingconSucc.

Various triple patterns that are used to encode the possibleconfigurations, runs andtheir relations inM are:

(x0, head, x1) denotes the fact that in configurationx0, the head of the DTM is at cellx1.

(x0, state, x1) denotes the fact that in configurationx0, the DTM is in statex1.(x0, σ, x1) whereσ ∈ Σ, denotes the fact that in configurationx0, the cellx1 contains

σ.(x0, succ, x1) denotes the linear order between cells of the tape.(x0, succt, x1) denotes the transitive closure ofsucc.(x0, conSucc, x1) to denote the fact thatx1 is a successor configuration ofx0.(x0,rdf:type, Accept) denotes the fact that the configurationx0 is an accepting

configuration.

Since in our construction, eachσ ∈ Σ is represented as a relation, we could constrainthat no two lettersσ 6= σ′ are on the same cell using the following axiom:

cn : (z1, σ, z2), cn : (z1, σ′, z2) →

for eachσ 6= σ′ ∈ Σ. Note that the above BR has an empty head, is equivalent toasserting the negation of its body.

Initialization Suppose the initial configuration isq0w�, wherew = σ0...σn−1, thenwe enforce this using the following BRs in our quad-systemQSM

C as:

cn : (x0,rdf:type, conInit), cn : (x1,rdf:type,minn) → cn : (x0, head, x1),

cn : (x0, state, q0)

cn : (x0,rdf:type,minn) ∧n−1∧

i=0

cn : (xi, succ, xi+1) ∧ cn : (xj ,rdf:type,

conInit) →n−1∧

i=0

cn : (xj , σi, xi) ∧ cn : (xj ,�, xn)

cn : (xj ,rdf:type, conInit), cn : (xj ,�, x0), cn : (x0, succt, x1) → cn : (xj ,�, x1)

The last BR copies the� to every succeeding cell in the initial configuration.

Transitions For every left transition∆(q, σ) = (qj , σ′, −1), the following BR:

cn : (x0, head, xi), cn : (x0, σ, xi), cn : (x0, state, q), cn : (xj , succ, xi), cn : (x0,

conSucc, x1) → cn : (x1, head, xj), cn : (x1, σ′, xi), cn : (x1, state, qj)

For every right transition∆(q, σ) = (qj , σ′,+1), the following BR:

cn : (x0, head, xi), cn : (x0, σ, xi), cn : (x0, state, q), cn : (xi, succ, xj), cn : (x0,

conSucc, x1) → cn : (x1, head, xj), cn : (x1, σ′, xi), cn : (x1, state, qj)

Inertia If in any configuration the head is at celli of the tape, then in every successorconfiguration, elements in preceding and following cells ofi in the tape are retained.The following two BRs ensures this:

cn : (x0, head, xi), cn : (x0, conSucc, x1), cn : (xj , succt, xi), cn : (x0, σ, xj)

→ cn : (x1, σ, xj)

cn : (x0, head, xi), cn : (x0, conSucc, x1), cn : (xi, succt, xj), cn : (x0, σ, xj)

→ cn : (x1, σ, xj)

The rules above are instantiated for everyσ ∈ Σ.

AcceptanceA configuration whose state isqA is accepting:

cn : (x0, state, qA) → cn : (x0,rdf:type, Accept)

If a configuration of accepting type is reached, then it can beback propagated to theinitial configuration, using the following BR:

cn : (x0, conSucc, x1), cn : (x1,rdf:type, Accept) → cn : (x0,rdf:type, Accept)

Finally M acceptsw iff the initial configuration is an accepting configuration.LetCQM be CCQ:∃y cn : (y, rdf:type, conInit), cn : (y, rdf:type, Accept). Itcan easily be verified thatQSM

C |= CQM iff the initial configuration is an acceptingconfiguration. In order to prove the soundness and completeness of our simulation, weprove the following claims:

Claim. (1) The quad-systemQSMC in the aforementioned simulation is a csafe quad-

system

It can be noted that the only BRs in which existentials are present are the BRs used togenerate the double exponential chain of tape cells and configurations, and are of theform (eBr). Note that in each of application of such a BR, a blank-node : b generatedin a contextci, for any i = 1, . . . , n, is such thatoriginContexts( : b) = {ci} andhas exactly two child blank-nodes, each of whose origin contexts is{ci−1}. Hence, anySkolem blank-node generated in anyci, for i = 1 . . . n is such that its child blank-nodeshas origin contextsci−1. Thanks to the above property, it turns out that there existsnotwo blank-nodes: b, : b′ in the dChase ofQSM

C such that : b is a descendant of: b′

andoriginContexts( : b) = originContexts( : b′). ThereforeQSMC is csafe.

Claim. (2)QSMC |= CQM iff M acceptsw.

Suppose thatQSMC |=CQM , then by Theorem 1, there exists an assignmentµ : V(CQM )

→ C, with CQM [µ] ⊆ dChase(QSC). This implies that there exists a constanto inC(dChase(QSC)), with {cn : (o,rdf:type,Accept), cn : (o,rdf:type, conInit)}⊆ dChase(QSC . But thanks to the acceptance axioms it follows that there exists anconstanto′ such that{cn : (o, conSucc, o1), cn : (o1, conSucc, o2), . . . , cn : (on,conSucc, o′)} ⊆ dChase(QSC), andcn : (o′, rdf:type,Accept) ∈ dChase(QSC).

Also thanks to the initialization axioms, it can be seen thato represents the initial con-figuration ofM i.e. it represents the configuration in which the initial state isq0, and theleft end of the read-write tape containsw followed by trailing�s, with the read-writehead positioned at the first cell of the tape. Also the transition axioms makes sure that ifcn : (o, conSucc, o

′′) ∈ dChase(QSC), theno′′ represents a successor configuration ofo. That is, ifo represents the configuration in whichM is at stateq with read-write headat positionpos of the tape that contains a letterσ ∈ Σ, and if∆(q, σ) = (q′, σ′, D),theno′′ represents the configuration in whichM is at stateq′, in which read-write headis at the positionpos − 1/pos + 1 depending on whetherD = −1/ + 1, andσ′ is atthe positionpos of the tape. As a consequence of the above arguments, it follows thato′ represents an accepting configuration ofM , i.e. a configuration in which the state isqA, the lone accepting, halting state. This means thatM accepts the stringw.

For the converse, we briefly show that ifQSMC 6|= CQM thenM does not acceptw.

Suppose thatQSMC 6|= CQM , then by Theorem 1, for every assignmentµ : V(CQM )

→C, it should be the case thatCQM [µ] 6⊆ dChase(QSC). By the initialization axioms,we know that there exists a constanto ∈ C(dChase(QSC)) with cn : (o, rdf:type,conInit) ∈ dChase(QSC). We know thato represents the initial configuration ofM .Also by the initial construction axioms ofQSM

C , we know thato is the initial elementof a double exponential chain of objects that are linearly ordered by property symbolconSucc. From transition axioms we know that, if, for anyo′′, cn : (o, conSucc, o′′)∈ dChase(QSC), theno′′ represents a valid successor configuration ofo, which itselfholds foro′′, and so on. This means that for none of the succeeding double exponentialconfigurations ofM , the accepting stateqA holds. This means thatM does not reachan accepting configuration with stringw, and hence rejects it.

Since the construction above shows the existence of a polynomial time reduction ofthe word problem of a 2EXPTIME DTM, which is a 2EXPTIME-hard problem, to theCCQ entailment problem over csafe quad-systems, it immediately follows that CCQentailment over csafe/msafe/safe quad-systems is 2EXPTIME-hard.

4.2 Procedure for detecting safe/msafe/csafe quad-systems

In this subsection, we present a procedure for deciding whether a given quad-systemis safe (resp. msafe, resp. csafe) or not. If the quad-systemis safe (resp. msafe, resp.csafe), the result of the procedure is asafe dChase(resp.msafe dChase, csafe dChase)that contains the standard dChase, and can be used for query answering. Since the safety(resp. msafety, resp. csafety) property of a quad-system isattributed to the dChase ofthe quad-system, the procedure nevertheless performs the standard operations for com-puting the dChase, but also generate quads that indicate origin ruleIds and origin vec-tors (resp. origin ruleIds, resp. origin-contexts) of eachSkolem blank node generated.In each iteration, a test for safety is performed, by checking the presence of Skolemblank-nodes that violate the safety (resp. msafety, resp. csafety) condition. In case aviolation is detected, a distinguished quad is generated and the safe (resp. msafe, resp.csafe) dChase construction is aborted, prematurely. On thecontrary, if there exists aniteration in which no new quad is generated, the safe (resp. msafe, resp. csafe) dChasecomputation stops with a completed safe (resp. msafe, resp.csafe) dChase that contains

the standard dChase. Since all the additional quads produced for accounting informa-tion use a distinguished context identifiercc 6∈ C, the computed safe (resp. msafe, resp.csafe) dChase itself can be used for standard query answering. Before geting to thedetails of the procedure, we give a few necessary definitions.

Definition 7 (Context Scope).The context scope of a termt in a set of quad-patternsQ, denoted bycScope(t, Q) is given as:cScope(t, Q) = {c | c : (s, p, o) ∈ Q, s =t ∨ p = t ∨ o = t}.

For any quad-systemQSC = 〈QC , R〉, let cc be an ad hoc context identifier such thatcc 6∈ C, then forri = body(ri)(x, z)→ head(ri)(x, y) ∈R, we define transformationsaugS(ri), augM(ri), augC(ri) as follows:

augS(ri) = body(ri)(x, z) → head(ri)(x,y) ∧ ∀yj ∈ {y} [∧

xk∈{x}

cc : (xk,

descendantOf, yj) ∧ cc : (yj , descendantOf, yj) ∧ cc : (yj , originRuleId, i) ∧

cc : (yj , originVector,x)]

It should be noted thatcc : (yj , originVector,x) is not a valid quad pattern, and is onlyused for notation brevity. In the actual implementation, vectors can be stored using anrdf container data structure such asrdf:List, rdf:Seq or by typecasting it as astring.

augM(ri) = body(ri)(x, z) → head(ri)(x,y) ∧ ∀yj ∈ {y} [∧

xk∈{x}

cc : (xk,

descendantOf, yj) ∧ cc : (yj , descendantOf, yj) ∧ cc : (yj , originRuleId, i)]

augC(ri) = body(ri)(x, z) → head(ri)(x,y) ∧ ∀yj ∈ {y} [∧

xk∈{x}

cc : (xk,

descendantOf, yj) ∧ cc : (yj , descendantOf, yj) ∧∧

c∈cScope(yj,head(ri))

cc : (yj ,

originContext, c)]

Intuitively, the transformationaugS/augM/augC on a BRri, augments the head partof ri with additional types of quad patterns, which are the following:

1. cc : (xk, descendantOf, yj), for every existentially quantified variableyj in y anduniversally quantified variablexk ∈ {x}. This is done because, during dChase com-putation any application of an assignmentµ to ri such thatx[µ] = a, resulting inthe generation of a Skolem blank node: b = µext(y)(yj), anyai ∈ {a} is a de-scendant of : b. Hence, due to these additional quad-patterns, quads of theformcc : (ai, descendantOf,: b) are also produced, and in this way, keeps track of thedescendants of any Skolem blank node produced.

2. cc : (yj , descendantOf,yj), in order to maintain also the reflexivity of ‘descen-dantOf’ relation.

3. cc : (yj , originContext, c), for every existentially quantified variableyj in {y}, ev-ery c ∈ cScope(yj , head(ri)). This is done because during dChase computation,any application of an assignmentµ onri, such thatx[µ] = a, resulting in the gen-eration of a Skolem blank node: b = µext(y)(yj), c is an origin context of : b.Hence due to these additional quad-patterns, quads of the formcc : ( : b, originContext, c)is also produced. In this way, we keep track of the origin-contexts of any Skolemblank node produced.

4. cc : (yj , originVector,x), This is done because during the dChase computation,for any application of an assignmentµ on ri, such thatx[µ] = a, resulting inthe generation of a Skolem blank node: b = µext(y)(yj), a is the origin vectorof : b. Hence, due to these additional quad-patterns, quads of theform cc : ( : b,originVector,a) is also produced. In this way, we keep track of the origin vector ofany Skolem blank node produced.

5. cc : (yj , originRuleId,i), for every existentially quantified variableyj in {y}, in-order to keep track of the ruleId of the BR used to create any Skolem blank node.

It can be noticed that for any BRri without existentially quantified variables, the trans-formationsaugS/augM/augC leavesri unchanged. For any set of BRsR, let

augS(R) (resp.augM(R), resp.augC(R)) =⋃

ri∈R

augS(ri) (resp.augM(ri),

resp.augC(ri)) ∪ {cc : (x1, descendantOf, z1) ∧ cc : (z1, descendantOf, x2)

→ cc : (x1, descendantOf, x2)}

The function unSafeTest (resp. unMSafeTest, resp. unCSafeTest) defined below, givena BR ri = body(ri)(x, z) → head(ri)(x, y), an assignmentµ, and a quad-graphQchecks, if application ofµ onri violates the safety (resp. msafety, resp. csafety) condi-tion onQ.unSafeTest(ri, µ,Q)=True iff ∃ : b, : b′ ∈ B, with all the following conditions beingsatisfied:

– : b ∈ {x[µ]}, and– cc : ( : b′, descendantOf, : b) ∈ Q, and– cc : ( : b′, originRuleId, i) ∈ Q, and– cc : ( : b′, originVector,a) ∈ Q, anda ∼= x[µ].

Intuitively, unSafeTest returns True, ifµ applied tori will produce a fresh Skolemblank node : b′′, whose child : b ∈ {x[µ]}, and according to knowledge inQ, : b′

is a descendant of: b such that the origin ruleId of: b′ is i (which is also the originruleId of : b′′) and the origin vector of: b′ is isomorphic to the origin vector ofx[µ](which is also the origin vector of: b′′). The functions unMSafeTest and unCSafeTestare similarly defined as follows:unMSafeTest(ri, µ, Q)=True iff ∃ : b, : b′ ∈ B, with all the following conditionsbeing satisfied:

– : b ∈ {x[µ]}, and– cc : ( : b′,descendantOf,: b) ∈ Q, and

– cc : ( : b′, originRuleId,i) ∈ Q.

unCSafeTest(ri, µ, Q)=True iff ∃ : b, : b′ ∈ B, ∃yj ∈ {y}, with all the followingbeing satisfied:

– : b ∈ {x[µ]}, and– cc : ( : b′, descendantOf,: b) ∈ Q, and– {c | cc : ( : b′, originContext,c) ∈ Q} = cScope( yj , head(ri)(x, y)) \ {cc}.

For any BRri and an assignmentµ, thesafe/msafe/csafe applicationof µ on ri w.r.t. aquad-graphQC is defined as follows:

applysafe(ri, µ,QC) =

{

unSafe, If unSafeTest(ri, µ,QC) = True;apply(ri, µ), Otherwise;

applymsafe(ri, µ,QC) =

{

unMSafe, If unMSafeTest(ri, µ,QC) = True;apply(ri, µ), Otherwise;

applycsafe(ri, µ,QC) =

{

unCSafe, If unCSafeTest(ri, µ,QC) = True;apply(ri, µ), Otherwise;

whereunSafe= cc : (unsafe, unsafe, unsafe) (resp.unMSafe= cc : (unmsafe, unmsafe,unmsafe), resp.unCSafe= cc : (uncsafe, uncsafe, uncsafe)) is a distinguished quadthat is generated, if the prerequisites of safety (resp. msafety, resp. csafety) is violated.For any quad-systemQSC = 〈QC , R〉, we define itssafe dChasedChasesafe(QSC) asfollows:

dChasesafe0 (QSC) = QC ; dChasesafe

m+1(QSC) = dChasesafem (QSC) ∪ applysafe(ri,

µ, dChasesafem (QSC)), if ∃ ri ∈ augS(R), assignmentµ such thatapplicableaugS(R)(ri,

µ, dChasesafem (QSC));

dChasesafem+1(QSC) = dChasesafe

m (QSC), otherwise; for anym ∈ N.dChasesafe(QSC) =

⋃

m∈NdChasesafe

m (QSC)The termination condition for safe dChase computation can be implemented using

the following conditional: If there existsm such thatdChasesafe

m (QSC) = dChasesafem+1(QSC); then

dChasesafe(QSC) = dChasesafem (QSC).

The dChasesdChasemsafe(QSC) anddChasecsafe(QSC) are defined, similarly, for msafeand csafe quad-systems, respectively. We bring to the notice of the reader that althoughapplication of anyaugS(r) (resp.augM(r), resp.augC(r)) produces quad-patterns ofthe formcc : ( : b, descendantOf,: b), for any Skolem blank node: b generated, thereis no raise of a false alarm in the unSafeTest (resp. unMSafeTest, resp. unCSafeTest).This is because unSafeTest (resp. unMSafeTest, resp. unCSafeTest) on a bridge ruler= body(r)(x, z) → head(r)(x, y) and assignmentµ checks if the application ofµ ofr with the fresh : b′′ assigned to ayi ∈ {y} by µext(y) would have a child : b 6= b′′

assigned to somexi ∈ {x} by µ, such that there exists a quad of the formcc : ( : b′,descendantOf,: b) in the safe (resp. msafe, resp. csafe) dChase constructed sofar, and: b′′ and : b′ have the same origin ruleId and originVector (resp. originRuleId, resp.

originContexts). Note that in the above: b′ should also be distinct from: b′′, andhence rules out the case in which unSafeTest (resp. unMSafeTest, resp. unCSafeTest)returns True because of the detection of a blank node as a selfdescendant of itself.

The following theorem shows that the procedure above described for detecting unsafequad-systems is sound and complete:

Theorem 5. For any quad-systemQSC = 〈QC , R〉, the quadunSafe (resp.unMSafe,resp.unCSafe) ∈ dChasesafe(QSC) (resp.dChasemsafe(QSC), resp.dChasecsafe(QSC)),iff QSC is unsafe (resp. unmsafe, resp. uncsafe).

It should be noted that for any quad-systemQSC = 〈QC , R〉, dChasesafe(QSC) (resp.dChasemsafe(QSC), resp.dChasecsafe(QSC)) is a finite set and hence the iterative pro-cedure which we described earlier terminates, regardless of whetherQSC is safe (resp.msafe, resp. csafe) or not. This is because ifQSC is safe (resp. msafe, resp. csafe), then,as we have seen before, there exists a double exponential bound on number of quads inits dChase. Hence, there is an iteration in which no new quad is generated, which leadsto stopping of computation. Otherwise, ifQSC is unsafe (resp. msafe, resp. csafe), thenfrom Theorem 5, we know that the quadunSafe(resp.unMSafe, resp.unCSafe) getsgenerated indChasesafe(QSC) (resp.dChasemsafe(QSC), resp.dChasecsafe(QSC)) innot more thanO(22

‖QSC‖

) iterations. This implies that there exists an iterationm suchthat the quadunSafe (resp.unMSafe, resp.unCSafe) is in dChasesafe

m (QSC) (resp.dChasemsafe

m (QSC), resp.dChasecsafem (QSC)). W.l.o.g, letm be the first such iteration.

This means that there exists a BRri ∈ R with headhead(ri)(x, y), assignmentµsuch thatapplicableaugS(R)(ri, µ, dChasesafe

m−1(QSC)) (resp.applicableaugM(R)(ri,µ, dChasemsafe

m−1(QSC)), resp.applicableaugC(R)(ri, µ, dChasecsafem−1(QSC)) holds. By

construction, sincehead(ri)[µext(y)] is not generated, and instead the quadunSafe(resp.unMSafe, resp.unCSafe) is generated,applicableaugS(R)(ri,µ,dChasesafe

m (QSC))(resp.applicableaugM(R)(ri, µ, dChasemsafe

m (QSC)), resp.applicableaugC(R)( ri, µ,dChasecsafe

m (QSC)) holds yet again. This means that the termination condition is satis-fied at iterationm + 1, and hence computation stops. Note that regardless of whethera given quad-system is safe (resp. msafe, resp. csafe) or not, the number of safe (resp.msafe, resp. csafe) dChase iterations is double exponentially bounded in the size of thequad-system. Consequently, we derive the following theorem.

Theorem 6. Recognizing whether a quad-system is safe/msafe/csafe is in 2EXPTIME.

Also notice that after running procedure described above, if the quadunSafe(resp.un-MSafe, resp.unCSafe) is not generated, then its safe (resp. msafe, resp. csafe) dChaseitself can be used for CCQ answering, as in such a case the standard dChase is containedin safe (resp. msafe, resp. csafe) dChase, and all the quads generated for accounting in-formation have the context identifiercc. Hence, for any safe (resp. msafe, resp. csafe)quad-system, for any boolean CCQ that does not contain quad patterns of the formcc : (s, p, o), the dChase entails CCQ iff the safe (resp. msafe, resp. csafe) dChase en-tails CCQ.

A set of BRsR is said to beuniversally safe(resp.msafe, resp.csafe) iff, for anyquad-graphQC , the quad-system〈QC , R〉 is safe (resp. msafe, resp. csafe). For anyset of BRsR, whose set of context identifiers isC, also letUR be the set of URIsthat occur in the triple patterns ofR plus an additional ad hoc blank node: bcrit, thecritical quad-graphof R is defined as the set{c : (s, p, o)|c ∈ C, {s, p, o} ⊆ UR}. Thefollowing property illustrates how the critical quad-graph of a set of BRsR can be usedto determine, whether or notR is universally safe/msafe/csafe.

Property 4. A set of BRsR is universally safe (resp. msafe, resp. csafe) iff〈QcritC , R〉

is safe (resp. msafe, resp. csafe), whereQcritC is the critical quad-graph ofR.

5 Range Restricted Quad-Systems: Restricting to RangeRestricted BRs

In this section, we investigate the complexity of CCQ entailment over quad-systems,whose BRs do not have existentially quantified variables. Such BRs are of the form:

c1 : t1(x, z) ∧ ... ∧ cn : tn(x, z) → c′1 : t′1(x) ∧ ... ∧ c′m : t′m(x)

Note that any set of BRsR of the form above can be replaced by semantically equivalentsetR′, such that eachr ∈ R′ is the form:

c1 : t1(x, z), ..., cn : tn(x, z) → c′1 : t′1(x) (5)

Also ‖R′‖ is at most quadratic in‖R‖, and hence, w.l.o.g, we assume that eachr ∈ Ris of the form (5). Borrowing the parlance from the∀∃ rules setting, where rules whosevariables in the head part are contained in the variables in the body part are calledrange restricted rules [15], we call such BRsrange restricted(RR) BRs. We call aquad-system whose BRs are all of RR-type, aRR quad-system. Since there exists noexistentially quantified variable in the BRs of a RR quad-system, no Skolem blanknode is produced during dChase computation. Hence, there can be no violation of thesafety/msafety/csafety condition in section 4, and hence,the class of RR quad-systemsare contained in the class of safe/msafe/csafe quad-systems, and is also a FEC. Ofcourse, this containment is strict as any quad-system that contains a BR with an exis-tential variable is not RR. Since one can determine whether or not a given quad-systemis RR or not by simply iterating through set of BRs and checking their syntax, thefollowing holds:

Theorem 7. Recognizing whether a quad-system is RR can be done in lineartime.

In the following, we see that restricting to RR BRs, size of the dChase becomes polyno-mial w.r.t. size of the input quad-system, and the complexity of CCQ entailment furtherreduces compared to safe/msafe/csafe quad-systems.

Lemma 5. For any RR quad-systemQSC = 〈QC , R〉, the following holds: (i)‖dChase(QSC)‖= O(‖QSC‖4) (ii) dChase(QSC) can be computed inEXPTIME (iii) If ‖R‖ is fixedto be a constant,dChase(QSC) can be computed inPTIME.

Proof. (i) Note that the number of constants inQSC is roughly equal to‖QSC‖. Asno existential variable occurs in any BR in a RR quad-systemQSC , the set of constantsC(dChase(QSC)) is contained inC(QSC). Since eachc : (s, p, o) ∈ dChase(QSC) issuch thatc, s, p, o ∈ C(QSC), |dChase(QSC)|=O(|C(QSC )|4). Hence‖dChase(QSC)‖= O(|C(QSC)|4) = O(‖QSC‖4).

(ii) Since from (i) |dChase(QSC)| = O(‖QSC‖4), and in each iteration of thedChase at least one new quad is added, the number of iterations cannot exceedO(‖QSC‖4).

Since by Lemma 1, computation of each iterationi of the dChase requiresO(|R| ∗‖dChasei−1(QSC)‖rs) time, wherers = maxr∈R‖r‖, andrs ≤ ‖QSC‖, time re-quired for each iteration is of the orderO(2‖QSC‖) time. Although the number of it-erations is a polynomial, each iteration requires an exponential amount of time w.r.t‖QSC‖. Hence time complexity of dChase computation is in EXPTIME.

(iii) As we know that the time taken for application of a BRR isO(‖dChasei−1(QSC)‖‖R‖).Since‖R‖ is fixed to a constant, application ofR can be done in PTIME. Hence, eachdChase iteration can be computed in PTIME. Also since the number of iterations is apolynomial in‖QSC‖, computing dChase is in PTIME.

Theorem 8. Data complexity of CCQ entailment over RR quad-systems isPTIME-complete.

Proof. (Membership) Follows from the membership in P of data complexity of CCQentailment for safe quad-systems, whose expressivity subsumes the expressivity of RRquad-systems (Theorem 4).

(Hardness) In order to prove P-hardness, we reduce a well known P-complete prob-lem, 3HornSat, i.e. the satisfiability of propositional Horn formulas with at most 3 lit-erals. Note that a (propositional) Horn formula is a propositional formula of the form:

P1 ∧ . . . ∧ Pn → Pn+1 (6)

wherePi, for 1 ≤ i ≤ n + 1, are either propositional variables or constantst, f , thatrepresents true and false, respectively. Note that for any propositional variableP , thefact that “P holds” is represented by the formulat→ P , and “P does not hold” is rep-resented by the formulaP → f . A 3Horn formula is a formula of the form (6), where1 ≤ n ≤ 2. Note that any (set of) Horn formula(s)Φ can be transformed in polynomialtime to a polynomially sized setΦ′ of 3Horn formulas, by introducing auxiliary propo-sitional variables such thatΦ is satisfiable iffΦ′ is satisfiable. A pure 3Horn formula isa 3Horn formula of the form (6), wheren = 2. Any 3Horn formulaφ that is not purecan be trivially converted to equivalent pure form by appending a∧ t on the body partof φ. For instance,P → Q, can be converted toP ∧ t→ Q. Hence, w.l.o.g. we assumethat any set of 3Horn formulas is pure, and is of the form:

P1 ∧ P2 → P3 (7)

In the following, we reduce the satisfiability problem of pure 3Horn formulas to CCQentailment problem over a quad-system whose set of schema triples, the set of BRs, andthe CCQCQ are all fixed.

For any set of pure Horn formulasΦ, we construct the quad-systemQSC = 〈QC , R〉,whereC = {ct, cf}. For any formulaφ ∈ Φ of the form (7),QC contains a quadcf : (P1, P2, P3). In additionQC contains a quadct : (t, rdf:type, T ). R is the sin-gleton that contains only the following fixed BR:

ct : (x1,rdf:type, T ), ct : (x2,rdf:type, T ), cf : (x1, x2, x3) → ct : (x3,

rdf:type, T )

Let theCQ be the fixed queryct : (f,rdf:type, T ).Now, it is easy to see thatQSC |= CQ, iff Φ is not satisfiable.

Theorem 9. Combined complexity of CCQ entailment over RR quad-systemsis in EX-PTIME.

Proof. (Membership) By Lemma 5, for any RR quad-systemQSC , its dChasedChase(QSC)can be computed in EXPTIME. Also by Lemma 5, its dChase size‖dChase(QSC)‖is a polynomial w.r.t to‖QSC‖. A boolean CCQCQ() can naively be evaluated bygrounding the set of constants in the dChase to the variablesin theCQ(), and thenchecking if any of these groundings are contained indChase(QSC). The number ofsuch groundings can at most be‖dChase(QSC)‖‖CQ()‖ (†). Since‖dChase(QSC)‖ isa polynomial in‖QSC‖, there are an exponential number of groundings w.r.t‖CQ()‖.Since containment of each of these groundings can be checkedin time polynomial w.r.t.the size ofdChase(QSC), and since‖dChase(QSC)‖ is a polynomial w.r.t.‖QSC‖,the time complexity of CCQ entailment is in EXPTIME.

Concerning the combined complexity of CCQ entailment of RR quad-systems, we leavethe lower bounds open.

5.1 Restricted RR Quad-Systems

We call those quad-systems with BRs of form (5) with a fixed bound onn asrestrictedRR quad-systems. They can be further classified as linear, quadratic, cubic,..., quad-systems, whenn = 1, 2, 3, ..., respectively.

Theorem 10. Data complexity of CCQ entailment over restricted RR quad-systems isP-complete.

Proof. The proof is same as in Theorem 8, since the size of BRs are fixedto constant.

Theorem 11. Combined complexity of CCQ entailment over restricted RR quad-systemsis NP-complete.

Proof. Let the problem of deciding ifQSC |= CQ() be called DP’.(Membership) for anyQSC whose rules are of restricted RR-type, the size of any

r ∈ R is a constant. Hence, by Lemma 1, any dChase iteration can be computed inPTIME. Since the number of iterations is also polynomial in‖QSC‖, dChase(QSC)can be computed in PTIME in the size ofQSC anddChase(QSC) has a polynomialnumber of constants. Hence, we can guess an assignmentµ for all the existential vari-ables in CCQCQ(), to the set of constants indChase(QSC). Then, one can evaluatethe CCQ, by checking ifc : (s, p, o) ∈ dChase(QSC), for eachc : (s, p, o) ∈ CQ()[µ],which can be done in timeO(‖CQ‖ ∗ ‖dChase(QSC)‖), and is hence is in non-deterministic PTIME, which implies that DP’ is in NP.

(Hardness) We show that DP’ is NP-hard, by reducing the well known NP-hardproblem of 3-colorability to DP’. Given a graphG = 〈V , E〉, whereV = {v1, ...,vn}is the set of nodes,E ⊆ V × V is the set of edges, the 3-colorability problem is todecide if there exists a labeling functionl : V → {r, b, g} that assigns eachv ∈ V toan element in{r, b, g} such that the condition:(v, v′) ∈ E → l(v) 6= l(v′), for each(v, v′) ∈ E, is satisfied.

One can construct a quad-systemQSc = 〈Qc, ∅〉, wheregraphQc(c) has the fol-

lowing triples:{(r, edge, b), (r, edge, g), (b, edge, g), (b, edge, r), (g, edge, r), (g, edge, b)}LetCQ be the boolean CCQ:∃v1, ...., vn

∧

(v,v′)∈E [ c : (v, edge, v′)∧ c : (v′, edge, v)].Then, it can be seen thatG is 3-colorable, iffQSc |= CQ.

6 Quad-Systems and Forall-Existential rules: A formalcomparison

In this section, we formally compare the formalism of quad-systems with forall-existential(∀∃) rules, which are also called Tuple generating dependencies (Tgds)/Datalog+- rules.∀∃ rules is a fragment of first order logic in which every formulais restricted to a certainsyntactic form. A∀∃ rule is a first order formula of the form:

∀x∀z [p1(x, z) ∧ ... ∧ pn(x, z) → ∃y p′1(x,y) ∧ ... ∧ p′m(x,y)] (8)

wherex,y, z are vectors of variables such that{x}, {y} and{z} are pairwise disjoint,pi(x, z), for 1 ≤ i ≤ n are predicate atoms whose variables are fromx or z, p′1(x,y),for 1 ≤ i ≤ m are predicate atoms whose variables are fromx or y. We, for short,occasionally note a∀∃ rule of the form (8) asφ(x, z) → ψ(x, y), whereφ(x, z) ={p1(x, z), ..., pn(x, z)},ψ(x, y) = {p′1(x,y), ...p′m(x,y)}. A set of∀∃ rules is calleda∀∃ rule set. In the realm of∀∃ rule sets, a conjunctive query (CQ) is an expression ofthe form:

∃y p1(x,y) ∧ ... ∧ pr(x,y) (9)

wherepi(x,y), for 1 ≤ i ≤ r are predicate atoms over vectorsx or y. A boolean CQis defined as usual. The decision problem of whether, for a∀∃ rule setP and a CQQ,if P |=fol Q is called theCQ EP, where|=fol is the standard first order logic entailmentrelation.

For any quad-graphQC = {c1 : (s1, p1, o1), . . . , cn : (sr, pr, or)}, let rQC be theBR

→ ∃yb1 , . . . , ybq c1 : (s1, p1, o1)[µB] ∧ . . . ∧ cr : (sr, pr, or)[µB],

where{ : b1, . . . , : bq} is the set of blank nodes inQC, andµB is the substitutionfunction { : bi → ybi}i=1,...,q that assigns each blank-node to a fresh existentiallyquantified variable. It can be noted that the quad-systems〈QC , R〉 and〈∅, R ∪ {rQC}〉are semantically equivalent. The following definition gives the translation functions thatwill be necessary to establish the relation between quad-systems and∀∃ rule sets.

Definition 8 (Translations τq, τr, τccq, τ ). The translation functionτq from the set ofquad patterns to the set of ternary atoms is defined as: for anyquad-patternc : (s, p, o),τq(c : (s, p, o)) = c(s, p, o).

The translation functionτbr from the set of BRs to the set of∀∃ rules is defined as:for any BRr of the form (2):

τbr(r) = ∀x∀z [τq(c1 : t1(x, z)) ∧ ... ∧ τq(cn : tn(x,

z)) → ∃y τq(c′1 : t

′1(x,y)) ∧ ... ∧ τq(c

′m : t′m(x,y))],

The translation functionτ from the set of quad-systems to forall-existential rule setsis defined as: for any quad-systemQSC = 〈QC , R〉, τ(QSC) = τbr(R) ∪ {τbr(rQC )},whereτbr(R) =

⋃

r∈R τbr(r).The translation functionτccq from the set of boolean CCQs to the set of boolean

CQs is defined as: for any boolean CCQCQ = ∃y c1 : t1(a,y) ∧ . . .∧ cr : tr(a,y),τccq(CQ) is:

∃y τq(c1 : t1(a,y)) ∧ . . . ∧ τq(cr : tr(a,y)).

The following property gives the relation between CCQ entailment of unrestricted quad-systems and standard first order CQ entailment of∀∃ rule sets.

Property 5. For any quad-systemQSC, CCQCQ,QSC |= CQ iff τ(QSC) |=fol τccq(CQ).

Proof. Notice that every contextc ∈ C becomes a ternary predicate symbol in theresulting translation. Also,τ(QSC) is a∀∃ rule set, and for any CCQCQ, τccq(CQ) isa CQ.

In order to construct the restricted chase forτ(QSC), suppose that≺q is also ex-tended to set of instances such that for any two quad-graphsQC, Q′

C′ , QC ≺q Q′C′ iff

τq(QC) ≺q τq(Q′C′). Suppose≺ is extended similarly to set of instances. Also assume

that during the construction of standard chasechase(τ(QSC)) of τ(QSC), for any ap-plication of aτbr(r) with existential variables, withr ∈ R, suppose that the Skolemblank nodes generated inchase(τ(QSC)) follow the same order as they are generatedin dChase(QSC). Also let us extend the rule applicability function to the∀∃ rules set-tings such that for any set of BRsR, for anyr ∈ R, quad-graphQ′

C′ , assignmentµ,applicableR(r, µ,Q

′C′) iff applicableτbr(R)(τbr(r), µ, τq(Q′

C′)).NowdChase0(〈∅,R ∪ {rQC}〉) = ∅, and alsochase0(τ(QSC)) = ∅,dChase1(QSC)

= apply(rQC ,µ∅), whereµ∅ is the empty function,chase1(τ(QSC)) = apply(τbr(rQC ),µ∅), and so on. It is straightforward to see that for anym ∈ N, τq( dChasem(〈∅, R ∪{rQC}〉)) = chasem(τ(QSC)). As a consequence,τq(dChase(QSC)) = chase(τ(QSC)),and{CQ}[σ] ⊆ dChase(QSC) iff {τccq(CQ)}[σ] ⊆ chase(τ(QSC)).

Hence, applying Theorem 1 and the analogous theorem for∀∃ rulesets from Deutchet al. [30], it follows that for any quad-systemQSC = 〈QC ,R〉 and a boolean CCQCQ,QSC |= CQ iff τ(QSC) |=fol τccq(CQ).

Theorem 12. There exists a polynomial time translation functionτ (resp.τccq) from theset of unrestricted quad-systems (resp. CCQs) to the set of∀∃ rule sets (resp. CQs), suchthat for any unrestricted quad-systemQSC and a CCQCQ, QSC |= CQ iff τ(QSC)|=fol τccq(CQ).

Proof. It is easy to see thatτq, τbr, τ , andτccq in Definition 8 can be implementedusing simple syntax transformation, by iterating through the respective components ofa quad-system/CCQ, and the time complexity of these functions are linear w.r.t theirinputs.

Notice that for any CCQCQ (resp. CQQ), → CQ (resp.→ Q) is a bridge (resp.∀∃)rule, with an empty body. Also, since for any quad-graphQC, the translation functionτbr defined above can directly be applied onrQC to obtain a∀∃ rule, the followingtheorem immediately follows:

Theorem 13. For quad-systems, the EPs: (i) quad EP, (ii) quad-graph EP, (iii) BREP, (iv) BRs EP, (v) Quad-System EP, and (vi) CCQ EP are polynomially reducible toentailment of∀∃ rule sets.

A ∀∃ rule setP is said to be aternary∀∃ rule set, iff all the predicate symbols in the vo-cabulary ofP are of arity less than or equal to three.P is apurely ternaryrule set, iff allthe predicate symbols in the vocabularyP is of arity three. Similarly, a (purely) ternaryCQ is defined. The following property gives the relation between the CQ entailmentproblem of∀∃ rule sets and CCQ EP of unrestricted quad-systems.

Theorem 14. There exists a polynomial time tranlation functionν (resp. νcq) fromternary ∀∃ rule sets (resp. ternary CQs) to unrestricted quad-systems(resp. CCQs)such that for any ternary∀∃ rule setP and a ternary CQQ, P |=fol CQ iff 〈∅, ν(P)〉|= νcq(Q).

Proof. Note that the CQ EP of any ternary∀∃ rule setP, whose set of predicate symbolsis P , and CQQ overP , can polynomially reduced to the CQ EP of a purely ternaryrule setP′ and purely ternary CQQ′, by the following transformation functionχ. Let� be an adhoc fresh URI;χ is such that for any ternary atomc(s, p, o), χ(c(s, p, o)) =c(s, p, o). For any binary atomc(s, p), χ(c(s, p)) = c(s, p,�), and for any unary atomc(s), χ(c(s)) = c(s,�,�). For any∀∃ ruler of the form (8),

χ(r) = ∀x∀z [χ(p1(x, z)) ∧ . . . ∧ χ(pn(x, z))

→ ∃y χ(p′1(x,y)) ∧ . . . ∧ χ(p′m(x,y))]

And, for any∀∃ rule setP, χ(P) =⋃

r∈Pχ(r). For any CQQ, χ(Q) is similarly

defined. Note that for any ternary∀∃ rule setP, ternary CQQ, χ(P) (resp.χ(Q)) ispurely ternary, andP |=fol Q iff χ(P) |=fol χ(Q).

Also, it can straightforwardly seen thatτ−1br (χ(P)) (resp.τ−1

ccq(χ(Q))) is a set ofBRs (resp. CCQ). Suppose,ν(P) is such thatν(P) = QSC = 〈∅, τ−1

br (χ(P))〉. Intu-itively, C contains a context identifierc, for each predicate symbolc ∈ P . Also suppose,νcq(Q) = τ−1

ccq(χ(Q)). Notice thatνcq(Q) is CCQ. It can straightforwardly seen thatνandνcq can be computed in polynomial time, andP |=fol Q iff ν(P) |= νcq(Q).

Thanks to Theorem 12 and Theorem 14, the following theorem immediately holds:

Theorem 15. The CCQ EP over quad-systems is polynomially equivalent to CQ EPover ternary∀∃ rule sets.

By virtue of the theorem above, we derive the following property:

Property 6. For quad-systems, the Quad EP, Quad-graph EP, BR(s) EP, and Quad-system EP are polynomially reducible to CCQ EP.

Proof. The following claim is a folklore in the realm of∀∃ rules.

Claim. (1) The∀∃ rule set EP is polynomially reducible to CQ EP.

Reducibility of∀∃ rule EP to CQ EP is a folklore in the realm of∀∃ rules. For a formalproof, we refer the reader to Baget et al. [15], where it is shown that the∀∃ rule EPis polynomially reducible to fact (a set of instances) EP, and fact EP are equivalent toCQ EP. Also, Cali et al [34] show that CQ containment problem,which is equivalent to∀∃ rule EP, is reducible to CQ EP. Since a∀∃ rule set is a set of∀∃ rules, by using aseries of oracle calls to a function that solves the∀∃ rule EP, we can define a functionfor deciding∀∃ rule set entailment. Hence, the claim holds.

(a) Thanks to translation functionsτ , τbr defined earlier, such that for any quad-systemQSC , quad-graphQ′

C′ , QSC |= Q′C′ iff τ(QSC) |=fol τbr(rQ′

C′), we can infer

that quad-graph EP is polynomially reducible to∀∃ rule set EP. Applying claim 1,it follows the quad-graph EP over quad-systems is polynomially reducible to CQ EPover∀∃ rule sets. By Theorem 14, we can deduce that quad-graph EP is polynomiallyreducible to CCQ EP.

(b) By the translation functionsτ andτbr , defined earlier, such that for any quad-systemQSC, a set of BRsR,QSC |= R iff τ(QSC) |=fol τbr(R), we can infer that BRsEP is polynomially reducible to∀∃ rule set EP. Similar to (a) above, we deduce thatBRs EP is polynomially reducible to CCQ EP.

From (a) and (b), it follows that Quad-system EP is reducibleto CCQ EP.

Having seen that the CCQ EP over quad-systems is polynomially equivalent to CQ EPover ternary∀∃ rule sets, we now compare some of the well known techniques used toensure decidability of CQ entailment in the∀∃ rules settings to the decidability tech-niques for quad-systems that we saw earlier in the previous sections. Note that sinceall the quad-system classes we proposed in this paper are FECs, for a judicious com-parison, the∀∃ rule classes to which we compare are classes which have a finite chaseproperty. We compare to the following three well known classes: (i) Weakly Acyclicrule sets (WA), (ii) Jointly Acyclic rule sets (JA), and (iii) Model Faithful Acyclic∀∃rule sets (MFA). The following property is well known in the realm of∀∃ rules:

Property 7. For the any∀∃ rule setP, the following holds:

1. If P ∈ WA, thenP ∈ JA (from [38]),2. If P ∈ JA, thenP ∈ MFA (from [32]),3. WA ⊂ JA ⊂ MFA (from [38] and [32]).

Note that a description of few other∀∃ rule classes that do not have the finite chaseproperty, but still enjoy decidability of CQ entailment aregiven in the related work.

6.1 Weak Acyclicity

Weak acyclicity [24, 26] is a popular technique used to detect whether a∀∃ rule sethas a finite chase, thus ensuring decidability of query answering. The setWA representsclass of ternary∀∃ rule sets that have the weak acyclicity property.

For any predicate atomp(t1, . . . , tn), an expression〈p, i〉, for i = 1, . . . , n is calleda position ofp. In the above case,t1 is said to occur at position〈p, 1〉, t2 at〈p, 2〉, and soon. For a set of∀∃ rulesP, its dependency graph is a graph whose nodes are positionsof predicate atoms inP; for eachr ∈ P of the form (8), and for any variablex occurringin position〈p, i〉 in head ofr:

〈c1, 1〉

〈c1, 2〉

〈c2, 1〉

〈c2, 3〉

〈c2, 2〉

〈c3, 3〉〈c3, 2〉

∗

∗

∗

∗

Fig. 3: Dependency graph of the quad-system in Example 1.

1. if x is universally quantified andx occurs in the body ofr at position〈p′, j〉, thenthere exists an edge from〈p′, j〉 to 〈p, i〉

2. if x is existentially quantified, then for any universally quantified variablex′ oc-curring in the head ofr, with x′ also occurring in the body ofr at position〈p′, j〉,there exists a special edge from〈p′, j〉 to 〈p, i〉.

P is called weakly acyclic, iff its dependency graph does not contain cycles goingthrough a special edge. For any∀∃ rule setP, if P is WA, then its chase is finite, andhence CQ EP is decidable. Note that the nodes in the dependency graph that has in-coming special edges corresponds to the positions of predicates where new values arecreated due to existential variables, and the normal edges capture the propagation ofconstants from one predicate position to another predicateposition. In this way, ab-sence of cycles involving special edges ensures that newly created Skolem blank nodesare not recursively used to create other new Skolem blank nodes in the same position,leading to termination of chase computation.

Example 3.Let us revisit the quad-systemQSC = 〈QC , R〉 mentioned in example 1,whose dependency graph is shown in Fig. 3. Note that theQSC is uncsafe, since itsdChase contains a Skolem blank-node: b4, which has as descendant another Skolemblank node : b1, with the same origin contextc2 (see Fig. 1). However, it can be seenfrom Fig. 3 that the dependency graph ofτ(QSC) does not contain any directed cycleinvolving special edges. Henceτ(QSC) is weakly acyclic.

It turns out that there exists no inclusion relationship between the classesWA andCSAFE

in either directions, i.e.WA 6⊆ CSAFE (from example 3), andCSAFE 6⊆ WA (from thefact thatWA ⊂ JA, and example 4 below). WhereasWA ⊂ MSAFE, sinceWA ⊂ MFA andMFA ≡ MSAFE (Theorem 16).

6.2 Joint Acyclicity

Joint acyclicity [38] extends weak acyclicity, by also taking into consideration the joinbetween variables in body of∀∃ rules while analyzing the rules for acyclicity. The set

JA represents the class of all ternary∀∃ rule sets that have the joint acyclicity property.A ∀∃ rule setP is said to berenamed apart, if for any r 6= r′ ∈ R, V(r) ∩V(r′) = ∅.Since any set of rules can be converted to an equivalent renamed apart one by simplevariable renaming, we assume that any rule setP is renamed apart. Also for anyr ∈ Pand for a variabley, letPosrH(y) (PosrB(y)) be the set of positions in whichy occurs inthe head (resp. body) ofr. For any∀∃ rule setP and an existentially quantified variabley occurring in a rule inP, we defineMovP(y) as the least set with:

– PosrH(y) ⊆MovP(y), if y occurs inr;– PosrH(x) ⊆ MovP(y), if x is a universally quantified variable andPosrB(x) ⊆MovP(y);

for any r ∈ P. The existential dependency graph of a (renamed apart) set of rulesPis a graph whose nodes are the existentially quantified variables inP. There exists anedge from a variabley to y′, if there is a ruler ∈ P in whichy′ occurs and there existsa universally quantified variablex in the head (and body) ofr such thatPosrB(x) ⊆MovP(y). A ∀∃ rule setP is jointly acyclic, iff its existential dependency graph isacyclic. Analyzing the containment relationships, it happens to be the case thatJA 6⊆CSAFE(sinceWA ⊂ JA, and eg. 3). Also example 4 shows us thatCSAFE 6⊆ JA. HoweverJA ⊂ MSAFE, sinceJA ⊂ MFA andMFA ≡ MSAFE (Theorem 16).

Example 4.Consider the quad-systemQSC = 〈QC , R〉, whereQC = {c1 : (a, b, c)}.SupposeR is the following set:

R =

c1 : (x11, x12, z1) → c2 : (x11, x12, y1) (r1)c1 : (x21, x22, z2), c2 : (x22, x21, x23) → c3 : (x21, x22, x23) (r2)

c3 : (x31, x32, x33) → c1 : (x33, x31, x32) (r3)

Iterations during the dChase construction are:

dChase0(QSC) = {c1:(a, b, c)}

dChase1(QSC) = {c1 : (a, b, c), c2 : (a, b, : b1)}

dChase(QSC) = dChase1(QSC)

Note that the lone Skolem blank node generated is: b1, which do not have any descen-dants. Hence, by definitionQSC is csafe (msafe/safe). Now analyzing the BRs for jointacyclicity, we note that for the only existentially quantified variabley1,

MovR(y1) = {〈c2, 3〉, 〈c3, 3〉, 〈c1, 1〉}Since the BRr1 in whichy1 occurs contains the universally quantified variablex11 inthe head ofr1 such thatPosr1B (x11) ⊆ MovR(y1), there exists a cycle fromy1 to y1itself in the existential dependency graph ofτ(QSC). Hence, by definitionτ(QSC) isnot joint acyclic. Also since the class of weakly acyclic rules are contained in the classof jointly acyclic rule, it follows thatτ(QSC) is also not weakly acyclic.

6.3 Model Faithful Acyclicity (MFA)

MFA, proposed in Cuenca Grau et al. [32], is an acyclicity technique that guaranteesfiniteness of chase and decidability of query answering, in the realm of∀∃ rules. The

setMFA denotes the class of all ternary∀∃ rule sets that are model faithfully acyclic. Asfar as we know, the MFA technique subsumes almost all other known techniques thatguarantee a finite chase, in the∀∃ rules setting. Obviously,WA ⊂ JA ⊂ MFA.

For any∀∃ ruler = φ(r)(x, z) → ψ(r)(x,y), for eachyj ∈ {y}, letY jr be a fresh

unary predicate unique foryj andr; furthermore, letS be a fresh binary predicate. Thetransformationmfa of r is defined as:

mfa(r) = φ(r)(x, z) → ψ(r)(x,y) ∧∧

yj∈{y}

[Y jr (yj) ∧

∧

xk∈{x}

S(xk, yj)]

Also letr1 andr2 be two additional rules defined as:

S(x1, z) ∧ S(z, x2) → S(x1, x2) (r1)

Y jr (x1) ∧ S(x1, x2) ∧ Y

jr (x2) → C (r2)

whereC is a fresh nullary predicate. For any set of∀∃ rulesP, letad(P) be the union ofr1 with the set of rules obtained by instantiatingr2, for eachr ∈ P, for each existentialvariableyj in r. For a set of∀∃ rulesP,mfa(P) =

⋃

r∈Pmfa(r)∪ad(P). A ∀∃ rule set

P is said to be MFA, iffmfa(P) 6|=fol C. It was shown in Cuenca Grau et al. [32] that ifP is MFA, thenP has a finite chase, thus ensuring decidability of query answering. Thefollowing theorem establishes the fact that the notion of msafety is equivalent to MFA,thanks to the polynomial time translations between quad-systems and ternary∀∃ rulesets.

Theorem 16. Letτ be the translation function from the set of unrestricted quad-systemsto the set of ternary∀∃ rule sets, as defined in Definition 8, then, for any quad-systemQSC = 〈QC ,R〉,QSC is msafe iffτ(QSC) is MFA.

Proof. (outline) Recall thatτ = 〈τq, τbr〉, whereτq is the quad translation function andτbr is the translation function from BRs to∀∃ rules. Also,τ(QSC) = τbr({rQC} ∪ R).Also, recall that for every blank nodeb in QC, the BRrQC contains a corresponding ex-istentially quantified variableyb. We already saw that for such a transformation, the fol-lowing property holds: for anym ∈ N, τq(dChasem(QSC)) = chasem(τ(QSC)), andfor any BRr ∈R ∪ {rQC}, an assignmentµ, applicableR∪{rQC

}(r,µ,dChasem(QSC))

iff applicableτ(QSC)( τbr(r), µ, chasem(τ(QSC))). Also notice that for any two blanknodes : b1, : b2, S( : b1, : b2) ∈ chase(τ(QSC)), iff : b1 is a descendant of: b2in dChase(QSC). Hence, the relationsS and descendantOf are identical.

Intuitively, MFA looks for cyclic creation of a Skolem blank-node whose descen-dant is another Skolem blank-node that is generated by the same ruler = body(r)(x, z)→ head(r)(x, y), by the same existential variable inyj ∈ {y} of r. Wheras, msafetylooks only for generation of a Skolem blank-node: b′ whose descendant is anotherSkolem : b using the same ruler. Hence, ifτ(QSC) is not MFA, thenQSC is notmsafe, and consequently onlyIf part of the theorem trivially holds.

(If part) SupposeQSC is unmsafe, andµ andµ′ are the assignments applied onr ∈ R to create Skolem blank nodes: b and : b′, respectively, and suppose: b isa descendant of: b′ in the dChase(QSC). That is : b = µ(yj) and : b′ = µ′(yk),for yj , yk ∈ {y} of r. Supposej = k, then the prerequisite of non-MFA is trivially

satisfied. Suppose ifj 6= k is the case, then there exists: b′′ in dChase(QSC) suchthat : b′′ = µ′(yj), sinceµ′ is applied onr andyj ∈ {y}. This means that also in thiscase, the prerequisite of non-MFA is satisfied. As a consequenceτ(QSC) is not MFA.Hence it follows that,QSC is msafe iffτ(QSC) is MFA.

Let us revisit the quad-systemQSC in example 2, it can be easily seen thatτ(QSC) isnot MFA. Recall that we have seen thatQSC is safe but not msafe. We consider theTheorem 16 to be of importance, as it not only establishes theequivalence of MFA andmsafety, but thanks to it and the translationτ , it can be deduced that the technique ofsafety, which we presented earlier, (strictly) extends theMFA technique. As far as weknow, the MFA class of∀∃ rule sets is one of the most expressive class in the realmof ∀∃ rule sets which allows a finite chase. Hence, the notion of safety that we proposecan straightforwardly be ported to∀∃ settings. The main difference between MFA andsafety is that MFA only looks for cyclic creation of two distinct Skolem blank-nodes: b, : b′ that are generated by the same ruler, by the same existential variable inr.

Whereas safety also takes into account the origin vectorsa anda′ used during ruleapplication to create: b and : b′, respectively, and only raises an alarm ifa ∼= a

′.Although, equivalence holds only between quad-systems andternary∀∃ rule sets, itcan easily be noticed that the technique of safety can be applied to ∀∃ rule sets ofarbitrary arity, and can be used to extend currently established tools and systems thatwork on existing notions of acyclicity such as WA, JA, or MFA.

7 Related Work

Contexts and Distributed LogicsWork on contexts gained its attention as early as inthe 80s, as McCarthy [1] proposed context as a solution to thegenerality problem in AI.After this, various studies about logics of contexts mainlyin the field of KR were doneby Guha [18],Distributed First Order Logicsby Ghidini et al. [17] andLocal ModelSemanticsby Giunchiglia et al. [8]. Primarily in these works, contexts were formal-ized as a first order/propositional theory and bridge rules were provided to inter-operatethe various theories of contexts. Some of the initial works on contexts relevant to se-mantic web were the ones likeDistributed Description Logics[5] by Borgida et al.,andContext-OWL[7] by Bouquet et al., and the work of CKR [13, 10] by Serafini etal. These were mainly logics based on DLs, which formalized contexts as OWL KBs,whose semantics is given using a distributed interpretation structure with additional se-mantic conditions that suits varying requirements. Compared to these works, the bridgerules we consider are much more expressive with conjunctions and existential variablesthat supports value/blank-node creation.

Temporal RDF/Annotated RDFStudies in extending standard RDF with dimensionssuch as time and annotations have already been accomplished. Gutierrez et al. in [41]tried to add a temporal extension to RDF and defines the notionof a ‘temporal rdfgraph’, in which a triple is augmented to a quadruple of the form t : (s, p, o), wheretis a time point. Whereas annotated extensions to RDF and querying annotated graphshave been studied in Udrea et al. [42] and Straccia et al. [43]. Unlike the case of time,

here the quadruple has the form:a : (s, p, o), wherea is an annotation. The authors pro-vide semantics, inference rules and query language that allows for expressing tempo-ral/annotated queries. Although these approaches, in a wayaddress contexts by meansof time and annotations, the main difference in our work is that we provide the meansto specify expressive bridge rules for inter-operating thereasoning between the variouscontexts.

DL+rules Works on extending DL KBs with Datalog like rules was studiedby Hor-rocks et al. [29] giving rise to the SWRL [29] language. Related initiatives proposea formalism using which one can mix a DL ontology with the Unary/Binary DatalogRuleML sublanguages of the Rule Markup Language, and hence enables Horn-likerules to be combined with an OWL KB. Since SWRL is undecidablein general, stud-ies on computable sub-fragments gave rise to works like Description Logic Rules [40],where the authors deal with rules that can be totally internalized by a DL knowledgebase, and hence if the DL considered is decidable, then also is a DL+rules KB. Theauthors give various fragments of the rule bases like SROIQ rules, EL++ rules etc. andshow that certain new constructs that are not expressible byplain DL can be expressedusing rules, although they are finally internalized into DL KBs. Unlike in our scenario,these works consider only horn rules without existential variables.

∀∃ rules, TGDs, Datalog+- rulesQuery answering over rules with universal-existentialquantifiers in the context of databases, where these rules are called Datalog+- rules/tuplegenerating dependencies (TGDs), was done by Beeri and Vardi[14] even in the early80s, where the authors show that the query entailment problem, in general, is undecid-able. However, recently many classes of such rules have beenidentified for which queryanswering is decidable. These classes (according to [15]) can broadly be divided intothe following three categories: (i)bounded treewidth sets(BTS), (ii) finite unificationsets (FUS), and (iii) finite extension sets (FES). BTS contains the classes of∀∃ rulesets, whose models have bounded treewidth. Some of the important classes of thesesets are the linear∀∃ rules [20], (weakly) guarded rules [34], (weakly) frontierguardedrules [15], and jointly frontier guarded rules [38]. BTS classes in general need not havea finite chase, and query answering is done by exploiting the fact that the chase is treeshaped, whose nodes (which are sets of instances) start replicating (up to isomorphism)after a while. Hence, one could stop the computation of the chase, once it can be madesure that any future iterations of chase can only produce nodes that are isomorphic toexisting nodes. A deterministic algorithm for deciding query entailment for the greedyBTS, which is a subset of this class is provided in Thomazo et al. [16].

FUS classes include the class of ‘sticky’ rules [36, 35], atomic hypothesis rules inwhich the body of each rule contains only a single atom, and also the class of linear∀∃ rules. The approach used for query answering in FUS classes is to rewrite the inputquery w.r.t. to the∀∃ rule sets to another query that can be evaluated directly on the setof instances, such that the answers for the former query and latter query coincides. Theapproach is called thequery rewriting approach. Compared to approaches proposed inthis paper, these approaches do not enjoy the finite chase property, and are hence notconducive to materialization/forward chaining based query answering.

Unlike BTS and FUS, the FES classes are characterized by the finite chase property,and hence are most related to the techniques proposed in our work. Some of the classesin this set employ termination guarantying checks called ‘acyclicity tests’ that analyzethe information flow between rules to check whether cyclic dependencies exists thatcan lead to infinite chase.Weak acyclicity[24, 26], was one of the first such notions, andwas extended tojoint acyclicity[38] andsuper weak acyclicity[37]. The main approachused in these techniques is to exploit the structure of the rules and use a dependencygraph that models the propagation path of constants across various predicates in therules, and restricting the dependency graph to be acyclic. The main drawback of theseapproaches is that they only analyze the schema/Tbox part ofthe rule sets, and ignorethe instance part, and hence produce a large number of false alarms, i.e. it is often thecase that although dependency graph is cyclic, the chase is finite. Recently, a moredynamic approach, called the MFA technique, that also takesinto account the instancepart of the rule sets was proposed in Cuenca grau et al. [32], where existence of cyclicSkolem blank-node/constant generations in the chase is detected by augmenting therules with extra information that keeps track of the Skolem function used to generateeach Skolem blank-node. As shown in section 6, our techniqueof safety subsumes theMFA technique, and supports for much more expressive rule sets, by also keeping trackof the vectors used by rule bodies while Skolem blank-nodes are generated.

Data integration Studies in query answering on integrated heterogeneous databaseswith expressive integration rules in the realm of data integration is primarily studied inthe following two settings: (i) Data exchange [24], in whichthere is a source databaseand target database that are connected with existential rules, and (ii) Peer-to-peer datamanagement systems (PDMS) [19], where there are an arbitrary number of peers thatare interconnected using existential rules.

The approach based on dependency graphs, for instance, is used by Halevi et al.in the context of peer-peer data management systems [19], and decidability is attainedby not allowing any kind of cycles in the peer topology. Whereas in the context ofData exchange, WA is used in [24, 26] to assure decidability,and the recent work byMarnette [37] employs the super weak acyclicity (SWA) to ensure decidability. It wasshown in Cuenca Grau et al [32] that their MFA technique strictly subsumes both WAand SWA techniques in expressivity. Since we saw in section 6that our technique ofsafety subsumes the MFA technique and allows the representation of much more ex-pressive rule sets, the safety technique can straightforwardly be employed in the abovementioned systems with decidability guarantees for query answering.

8 Summary and Conclusion

In this paper, we study the problem of query answering over contextualized RDF knowl-edge in the presence of forall-existential bridge rules. Weshow that the problem, ingeneral, is undecidable, and present a few decidable classes of quad-systems. Table1 displays the complexity results of chase computation and query entailment for thevarious classes of quad-systems we have derived. Classes csafe, msafe, and safe, en-sure decidability by restricting the structure of Skolem blank-nodes generated in the

Quad-System Chase size w.r.t Data Complexity ofCombined ComplexityComplexity ofFragment input quad-system CCQ entailment of CCQ entailment Recognition

Unrestricted Quad-Systems Infinite Undecidable Undecidable PTIMESafe Quad-Systems Double exponential PTIME-complete 2EXPTIME-complete 2EXPTIME

MSafe Quad-Systems Double exponential PTIME-complete 2EXPTIME-complete 2EXPTIMECSafe Quad-Systems Double exponential PTIME-complete 2EXPTIME-complete 2EXPTIMERR Quad-Systems Polynomial PTIME-complete EXPTIME PTIME

Restricted RR Quad-Systems Polynomial PTIME-complete NP-complete PTIMETable 1: Complexity info for various quad-system fragments

dChase. Briefly, the above classes do not allow an infinite descendant chain for Skolemblank-nodes generated, by constraining each Skolem blank-node in a descendant chainto have a different value for certain attributes, whose value sets are finite. RR and re-stricted RR quad-systems, do not allow the generation of Skolem blank nodes, thusconstraining the dChase to have only constants from the initial quad-system. The aboveclasses which suit varying situations, can be used to extendthe currently establishedtools for contextual reasoning to give support for expressive bridge rules with conjunc-tions and existential quantifiers with decidability guarantees. From an expressivity pointof view, the class of safe quad-systems subsumes all the above classes, and other wellknown classes in the realm of∀∃ rules with finite chases. We view the results obtainedin this paper as a general foundation for contextual reasoning and query answering overcontextualized RDF knowledge formats such as quads, and canstraightforwardly beused to extend existing quad stores.

9 Acknowledgements

We sincerely thank Loris Bozzatto (FBK-IRST, Italy), and Francesco Corcoglionitti(FBK-IRST, Italy), and Prof. Roberto Zunino (DISI, University of Trento, Italy) forall their helpful technical feedbacks on an initial versionof this paper. We also thankDr. Christoph Lange (School of Computer Science, University of Birmingham, UK),Prof. Sethumadhavan (Center for Cyber Security, Amrita University, India), and Prof.Padmanabhan T.R. (Dept. of Computer Science, Amrita University, India), for theirtime and motivating discussions.

References

1. J.McCarthy, “Generality in AI,”Communications of the ACM, vol. 30, no. 12, pp. 1029–1035,1987.

2. J. Carroll, C. Bizer, P. Hayes, and P. Stickler, “Named graphs, provenance and trust,” in AllanEllis, Tatsuya Hagino (Eds.)WWW ’05: Proceedings of the 14th international conference onWorld Wide Web, (New York, NY, USA), pp. 613–622, ACM, 2005.

3. B. Schueler, S. Sizov, S. Staab, and D. T. Tran, “Querying for meta knowledge,” in JinpengHuai, Robin Chen, Hsiao-Wuen Hon, Yunhao Liu, Wei-Ying Ma, Andrew Tomkins, Xiaodong

Zhang (Eds.)WWW ’08: Proceedings of the 17th international conference on World Wide Web,(New York, NY, USA), pp. 625–634, ACM, 2008.

4. D.Lenat, “The Dimensions of Context Space,” tech. rep., CYCorp, 1998. Published onlinehttp://www.cyc.com/ doc/context-space.pdf.

5. A. Borgida and L. Serafini, “Distributed Description Logics: Assimilating Information fromPeer Sources,”Journal on Data Semantics, vol. 1, Lecture Notes in Computer Science, Vol-ume 2800, pp. 153–184, 2003.

6. J. McCarthy, “Notes on Formalizing Context,” inProceedings of the 13th international jointconference on Artifical intelligence (ICAI’ 95)- Volume 1, Morgan Kaufmann Publishers Inc.Pages 555-560, 1995.

7. P. Bouquet, F. Giunchiglia, F. van Harmelen, L. Serafini, and H. Stuckenschmidt. C-OWL:Contextualizing Ontologies. In Dieter Fensel, Katia P. Sycara, John Mylopoulos (Eds.):TheSemantic Web - ISWC 2003, Springer 2003 Lecture Notes in Computer Science Volume,2870, pages 164–179, 2003.

8. F. Giunchiglia and C. Ghidini. Local models semantics, orcontextual reasoning = locality +compatibility. Artificial Intelligence, Vol. 127, 2001, Pages 221–259.

9. L. Bozzato, C. Ghidini and L. Serafini. Comparing contextual and flat representations ofknowledge: a concrete case about football data. In V. Richard Benjamins, Mathieu d’Aquin,Andrew Gordon (Eds.)Proceedings of the seventh international conference on Knowledgecapture (K-CAP ’13), 9-16, ACM 2013.

10. M.Joseph and L.Serafini. Simple reasoning for contextualized RDF knowledge. In OliverKutz, Thomas Schneider (Eds.):Modular Ontologies - Proceedings of the Fifth InternationalWorkshop (WOMO-2011), Volume 230, IOS Press, Frontiers in Artificial Intelligence andApplications, 2011.

11. M.Joseph and G.Kuper and L.Serafini. Query Answering over contextualized RDF Knowl-edge with Forall-Existential Bridge Rules: Attaining Decidability using Acyclicity. In LauraGiordano, Valentina Gliozzi, Gian Luca Pozzato (Eds.):Proceedings of the 29th Italian Con-ference in Computational Logic (CILC-2014), Volume 1195 of CEUR Workshop Proceedings,pages 210-224, CEUR-WS.org, 2014.

12. M.Joseph and G.Kuper and L.Serafini. Query Answering over contextualized RDF/OWLKnowledge with Forall-Existential Bridge Rules: Attaining Decidability using Acyclicity. InRoman Kontchakov, Marie-Laure Mugnier (Eds.):Web Reasoning and Rule Systems - 8thInternational Conference (RR-2014), Springer Lecture Notes in Computer Science Volume8741,s pp 60-75, 2014.

13. L. Serafini and M. Homola. Contextualized knowledge repositories for the semantic web.Web Semantics: Science, Services and Agents on the World Wide Web, Special Issue: Reason-ing with Context in the Semantic Web, Elsevier, Vol 12 - 13 (2012), 2012.

14. C. Beeri and M. Y. Vardi. The Implication Problem for DataDependencies. In ShimonEven, Oded Kariv (Eds.): Automata, Languages and Programming, 8th Colloquium,ICALP,Springer Lecture Notes in Computer Science Volume 115, pp 73-85, 1981.

15. Baget, J.-F.; Leclere, M.; Mugnier, M.-L.; and Salvat,E. 2011. On rules with existentialvariables: Walking the decidability line.Artificial Intelligence175(9-10):1620–1654.

16. Thomazo, M.; Baget, J.-F.; Mugnier, M.-L.; and Rudolph,S. A Generic Querying Algorithmfor Greedy Sets of Existential Rules. In Gerhard Brewka, Thomas Eiter, Sheila A. McIlraith(Eds.):KR’12: International Conference on Principles of Knowledge Representation and Rea-soning, 096–106. 2012.

17. C. Ghidini and L. Serafini. Distributed first order logics. In Frontiers Of Combining Systems2, Studies in Logic and Computation, pages 121–140. Research Studies Press, 1998.

18. R.Guha.Contexts: a Formalization and some Applications. PhD thesis, Stanford, 1992.

19. A. Y. Halevy, Z. G. Ives, D. Suciu, and I. Tatarinov, “Schema mediation in peer data man-agement systems,” in Umeshwar Dayal, Krithi Ramamritham, T. M. Vijayaraman (Eds.): 19thInternational Conference on Data EngineeringIn ICDE, IEEE Computer Society, pp. 505–516, 2003.

20. D. S. Johnson and A. C. Klug, “Testing containment of conjunctive queries under func-tional and inclusion dependencies,”Journal of Computer and System Sciences, vol. 28, no. 1,pp. 167–189, 1984.

21. S. Abiteboul, R. Hull, and V. Vianu,Foundations of Databases. Addison-Wesley, 1995.22. O. Kutz, C. Lutz, F. Wolter, and M. Zakharyaschev, “E-Connections of Abstract Description

Systems,”Artificial Intelligence, vol. 156, no. 1, pp. 1–73, 2004.23. S. Klarman and V. Gutierrez-Basulto, “Two-dimensional description logics for context-based

semantic interoperability,” in Wolfram Burgard, Dan Roth (Eds.):Proceedings of Twenty-FifthAAAI Conference on Artificial Intelligence (AAAI-11), AAAI Press 2011.

24. R. Fagin, P. G. Kolaitis, R. J. Miller, and L. Popa, “Data Exchange: Semantics and QueryAnswering,” inTheoretical Computer Science, pp. 28(1):89–124, 2005.

25. D. Calvanese, G. Giacomo, D. Lembo, M. Lenzerini, R. Rosati, ”Tractable Reasoning andEfficient Query Answering in Description Logics: The DL-Lite Family”, InJournal of Auto-mated Reasoning, Springer-Verlag New York, Inc., pp. 385–429, 2007.

26. A. Deutsch and V. Tannen, “Reformulation of XML Queries and Constraints,” in Diego Cal-vanese, Maurizio Lenzerini, Rajeev Motwani (Eds.):In Proceedings of the 9th InternationalConference on Database Theory (ICDT’ 03), Springer Lecture Notes in Computer Science,pp. 225–241, 2003.

27. H. J. ter Horst, “Completeness, decidability and complexity of entailment for RDF Schemaand a semantic extension involving the OWL vocabulary,”Web Semantics: Science, Servicesand Agents on the WWW, vol. 3, no. 2-3, pp. 79–115, 2005. Selected Papers from the ISWC,2004.

28. B. Glimm, C. Lutz, I. Horrocks, and U. Sattler, “Answering conjunctive queries in theSHIQ description logic,” in Manuela M. Veloso (Ed.)Proceedings of the Twentieth Inter-national Joint Conference on Artificial Intelligence (IJCAI-07), pp. 299–404, AAAI Press,2007.

29. I. Horrocks, P. F. Patel-Schneider, H. Boley, S. Tabet, B. Grosof, and M. Dean, “SWRL: ASemantic Web Rule Language Combining OWL and RuleML,” W3C member submission,World Wide Web Consortium, 2004.http://www.w3.org/Submission/SWRL/

30. A. Deutsch, A. Nash, and J. Remmel, “The chase revisited,” in Maurizio Lenzerini,Domenico Lembo (Eds.):Proceedings of the twenty-seventh ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, PODS ’08, (New York, NY, USA),pp. 149–158, ACM, 2008. -

31. P. Hayes, ed., RDF Semantics. W3C Recommendation, Feb. 2004.http://www.w3.org/TR/2004/ REC-rdf-mt-20040210/

32. B. Cuenca Grau, I. Horrocks, M. Krotzsch, C. Kupke, D. Magka, B. Motik, and Z. Wang,“Acyclicity Notions for Existential Rules and Their Application to Query Answering in On-tologies,” inJournal of Artificial Intelligence Research (JAIR), vol. 47, pp. 741–808, AI Ac-cess Foundation, 2013.

33. M. A. Harrison,Introduction to Formal Language Theory. Boston, MA, USA: Addison-Wesley Longman Publishing Company, Inc., 1st ed., 1978.

34. A. Calı, G. Gottlob, and M. Kifer Taming the infinite chase: Query answering under expres-sive relational constraints. In Gerhard Brewka, Jrme Lang (Eds.):Principles of KnowledgeRepresentation and Reasoning (KR’ 08), 70–80. 2008.

35. A. Calı, G. Gottlob, and A. Pieris, “Towards more expressive ontology languages: The queryanswering problem,” inArtificial Intelligence, vol. 93, pp. 87–128, Elsevier, 2012.

36. A. Calı, G. Gottlob, and A. Pieris, “Query Answering under Non-guarded Rules inDatalog+/-,” in Pascal Hitzler, Thomas Lukasiewicz (Eds.)Web Reasoning and Rule Systems- Fourth International Conference (RR’ 10), vol. 6333 of SpringerLecture Notes in ComputerScience, pp. 1–17, Springer, 2010.

37. B. Marnette, “Generalized schema-mappings: from termination to tractability,” in JanParedaens, Jianwen Su (Eds.):Proceedings of the twenty-eighth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, PODS ’09, (New York, NY, USA),pp. 13–22, ACM, 2009.

38. M. Krotzsch and S. Rudolph, “Extending decidable existential rules by joining acyclicity andguardedness,” in Toby Walsh (Ed.)Proceedings of the 22nd International Joint Conference onArtificial Intelligence (IJCAI’11)(T. Walsh, ed.), pp. 963–968, AAAI Press/IJCAI, 2011.

39. M. Krotzsch and S. Rudolph, “Conjunctive Queries for ELwith Role Composition” in DiegoCalvanese, Enrico Franconi, Volker Haarslev, Domenico Lembo, Boris Motik, Anni-YasminTurhan, Sergio Tessaris (Eds.):Proceedings of the 20th International Workshop on Descrip-tion Logics (DL’07)(D. Calvanese, ed.), Vol. 250, CEUR Workshop Proceedings, 2007.

40. M. Krotzsch, S. Rudolph, and Pascal Hitzler. Description logic rules. In Malik Ghallab,Constantine D. Spyropoulos, Nikos Fakotakis, Nikolaos M. Avouris (Eds.):Proceedings ofthe 18th European Conference on Artificial Intelligence (ECAI’08), pages 80–84. IOS Press,Frontiers in Artificial Intelligence and Applications, 2008.

41. C. Gutierrez, C. A. Hurtado, and A. A. Vaisman, “Temporalrdf,” in Lora Aroyo, GrigorisAntoniou, Eero Hyvnen, Annette ten Teije, Heiner Stuckenschmidt, Liliana Cabral, Tania Tu-dorache (Eds.):2nd Annual European Semantic Web Conference (ESWC’ 05), pp. 93–107,Springer, Lecture Notes in Computer Science, 2005.

42. O. Udrea, D. R. Recupero, and V. S. Subrahmanian, “Annotated RDF,”ACM Transactions inComputational Logic, vol. 11, no. 2, pp. 1–41, 2010.

43. U. Straccia, N. Lopes, G. Lukacsy, and A. Polleres, “A general framework for representingand reasoning with annotated semantic web data,” in Maria Fox, David Poole (Eds.):Pro-ceedings of the 24th AAAI Conference on Artificial Intelligence (AAAI 2010), Special Trackon Artificial Intelligence and the Web, July 2010.

A Proofs for Section 3

Proof (Property 1).Note that a strict linear order is a relation that is irreflexive, transi-tive, and linear.

Irreflexivity: By contradiction, suppose≺q is not irreflexive, then there existsQ ∈Q such thatQ ≺q Q holds. This means that neither of the conditions (i) and (ii)of ≺q

definition holds forQ. Hence, due to condition (iii)Q 6≺q Q, which is a contradiction.Linearity: Note that for any two distinctQ,Q′ ∈ Q, one of the following holds: (a)

Q ⊂ Q′, (b)Q′ ⊂ Q, or (c)Q \ Q′ andQ′ \ Q are non-empty and disjoint. Suppose(a) is the case, thenQ ≺q Q

′ holds. Similarly, if (b) is the case thenQ′ ≺q Q holds.Otherwise if (c) is the case, then by condition (ii), eitherQ ≺q Q

′ orQ′ ≺q Q shouldhold. Hence,≺q is a linear order overQ.

Transitivity: Suppose there existsQ,Q′, Q′′ ∈ Q such thatQ ≺q Q′ andQ′ ≺q Q

′′.Then, one of the following four cases hold: (a)Q ≺q Q

′ due to (i) andQ′ ≺q Q′′ due

to (i), (b)Q ≺q Q′ due to (i) andQ′ ≺q Q

′′ due to (ii), (c)Q ≺q Q′ due to (ii) and

Q′ ≺q Q′′ due to (i), (d)Q ≺q Q

′ due to (ii) andQ′ ≺q Q′′ due to (ii).

Suppose if (a) is the case, then triviallyQ ⊂ Q′′, and hence by applying condition(i) Q ≺q Q

′′. Otherwise if (b) is the case, then either (1)Q ⊂ Q′′ or (2)Q 6⊂ Q′′.

Suppose, (1) is the case then, by (i)Q ≺q Q′′. Otherwise, if (2) is the case, then since,

Q ⊂ Q′, it cannot be the case that greatestQuad≺l(Q′′\Q)≺l greatestQuad≺l

(Q′′\Q′),and it cannot be the case that greatestQuad≺l

(Q′ \ Q′′) ≺l greatestQuad≺l(Q \ Q′′).

Hence, it should be the case that greatestQuad≺l(Q′′ \Q′) �l greatestQuad≺l

(Q′′ \Q)and greatestQuad≺l

(Q \Q′′) ≺l greatestQuad≺l(Q′ \Q′′). But since, greatest-

Quad≺l(Q′\Q′′)≺l greatestQuad≺l

(Q′′\Q′), it allows us to derive greatestQuad≺l(Q

\ Q′′) ≺l greatestQuad≺l(Q′′ \ Q), and hence by condition (ii),Q ≺q Q

′′. Hence, if(b) is the case, then in both possible cases (1) or (2), it should be the case thatQ ≺q Q

′′.Otherwise if (c) is the case, then similar to the arguments in(b), by condition (i) or (ii),it can easily be seen thatQ ≺q Q

′′.Otherwise, if (d) is the case, then the following must hold: greatestQuad≺l

(Q \Q′) ≺l greatestQuad≺l

(Q′ \Q) (†) and greatestQuad≺l(Q′ \Q′′) ≺l greatestQuad≺l

(Q′′ \ Q′) (‡). Suppose by contradictionQ′′ ≺q Q, then one of the following holds:(1) Q′′ ≺q Q by condition (i) or (2)Q′′ ≺q Q by condition (ii). Suppose, (1) is thecase, then it should be the case thatQ′′ ⊂ Q. Hence, it should not be the case thatgreatestQuad≺l

(Q\Q′)≺l greatestQuad≺l(Q′′ \Q′) and it should not be the case that

greatestQuad≺l(Q′ \Q′′) ≺l greatestQuad≺l

(Q′ \Q). Hence, it should be the case thatgreatestQuad≺l

(Q′′ \Q′)�l greatestQuad≺l(Q\Q′) (♥), and it should be the case that

greatestQuad≺l(Q′ \Q)�l greatestQuad≺l

(Q′ \Q′′) (♠). Applying (‡) in (♥), we getgreatestQuad≺l

(Q′ \Q′′) ≺l greatestQuad≺l(Q \Q′), and Applying (†) in (♠), we get

greatestQuad≺l(Q\Q′)≺l greatestQuad≺l

(Q′\Q′′), which is a contradiction. Supposeif (2) is the case, then greatestQuad≺l

(Q′′ \Q)≺l greatestQuad≺l(Q\Q′′). The above

can be written as: greatestQuad≺l(Q′′ \ (Q∩Q′′)) ≺l greatestQuad≺l

(Q \ (Q∩Q′′)).UsingQ∩Q′ ∩Q′′ ⊆ Q∩Q′, it follows that greatestQuad≺l

(Q′′ \ (Q∩Q′ ∩Q′′)) �l

greatestQuad≺l(Q\(Q∩Q′∩Q′′)) (♣). Also applying similar transformation in(†) and

(‡), we get greatestQuad≺l(Q\(Q∩Q′∩Q′′))�l greatestQuad≺l

(Q′\(Q∩Q′∩Q′′)),and greatestQuad≺l

(Q′\(Q∩Q′∩Q′′))�l greatestQuad≺l(Q′′\(Q∩Q′∩Q′′)). From

which, it follows that greatestQuad≺l(Q \ (Q ∩ Q′ ∩ Q′′)) �l greatestQuad≺l

(Q′′ \(Q∩Q′∩Q′′)). Using (♣) in the above, we get greatestQuad≺l

(Q \ (Q∩Q′∩Q′′)) =greatestQuad≺l

(Q′ \ (Q ∩Q′ ∩Q′′)) = greatestQuad≺l(Q′′ \ (Q ∩Q′ ∩Q′′)), which

is a contradiction. Hence, it should be the case thatQ ≺q Q′′.

Proof (Theorem 2).We show that CCQ entailment is undecidable for unrestrictedquad-systems, by showing that the well known undecidable problemof “non-emptiness ofintersection of context-free grammars” is reducible to theCCQ answering problem.

Given an alphabetΣ, stringw is a sequence of symbols fromΣ. A languageL is asubset ofΣ∗, whereΣ∗ is the set of all strings that can be constructed from the alphabetΣ, and also includes the empty stringǫ. Grammars are machineries that generate aparticular language. A grammarG is a quadruple〈V, T, S, P 〉, whereV is the set ofvariables,T , the set of terminals,S ∈ V is the start symbol, andP is a set of productionrules (PR), in which each PRr ∈ P , is of the form:

w → w′

wherew,w′ ∈ {T ∪ V }∗. Intuitively application of a PRr of the form above on astringw1, replaces every occurrence of the sequencew in w1 with w

′. PRs are appliedstarting from the start symbolS until it results in a stringw, with w ∈ Σ∗ or no more

production rules can be applied onw. In the former case, we say thatw ∈ L(G), thelanguage generated by grammarG. For a detailed review of grammars, we refer thereader to Harrison et al. [33]. Acontext-free grammar(CFG) is a grammar, whose setof PRsP , have the following property:

Property 8. For a CFG, every PR is of the formv → w, wherev ∈ V , w ∈ {T ∪ V }∗.

Given two CFGs,G1 = 〈V1, T, S1, P1〉 andG2 = 〈V2, T, S2, P2〉, whereV1, V2 are theset of variables,T such thatT ∩ (V1 ∪ V2) = ∅ is the set of terminals.S1 ∈ V1 is thestart symbol ofG1, andP1 are the set of PRs of the formv → w, wherev ∈ V , wis a sequence of the formw1...wn, wherewi ∈ V1 ∪ T . S2, P2 are defined similarly.Deciding whether the language generated by the grammarsL(G1) andL(G2) havenon-empty intersection is known to be undecidable [33].

Given two CFGs,G1 = 〈V1, T, S1, P1〉 andG2 = 〈V2, T, S2, P2〉, we encode gram-marsG1, G2 into a quad-system of the formQSc = 〈Qc, R〉, with a single contextidentifierc. Each PRr = v → w ∈ P1 ∪ P2, with w = w1w2w3..wn, is encoded as aBR of the form:

c : (x1, w1, x2), c : (x2, w2, x3), ..., c : (xn, wn, xn+1) → c : (x1, v, xn+1) (10)

wherex1, .., xn+1 are variables. W.l.o.g. we assume that the set of terminal symbolsTis equal to the set of terminal symbols occurring inP1 ∪ P2. For each terminal symbolti ∈ T ,R contains a BR of the form:

c : (x,rdf:type, C) → ∃y c : (x, ti, y), c : (y,rdf:type, C) (11)

andQc contains only the triple:

c : (a,rdf:type, C)

We in the following show that:

QSc |= ∃y c : (a, S1, y) ∧ c : (a, S2, y) ↔ L(G1) ∩ L(G2) 6= ∅ (12)

Claim. (1) For anyw = t1, ..., tp ∈ T ∗, there existsb1, ...bp, such thatc : (a, t1, b1),c : (b1, t2, b2), ...,c : (bp−1, tp, bp), c : (bp,rdf:type, C) ∈ dChase( QSc).

we proceed by induction on|w|.

base casesuppose if|w| = 1, thenw = ti, for someti ∈ T . But by constructionc : (a, rdf:type, C) ∈ dChase0(QSc), on which rules of the form (11) is ap-plicable. Hence, there exists ani such thatdChasei(QSc) containsc : (a, ti, bi),c : (bi,rdf:type, C), for eachti ∈ T . Hence, the base case.

hypothesis for any w = t1...tp, if |w| ≤ p′, then there existsb1, ..., bp, such thatc : (a, t1, b1), c : (b1, t2, b2), ...,c : (bp−1, tp, bp), c : (bp,rdf:type,C) ∈ dChase(QSc).

inductive step supposew = t1...tp+1, with |w| ≤ p′ + 1. Sincew can be writtenas w

′tp+1, wherew′ = t1...tp, and by hypothesis, there existsb1, ..., bp suchthat c : (a, t1, b1), c : (b1, t2, b2), ..., c : (bp−1, tp, bp), c : (bp,rdf:type, C) ∈dChase(QSc). Also since rules of the form (11) are applicable onc : (bp,rdf:type,C), and hence produces triples of the formc : (bp, ti, bip+1), c : (b

ip+1, rdf:type,

C), for eachti ∈ T . Sincetp+1 ∈ T , the claim follows.

For a grammarG = 〈V, T, S, P 〉, whose start symbol isS, and for anyw ∈ {V ∪T }∗, for someVj ∈ V , we denote byVj →i

w, the fact thatw was derived fromVjby i production steps, i.e. there exists stepsVj → r1, ..., ri → w, which lead to theproduction ofw. For anyw, w ∈ L(G), iff there exists ani such thatS →i

w. For anyVj ∈ V , we useVj →∗

w to denote the fact that there exists an arbitraryi, such thatVj →i

w.

Claim. (2) For anyw = t1...tp ∈ {V ∪ T }∗, and for anyVj ∈ V , if Vj →∗w and

there existsb1, ..., bp+1, with c : (b1, t1, b2), ..., c : (bp, tp, bp+1) ∈ dChase(QSc), thenc : (b1, Vj , bp+1) ∈ dChase(QSc).

We prove this by induction on the size ofw.

base caseSuppose|w| = 1, thenw = tk, for sometk ∈ T . If there existsb1, b2 suchthatc : (b1, tk, b2). But since there exists a PRVj → tk, by transformation given in(10), there exists a BRc : (x1, tk, x2) → c : (x1, Vj , x2) ∈ R, which is applicableon c : (b1, tk, b2) and hence the quadc : (b1, Vj , b2) ∈ dChase(QSc).

hypothesis For anyw = t1...tp, with |w| ≤ p′, and for anyVj ∈ V , if Vj →∗

w and there existsb1, ...bp, bp+1, such thatc : (b1, t1, b2), ..., c : (bp, tp, bp+1) ∈dChase(QSc), thenc : (b1, Vj , bp+1) ∈ dChase(QSc).

inductive step Suppose ifw = t1...tp+1, with |w| ≤ p′ + 1, andVj →iw, and

there existsb1, ...bp+1, bp+2, such thatc : (b1, t1, b2), ..., c : (bp+1, tp+1, bp+2) ∈dChase(Qc). Also, one of the following holds (i)i = 1, or (ii) i > 1. Suppose(i) is the case, then it is trivially the case thatc : (b1, Vj , bp+2) ∈ dChase(QSc).Suppose if (ii) is the case, one of the two sub cases holds (a)Vj →i−1 Vk, for someVk ∈ V andVk →1

w or (b) there exist aVk ∈ V , such thatVk →∗ tq+1...tq+l,with 2 ≤ l ≤ p, whereVj →∗ t1...tqVktp−l+1...tp+1. If (a) is the case, triv-ially thenc : (b1, Vk, bq+2) ∈ dChase(QSc), and since by construction there existsc : (x0, Vk, x1) → c : (x0, Vk+1, x1), ..., c : (x0, Vk+i, x1) → c : (x0, Vj , x1) ∈ R,c : (b1, Vj , bq+2) ∈ dChase( QSc). If (b) is the case, then since|tq+1...tq+l| ≥ 2,|t1...tqV2tp−l+1...tp+1| ≤ p′. This implies thatc : (b1, Vj , bp+2) ∈ dChase(QSc).

Similarly, by construction ofdChase(QSc), the following claim can straightforwardlybe shown to hold:

Claim. (3) For anyw = t1...tp ∈ {V ∪ T }∗, and for anyVj ∈ V , if there existsb1, ..., bp, bp+1, with c : (b1, t1, b2), ..., c : (bp, tp, bp+1) ∈ dChase(QSc) and c : (b1,Vj , bp+1) ∈ dChase(QSc), thenVj →∗

w.

(a) For anyw = t1...tp ∈ T ∗, if w ∈ L(G1) ∩ L(G2), then by claim 1, sincethere existsb1, ..., bp, such thatc : (a, t1, b1), ..., c : (bp−1, tp, bp) ∈ dChase(QSc).But sincew ∈ L(G1) andw ∈ L(G2), S1 → w andS2 → w. Hence by claim 2,c : (a, S1, bp), c : (a, S2, bp) ∈ dChase(QSc), which implies thatdChase(QSc) |= ∃yc : (a, s1, y)∧ c : (a, s2, y). Hence, by Theorem 1,QSc |= ∃y c : (a, s1, y)∧ c : (a, s2, y).(b) Suppose ifQSc |= ∃y c : (a, S1, y)∧ c : (a, S2, y), then applying Theorem 1, it fol-lows that there existsbp such thatc : (a, S1, bp), c : (a, S2, bp) ∈ dChase(QSC). Thenit is the case that there existsw = t1...tp ∈ T ∗, andb1, ..., bp such thatc : (a, t1, b1),..., c : (bp−1, tp, bp), c : (a, S1, bp), c : (a, S2, bp) ∈ dChase(QSc). Then by claim 3,S1 →∗

w, S2 →∗w. Hence,w ∈ L(G1) ∩ L(G2).

By (a),(b) it follows that there existsw ∈ L(G1)∩L(G2) iff QSc |= ∃y c : (a, s1, y)∧c : (a, s2, y). As we have shown that the intersection of CFGs, which is an undecidableproblem, is reducible to the problem of query entailment on unrestricted quad-system,the latter is undecidable.

B Proofs for Section 4

Proof (Theorem 5).We in the following show the case ofdChasecsafe(QSC), i.e.unC-Safe∈ dChasecsafe(QSC) iff QSC is uncsafe. The proof follows from Lemma 6 andLemma 7 below.

The proofs for the case ofdChasesafe(QSC) anddChasemsafe(QSC) is similar, andis omitted.

Lemma 6 (Soundness).For any quad-systemQSC = 〈QC , R〉, if the quadunCSafe∈ dChasecsafe(QSC), thenQSC is uncsafe.

Proof. Note thataugC(R) =⋃

r∈R augC(r) ∪ {brTR}, wherebrTR is the rangerestricted BRcc : (x1, descendantOf,z), cc : (z, descendantOf,x2)→ cc : (x1, descen-dantOf,x2). Also for eachr ∈ R, body(r) = body(augC(r)), and for anyc ∈ C,c : (s, p, o) ∈ head(r) iff c : (s, p, o) ∈ head(augC(r)). That is,head(r) = head(au-gC(r))(C), wherehead( r)(C) denotes the quad-patterns inhead(r), whose contextidentifiers is inC. Also,head(augC(r)) = head(augC(r))(C) ∪ head(augC(r))(cc),and also the set of existentially quantified variables inhead(augC(r))(cc) is containedin the set of existentially quantified variables inhead(augC(r))(C) (†). We first provethe following claim:

Claim. (0) For any quad-systemQSC = 〈QC , R〉, let i be a csafe dChase iteration, letj be the number of csafe dChase iterations beforei in which brTR was applied, thendChasei−j(QSC) = dChasecsafe

i (QSC)(C).

We approach the proof of the above claim by induction oni.

base caseIf i = 1, then dChasecsafe0 (QSC)(cc) = ∅ and dChasecsafe

0 (QSC)(C) =dChasecsafe

0 (QSC) = dChase0(QSC). Hence, it should be the case thatapplicab-leaugC(R)(brTR,µ, dChasecsafe

0 (QSC)) does not hold, for anyµ. Hence,applicab-leR( r,µ, dChase0(QSC)) iff applicableaugC(R)( augC(r),µ,dChasecsafe

0 (QSC)),for any r ∈ R, assignmentµ. Also using(†), it follows thatdChase1(QSC) =dChasecsafe

1−0(QSC)(C).hypothesis for anyi ≤ k, if i is a csafe dChase iteration, andj be the number of csafe

dChase iterations beforei in which brTR was applied, thendChasei−j(QSC) =dChasecsafe

i (QSC)(C).inductive supposei = k + 1, then one of the following three cases should hold: (a)

applicableaugC(R)(r, µ, dChasecsafek (QSC)) does not hold for anyr ∈ augC(R),

assignmentµ, anddChasecsafek+1(QSC) = dChasecsafe

k (QSC), or (b)applicableaugC(R)(

brTR,µ,dChasecsafek (QSC)) holds, for some assignmentµ, or (c)applicableaugC(R)(r,

µ, dChasecsafek (QSC)) holds, for somer ∈ augC(R) \ {brTR}, for some as-

signmentµ. If (a) is the case, then it should be the case thatapplicableR(r′,

µ, dChasek−j(QSC)) does not hold, for anyr′ ∈ R, assignmentµ. As a re-sultdChasek+1−j(QSC) = dChasek−j(QSC), and hence,dChasek+1−j( QSC)= dChasecsafe

k+1(QSC)(C). If (b) is the case, then sincedChasecsafek+1(QSC)(C) =

dChasecsafek ( QSC)(C), dChasecsafe

k+1(QSC)(C) = dChasek+1−j−1( QSC) =dChasek−j(QSC). If (c) is the case, then it should the case thatapplicableR(r

′,µ, dChasek−j(QSC), wherer = augC(r′) andhead(r)(C) = head(r). Hence, itshould be the case thatdChasecsafe

k+1(QSC)(C) = dChasek+1−j( QSC).

The following claim, which straightforwardly follows fromclaim 0, shows that anyquadc : (s, p, o), with c ∈ C derived in csafe dChase, is also derived in its standarddChase. In this way, csafe dChase do not generate any unsoundtriples in any contextc ∈ C.

Claim. (1) For any quadc : (s, p, o), wherec ∈ C, if c : (s, p, o) ∈ dChasecsafe(QSC),thenc : (s, p, o) ∈ dChase(QSC).

The following claim shows that the set of origin context quads are also sound.

Claim. (2) If there exists quadcc : (b, originContext, c) ∈ dChasecsafe(QSC), thenc ∈originContexts(b).

If cc : (b, originContext,c) ∈ dChasecsafe(QSC), there existsi ∈ N, such thatcc : (b,originContext,c) ∈ dChasecsafe

i ( QSC) and there exists noj < i with cc : (b, origin-Context,c) ∈ dChasecsafe

j (QSC). But if cc : (b, originContext,c) ∈ dChasecsafei (QSC)

implies that there exists anaugC(r) = body(x, z) → head(x,y) ∈ augC(R), withcc : (yj , originContext,c) ∈ head(x, y), yj ∈ {y}, such thatcc : (b, originContext,c)was generated due to application of an assignmentµ onaugC(r), with b = yj[µ

ext(y)].This implies that there existsc : (s, p, o) ∈ head(x,y), with s = yj or p = yj oro = yj, c ∈ C. Since according to our assumption,i is the first iteration in whichcc : (b, originContext,c) is generated, it follows thati is the first iteration in whichc : (s, p, o)[µext(y)] is also generated. Letk be the number of iterations beforei in whichbrTR was applied. By applying claim 0, it should be the case thatc : (s, p, o)[µext(y)]∈ dChasei−k(QSC), and i − k should be the first such dChase iteration. Hence,c ∈ orginContexts(b).In the following claim, we prove the soundness of the descendant quads generated in asafe dChase.

Claim. (3) For any two distinct blank nodesb, b′ in dChasecsafe(QSC), if cc : (b′,descendantOf,b) ∈ dChasecsafe(QSC) thenb′ is a descendant ofb.

Since any quad of the formcc : (b′, descendantOf,b) ∈ dChasecsafe(QSC) is not an el-ement ofQC , and can only be introduced by an application of a BRr ∈ augC(R), anyquad of the formcc : (b′, descendantOf,b) can only be introduced, earliest in the first it-eration ofdChasecsafe(QSC). Supposecc : (b′, descendantOf,b) ∈ dChasecsafe(QSC),then there exists an iterationi ≥ 1 such thatcc : (b′, descendantOf,b)∈ dChasecsafe

j (QSC),for anyj ≥ i, andcc : (b′, descendantOf,b) 6∈ dChasecsafe

j′ (QSC), for anyj′ < i. Weapply induction oni for the proof.

base casesupposecc:(b′, descendantOf,b) ∈ dChas- -ecsafe1 ( QSC) and sinceb 6=

b′, then there exists a BRr ∈ augC(R), ∃µ such thatapplicableaugC(R)( r, µ,dChasecsafe

0 (QSC)), i.e. body(r)(x, z)[µ] ⊆ dChasecsafe0 (QSC) and cc : (b′, de-

scendantOf,b) ∈ head(r)(x,y)[µext(y)]. Then by construction ofaugC(r), itfollows that b = yj [µ

ext(y)], for someyj ∈ {y} and b′ = µ(xi), for somexi ∈ {x}. SincedChase0(QSC) = dChasecsafe

0 (QSC), it follows using (†) thatapplicableR(r

′, µ, dChas- -e0(QSC)) holds, forr′ = body(r′)(x,z)→ head(r′)(x,y), with augC(r′) = r. Hence, by construction, it follows thatb = yj[µ

ext(y)] ∈C(dChase1(QSC)), for yj ∈ {y} andb′ = µ(xi), for xi ∈ {x}. Henceb′ is adescendant ofb (by definition).

hypothesis if cc : (b′, descendantOf,b) ∈ dChasecsafei ( QSC), for 1 ≤ i ≤ k, thenb′ is

a descendant ofb.inductive step supposecc : (b′, descendantOf,b) ∈ dChasecsafe

k+1(QSC), then either (i)cc : (b

′, descendantOf,b) ∈ dChasecsafek (QSC) or (ii) cc : (b′, descendantOf,b) 6∈

dChasecsafek (QSC). Suppose (i) is the case, then by hypothesis,b′ is a descendant of

b. If (ii) is the case, then either (a)cc : (b′, descendantOf, b) is the result of the appli-cation of abrTR ∈ augC(R) ondChasecsafe

k (QSC) or (b)cc : (b′, descendantOf, b)is the result of the application of ar ∈ augC(R)\{brTR}ondChasecsafe

k (QSC). If(a) is the case, then there exists ab′′ ∈ C(dChasecsafe

k (QSC)) such thatcc : (b′, de-scendantOf,b′′)∈ dChasecsafe

k (QSC) andcc : (b′′, descendantOf, b) ∈ dChasecsafek (

QSC). Hence, by hypothesisb′ is a descendantOfb′′ andb′′ is a descendantOfb.Since ‘descendantOf’ relation is transitive,b′ is a descendantOfb. Otherwise if (b)is the case then similar to the arguments used in the base case, it can easily be seenthatb′ is a descendant ofb.

Suppose if the quadunCSafe∈ dChasecsafe(QSC), then this implies that there exists aniterationi such that the function unCSafeTest onaugC(r), with r = body(r)(x, z) →head(r)(x, y) ∈ R, assignmentµ, anddChasecsafe

i (QSC) returns True. This impliesthat, there existsb, b′ ∈ B, yj ∈ {y} such thatbody(r)(x, z)[µ] ⊆ dChasecsafe

i (QSC),b ∈ {µ(x)}, cc : (b′, descendantOf,b) ∈ dChasecsafe

i (QSC) and{c | cc : (b′, originCon-text, c) ∈ dChasecsafe

i (QSC)} = cScope(yj , head(r)(x, y)). Supposek be the num-ber of csafe dChase iterations beforei, in which brTR was applied. Hence, by claim0,dChasei−k−1(QSC) = dChasecsafe

i−1 (QSC)(C), and consequentlyapplicableR( r, µ,dChasei−k−1(QSC)) holds. Hence, as a result ofµ being applied onr, there existsb′′ = yj [µ

ext(y)] ∈ B(dChasei−k(QSC))), with b ∈ {µ(x)}. Hence, by definitionoriginContext(b′′) = cScope(yj , head(r)), andb is a descendantOfb′′. If b 6= b′,then by Claim 2,b′ is a descendantOfb, otherwiseb′ = b and henceb′ is a descen-dantOfb′′. Consequently,b′ is a descendantOfb′′. Also, applying claim 3, we get thatoriginContexts(b′) = originContexts(b′′), which means that prerequisites of unc-safety is satisfied, and hence,QSC is uncsafe.

Lemma 7 (Completeness).For any quad-system,QSC = 〈QC , R〉, if QSC is uncsafethenunCSafe ∈ dChasecsafe(QSC).

Proof. We first prove a few supporting claims in order to prove the theorem.

Claim. (0) For any quad-systemQSC = 〈QC ,R〉, supposeunCSafe6∈ dChasecsafe(QSC),then for any dChase iterationi, there exists aj ≥ 0 such thatdChasei(QSC) =dChasecsafe

i+j (QSC)(C).

We approach the proof by induction oni.

base casefor i = 0, we know thatdChase0(QSC) = dChasecsafe0 (QSC) = QC .

Hence, the base case trivially holds.hypothesis for i ≤ k ∈ N, there existsj ≥ 0 such thatdChasei(QSC) = dChasecsafe

i+j (QSC)

step casefor i= k+1, one of the following holds: (a)dChasek+1(QSC) = dChasek(QSC) or (b)dChasek+1(QSC) = dChasek(QSC) ∪ head(r)( x, y)[µext(y)] andapplicableR(r,µ, dChasek(QSC)) holds, for somer= body(r)(x, z)→ head(r)(x, y), assignmentµ. If (a) is the case, then trivially the claim holds. Otherwise, if(b) is the case, then letj ∈ N be such thatdChasek(QSC) = dChasecsafe

k+j(QSC)(C).Let j′ ≥ j, l ∈ N be such thatapplicableaugC(R)(brTR, µ, dChasecsafe

k+l (QSC)),for anyj′ ≥ l ≥ j, andapplicableaugC(R)(brTR, µ, dChasecsafe

k+j′+1(QSC )) doesnot hold. By construction, it should be the case thatapplicable(r′, µ,dChasecsafe

k+j′+1(QSC)) holds, wherer′ = augC( r). Also since no new Skolemblank node was introduced in any csafe dChase iterationk + l, for anyj ≤ l ≤ j′.It should be the case thathead(r)[µext(y)] = head(r′)[µext(y)](C). Since,dCha-secsafe

k+l (QSC)(C) = dChasek(QSC), for anyj ≤ l ≤ j′, anddChasecsafek+j′+1(QSC)

= dChasecsafek+j′(QSC)∪ head(r′)[µext(y)],dChasecsafe

k+j′+1(QSC)(C) = dChasek+1(QSC). Hence, the claim follows.

The following claim, which straightforwardly follows fromclaim 0, shows that, forcsafe quad-systems its standard dChase is contained in its safe dChase.

Claim. (1) SupposeunCSafe6∈ dChasecsafe(QSC), thendChase(QSC)⊆ dChasecsafe(QSC).

Claim below shows that the generation of originContext quads in csafe dChase is com-plete.

Claim. (2) For any quad-systemQSC , if unCSafe 6∈ dChasecsafe(QSC), then for anySkolem blank-nodeb generated indChase(QSC), and for anyc ∈ C, if c ∈ originCon-texts(b), then there exists a quadcc : (b, originContext,c) ∈ dChasecsafe(QSC).

Since the only way a Skolem blank nodeb gets generated in any iterationi of dChase(QSC) is by the application of a BRr ∈ R, i.e. when there∃r = body(r)(x, z) →head(r)(x, y) ∈ R, assignmentµ, such thatapplicableR(r, µ, dChasei−1(QSC)),andb = yj [µ

ext(y)], for someyj ∈ {y}, anddChasei(QSC) = dChasei−1(QSC) ∪head(r)(x, y)[µext(y)]. Also sincec ∈ originContexts(b), it should be the case thatc ∈ cScope(yj, head(r)). From claim 0, we know that there existsj ≥ 0, such thatdChasei(QSC) = dChasecsafe

i+j (QSC)(C). W.l.o.g, assume thati + j is the first suchcsafe dChase iteration. Hence, it follows thatapplicableaugC(R)(r

′, µ, dChasecsafei+j−1(

QSC)), wherer′ = augC(r). Since,head(r) ⊆ head(r′), it should be the case thatc ∈cScope(yj, head(r′)). Hence, by construction ofaugC, cc : (yj , originContext,c) ∈

head(r′), and as a result of application ofµ onr′ in iterationi+j, cc : (b, originContext,c) gets generated indChasecsafe

i+j (QSC). Hence, the claim holds.For the claim below, we introduce the concept of the sub-distance. For any two

blank nodes, their sub-distance is inductively defined as:

Definition 9. For any two blank nodesb, b′, sub-distance(b, b′) is defined inductivelyas:

– sub-distance(b, b′) = 0, if b′ = b;– sub-distance(b, b′) = ∞, if b 6= b′ andb is not a descendant ofb′;– sub-distance(b, b′) =mint∈{x[µ]}{ sub-distance(b, t)} + 1, if b′ was generated by

application ofµ on r = body(r)(x, z) → head(r)(x,y), i.e.b′ = yj[µext(y)], for

someyj ∈ {y}, andb is a descendant ofb′.

Claim. (3) For any quad-systemQSC = 〈QC , R〉, if unCSafe 6∈ dChasecsafe(QSC),then for any two Skolem blank nodesb, b′ in dChase(QSC), if b is a descendant ofb′

then there exists a quad of the formcc : (b, descendantOf,b′) ∈ dChasecsafe(QSC).

Note by the definition of sub-distance that ifb is a descendant ofb′, then sub-distance(b,b′) ∈ N. AssumingunCSafe 6∈ dChasecsafe(QSC), andb is a descendant ofb′, weapproach the proof by induction on sub-distance(b, b′).

base caseSuppose sub-distance(b, b′) = 1, then this implies that there existsr =body(x, z) → head(r)(x, y), assignmentµ such thatb′ was generated due to ap-plication of µ on r, i.e. b′ = yj[µ

ext(y)], for someyj ∈ {y}, andb ∈ {x[µ]}.This implies that there exists a dChase iterationi such thatapplicableR(r, µ,dChasei(QSC)) anddChasei+1(QSC) = dChasei(QSC) ∪ apply(r, µ). SinceunCSafe6∈ dChasecsafe(QSC), using claim 0,∃ k ≥ i such thatdChasei(QSC) =dChasecsafe

k (QSC)(C). W.l.o.g., letk be the first such csafe dChase iteration. Thismeans thatapplicableaugC(R)(r

′, µ, dChasecsafek (QSC)), wherer′ = augC(r),

anddChasecsafek+1 = dChas ecsafe

k (QSC) ∪ head(r′)[µext(y)], andb, b′ ∈ head(r′

)[µext(y)], b ∈ {x[µ]}, b′ = yj [µext(y)]. By construction ofaugC(), since there

exists a quad-patterncc : (xl, descendantOf,yj) ∈ head(r′), for anyxl ∈ {x},yj ∈ {y}, it follows thatcc : (b, descendantOf,b′) ∈ dChasecsafe

k+1(QSC).hypothesis Suppose sub-distance(b, b′) ≤ k, k ∈ N, thencc : (b, descendantOf,b′) ∈

dChasecsafe(QSC).inductive step Suppose sub-distance(b, b′) = k+1, then there exists ab′′ 6= b, assign-

mentµ, and BRr = body(r)(x, z) → head(r)(x,y) ∈ R such thatb′ was gen-erated due to the application ofµ or r with b′′ ∈ {x[µ]}, i.e. b′ = yj[µ

ext(y)], foryj ∈ {y}, andb is a descendant ofb′′. This implies that sub-distance(b′′, b′) = 1,and sub-distance(b, b′′) = k, and hence by hypothesiscc : (b, descendantOf,b′′) ∈dChasecsafe(QSC), andcc : (b′′, descendantOf,b′) ∈ dChasecsafe(QSC). Hence,by construction of csafe dChase,cc : (b, descendantOf,b′) ∈ dChasecsafe( QSC).

SupposeQSC is uncsafe, then by definition, there exists a blank nodesb, b′ in Bsk(dChase(QSC)), such thatb is descendant ofb′, andoriginContexts(b) is equal tooriginContexts(b′). By contradiction, ifunCSafe 6∈ dChasecsafe(QSC), then by claim1,dChase(QSC) ⊆ dChasecsafe(QSC). Since by claim 2, for anyc ∈ originContexts(b),

there exists quads of the formcc : (b, originContext,c) ∈ dChasecsafe(QSC) and for ev-eryc′ ∈ originContexts(b′), there existscc : (b′, originContext,c′)∈ dChasecsafe(QSC).SinceoriginContexts(b) = originContexts(b′), it follows that{c | cc : (b, origin-Context,c) ∈ dChasecsafe( QSC)} = {c′ | cc : (b′, originContext,c′) ∈ dChasecsafe(QSC)} Also by claim 3, sinceb is a descendant ofb′, there exists a quad of the formcc : (b, descendantOf,b′) in dChasecsafe(QSC). But, by construction ofdChasecsafe(QSC),it should be the case that there exist ab′′ ∈ Bsk(dChase

csafe(QSC)), r= body(r)(x, z)→ head(r)(x, y) ∈ augC(R), assignmentµ such thatb′ was generated due to the ap-plication ofµ onr, i.e.b′ = yj[µ

ext(y)] with b′′ ∈ {x[µ]}, andcc : (b, descendantOf,b′′)∈ dChasecsafe(QSC). But, since{c | cc : (b, originContext,c) ∈ dChasecsafe(QSC)}= cScope(yj, head(ri)), the methodunCSafeTest(r, µ, dChasecsafe

l (QSC)) should re-turn True, for somel ∈ N. Hence, it should be the case thatunCSafe∈ dChasecsafe(QSC),which is a contradiction to our assumption. HenceunCSafe∈ dChasecsafe(QSC), ifdChase(QSC) is uncsafe.

Proof (Property 4).(Only If) By definition,R is universally safe (resp. msafe, respcsafe) iff 〈QC , R〉 is safe (resp. msafe, resp. csafe), for any quad-graphQC . Hence,〈Qcrit

C , R〉 is safe (resp. msafe, resp. csafe).

(If part) We give the proof for the case of safe quad-systems.The proof for the msafeand csafe case can be obtained by slight modification. In order to show that if〈Qcrit

C ,R〉 is safe, thenR is universally safe, we prove the contrapositive. That is weshowthat if there existsQC such that〈QC ,R〉 is unsafe, thenQScrit

C = 〈QcritC ,R〉 is unsafe.

Suppose, there exists such an unsafe quad-systemQSC = 〈QC ,R〉, we show how to in-crementally construct a homomorphismh from constants indChase(QSC) to the con-stants indChase(QScrit

C ) such that for any Skolem blank node: b in dChase(QSC),there exists a homomorphism from descendance graph of: b to the descendance graphof h( : b) in dChase(QScrit

C ). Supposeh is initialized as: for any constantc ∈ C(QSC),h(c) = : bcrit, if c ∈ C(QSC) \ C(QScrit

C ); andh(c) = c otherwise . It can benoted that for any BRr = body(r)(x, z) → head(r)(x,y) ∈ R, if body(r)[µ] ⊆dChase0(QSC) thenbody(r)[µ][h] ⊆ dChase0(QS

cricC ). Now it follows that for any

i ∈ N, level(body(r)[µ]) = 0 if applicable(r, µ, dChasei(QSC)), then there existsj ≤ i such thatapplicable(r, h ◦ µ, dChasej(QScrit

C )). Let h be extended so that foranyi ∈ N, for any Skolem blank node: b introduced indChasei+1(QSC) while ap-plyingµ onr, for existential variabley ∈ {y}, leth( : b) be the blank node introducedin dChasej+1(QS

critC ), for the existential variabley while applyingh ◦µ onr. Hence,

it follows that, for anyi ∈ N, applicableR(r, µ, dChasei(QSC)) implies there existsj ≤ i such thatapplicable(r,h◦µ, dChasej(QScrit

C )), for anyr, µ. Also note that, forany Skolem blank node: b generated indChasei(QSC), it can be noted thatλr( : b)= λr(h( : b)) andλc( : b) = λc(h( : b)) andλv( : b)[h] = λv(h( : b)). Hence, itfollows that for any Skolem blank node: b in dChase(QSC), h is a homomorphismfrom descendance graph of: b to the descendance graph ofh( : b) in dChase(QScrit

C .Hence, if there exists two Skolem blank nodes: b, : b′ in dChase(QSC), with : b′

a descendant of: b andoriginRuleId( : b) = originRuleId( : b′) andoriginV ec-tor( : b) ∼= originV ector( : b′), then it follows that there existsh( : b), h( : b′) indChase( QScrit

C ), with h( : b′) descendant ofh( : b) andoriginRuleId(h( : b)) =

originRuleId(h( : b′)) andoriginV ector(h( : b))∼= originV ector(h( : b′)). Hence,it follows from the definition thatQScritic

C is unsafe.