Schema.org as a Description Logic

1 Introduction

The Schema.org initiative was launched in 2011 and is supported today by Bing, Google, Yahoo!, and Yandex. In the spirit of the Semantic Web, it provides a collection of ontologies that establish a standard vocabulary to mark up website content with metadata (https://schema.org/). In particular, web content that is generated from structured data as found in relational databases is often difficult to recover for search engines and Schema.org markup elegantly solves this problem. The markup is used by search engines to more precisely identify relevant pages, to provide richer search results, and to enable new applications. Schema.org is experiencing very rapid adoption and is used today by more than 15 million webpages including all major ones [Guha, 2013].

Schema.org does neither formally specify the language in which its ontologies are formulated nor does it provide a formal semantics for the published ontologies. However, the provided ontologies are extended and updated frequently and follow an underlying language pattern. This pattern and its meaning is described informally in natural language. Schema.org adopts a class-centric representation enriched with binary relations and datatypes, similar in spirit to description logics (DLs) and to the OWL family of ontology languages; the current version includes 622 classes and 891 binary relations. Partial translations into RDF and into OWL are provided by the linked data community. Based on the informal descriptions at https://schema.org/ and on the mentioned translations, Patel-Schneider [2014] develops an ontology language for Schema.org with a formal syntax and semantics that, apart from some details, can be regarded as a fragment of OWL DL.

In this paper, we abstract slightly further and view the Schema.org ontology language as a DL, in line with the formalization by Patel-Schneider. Thus, what Schema.org calls a type becomes a concept name and a property becomes a role name. The main characteristics of the resulting 'Schema.org DL' are that (i) the language is very restricted, allowing only inclusions between concept and role names, domain and range restrictions, nominals, and datatypes; (ii) ranges and domains of roles can be restricted to disjunctions of concept names (possibly mixed with datatypes in range restrictions) and nominals are used in 'one-of enumerations' which also constitute a form of disjunction. While Point (i) suggests that the Schema.org DL is closely related to the tractable profiles of OWL2, because of Point (ii) it does actually not fall into any of them. There is a close connection to the DL-Lite family of DLs [Calvanese et al., 2007], and in particular to the DL-LiteHbool variant [Artale et al., 2009]. However, DL-LiteHbool admits existential restriction, negation, conjunction, and free use of disjunction whereas the Schema.org DL allows no existential quantification and includes nominals and datatypes. We use the term schema.org-ontology to refer to ontologies formulated in the Schema.org DL; in contrast, 'Schema.org 2015' refers to the concrete collection of ontologies provided at https://schema.org/ as of end of April, 2015.

Our main aim is to investigate the complexity of querying data in the presence of schema.org-ontologies, where the data is the markup that was extracted from webpages. While answering queries over such data is the main reasoning task that arises in Schema.org applications and the Schema.org initiative specifies a format for the data in terms of so-called items, no information is given on what form of querying is used. We consider conjunctive queries (CQs) and unions of conjunctive queries (UCQ), a basic querying mechanism that is ubiquitous in relational database systems and research, and that also can be viewed as a core of the Semantic Web query language SPARQL. In particular, we also consider CQs and UCQs without quantified variables since these are not allowed in the relevant SPARQL entailment regimes [Glimm and Kr¨otzsch, 2010]. We often view a pair (O, q) that consists of a schema.org-ontology and an actual query as a compound query called an ontology-mediated query (OMQ).

We start with the observation that evaluating OMQs is intractable in general, namely Πp2 -complete in combined complexity and CONP-complete in data complexity. In the main part of the paper, we therefore have two aims: (i) identify large and practically useful classes of OMQs with lower combined and data complexity, and (ii) investigate in how far it is possible to obtain a full classification of each schema.org ontology or each OMQ according to its data complexity. While the utility of aim (i) is obvious, we note that aim (ii) is also most useful from a user's perspective as it clarifies the complexity of every concrete ontology or OMQ that might be used in an actual application. Apart from classical tractability (that is, PTIME), we are particularly interested in the rewritability of OMQs into first-order (FO) queries (actually: UCQs) and into datalog programs. One reason is that this allows to implement querying based on relational database systems and datalog engines, taking advantage of those systems' efficiency and maturity. Another reason is that there is significant research on how to efficiently answer UCQs and datalog queries in cluster computing models such as MapReduce [Afrati and Ullman, 2011; 2012], a natural framework when processing web-scale data.

For both aims (i) and (ii) above, we start with analyzing basic schema.org ontologies in which enumeration definitions ('one of' expressions) and datatypes are disallowed. Regarding aim (i), we show that all OMQs which consist of a basic schema.org-ontology and a CQ q of qvar-size two (the restriction of q to quantified variables is a disjoint union of queries with at most two variables each) are datalog-rewritable in polynomial time and can be evaluated in PTime in combined complexity. This result trivially extends to basic schema.orgontologies with datatypes, but does not hold for unrestricted schema.org-ontologies. In the latter case, we establish the same tractability results for OMQs with CQs that do not contain any quantified variables.

Regarding aim (ii), we start with classifying each single schema.org-ontology O according to the data complexity of all OMQs (O, q) with q a UCQ. We establish a dichotomy between AC0 and CONP in the sense that for each ontology O, either all these OMQs are in AC0 or there is one OMQ that is CONP-hard. The dichotomy comes with a transparent syntactic characterization and is decidable in PTIME. Though beautiful, however, it is of limited use in practice since most interesting ontologies are of the intractable kind. Therefore, we also consider an even more fine-grained classification on the level of OMQs, establishing a useful connection to constraint satisfaction problems (CSPs) in the spirit of [Bienvenu et al., 2014b]. It turns out that even for basic schema.org-ontologies and for ontologies that consist exclusively of enumeration definitions, a complexity classification of OMQs implies a solution to the dichotomy conjecture for CSPs, a famous open problem [Feder and Vardi, 1998; Bulatov, 2011]. However, the CSP connection can also be used to obtain positive results. In particular, we show that it is decidable in NEXPTIME whether an OMQ based on a schema.org-ontology and a restricted form of UCQ is FOrewritable and, respectively, datalog-rewritable. We also establish a PSpace lower bound for this problem.

Detailed proofs are provided in the full version at http://cgi.csc.liv.ac.uk/∼frank/publ/publ.html.

2 Preliminaries

Let NC, NR, and NI be countably infinite and mutually disjoint sets of concept names, role names, and individual names. Throughout the paper, concepts names will be denoted by A, B, C, . . ., role names by r, s, t, . . ., and individual names by a, b, c, . . ..

A schema.org-ontology consists of concept inclusions of different forms, role inclusions, and enumeration definitions. A concept inclusion takes the form A ⊑ B (atomic concept inclusion), ran(r) ⊑ A1 ⊔ · · · ⊔ An (range restriction), or dom(r) ⊑ A1⊔· · ·⊔An (domain restriction). A role inclusion takes the form r ⊑ s.

Example 1. The following are examples of concept inclusions and role inclusions (last line) in Schema.org 2015:

Movie ⊑ CreativeWork ran(musicBy) ⊑ Person ⊔ MusicGroup

dom(musicBy) ⊑ Episode ⊔ Movie ⊔ RadioSeries ⊔ TVSeries

sibling ⊑ relatedTo

We now define enumeration definitions. Fix a set NE ⊆ NI of enumeration individuals such that both NE and NI \ NE are infinite. An enumeration definition takes the form A ≡ {a1, . . . , an} with A ∈ NC and a1, . . . , an ∈ NE.

Example 2. An enumeration definition in Schema.org 2015 is Booktype ≡ {ebook, hardcover, paperback}.

A datatype D = (D, ∆D ) consists of a datatype name D and a non-empty set of data values ∆D . Examples of datatypes in Schema.org 2015 are Boolean, Integer, and Text. We assume that datatype names and data values are distinct from the symbols in NC ∪ NR ∪ NI and that there is an arbitrary but fixed set DT of datatypes such that ∆D1 ∩ ∆D2 = ∅ for all D1 ̸= D2 ∈ DT.

To accommodate datatypes in ontologies, we generalize range restrictions to range restrictions with datatypes, which are inclusions of the form ran(r) ⊑ A1 ⊔ · · · ⊔ An with A1, . . . , An concept names or datatype names from DT.

Example 3. A range restriction with datatypes in Schema.org 2015 is ran(acceptsReservation) ⊑ Boolean ⊔ Text

A schema.org-ontology O is a finite set of concept inclusions (including range restrictions with datatypes), role inclusions, and enumeration definitions. We denote by NC(O) the set of concept names in O, by NR(O) the set of role names in O, and by NE(O) the set of enumeration individuals in O.

A data instance A is a finite set of

• concept assertions A(a) where A ∈ NC and a ∈ NI;
• role assertions r(a, b) where r ∈ NR, a ∈ NI and b ∈ NI ∪ ⋃D∈DT ∆D .

We say that A is a data instance for the ontology O if A contains no enumeration individuals except those in NE(O). We use Ind(A) to denote the set of all individuals (including datatype elements) in A.

Example 4. Examples for assertions are Movie(a), name(a, 'avatar'), director(a, b), name(b, 'Cam').

Let O be a schema.org-ontology. An interpretation I = (∆I , ·I ) for O consists of a non-empty set ∆I disjoint from ⋃D∈DT ∆D and with ∆I ∩ NE = NE(O), and a function ·I that maps

• every concept name A to a subset AI of ∆I ,
• every role name r to a subset rI of ∆I ×∆I,DT , where ∆I,DT = ∆I ∪ ⋃D∈DT ∆D ;
• every individual name a ∈ (NI \ NE) ∪ NE(O) to some aI ∈ ∆I such that aI = a for all a ∈ NE(O).

Note that we make the standard name assumption (and, therefore, unique name assumption) for individuals in NE. Individual names from NE that do not occur in O are not interpreted by I to avoid enforcing infinite domains.

For an interpretation I and role name r, set dom(r)I = {d | (d, d′ ) ∈ rI } and ran(r)I = {d′ | (d, d′ ) ∈ rI }. To achieve uniform notation, set DI = ∆D for every datatype (D,∆D ) in DT and dI = d for every d ∈ ∆D , D ∈ DT. For concept or datatype names A1, . . . ,An, set (A1 ⊔ · · · ⊔ An)I = AI1 ∪· · ·∪AIn . An interpretation I for an ontology O satisfies a (concept or role) inclusion X1 ⊑ X2 ∈ O if XI 1 ⊆ XI 2 , an enumeration definition A ≡ {a1, . . . , an} if AI = {a1, . . . , an}, a concept assertion A(a) if aI ∈ AI , and a role assertion r(a, b) if (aI , bI ) ∈ rI . These satisfaction relationships are denoted with "|=", as in I |= X1 ⊑ X2.

An interpretation I for O is a model of O if it satisfies all inclusions and definitions in O and a model of a data instance A for O if it satisfies all assertions in A. We say that A is satisfiable w.r.t. O if O and A have a common model. Let α be a concept or role inclusion, or an enumeration definition. We say that α follows from O, in symbols O |= α, if every model of O satisfies α.

We introduce the query languages considered in this paper. A term t is either a member of NI ∪ ⋃D∈DT ∆D or an individual variable taken from an infinite set NV of such variables. A first-order query (FOQ) consist of a (domainindependent) first-order formula ϕ(⃗x) that uses unary predicates from NC ∪ {D | (D, D) ∈ DT}, binary predicates from NR, and only terms as introduced above. The unary datatype predicates are built-ins that identify the elements of the respective datatype. We call ⃗x the answer variables of ϕ(⃗x), the remaining variables are called quantified. A query without answer variables is Boolean. A conjunctive query (CQ) is a FOQ of the form ∃⃗y ϕ(⃗x, ⃗y) where ϕ(⃗x, ⃗y) is a conjunction of atoms such that every answer variable x occurs in an atom that uses a symbol fromNC ∪NR, that is, an answer variable x is not allowed to occur exclusively in atoms of the formD(x) with D a datatype name (to ensure domain independence). A union of conjunctive queries (UCQ) is a disjunction of CQs. A CQ q can be regarded as a directed graph Gq with vertices {t | t term in q} and edges {(t, t′ ) | r(t, t′ ) in q}. If Gq is acyclic and r(t1, t2), s(t1, t2) ∈ q implies r = s, then q is an acyclic CQ. A UCQ is acyclic if all CQs in it are.

We are interested in querying data instances A using a UCQ q(⃗x) taking into account the knowledge provided by an ontology O. A certain answer to q(⃗x) in A under O is a tuple ⃗a of elements of Ind(A) of the same length as ⃗x such that for every model I of O and A, we have I |= q[⃗a]. In this case, we write O, A |= q(⃗a).

Query evaluation is the problem to decide whether O, A |= q(⃗a). For the combined complexity of this problem, all of O,A, q, and ⃗a are the input. For the data complexity, only A and ⃗a are the input while O and q are fixed. It often makes sense to combine the ontology O and actual query q(⃗x) into an ontology-mediated query (OMQ) Q = (O, q(⃗x)), which can be thought of as a compound overall query. We show the following by adapting techniques from [Eiter et al., 1997] and [Bienvenu et al., 2014b].

Theorem 5. Query evaluation of CQs and UCQs under schema.org-ontologies is Πp2 -complete in combined complexity. In data complexity, each OMQ (O, q) from this class can be evaluated in CONP; moreover, there is such a OMQ (with q a CQ) that is CONP-complete in data complexity.

An OMQ (O, q(⃗x)) is FO-rewritable if there is a FOQ Q(⃗x) (called an FO-rewriting of (O, q(⃗x))) such that for every data instance A for O and all ⃗a ∈ Ind(A), we have O, A |= q(⃗a) iff IA |= Q(⃗a) where IA is the interpretation that corresponds to A (in the obvious way). We also consider datalogrewritability, defined in the same way as FO-rewritability, but using datalog programs in place of FOQs. Using Rossman's homomorphism preservation theorem [Rossman, 2008], one can show that an OMQ (O, q(⃗x)) with O a schema.orgontology and q(⃗x) a UCQ is FO-rewritable iff it has a UCQrewriting iff it has a non-recursive datalog rewriting, see [Bienvenu et al., 2014b] for more details. Since non-recursive datalog-rewritings can be more succinct than UCQ-rewritings, we will generally prefer the former.

3 Basic schema.org-Ontologies

We start with considering basic schema.org-ontologies, which are not allowed to contain enumeration definitions and datatypes. The results obtained for basic schema.orgontologies can be easily extended to basic schema.orgontologies with datatypes but do not hold for ontologies with enumeration definitions (as will be shown in the next section). In Schema.org 2015, 45 concept names from a total of 622 are defined using enumeration definitions, and hence are not covered by the results presented in this section.

We start with noting that the entailment problem for basic schema.org-ontologies is decidable in polynomial time. This problem is to check whether O |= α for a given basic schema.org-ontology O and a given inclusion α of the form allowed in such ontologies. In fact, the algorithm is straightforward. For example, O |= ran(r) ⊑ A1 ⊔ · · · ⊔An if there is a role name s and a range restriction ran(s) ⊑ B1 ⊔ · · · ⊔Bm ∈ O such that OR |= r ⊑ s and OC |= Bj ⊑ A1 ⊔ · · · ⊔ An for all 1 ≤ j ≤ m, where OR and OC denote the set of role inclusions and atomic concept inclusions in O.

Theorem 6. The entailment problem for basic schema.orgontologies is in PTIME.

The hardness results reported in Theorem 5 crucially rely on existential quantification in the actual query. In fact, it follows from results in [Grau et al., 2013; Kaminski et al., 2014b] that given an OMQ Q = (O, q(⃗x)) with O a basic schema.orgontology and q(⃗x) a CQ without quantified variables, it is possible to construct a non-recursive datalog rewriting of Q

in polynomial time, and thus such OMQs can be evaluated in PTIME in combined complexity. We aim to push this bound further by admitting restricted forms of quantification.

A CQ q has qvar-size n if the restriction of q to quantified variables is a disjoint union of queries with at most n variables each. For example, quantifier-free CQs have qvar-size 0 and the following query q(x, y) has qvar-size 1:

The above consequences of the work by Grau, Kaminski, et al. can easily be extended to OMQs where queries have qvar-size one. In what follows, we consider qvar-size two, which is more subtle and where, in contrast to qvar-size one, reasoning by case distinction is required. The following example shows that there are CQs of qvar-size two for which no non-recursive datalog rewriting exists.

Example 7. Let O = {ran(s) ⊑ A ⊔ B} and consider the following CQ of qvar-size two:

It is easy to see that O,Am |= q(a) for every data instance Am with m ≥ 2 as defined in Figure 1.

By applying locality arguments and using the data instances Am, one can in fact show that (O, q(x)) is not FO-rewritable (note that removing one r(bi, bi+1) from Am results in q(a) being no longer entailed).

Theorem 8. For every OMQ (O, q(⃗x)) with O a basic schema.org-ontology and q(⃗x) a CQ of qvar-size at most two, one can construct a datalog-rewriting in polynomial time. Moreover, evaluating OMQs from this class is in PTIME in combined complexity.

Applied to Example 7, the proof of Theorem 8 yields a datalog rewriting that consists of the rules

where the Xi range over A, B, and ∃y r(y, ·), plus

The recursive rule for IA (the one for IB is dual) says that if the only option to possibly avoid a match for (x1, x2, x) is to color (x1, x) with IA, then the only way to possibly avoid a match for (x1, x2, x) is to color (x2, x) with IA (otherwise, since ran(s) ⊑ A ⊔ B ∈ O, it would have to be colored with IB which gives a match).

Theorem 8 can easily be extended to basic schema.orgontologies enriched with datatypes. For schema.orgontologies O that also contain enumeration definitions, the rewriting is sound but not necessarily complete, and can thus be used to compute approximate query answers.

Interestingly, Theorem 8 cannot be generalized to UCQs. This follows from the result shown in the full version that for basic schema.org-ontologies O and quantifier-free UCQs q(x) (even without role atoms), the problemO,A |= q(a) is coNPhard regarding combined complexity for data instances A with a single individual a. We also note that it is not difficult to show (and follows from FO-rewritability of instance queries in DL-LiteHbool [Artale et al., 2009]) that given an OMQ (O, q(⃗x)) with O a basic schema.org-ontology and q(⃗x) a quantifier-free UCQ, one can construct an FO-rewriting in exponential time, and thus query evaluation is in AC0 in data complexity.

We now classify basic schema.org-ontologies O according to the data complexity of evaluating OMQs (O, q) with q a UCQ (or CQ). It is convenient to work with minimized ontologies where for all inclusions F ⊑ A1 ⊔ · · · ⊔ An ∈ O and all i ≤ n, there is a model I of O and a d ∈ ∆I such that d satisfies F ⊓Ai ⊓ ⊓ j̸=i ¬Aj (defined in the usual way). Every

schema.org-ontology can be rewritten in polynomial time into an equivalent minimized one. We establish the following dichotomy theorem.

Theorem9. Let O be a minimized basic schema.org-ontology. If there exists F ⊑ A1 ⊔ · · · ⊔ An ∈ O with n ≥ 2, then there is a Boolean CQ q that uses only concept and role names from O and such that (O, q) is CONP-hard in data complexity. Otherwise, a given OMQ (O, q) with q a UCQ can be rewritten into a non-recursive datalog-program in polynomial time (and is thus in AC0 in data complexity).

The proof of the second part of Theorem 9 is easy: if there are no F ⊑ A1 ⊔ · · · ⊔ An ∈ O with n ≥ 2, then O essentially is already a non-recursive datalog program and the construction is straightforward. The proof of the hardness part is obtained by extending the corresponding part of a dichotomy theorem for ALC-ontologies of depth one [Lutz and Wolter, 2012]. The main differences between the two theorems are that (i) for basic schema.org-ontologies, the dichotomy is decidable in PTIME (whereas decidability is open for ALC), (ii) the CQs in CONP-hard OMQs use only concept and role names from O (this is not possible in ALC), and (iii) the dichotomy is between AC0 and CONP whereas for ALC OMQs can be complete for PTIME, NL, etc.

By Theorem 9, disjunctions in domain and range restrictions are the (only!) reason that query answering is non-tractable for basic schema.org-ontologies. In Schema.org 2015, 14% of all range restrictions and 20% of all domain restrictions contain disjunctions.

In Theorem 9, we have classified the data complexity of ontologies, quantifying over the actual queries. In what follows, we aim to classify the data complexity of every OMQ. This problem turns out to be much harder and, in fact, we show that a classification of the data complexity of OMQs based on basic schema.org-ontologies and UCQs implies a classification of constraint satisfaction problems according to their complexity

(up to FO-reductions), a famous open problem that is the subject of significant ongoing research [Feder and Vardi, 1998; Bulatov, 2011].

A signature is a set of concept and role names (also called symbols). Let B be a finite interpretation that interprets only the symbols from a finite signature Σ. The constraint satisfaction problem CSP(B) is to decide, given a data instance A over Σ, whether there is a homomorphism from A to B. In this context, B is called the template of CSP(B).

Theorem 10. For every template B, one can construct in polynomial time an OMQ (O, q) with O a basic schema.orgontology and q a Boolean acyclic UCQ such that the complement of CSP(B) and (O, q) are mutually FO-reducible.

Theorem 18 below establishes the converse direction of Theorem 10 for unrestricted schema.org-ontologies and a large class of (acyclic) UCQs. From Theorem 18, we obtain a NEXPTIME-upper bound for deciding FO-rewritability and datalog-rewritability of a large class of OMQs (Theorem 19 below). It remains open whether this bound is tight, but we can show a PSPACE lower bound for FO-rewritability using a reduction of the word problem of PSPACE Turing machines. The proof uses the ontology O and data instances Am from Example 7 and is similar to a PSPACE lower bound proof for FO-rewritability in consistent query answering [Lutz and Wolter, 2015] which is, in turn, based on a construction from [Cosmadakis et al., 1988].

Theorem 11. It is PSPACE-hard to decide whether a given OMQ (O, q) with O a basic schema.org-ontology and q a Boolean acyclic UCQ is FO-rewritable.

4 Incoherence and Unsatisfiability

In the subsequent section, we consider unrestricted schema.org ontologies instead of basic ones, that is, we add back enumeration definitions and datatypes. The purpose of this section is to deal with a complication that arises from this step, namely the potential presence of inconsistencies.

A symbol X ∈ NC ∪ NR is incoherent in an ontology O if XI = ∅ for all models I of O. An ontology O is incoherent if some symbol is incoherent in O. The problemwith incoherent ontologies O is that there are clearly data instances A that are unsatisfiable w.r.t. O. Incoherent ontologies can result from the UNA for enumeration individuals such as in O = {A ≡ {a}, B ≡ {b}, A ⊑ B}, which has no model (if a ̸= b) and thus any symbol is incoherent in O; they can also arise from interactions between concept names and datatypes such as in O′ = {ran(r) ⊑ Integer, ran(s) ⊑ A, r ⊑ s} with A ∈ NC, in which r is incoherent since ∆I ∩∆Integer = ∅ in any model I of O′ . Using Theorem 6, one can show the following.

Theorem 12. Incoherence of schema.org-ontologies can be decided in PTime.

We now turn to inconsistencies that arise from combining an ontology O with a particular data instance A for O. As an example, consider O = {A ≡ {a}, B ≡ {b}} and A = {A(c),B(c)}. Although O is coherent, A is unsatisfiable w.r.t. O. Like incoherence, unsatisfiability is decidable in polynomial time. In fact, we can even show the following stronger result.

Theorem 13. Given a schema.org-ontology O, one can compute in polynomial time a non-recursive datalog program Π such that for any data instance A for O, A is unsatisfiable w.r.t. O iff Π(A) ̸= ∅.

In typical schema.org applications, the data is collected from the web and it is usually not acceptable to simply report back an inconsistency and stop processing the query. Instead, one would like to take maximum advantage of the data despite the presence of an inconsistency. There are many semantics for inconsistent query answering that can be used for this purpose. As efficiency is paramount in schema.org applications, our choice is the pragmatic intersection repair (IAR) semantics which avoids CONP-hardness in data complexity [Lembo et al., 2010; Rosati, 2011; Bienvenu et al., 2014a]. A repair of a data instance A w.r.t. an ontology O is a maximal subset A′ ⊆ A that is satisfiable w.r.t. O. We use repO(A) to denote the set of all repairs of A w.r.t. O. The idea of IAR semantics is then to replace A with ⋂A′∈repO (A) A′ . In other words, we have to remove fromA all assertions that occur in some minimal subset A′ ⊆ A that is unsatisfiable w.r.t. O. We call such an assertion a conflict assertion.

Theorem 14. Given a schema.org-ontology O and concept name A (resp. role name r), one can compute a non-recursive datalog program Π such that for any data instance A for O, Π(A) is the set of all a ∈ Ind(A) (resp. (a, b) ∈ Ind(A)2 ) such that A(a) (resp. r(a, b)) is a conflict assertion in A.

By Theorem 14, we can adopt the IAR semantics by simply removing all conflict assertions from the data instance before processing the query. Programs from Theorem 14 become exponential in the worst case, but we expect them to be small in practical cases. In the remainder of the paper, we assume that ontologies are coherent and that A is satisfiable w.r.t. O if we query a data instance A using an ontology O.

5 Unrestricted schema.org-Ontologies

We aim to lift the results from Section 3 to unrestricted schema.org-ontologies. Regarding Theorem 8, it turns out that quantified variables in CQs are computationally much more problematic when there are enumeration definitions in the ontology. In fact, one can expect positive results only for quantifier-free CQs, and even then the required constructions are quite subtle.

Theorem 15. Given an OMQ Q = (O, q) with O a schema.org-ontology and q a quantifier-free CQ, one can construct in polynomial time a datalog-rewriting of Q. Moreover, evaluating OMQs in this class is in PTIME in combined complexity. The rewriting is non-recursive if q = A(x).

The following example illustrates the construction of the datalog program. Let O = {A ≡ {a1, a2}} and q() = r(a1, a2). Observe that O,A′m |= q() for every data instance A′m defined in Figure 2. Similarly to Example 7, one can use the data instances A′m to show that (O, q()) is not FO-rewritable.

A datalog-rewriting of (O, q()) is given by the program Πa1,a2 which contains the rules

Given a data instance A, the program checks whether there is an r-path from a1 to a2 in A with inner nodes in A. If b0, b1, . . . , bn is such a path, then in all models I of O and A there is an i < n with (bIi-1 , bIi ) = (a1, a2), hence I |= q(). Otherwise, we obtain a model I with I ̸|= q() by assigning a1 to all individual names b with A(b) ∈ A that are reachable from a1 by a path with inner nodes in A, and an individual ̸= a1 to all other individual names in A.

We now modify the datalog program to obtain a rewriting of the OMQ (O, q′ (x, y)) with q(x, y) = r(x, y). First, we include in Πr the rules A(a1) ← true, A(a2) ← true, and

We want to use the latter rule to check that (1) in every model, x and y have to be identified with an individual in {a1, a2}, and (2) for all i, j ∈ {1, 2}, all models that identify x and y with ai and aj satisfy r(ai, aj). Notice that r(x, y) is false in a model of O and A iff A does not contain r(x, y) and (1) or (2) is violated. To implement (2), we add the rules:

The first row checks admissibility of the assignment x, y ↦→ ai, aj: if x is one of the enumeration individuals in {a1, a2} and ai ̸= x, then there is no model that identifies x with ai, hence the statement (2) above is trivially true. Similarly for y and aj. It remains to add rules 3 and 4 fromΠa1,a2 and

for 1 ≤ i, j ≤ 2 and i ̸= j.

Theorem 15 is tight in the sense that evaluating CQs with a single atom and a single existentially quantified variable, as well as quantifier-free UCQs, is coNP-hard in data complexity. For instance, let O = {dom(e) ⊑ A, ran(e) ⊑ A, A ≡ {r, g, b}}. Then, an undirected graph G = (V,E) is 3colorable iff O, {e(v, w) | (v, w) ∈ E} ̸|= ∃x e(x, x). Alternatively, one may replace the query by r(r, r)∨r(g, g)∨r(b, b). In fact, one can prove the following variant of Theorem 10 which shows that classifying OMQs with ontologies using only enumeration definitions and quantifier-free UCQs according to their complexity is as hard as CSP.

Theorem 16. Given a template B, one can construct in polynomial time an OMQ (O, q) where O only contains enumeration definitions and q is a Boolean variable-free UCQ such that the complement of CSP(B) and (O, q) are mutually FOreducible.

We now turn to classifying the complexity of ontologies and of OMQs, starting with a generalization of Theorem 9 to unrestricted schema.org-ontologies.

Theorem 17. Let O be a coherent and minimized schema.orgontology. If O contains an enumeration definition A ≡ {a1, . . . , an} with n ≥ 2 or contains an inclusion F ⊑ A1 ⊔ · · · ⊔An such that there are at least two concept names in {A1, . . . ,An} and O ̸|= F ⊑ A ⊔ ⊔ (D,∆D )∈DT D for any

A with A ≡ {a} ∈ O, then (O, q) is coNP-hard for some Boolean CQ q. Otherwise every (O, q) with q a UCQ is FOrewritable (and thus in AC0 in data complexity).

Note that, in contrast to Theorem 9, being in AC0 does not mean that no 'real disjunction' is available. For example, for O = {ran(r) ⊑ A ⊔ B, A ⊑ C, B ⊑ C, C ≡ {c}} and A = {r(a, b)} we have O, A |= A(b)∨B(b) and neither A(b) nor B(b) are entailed. This type of choice does not effect FOrewritability, since it is restricted to individuals that must be identified with a unique individual in NE(O). Note that, for the hardness proof, we now need to use a role name that possibly does not occur in O. For example, for O = {A ≡ {a1, a2}} there exists a Boolean CQ q such that (O, q) is NP-hard, but a fresh role name is required to construct q.

We now consider the complexity of single OMQs and show a converse of Theorems 10 and 16 for schema.org-ontologies and UCQs that are qvar-acyclic, that is, when all atoms r(t, t′ ) with neither of t, t′ a quantified variable are dropped, then all CQs in it are acyclic. We use generalized CSPs with marked elements in which instead of a single template B, one considers a finite set Γ of templates whose signature contains, in addition to concept and role names, a finite set of individual names. Homomorphisms have to respect also the individual names and the problem is to decide whether there is a homomorphism from the input interpretation to some B ∈ Γ. It is proved in [Bienvenu et al., 2014b] that there is a dichotomy between PTIME and NP for standard CSPs if, and only if, there is such a dichotomy for generalized CSPs with marked elements.

Theorem 18. Given an OMQ (O, q) with O a schema.orgontology and q a qvar-acyclic UCQ, one can compute in exponential time a generalized CSP with marked elements Γ such that (O, q) and the complement of CSP(Γ) are mutually FO-reducible.

The proof uses an encoding of qvar-acyclic queries into concepts in the description logic ALCIUO that extends ALC by inverse roles, the universal role, and nominals. It extends the the template constructions of [Bienvenu et al., 2014b] to description logics with nominals. It is shown in [Bienvenu et al., 2014b] that FO-definability and datalog definability of the complement of generalized CSPs with marked elements are NP-complete problems. Thus, we obtain the following result as a particularly interesting consequence of Theorem 18.

Theorem 19. FO-rewritability and datalog-rewritability of OMQs (O, q) with O a schema.org-ontology and q a qvaracyclic UCQ are decidable in NEXPTIME.

6 Practical Considerations

In this paper, we have introduced a novel description logic motivated by Schema.org and studied the complexity of the resulting querying problems from various angles. From a practical perspective, a central observation is that intractability is caused by the combination of disjunction in the ontology (in domain/range restrictions and, with {a, b} ≡ {a} ⊔ {b}, in enumeration definitions) and quantification in the query. For practical feasibility, one thus has to tame the interaction between these features.

One may speculate that professional users of Schema.org such as the major search engine providers take a pragmatic approach and essentially ignore disjunction. However, the results in this paper show that one can do better without compromising tractability when the query contains no quantified variables (Theorem 15). For basic ontologies, it is even possible to handle some queries with quantified variables (Theorem 8); in fact, we believe that the restriction to qvar-size 2 is a mild one from a practical perspective. It is also interesting to observe that the datalog-rewritings constructed in the proofs of these two theorems are sound if applied to unrestricted CQs and can be seen as tractable approximations that go beyond simply ignoring disjunction.

Another practically interesting way to address intractability is to require suitable forms of completeness of the data. For example, whenever the data contains an assertion r(a, b) and there is a range restriction ran(r) ⊑ A1 ⊔ · · · ⊔ An in the ontology, one could require that Ai(b) is also in the data, for some i. This could be easily implemented in existing Schema.org validators that webpage developers use to verify their annotations. If all disjunctions are 'disabled' in the described way, tractability is regained.