Reasonable Highly Expressive Query Languages: Extended Technical Report

Reasonable Highly Expressive Query Languages: Extended Technical Report

Pierre Bourhis

and Markus Krötzsch

and Sebastian Rudolph

†

CNRS CRIStAL UMR 9189

Technische Universität Dresden, Germany

pierre.bourhis@inria.fr {markus.kroetzsch,sebastian.rudolph}@tu-dresden.de

Abstract

Expressive query languages are gaining relevance in knowledge representation (KR), and new reason- ing problems come to the fore. Especially query containment is interesting in this context. The prob- lem is known to be decidable for many expres- sive query languages, but exact complexities are often missing. We introduce a new query lan- guage, guarded queries (GQ), which generalizes most known languages where query containment is decidable.GQs can be nested (more expressive), or restricted to linear recursion (less expressive). Our comprehensive analysis of the computational prop- erties and expressiveness of (linear/nested) GQs also yields insights on many previous languages.

1 Introduction

The significance of query languages in KR is twofold. On the one hand, evaluating queries in the presence of a back- ground ontology allows us to express more complex infor- mation needs, leading to the notion ofontology-based query answering. This topic has been studied for a wide range of ontology languages and many different query languages, in- cluding conjunctive queries [Calvanese et al., 2007b; Eiter et al., 2009] and (many variants of) regular path queries [Calvanese et al., 2007a; Calvanese et al., 2009; Bienvenu et al., 2014]. On the other hand, recursive queries can be used to “implement” reasoning, such that the query language plays the role of a logical calculus that computes subsump- tions. Examples include [Xiaoet al., 2010; Krötzsch, 2011;

Bischoffet al., 2014], and the references given therein.

In both application areas, we can see a tendency towards more and more powerful recursive queries. Recent works in- troduced several highly expressive query languages related to applications in KR: Monadically Defined Queries(MQs) [Rudolph and Krötzsch, 2013] andMonadic Disjunctive SNP queries (coMMSNP) [Bienvenu et al., 2013]. Both can be viewed as fragments of (disjunctive) Datalog.

The proliferation of query languages and their uses in KR brings new questions to the fore. The complexity of ontology- based query answering has been studied from its inception, whereas the equally important question of relative expressive- ness was studied only recently [Bienvenuet al., 2013]. An-

other important question is the problem ofquery containment, where we consider two queriesQ₁ andQ₂, and asks if every answer toQ1is also an answer toQ2over all possible inputs.

Deciding query containment is relevant for query rewriting algorithms, where it needs to be checked if new queries are subsumed by previous ones to ensure termination. Further relevant applications are query optimization (finding a sim- pler yet equivalent query), and verification (checking that a query contains specific test cases). In addition, query con- tainment has a range of applications in databases, e.g. in in- formation integration and database integrity checking.

Although Datalog provides a useful framework for study- ing many recursive query languages, it does, unfortunately, not have a decidable query containment problem [Shmueli, 1987]. In contrast, the containment is known to be decid- able for regular path queries, MQs, andcoMMSNPqueries.

In the latter two cases, however, no upper complexity bound is known. Nevertheless, numerous results exist for various smaller query languages. For the following overview, recall that a predicate in a Datalog program isintensional (IDB)if it occurs in some rule head, andextentional (EDB)otherwise.

Non-recursive Datalog and unions of conjunctive queries A non-recursive Datalog program is equivalent to a (pos- sibly exponential) union of conjunctive queries (UCQ), and thus expressible in first-order logic. Containment of Datalog (in the following referred to as Dlog) inUCQis 2ExpTime- complete, while containment ofDlog in non-recursive Dat- alog is 3ExpTime-complete [Chaudhuri and Vardi, 1997].

Some restrictions for decreasing the complexity of these problems have been considered. Deciding if a linearDat- alog program (LinDlog, where rule bodies contain at most one recursive predicate) is contained in aUCQis ExpSpace- complete; complexity further decreases to PSpacewhen the linear Datalog program is monadic (LinMDlog, see below) [Chaudhuri and Vardi, 1994; Chaudhuri and Vardi, 1997].

Monadic Datalog A monadic Datalog (MDlog) program is one with only unary IDB predicates. Containment be- tween twoMDlogprograms is 2ExpTime-complete. The up- per bound is well known since the 80’s [Cosmadakiset al., 1988], while the lower bound has been established only re- cently [Benediktet al., 2012]. Moreover, the containment of DloginMDlog is also decidable by a straightforward appli-

LinMQ LinMDlog

LinGQ LinGDlog

LinMQ^k

LinMQ⁺ LinGQ^k

LinGQ⁺ MQ

GQ MQ^k

MQ⁺

GQ^k GQ⁺

LinDlog Dlog

MDlog GDlog

AC0

NP PH PSpace Exp

CQ C2RPQ NLogSpacePTime

DataComplexityofQueryAnswering

Combined Complexity of Query Answering

Figure 1: Query languages and complexities; languages higher up in the graph are more expressive

cation of [Courcelle, 1991, Theorem 5.5].¹ So far, however, tight bounds have not been known for this case.

Guarded Datalog Guarded Datalog (GDlog) requires that, for each rule, the variables of the head should appear in a single EDB atom in the rule body. This notion of (frontier- )guarded rules has been known for a while [Calìet al., 2008;

Bagetet al., 2011], but its first use as a query language is recent [Bárány et al., 2012]. GDlog is a proper extension ofMDlog, since monadic rules can always be rewritten into guarded rules [Bárányet al., 2012]. Query containment for GDlogis 2ExpTime-complete, as it corresponds to a satisfia- bility problem for guarded negation fixed point logic [Bárány et al., 2011].

Navigational Queries Conjunctive two-way regular path queries (C2RPQs) generalize conjunctive queries (CQs) by regular expressions over binary predicates [Florescu et al., 1998; Calvaneseet al., 2003]. Variants of this idea are used in the RDF query language SPARQL 1.1 and the XML query language XPath. Roughly,C2RPQis a conjunction of atoms of the form xLy where L is a two-way regular expression.

A pair of nodeshn₁,n₂iis a valuation of the pairhx,yiif and only if there exists a path betweenn1andn2matchingL. Con- tainment of such queries is ExpSpace-complete [Florescu et al., 1998; Calvaneseet al., 2003; Abiteboul and Vianu, 1999;

Deutsch and Tannen, 2002], while containment of Dlog in C2RPQis 2ExpTime-complete [Calvaneseet al., 2005].

Fragments of Monadic Second-Order Logic More re- cently, Monadically Defined Queries (MQs) and their nested version (MQ⁺s) have been introduced [Rudolph and Krötzsch, 2013] as a proper generalization ofMDlogthat also captures (unions of)C2RPQs. MQs are expressible in bothDlogand monadic second-order logic, but (in contrast to these lan- guages), feature a decidable query containment problem. The most general recent query language for which containment is known to be decidable iscoMMSNP[Bienvenuet al., 2013],

1We thank Michael Benedikt for this observation.

a fragment of monadic second-order logic motivated by de- scriptive complexity. As opposed to the above languages, coMMSNPis a non-deterministic query language, closely re- lated to disjunctive Datalog. A simple inspection of the def- initions shows that the deterministic (disjunction-free) frag- ment, i.e., “Horn-coMMSNP”, agrees withMQ.

In this paper, we further extend the known recursive query languages and at the same time settle all major questions re- lated to the complexity of their query containment problems.

Figure 1 gives an overview of all languages we consider, to- gether with their respective query-answering complexities.

The main new query language we consider is called guarded queries(GQ), and is based on the use of frontier- guarded Datalog rules. GQcan be viewed as an extension of MQ, and is indeed inspired by a similar extension for coMMSNP[Bienvenuet al., 2013]. GQthus also generalizes frontier-guarded Datalog. We further introduce the nested and linear variant ofGQ, and establish complexity results for query answering in all cases.

We then turn towards query containment. We obtain tight complexity bounds for (nested)GQs and many other query languages, which are summarized in Table 1. To show the upper bounds, we extend known automata-based approaches by a number of new techniques. Lower bounds are obtained by simulating space-bounded alternating Turing machines in a way that allows for an exponential increase in space with each nesting level. Finally, we also sketch how our results transfer to the case of linear Datalog, where many complexi- ties can be slightly reduced.

In summary, our results settle open problems for (nested) MQs, and they paint a comprehensive and detailed picture of the state of the art in Datalog query containment.

2 Preliminaries

We consider a standard language of first-order predicate logic, based on an infinite setCofconstant symbols, an infi- nite setPofpredicate symbols, and an infinite setVof first-

ordervariables. Each predicatep∈Pis associated with a nat- ural numberar(p) called thearityofp. The list of predicates and constants forms the language’s signatureS = hP,Ci.

We generally assumeS =hP,Cito be fixed, and only refer to it explicitly if needed.

Formulae, Rules, and Queries Atermis a variable x∈V or a constantc ∈ C. We use symbols s,tto denote terms, x,y,z,v,wto denote variables,a,b,cto denote constants. Ex- pressions liket,x,cdenote finite lists of such entities. We use the standard predicate logic definitions ofatomandformula, using symbolsϕ,ψfor the latter.

Datalog queries are defined over an extended signature with additional predicate symbols, calledIDB predicates; all other predicates are calledEDB predicates. ADatalog ruleis a formula of the form∀x,y.ϕ[x,y]→ψ[x] whereϕandψare conjunctions of atoms, called thebodyandheadof the rule, respectively, and whereψonly contains IDB predicates. We usually omit universal quantifiers when writing rules. Sets of Datalog rules will be denoted by symbolsP,R,S. A set of Datalog rulesPis

• monadicif all IDB predicates are of arity one;

• frontier-guarded if the body of every rule contains an atomp(t) such thatpis an EDB predicate andtcontains all variables that occur in the rule’s head;

• linearif every rule contains at most one IDB predicate in its body.

Aconjunctive query(CQ) is a formulaQ[x] =∃y.ψ[x,y]

whereψ[x,y] is a conjunction of atoms; aunion of conjunc- tive queries(UCQ) is a disjunction of such formulae. ADat- alog queryhP,Qi consists of a set of Datalog rulesPand a conjunctive query Qover IDB or EDB predicates (Qcould be expressed as a rule in Datalog, but not in all restrictions of Datalog we consider). We writeDlogfor the language of Datalog queries. A monadic Datalog query is one whereP is monadic, and similarly for other restrictions. We use the query languagesMDlog(monadic),GDlog(frontier-guarded), LinDlog(linear), andLinMDlog(linear, monadic).

Databases and Semantics We use the standard semantics of first-order logic (FOL). Adatabase instanceIover a sig- nature S = hP,Ciconsists of a set∆^I calleddomainand a function ·^I that maps constants c ∈ C to domain ele- ments c^I ∈ ∆^I and predicate symbols p ∈ P to relations p^I⊆(∆^I)^ar(p), wherep^Iis theextensionof p.

Given a database instanceIand a formulaϕ[x] with free variablesx=hx1, . . . ,xmi, theextensionofϕ[x] is the subset of (∆^I)^m containing all those tuples hδ1, . . . , δmi for which I,{x_i 7→ δ_i | 1 ≤ i ≤ m} |= ϕ[x]. We denote this by hδ1, . . . , δmi ∈ ϕ^I or byI |= ϕ(δ1, . . . , δm); a similar nota- tion is used for all other types of query languages. Two for- mulaeϕ[x] andψ[x] are calledequivalentif their extensions coincide for every database instanceI.

The set of answers of aUCQQ[x] overIis its extension.

A Datalog programPissatisfiedby database instanceI⁰over the extended signature of EDB and IDB predicates, if all rules ofPare satisfied byI⁰in the usual sense. The set of answers

of a Datalog queryhP,Qi over Iis the intersection of the extensions ofQover all extended database instancesI⁰that satisfyPand agree withIon constants and EDB predicates.

Datalog can also be defined as the least fixpoint of the infla- tionary evaluation ofQonI[Abiteboulet al., 1994].

Note that we do not require database instances to have a finite domain, since all of our results are valid in either case.

This is due to the fact that every entailment of a Datalog pro- gram has a finite witness, and that all of our query languages are positive, i.e., that their answers are preserved under ho- momorphisms of database instances.

One of the main tasks on reasoning on queries is to deter- mine if a query contains another. In particular, for two Data- log querieshP,QiandhP⁰,Q⁰i, we say thathP,Qiis contained inhP⁰,Q⁰i, denotedhP,Qi v hP⁰,Q⁰iifffor each database in- stanceIover the signature of EDB predicates and constants, the set of answers ofhP,QioverIis included in the set of answers ofhP⁰,Q⁰ioverI.

3 Guarded Queries

Rudolph and Krötzsch [2013] introduced monadically de- fined queries(MQs²) as a generalization of conjunctive two- way regular path queries (C2RPQs) and monadic Datalog (MDlog) for which query containment is still decidable. The idea underlying this approach is that candidate query answers are checked by evaluating a monadic Datalog program, i.e., in contrast to the usual evaluation of Datalog queries, we start with a “guessed” answer that is the input to a Datalog pro- gram. To implement this, the candidate answer is represented by special constantsλthat the Datalog program can refer to.

This mechanism was called flag &check, since the special constants act as flags to indicate the answer to be checked.

Example 1. A query that computes the transitive closure over a relation p can be defined as follows.

p(λ1,y)→U(y) U(y)∧p(y,z)→U(z) U(λ2)→hit

One defines the answer of the query to contain all pairs hδ₁, δ₂ifor which the rules entailhitwhen interpretingλ₁as δ1andλ2asδ2.

The original approach used monadic Datalog for its close relationship to monadic second-order logic, which was the basis for showing decidability of query containment. In this work, however, we develop new techniques for showing the decidability (and exact complexity) of this problem directly.

It is therefore suggestive to consider other types of Datalog programs for the “check” part. The next definition introduces the general approach for arbitrary Datalog programs, and de- fines interesting fragments by imposing further restrictions.

Definition 1. Consider a signatureS. An FCP (“flag &

check program”) of arity m is a set of Datalog rulesPwith k≥0IDB predicatesU₁, . . . ,U_k, that may use the additional constant symbolsλ1, . . . , λm < S and an additional nullary predicate symbol hit. An FCQ (“flag& check query”) P is

2Here we shorten the original acronymMODEQtoMQ.

of the form∃y.P(z), where Pis an FCP of arity |z|and all variables inyoccur inz. The variablesxthat occur inzbut not inyare thefree variablesof P.

LetIbe a database instance overS. TheextensionP^Iof Pis the set of all tupleshδ1, . . . , δmi ∈ (∆^I)^msuch that every database instanceI⁰that extendsIto the signature ofPand that satisfieshλ^I₁⁰, . . . , λ^I_m⁰i=hδ1, . . . , δmialso entailshit. The semantics of FCQs is defined in the obvious way based on the extension of FCPs.

AGQis an FCQ ∃y.P(z)such thatPis frontier-guarded.

Similarly, we defineMQ(monadic),LinMQ(linear, monadic), andLinGQ(linear, frontier-guarded) queries.

In contrast to Rudolph and Krötzsch [2013], we do not de- fine monadic queries as conjunctive queries of FCPs, but we merely allow existential quantification to project some of the FCP variables. Proposition 1 below shows that this does not reduce expressiveness.

We generally consider monadic Datalog as a special case of frontier-guarded Datalog. Monadic Datalog rules do not have to be frontier-guarded. A direct way to obtain a suitable guard is to assume that there is a unarydomainpredicate that contains all (relevant) elements of the domain of the database instance. However, it already suffices to requiresafetyof Dat- alog rules, i.e., that the variable in the head of a rule must also occur in the body. Then every element that is inferred to belong to an IDB relation must also occur in some EDB relation. We can therefore add single EDB guard atoms to each rule in all possible ways without modifying the seman- tics. This is a polynomial operation, since all variables in the guards are fresh, other than the single head variable that we want to guard. We therefore find, in particular, thatGQcap- tures the expressiveness ofMQ. The converse is not true, as the following example illustrates.

Example 2. The following4-aryLinGQgeneralizes Exam- ple 1 by checking for the existence of two parallel p-chains of arbitrary length, where each pair of elements along the chains is connected by a relation q, like the steps of a ladder.

q(λ₁, λ₂)→U_q(λ₁, λ₂) U_q(x,y)∧p(x,x⁰)∧p(y,y⁰),q(x⁰,y⁰)→U_q(x⁰,y⁰)

U_q(λ₃, λ₄)→hit One might assume that the followingMQis equivalent:

q(λ₁, λ₂)→U₁(λ₁) q(λ₁, λ₂)→U₂(λ₂) U₁(x)∧U₂(y)∧p(x,x⁰)∧p(y,y⁰),q(x⁰,y⁰)→U₁(x⁰) U₁(x)∧U₂(y)∧p(x,x⁰)∧p(y,y⁰),q(x⁰,y⁰)→U₂(y⁰)

U₁(λ₃)∧U₂(λ₄)→hit However, the latter query also matches struc- tures that are not ladders. For example, the fol- lowing database yields the answer ha,b,c,di, al- though there is no corresponding ladder structure:

{q(a,b),p(a,c),p(b,e),q(c,e),p(a,e⁰),p(b,d),q(e⁰,d)}. One can extend theMQto avoid this case, but any such fix is “local” in the sense that a sufficiently large ladder-like structure can trick the query.

Rudolph and Krötzsch [2013] showed that monadically defined queries can be expressed both in Datalog and in monadic second-order logic. While we lose the connection to monadic second-order logic withGQs, the expressibility in Datalog remains. The encoding is based on the intuition that the choice of the candidate answers for λ“contextualizes”

the inferences of the Datalog program. To express this with- out special constants, we can store this context information in predicates of suitably increased arity.

Example 3. The4-aryLinGQof Example 2 can be expressed with the following Datalog query. For brevity, let ybe the variable listhy1,y2,y3,y4i, which provides the context for the IDB facts we derive.

q(y1,y2)→U⁺_q(y1,y2,y) U_q(x,y,y)∧p(x,x⁰)∧p(y,y⁰),q(x⁰,y⁰)→U⁺_q(x⁰,y⁰,y)

U_q(y3,y4,y)→goal(y) This result is obtained by a straightforward extension of the translation algorithm forMQs [Rudolph and Krötzsch, 2013], which may not produce the most concise representation. Also note that the first rule in this program is not safe, since y3

and y4 occur in the head but not in the body. According to the semantics we defined, such variables can be bound to any element in the active domain of the given database instance (i.e., they behave as if bound by a unarydomainpredicate).

This observation justifies that we considerMQs,GQs, etc.

as Datalog fragments. It is worth noting that the translation does not change the number of IDB predicates in the body of rules, and thus preserves linearity. The relation to (lin- ear) Datalog also yields some complexity results for query answering; we will discuss these at the end of the next sec- tion, after introducing nested variants our query languages.

4 Nested Queries

Every query language gives rise to a nested language, where we allow for nested queries to be used as if they were predi- cates. Sometimes, this does not lead to a new query language (like forCQandDlog), but often it affects complexities and/or expressiveness. It has been shown that both are increased when moving fromMQs to their nested variants [Rudolph and Krötzsch, 2013]. We will see that nesting also has strong ef- fects on the complexity of query containment.

Definition 2. We define k-nested FCPs inductively. A 1- nested FCP is an FCP. A k+1-nested FCP is an FCP that may use k-nested FCPs of arity m instead of predicate symbols of arity m in rule bodies. The semantics of nested FCPs is im- mediate based on the extension of FCPs. A k-nested FCQ P is of the form∃y.P(z), wherePis a k-nested FCP of arity|z|

and all variables inyoccur inz.

A k-nestedGQquery is a k-nested frontier-guarded FCQ.

For the definition of frontier-guarded, we still require EDB predicates in guards: subqueries cannot be guards. The lan- guage of k-nestedGQqueries is denotedGQ^k; the language of arbitrarily nestedGQqueries is denotedGQ⁺. Similarly, we define languagesMQ^k andMQ⁺(monadic), LinMQ^k and LinMQ⁺(linear, monadic), andLinGQ^kand LinGQ⁺(linear, frontier-guarded).

Note that nested queries can use the same additional sym- bols (predicates and constants); this does not lead to any se- mantic interactions, however, as the interpretation of the spe- cial symbols is “private” to each query. To simplify notation, we assume that distinct (sub)queries always contain distinct special symbols. The relationships of the query languages we introduced here are summarized in Figure 1, where upwards links denote increased expressiveness. An interesting obser- vation that is represented in this figure is that linear Datalog is closed under nesting:

Theorem 3. LinDlog=^LinDlog+.

Proof. We will prove that anyLinDlog⁺query can be rewrit- ten into aLinDlogquery of polynomial size. We make simpli- fying assumptions on the structure of the nested query which can be easily obtained by polynomial transformations and make the presentation easier: we assume that every rule body of any query occurring at any nesting depth contains at most one subquery atom (using, e.g., Proposition 1). Second, we assume that all variables and IDB predicates that are not in the same scope are appropriately renamed apart.

In order to proof our claim, we will first show that any LinDlog² can be rewritten into an equivalentLinDlog query.

Applying the rewriting iteratively inside-out (and observing that even manyfold application can be done in polynomial total time) then allows to conclude that there is a polynomial rewriting of anyLinDlog⁺query of arbitrary depth into aLinD- logquery.

Consider aLinDlog² queryP=hP,piand assume w.l.o.g.

that every rule body of the rules contains at most oneLinDlog¹ subquery. Now, going through all rules ofPwe produce the rulesP⁰of the unnested but equivalent version.

Consider a ruleρ∈Phaving the shape

Q(x1, . . . ,xn)∧p(y1, . . .y`)∧B1∧. . .∧Bk→H wherepis the body IDB predicate and whereQ =hQ,qiis aLinDlog<sup>1</sup>query. For anyk-ary IDB predicaterinsideQwe increase its arity by`and letP⁰contain all rules ofQ⁰which is obtained from the rulesρ⁰ofQby

• replacing any (head or body) IDB atomr(z1, . . . ,zk) of ρ⁰byr(z1, . . . ,z_k,y1, . . .y_`) and

• in case ρ⁰ does not contain any IDB body atom, add p(y1, . . .y`) to the body.

Further we letP⁰contain the rule

q(x₁, . . . ,xn,y1, . . .y`)∧ ∧B1∧. . .∧Bk→H.

In case of a ruleρ∈Phaving the shape Q(x₁, . . . ,x_n)∧B₁∧. . .∧B_k→H

we addQtoP⁰without change and letP⁰contain the rule q(x1, . . . ,x_n)∧B1∧. . .∧B_k→H.

In case a ruleρ∈ Pdoes not contain a subquery atom we simply addρtoP⁰.

It can now easily verified thathP,piandhP⁰,piare equiv- alent: first it is straightforward, that hP,pi is equivalent to hP^[,pi where P^[ is obtained from P by replacing every

Q(x1, . . . ,xn) by q(x1, . . . ,xn) (that is, the according goal predicate) and then adding all rules fromQwith no changes made to them. Second one can show that there is a direct correspondence between proof trees ofhP^[,piand linearized proof trees ofhP⁰,piwhich yields the desired result.

Another kind of nesting that does not add expressiveness is the nesting of FCQs in UCQs. Indeed, it turns out that (nested) FCQs can internalize arbitrary conjunctions and dis- junctions of FCQs (of the same nesting level). This even holds when restricting to linear rules.

Proposition 1. Let P be a positive query, i.e., a Boolean ex- pression of disjunctions and conjunctions, ofLinMQ^kqueries with k ≥ 1. Then there is a LinMQ^k query P⁰ of size poly- nomial in P that is equivalent to P. Analogous results hold when replacingLinMQ^kbyMQ^k,GQ^k, orLinMQ^kqueries.

Proof. We show the claim by induction, by expressing the innermost disjunctions and conjunctions ofPwith equivalent LinMQ^kqueries of linear size. We consider positive queries without existential quantifiers (i.e., where all variables are answer variables), but the innerLinMQ^k may use existential quantifiers.

LetP[x]=P1[x1]∨. . .∨Pn[xn] be a disjunction ofLinMQ^k queries. Each queryP_iis of the form∃z_i.P⁰_i[x⁰

i], where x⁰

i is the list of free variables ofP⁰_i(corresponding to constantsλ), andzicontains exactly those variables ofx⁰

ithat do not occur inxi. We assume without loss of generality that ziis disjoint fromzjifi , j, and that eachP⁰_i uses a unique set of IDBs that does not occur in other queries. We consider queries ¯Pi

obtained by replacing the special constant that represents a variablexj ∈ x by the special constantλ_j (assumed to not occur inPyet). Thus, the queries ¯Pishare special constants exactly where queriesP₁share variables. We can now define theLinMQ^kP⁰as∃z1. . .zn.P¯1∪. . .∪P¯n, where we assume that the correspondence of special constants to free variables is such that the existential quantifiers refer to the same variables as before.

Let P[x] = P1[x1] ∧. . . ∧Pn[xn] be a conjunction of LinMQ^k queries. Let P_i = ∃zi.P⁰_i[x⁰

i] as before, and letU_i fori ∈ {1, . . . ,n−1}be fresh IDB predicates. The queries P¯iare defined as before by renaming special constants to re- flect shared variables. For eachi∈ {1, . . . ,n}, the set of rules Pˆi is obtained from ¯Pias follows: if i < n, then every rule ϕ→hit∈P¯iis replaced by the ruleϕ→U_i(λ1), whereλ1is a fixed special constant in the queries; ifi>1, then every rule ϕ → ψ ∈ P¯i whereϕdoes not contain an IDB predicate is replaced by the ruleϕ∧U_i−1(λ₁)→ψ, whereλ₁is as before.

TheLinMQ^kP⁰is defined as∃z1. . .zn.Pˆ1∪. . .∪Pˆn. These constructions lead to equivalentLinMQ^kqueries of linear size, so the claim follows by inductions. The cases for MQ^k, GQ^k, andLinMQ^kfollow from the same constructions (note that, without the requirement of linearity, a simpler con- struction is possible in the case of conjunctions).

Query answering for MQs has been shown to be NP- complete (combined complexity) and P-complete (data com- plexity). For MQ⁺, the combined complexity increases to PSpacewhile the data complexity remains the same. These

results can be extended toGQs. We also note the complexity for frontier-guarded Datalog, for which we are not aware of any published result.

Theorem 4. The combined complexity of evaluating GQ queries over a database instance isNP-complete. The same holds forGDlogqueries. The combined complexity of evalu- atingGQ⁺queries isPSpace-complete. The data complexity isP-complete forGDlog,GQ, andGQ⁺.

Proof. The lower bounds are immediate from the matching complexities forMQandMQ⁺queries, respectively [Rudolph and Krötzsch, 2013].

First, we prove that checking if a tuple is an answer of aGQ over a database instanceIis in NP for combined complexity.

LetIbe an instance, letPbe aGQwith frontier guarded rules P, and letδbe be a candidate answer forPas in Definition 1.

Since each rule in Pis frontier-guarded, each intentional fact that is derived when checking the answer follows from the application of one particular rule, instantiated to match one particular (guard) EDB fact in the body. Therefore, the number of IDB facts that can be derived is polynomially bounded in the size ofIandP.

Thus, for every derivation ofP, only a polynomial number of rule applications are necessary, since it is enough to derive each IDB fact once. It is clear that one can guess such a derivation, where we guess, for each derivable IDB fact, one specific rule instance by which it is derived. The correctness of this guess can be checked in polynomial time, showing that the problem can be solved in NP.

We now show that checking an answer of aGQ⁺over an instanceIis in PSpace. LetIbe an instance, letPbe aGQ^k with frontier guarded rulesP(that may contain subqueries), and letδbe be a candidate answer forPas in Definition 1. We demonstrate by induction onkthat checking ifδis a solution forPw.r.t.Iis in NPSpace. For the induction base, the claim follows from the above result forGQs.

For the induction step, using the same argument as before, we can see that the number of IDB facts that can be derived by Pis still polynomial. Therefore, we can again guess a poly- nomial derivation as before, though the rule instances now may refer to subqueries of smaller nesting depth. By the in- duction hypothesis, whenever we need to verify the applica- bility of such a rule, we can use an NPSpacealgorithm for the nested query. The overall number of such checks is poly- nomial, yielding the overall NPSpacealgorithm. The result follows since NPSpace=PSpace[Savitch, 1970].

The fact that query evaluation is in P for data complexity is immediate from the fact our queries can be expressed in Dat- alog, which is known to have this data complexity. A direct proof is also obtained by observing that the number of pos- sible derivation sequences that the above algorithms need to consider is in itself polynomial inIifPis fixed, so that the algorithms themselves are already in P for data complexity.

The lower bounds in the previous case are immediate from know results forMQs. In particular, the hardness proof for nested MQs also shows that queries of a particular fixed nesting level can encode the validity problem for quantified

boolean formulae with a certain number of quantifier alterna- tions; this explains why we show the combined complexity of MQ^kto be in the Polynomial Hierarchy in Figure 1. A modifi- cation of this hardness proof of Rudolph and Krötzsch [2013]

allows us to obtain the same results for the combined com- plexities in the linear cases; matching upper bounds follow from Theorem 4.

Theorem 5. The combined complexity of evaluatingLinMQ, LinGDlog, orLinGQqueries over a database instance isNP- complete. The combined complexity of evaluatingLinMQ⁺or LinGQ⁺queries isPSpace-complete. The data complexity is NLogSpace-complete for all of these query languages.

Proof. The claimed NP-completeness is immediate. Hard- ness follows from the hardness of CQ query answering.

Membership follows from the membership ofGQ.

The claimed membership in PSpace follows from the PSpace-membership of LinDlog; note that this uses Theo- rem 3. Hardness for LinGQ⁺follows from the hardness for LinMQ⁺, which we show by modifying the PSpace-hardness proof for monadically defined queries from [Rudolph and Krötzsch, 2013].

We show the result by providing a reduction from the va- lidity problem of quantified Boolean formulae (QBFs). We recap that for any QBF, it is possible to construct in polyno- mial time an equivalent QBF that has the specific shape

Q1x1Q2x2. . .Qnxn

_

L∈L

^

`∈L

`,

with Q1, . . .Qn ∈ {∃,∀} and L being a set of sets of lit- erals over the propositional variables x1, . . . ,xn. In words, we assume our QBF to be in prenex form with the propo- sitional part of the formula in disjunctive normal form. For every literal setL = {x_k1, . . . ,x_ki,¬x_ki+1, . . . ,¬x_kj}, we now define then-ary FCPpL = {t(λk1)∧. . .∧t(λk_i)∧f(λk_i+1)∧ . . . ∧f(λk_j) → hit}. Moreover, we define the n-ary FCP pL = {pL(λ₁, . . . , λ_n) → hit | L ∈ L}. LettingpL = pn we now define FCPspn−1. . .p0 in descending order. IfQi =∃, then thei−1-ary FCPp_i−1is defined as the singleton rule set {pi(λ1, . . . , λi−1,y)→hit}. In caseQi=∀, we letpi−1contain the rules

f(x)→U_?(x) U_!(x)∧f(x)∧t(y)→U_?(y)

U_!(x)∧t(x)→hit U_?(x)∧p_i(λ₁, . . . , λi−1,x)→U_!(x)

Note thatp0is a BooleanLinMQ⁺query the size of which is polynomial in the size of the input QBF.

Now, let Dbe the database containing the two individu- als 0 and 1 as well as the factsf(0) andt(1). We now show that the considered QBF is true exactly ifD|=p0(). To this end, we first note that by construction the extension of pL

contains exactly thosen-tupleshδ1, . . . , δnifor which the cor- responding truth value assignmentval, sendingxitotrueiff δi = 1, makes the formula V

`∈L` true. In the same way,

the extension ofpL represents the set of truth value assign- ments satisfying W

L∈LV

`∈L`. Then, by descending induc- tion, we can show that the extensions ofpi encode the as- signments to free propositional variables of the subformula Qi+1xi+1. . .QnxnW

L∈LV

`∈L` that make this formula true.

Consequently,p0has a nonempty extension if the entire con- sidered QBF is true.

Finally, the NLogSpace-completeness for data complexity is again immediate, where the upper bound is obtained from LinDlog, and the lower bound follows from the well-known hardness of reachability queries, which can be expressed in

LinMDlog.

5 Complexity of Query Subsumption

In this section, we first discuss an automata-based way to de- cide query containment, which will give rise to upper com- plexity bounds.To obtain matching lower bounds, we provide direct encodings of Alternating Turing Machines (ATMs) with a fixed space bound [Chandraet al., 1981]. Finally we show that containment checking is often slightly simpler in fragments of linear Datalog.

5.1 Deciding Query Containment with Automata We first recall a general technique of reducing query contain- ment to the containment problem for (tree) automata [Chaud- huri and Vardi, 1997], which we build our proofs on. An introduction to tree automata is included in the appendix.

A common way to describe the answers of a Dlogquery P = hP,pi is to consider its expansion trees. Intuitively speaking, the goal atom p(x) can be rewritten by applying rules ofPin a backward-chaining manner until all IDB predi- cates have been eliminated, resulting in aCQ. The answers of P coincide with the (infinite) union of answers to the CQs obtained in this fashion. The rewriting itself gives rise to a tree structure, where each node is labeled by the instance of the rule that was used in the rewriting, and the leaves are instances of rules that contain only EDB predicates in their body. The set of all expansion trees provides a regular de- scription ofPthat we exploit to decide containment.

To formalize this approach, we describe the set of all ex- pansion trees as a tree language, i.e., as a set of trees with node labels from a finite alphabet. The number of possible labels of nodes in expansion trees is unbounded, since rules are instantiated using fresh variables. To obtain a finite alpha- bet of labels, one limits the number of variables and thus the overall number of possible rule instantiations [Chaudhuri and Vardi, 1997].

Definition 6. Given aDlogquery P=hP,pi,R_Pis the set of all instantiations of rules ofPusing only the variablesV_P= {v1, . . . ,vn}, where n is twice the maximal number of variables occurring in any rule ofP.

Aproof treefor P is a tree with labels fromR_P, such that (a) the root is labeled by a rule with p as its head predicate;

(b) if a node is labeled by a ruleρwith an IDB atom B in its body, then it has a child node that is labeled byρ⁰with head atom B. The label of a node e is denotedπ(e).

Consider two nodes e1 and e2 in a proof tree with lowest common ancestor e. Two occurrences of a variable v inπ(e1)

andπ(e2)areconnectedif v occurs in the head ofπ(f) for all nodes f on the shortest path between e₁ and e₂, with the possible exception of e.

A proof tree encodes an expansion tree where we replace every set of mutually connected variable occurrences by a fresh variable. Conversely, every expansion tree is repre- sented by a proof tree that replaces fresh body variables by variables that do not occur in the head; this is always possible since proof trees can use twice as many variables as any rule ofP. The set of proof trees is a regular tree language that can be described by an automaton.

Proposition 2(Proposition 5.9 [Chaudhuri and Vardi, 1997]).

For aDlogquery P=hP,pi, there is a tree automatonA_Pof size exponential in P that accepts exactly the set of all proof trees of P.

In order to useA_Pto decide containment ofPin another queryP⁰, we construct an automaton A_PvP0 that accepts all proof trees ofPthat are “matched” byP⁰. Indeed, every proof tree induces awitness, i.e., a minimal matching database in- stance, and one can check whether or notP⁰can produce the same query answer on this instance. If this is the case for all proof trees ofP, then containment is shown.

5.2 Deciding Guarded Query Containment

Our first result provides the upper bound for deciding con- tainment ofGQqueries. In fact, the result extends to arbitrary Dlogqueries on the left-hand side.

Theorem 7. Containment ofDlogqueries inGQqueries can be decided in3ExpTime.

To prove this, we need to construct the tree automaton A_PvP⁰for an arbitraryGQP⁰. As a first step, we construct an alternating 2-way tree automatonA⁺_PvP0that accepts the proof trees that we would likeA_PvP0 to accept, but with nodes ad- ditionally being annotated with information about the choice ofλvalues to guide the verification.

We first construct automata to verify the match of a single, non-recursive rule that may refer toλconstants. The rule does not have to be monadic or frontier-guarded. Our construction is inspired by a similar construction forCQs by Chaudhuri and Vardi [Chaudhuri and Vardi, 1997], with the main differ- ence that the answer variables in our case are not taken from the root of the tree but rather from one arbitrary node that is marked accordingly.

To define this formally, we introduce trees with additional annotations besides their node labels. Clearly, such trees can be viewed as regular labelled trees by considering annotations to be components of one label; our approach, however, leads to a more readable presentation.

Definition 8. Consider a Datalog programP, a ruleρ=ϕ→ p(x), and n≥0special constantsλ=λ1, . . . , λn. The proof- tree variablesV_Pused inR_Pare as in Definition 6.

A proof tree forPisλ-annotatedif every node has an ad- ditionalλ-labelthat is a partial mapping{λ1, . . . , λ_n} → V_P, such that: every special constantλ_ioccurs in at least oneλ- label, and whenever a constantλioccurs in twoλ-labels, it is mapped to the same variable and both variable occurrences are connected.

A proof tree for Pis p-annotatedif exactly one node has an additional p-label of the form p(v), where vis a list of variables fromV_P.

A matching tree T for ρand P is a λ-annotated and p- annotated proof tree forP for which there is a mappingν : Var(ρ)∪ {λ₁, . . . , λ_n} → V_Psuch that

1. ν(p(x))=p(v);

2. for every atom α of ϕ, there is a node eα in T such that the rule instance that eα is labeled with contains the EDB atomν(α)in its body;

3. ifλioccurs inα, then theλ-label mapsλito the occur- rence ofν(λ_i)in e_α;

4. ifα, α⁰ ∈ϕshare a variable x, then the occurrences of ν(x)in eαand eα⁰are connected.

Proposition 3. There is an automatonA_P,ρthat accepts ex- actly the annotated matching trees forρandP, and which is exponential in the size ofρandP.

Proof. We first construct an automaton A⁰_P,ρ that accepts matching trees where each node is additionally annotated by a partial mapping of the formVar(ρ) → V_P(calledVar(ρ)- label), such that: every special variablex∈Var(ρ) occurs in at least oneVar(ρ)-label, and whenever a variablex∈Var(ρ) occurs in two, it is mapped to the same variable and both vari- able occurrences are connected. Note that this is essentially the same condition that we imposed forλ-annotations.

The intersection of tree automata can be computed in poly- nomial time. We can therefore construct automata to check part of the conditions for (annotated) matching trees to sim- plify the definitions. We first construct an automaton A_x for checking the condition onVar(ρ)-labels for one variable x ∈ Var(ρ). We defineA_x = hΣ,Qx,Q^s_x, δx,Q^e_xi, where the alphabetΣconsists of quadruples of proof-tree labels (from R_P),λ-labels, p-labels, andVar(ρ)-labels. The state setQx

is{a,b,accept} ∪ {q_v | v ∈ V_P}, signifying that the current node isabove the first node annotated with a mapping forx, below orbesides any nodes that were annotated with a map- ping for x, or at a node where xis mapped to a variablev.

That start-state set isQ^s_x ={a} ∪ {qv|v∈ V_P}; the end-state set ifQ^e_x={accept}.

Consider a ruleρ⁰∈ R_Pof the formr1(v1)∧. . .∧r_n(vn)∧ h1(w₁)∧. . .∧hm(w_m)→ h(v), whereriare EDB predicates andh(i) are IDB predicates. For the case thatm > 0, there is a transition hq1, . . . ,qmi ∈ δ(q,hρ⁰,_,_, νi) exactly if the following conditions are satisfied:

• ifq =aandν(x) is undefined, thenqi =afor one 1 ≤ i≤mandq_j=bfor all 1≤ j≤mwithi, j;

• ifq = qvandν(x) =v, thenqi =qvfor all 1 ≤i ≤ m such thatvoccurs inw_iandqi=bfor all otheri;

• ifq=bandν(x) is undefined, thenqi=bfor all 1≤i≤ m.

For the case m = 0, there is a transition haccepti ∈ δ(q,hρ⁰,_,_, νi) exactly if:

• ifq=qvandν(x)=v;

• ifq=bandν(x) is undefined.

It is easy to check that the automatonA_xsatisfies the required condition. Now an automaton for checking the condition on Var(ρ)-labels can be constructed as the intersectionA⁰_Var(ρ)= T

x∈Var(ρ)A_x. The automatonA⁰_λ for checking the condition onλ-labels is constructed in a similar fashion. Likewise, an automatonA⁰_pfor checking the condition onp-labels is easy to define.

It remains to construct an automaton for checking the con- ditions (a)–(d) of Definition 8. To do this, we interpret the Var(ρ)-labels andλ-labels as partial specifications of the re- quired mappingν. Condition (a) further requires thatν(x)= v, i.e., that theVar(ρ)-label at the unique node annotated with p(v) contains this mapping. It is easy to verify this with an automatonA⁰_(a). Together, A⁰_(a), A⁰_λ, andA⁰_Var(ρ) provide a consistent variable mapping that respects thep-label (a) and the connectedness of variable occurrences, i.e., (c) and (d).

To check the remaining condition (b), we use an automaton A⁰_(b).

The automaton for (b) will use auxiliary markers to record which atoms have been matched in the current node and how exactly this was done. We record such a match as a partial function from atomsq(z)∈ϕto instancesq(w) of such atoms using variablesw⊆ V_P. The set of all such partial functions is denoted Matchϕ,P. Note that this set is exponential (not double exponential).

We now define A⁰

(b) = hΣ,Q,Qs, δ,QeiwhereΣis as for A_xabove. The set of statesQis{accept} ∪(2^ϕ×Match_ϕ,P), where elements from 2^ϕ encode the subset ofϕthat should be witnessed at or below the current node, and the ele- ments from Match_ϕ,P encode atoms that must be matched at the current node with their respective instantiations. The start-state set Q_s is {hϕ, µi | µ ∈ Match_ϕ,P}; the end- state set Qe is {accept}. The transition function δ is de- fined as follows. Consider a rule ρ⁰ ∈ R_P of the form r1(v₁)∧. . .∧rn(v_n)∧h1(w₁)∧. . .∧hm(w_m)→h(v), where ri are EDB predicates and h(i) are IDB predicates. For the case m > 0, there is a transition hhβ₁, µ₁i, . . . ,hβ_m, µ_nii ∈ δ(hβ, µi,hρ⁰, νλ,_, νVar(ρ)i) exactly if the setβ⊆ϕcan be par- titioned into sets β⁰, β₁, . . . , β_msuch that (ν_λ∪ν_Var(ρ))(β⁰) = µ(β⁰) and µ(β⁰) ⊆ {r1(v1), . . . ,rn(vn)}. The element µi of successor states can be chosen freely; the validity of the choice will be checked later. For the case m = 0, there is a transition haccepti ∈ δ(hβ, µi,hρ⁰, ν_λ,_, νVar(ρ)i) exactly if (νλ∪νVar(ρ))(β)=µ(β) andµ(β)⊆ {r1(v₁), . . . ,rn(v_n)}. In fact, the information fromMatchϕ,Pis not strictly necessary to de- fine the transition, since the relevant elementsµare always determined by other choices in the transition. However, hav- ing this information explicit will be important in later proofs.

The automatonA⁰_P,ρis obtained as the intersectionA⁰_Var(ρ)∩ A⁰_λ∩ A⁰_p∩ A⁰_(a)∩ A⁰_(b). It is easy to verify that it accepts ex- actly theVar(ρ)-annotated matching trees. Note thatA⁰_P,ρis exponential in size, already due to the exponentially large al- phabetΣ. Now the required automatonA_P,ρ is obtained by

“forgetting” theVar(ρ)-label in transitions ofA⁰_P,ρ. This pro- jection operation for tree automata is possible with a polyno- mial increase in size: every state ofA_P,ρ is a pair of a state ofA⁰_P,ρand aVar(ρ)-label; transitions ofA_P,ρare defined as

forA⁰_P,ρ, but keepingVar(ρ)-label information in states and introducing transitions for all possibleVar(ρ)-labels in child

nodes.

We want to use the automataA_P,ρto verify the entailment of a single rule within a Datalog derivation. We would like an automaton to check whether a whole derivation is possi- ble. Unfortunately, we cannot check these derivations using automata of the formA_P,ρ, which each need to be run on a p-annotated tree which has the unique entailment of the rule marked. The length of a derivation is unbounded, and we would not be able to distinguish an unbounded amount ofp- markers. To overcome this problem, we create a modified automatonA⁺_P,ρ,vthat simulates the behavior ofA_P,ρon a tree with annotationp(v). ForA⁺_P,ρ,vto know which node the an- notationp(v) refers to, it has to be started at this node. This is a non-standard notion of run, where we do not start at the root of the tree. Moreover, starting in the middle of the tree makes it necessary to consider both nodes below and above the cur- rent position, andA⁺_P,ρ,vtherefore needs to be analternating 2-way tree automaton.

Proposition 4. There is an alternating 2-way tree automaton A⁺_P,ρ,vthat is polynomial in the size ofA_P,ρsuch that, when- everA_P,ρaccepts a matching tree T that has the p-annotation p(v)on node e, thenA⁺_P,ρ,vhas an accepting run that starts from the corresponding node e⁰on the tree T⁰that is obtained by removing the p-annotation from T .

Proof. Using alternating 2-way automata, we can traverse a tree starting from any node, visiting each node once. To con- trol the direction of the traversal, we create multiple copies of each stateq: statesqdownare processed like normal states inA_P,ρ, statesqupuse an inverted transition ofA_P,ρto move up the tree into a stateq_σ,i; these auxiliary states are used to check that the label of the upper node is actuallyσ and to start new downwards processes for all child nodes other than the one (i) that we came from.

To ensure that the constructed automatonA⁺_P,ρ,vsimulates the behavior of A_P,ρ in case the annotation p(v) is found, we eliminate all transitions that mention otherp-annotations.

Moreover, we assume without loss of generality that the states ofA_P,ρthat allow a transition mentioning p(v) cannot be left through any other transition; this can always be ensured by duplicating states and using them exclusively for one kind of transition. LetQpbe the set of states ofA_P,ρthat admit (only) transitions mentioningp(v). LetA⁰_P,ρ=hΣ⁰,Q,Qs, δ⁰,Qeide- note the automaton over the alphabetΣ⁰ofλ-annotated proof trees (withoutp-annotations), with the same (start/end) states asA_P,ρ, and whereδ⁰is defined based on the transition func- tionδofA_P,ρas follows:δ⁰(hρ⁰,Mi) is the union of all sets of the formδ(hρ⁰,λ-label,p-labeli) where p-label is either p(v) or empty. By this construction, there is a correspondence be- tween the accepting runs ofA_P,ρover trees where one node eis annotated withp(v) and accepting runs ofA⁰_P,ρ(on trees withoutp-annotations) for which the nodeeis visited in some state ofQp.

Letsbe the maximal out-degree of proof trees forP, i.e., the maximal number of IDB atoms in bodies ofP. The state

setQ⁺ of A⁺_P,ρ,v is given by the disjoint union{qup | q ∈ Q} ∪ {qσ,i | q ∈ Q, σ ∈ Σ,1 ≤ i ≤ s} ∪ {qdown | q ∈ Q} ∪ {start,accept}. The start-state set isQ⁺_s = {start}and the end-state set isQ⁺_e ={accept} ∪ {q_down|q∈Q_e}.

Transitions ofA⁺_P,ρ,vare defined as follows:

• For all σ ∈ Σ, letδ⁺(start, σ) be the disjunction of all formulaeh0,qupi ∧ h0,qdowniwhereq∈Qp.

• For states qdownandσ ∈ Σ, letδ⁺(qdown, σ) be the dis- junction of all formulaeh1,q¹_downi ∧. . .∧ hm,q^m_downifor whichA⁰_P,ρhas a transitionhq¹, . . . ,q^mi ∈δ⁰(q, σ).

• For statesqupandσ∈Σ, letδ⁺(qup, σ) be the disjunction of all formulaeh−1,q⁰_σ0,iifor whichA⁰_P,ρhas a transition hq¹, . . . ,qⁱ⁻¹,q,qⁱ⁺¹, . . . ,q^mi ∈ δ⁰(q⁰, σ⁰) and the current node is theith child of its parent (we can assume that this information is encoded in the labelsσ, even for basic proof trees, which increases the alphabet only linearly;

we omit this in our definitions since it would clutter all other parts of our proof without need).

• For states q_σ,i,q⁰, let δ⁺(q_σ,i,q⁰, σ) be the disjunction of all formulaeh0,qupi ∧ h1,q¹_downi ∧. . .∧ hi−1,qⁱ⁻¹_downi ∧ hi+1,qⁱ_down⁺¹ i ∧. . .∧ hm,q^m_downifor whichA⁰_P,ρhas a tran- sitionhq¹, . . . ,qⁱ⁻¹,q⁰,qⁱ⁺¹,q^mi ∈δ⁰(q, σ).

• For all starting states q ∈ Qs of A⁰_P,ρ andσ ∈ Σ, let δ(qup, σ)=h0,accepti.

It is not hard to verify thatA⁺_P,ρ,vhas the required properties.

Using the automataA⁺_P,ρ,v, we can now obtain the claimed alternating 2-way automatonA⁺_PvP0 for aGQP⁰. Intuitively speaking, A⁺_PvP0 concatenates the automata A⁺_P,ρ,vusing al- ternation: whenever a derivation requires a (recursive) IDB atom, a suitable process A⁺_P,ρ,v is initiated, starting from a node in the middle of the tree. The construction relies on guardedness, which ensures that we can always find a suitable start node (corresponding to the node that was p-annotated earlier), by finding a suitable guard EDB atom in the tree.

Proposition 5. For aDlogquery P and aGQquery P⁰with special constantsλ, there is an alternating 2-way automaton A⁺_PvP0 of exponential size that accepts theλ-annotated proof trees of P that encode expansion trees withλassignments for which P⁰has a match.

Proof. LetP⁰be the set{ρ₁, . . . , ρ_`}. For every IDB predicate p, let P⁰_p denote the set of rules in P⁰ with head predicate p(possiblyhit). Without loss of generality, we assume that distinct rules use distinct sets of variables. For every frontier- guarded ruleρ⁰, letguard(ρ⁰) be a fixed EDB atom that acts as a guard in this rule, i.e., an atom that refers to all variables in the head ofρ⁰.

Consider a ruleρ⁰∈P⁰with IDB atomsq1(t1), . . . ,qm(tm) in its body. We construct new rules from ρ⁰ by replacing each atom qi(t_i) with a guard atomguard(ρ⁰_i), suitably uni- fied. Formally, assume that there are rulesρ⁰_i ∈P⁰_qiwith head qi(s_i) and a substitution θthat is a most general unifier for the problemstiθ= siθ, for alli ∈ {1, . . . ,m}, and that maps