Please refer to theerrata for this document, which may include some normative corrections.
Acolor-coded version of this document showing changes made since the previous version is also available.
This document is also available in these non-normative formats:PDF version.
See alsotranslations.
Copyright © 2012W3C® (MIT,ERCIM,Keio), All Rights Reserved. W3Cliability,trademark anddocument use rules apply.
The OWL 2 Web Ontology Language, informally OWL 2, is an ontology language for the Semantic Web with formally defined meaning. OWL 2 ontologies provide classes, properties, individuals, and data values and are stored as Semantic Web documents. OWL 2 ontologies can be used along with information written in RDF, and OWL 2 ontologies themselves are primarily exchanged as RDF documents. The OWL 2Document Overview describes the overall state of OWL 2, and should be read before other OWL 2 documents.
This document provides the direct model-theoretic semantics for OWL 2, which is compatible with the description logicSROIQ. Furthermore, this document defines the most common inference problems for OWL 2.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in theW3C technical reports index at http://www.w3.org/TR/.
Please send any comments topublic-owl-comments@w3.org (public archive). Although work on this document by theOWL Working Group is complete, comments may be addressed in theerrata or in future revisions. Open discussion among developers is welcome atpublic-owl-dev@w3.org (public archive).
This document has been reviewed by W3C Members, by software developers, and by other W3C groups and interested parties, and is endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited from another document. W3C's role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.
This document was produced by a group operating under the5 February 2004 W3C Patent Policy. W3C maintains apublic list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent.
This document defines the direct model-theoretic semantics of OWL 2. The semantics given here is strongly related to the semantics of description logics [Description Logics] and it extends the semantics of the description logicSROIQ [SROIQ]. As the definition ofSROIQ does not provide for datatypes and punning, the semantics of OWL 2 is defined directly on the constructs of the structural specification of OWL 2 [OWL 2 Specification] instead of by reference toSROIQ. For the constructs available inSROIQ, the semantics ofSROIQ trivially corresponds to the one defined in this document.
Since each OWL 1 DL ontology is an OWL 2 ontology, this document also provides a direct semantics for OWL 1 Lite and OWL 1 DL ontologies; this semantics is equivalent to the direct model-theoretic semantics of OWL 1 Lite and OWL 1 DL [OWL 1 Semantics and Abstract Syntax]. Furthermore, this document also provides the direct model-theoretic semantics for the OWL 2 profiles [OWL 2 Profiles].
The semantics is defined for OWL 2 axioms and ontologies, which should be understood as instances of the structural specification [OWL 2 Specification]. Parts of the structural specification are written in this document using the functional-style syntax.
OWL 2 allows ontologies, anonymous individuals, and axioms to be annotated; furthermore, annotations themselves can contain additional annotations. All these types of annotations, however, have no semantic meaning in OWL 2 and are ignored in this document. OWL 2 declarations are used only to disambiguate class expressions from data ranges and object property from data property expressions in the functional-style syntax; therefore, they are not mentioned explicitly in this document.
This section specifies the direct model-theoretic semantics of OWL 2 ontologies.
Adatatype map, formalizingdatatype maps from the OWL 2 Specification [OWL 2 Specification], is a 6-tupleD = (NDT ,NLS ,NFS ,⋅ DT ,⋅ LS ,⋅ FS ) with the following components:
The set of datatypesNDT of a datatype mapD is not required to contain all datatypes from theOWL 2 datatype map; this allows one to talk about subsets of the OWL 2 datatype map, which may be necessary for the various profiles of OWL 2. If, however,D contains a datatypeDT from theOWL 2 datatype map, thenNLS(DT),NFS(DT),(DT)DT, (LV ,DT )LS for eachLV ∈NLS(DT), and (F ,v )FS for each (F ,v ) ∈NFS(DT) are required to coincide with the definitions forDT in theOWL 2 datatype map.
AvocabularyV = (VC ,VOP ,VDP ,VI ,VDT ,VLT ,VFA ) over a datatype mapD is a 7-tuple consisting of the following elements:
Given a vocabularyV, the following conventions are used in this document to denote different syntactic parts of OWL 2 ontologies:
Given a datatype mapD and a vocabularyV overD, aninterpretationI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) forD andV is a 10-tuple with the following structure:
The following sections define the extensions of⋅ OP,⋅ DT, and⋅ C to object property expressions, data ranges, and class expressions.
The object property interpretation function⋅ OP is extended to object property expressions as shown in Table 1.
Object Property Expression | Interpretation⋅ OP |
---|---|
ObjectInverseOf( OP ) | { (x ,y ) | (y ,x ) ∈(OP)OP } |
The datatype interpretation function⋅ DT is extended to data ranges as shown in Table 3. All datatypes in OWL 2 are unary, so each datatypeDT is interpreted as a unary relation overΔD — that is, as a set(DT)DT ⊆ΔD. OWL 2 currently does not define data ranges of arity more than one; however, by allowing forn-ary data ranges, the syntax of OWL 2 provides a "hook" allowing implementations to introduce extensions such as comparisons and arithmetic. Ann-ary data rangeDR is interpreted as ann-ary relation(DR)DT overΔD — that is, as a set(DT)DT ⊆(ΔD)n
Data Range | Interpretation⋅ DT |
---|---|
DataIntersectionOf( DR1 ... DRn ) | (DR1)DT ∩ ... ∩(DRn)DT |
DataUnionOf( DR1 ... DRn ) | (DR1)DT ∪ ... ∪(DRn)DT |
DataComplementOf( DR ) | (ΔD)n \(DR)DT wheren is the arity ofDR |
DataOneOf( lt1 ... ltn ) | {(lt1)LT , ... ,(ltn)LT } |
DatatypeRestriction( DT F1 lt1 ... Fn ltn ) | (DT)DT ∩ (F1 ,lt1 )FA ∩ ... ∩ (Fn ,ltn )FA |
The class interpretation function⋅ C is extended to class expressions as shown in Table 4. ForS a set,#S denotes the number of elements inS.
Class Expression | Interpretation⋅ C |
---|---|
ObjectIntersectionOf( CE1 ... CEn ) | (CE1)C ∩ ... ∩(CEn)C |
ObjectUnionOf( CE1 ... CEn ) | (CE1)C ∪ ... ∪(CEn)C |
ObjectComplementOf( CE ) | ΔI \(CE)C |
ObjectOneOf( a1 ... an ) | {(a1)I , ... ,(an)I } |
ObjectSomeValuesFrom( OPE CE ) | {x | ∃y : (x,y ) ∈(OPE)OP andy ∈(CE)C } |
ObjectAllValuesFrom( OPE CE ) | {x | ∀y : (x,y ) ∈(OPE)OP impliesy ∈(CE)C } |
ObjectHasValue( OPE a ) | {x | (x ,(a)I ) ∈(OPE)OP } |
ObjectHasSelf( OPE ) | {x | (x ,x ) ∈(OPE)OP } |
ObjectMinCardinality( n OPE ) | {x | #{y | (x ,y ) ∈(OPE)OP } ≥ n } |
ObjectMaxCardinality( n OPE ) | {x | #{y | (x ,y ) ∈(OPE)OP } ≤ n } |
ObjectExactCardinality( n OPE ) | {x | #{y | (x ,y ) ∈(OPE)OP } = n } |
ObjectMinCardinality( n OPE CE ) | {x | #{y | (x ,y ) ∈(OPE)OP andy ∈(CE)C } ≥ n } |
ObjectMaxCardinality( n OPE CE ) | {x | #{y | (x ,y ) ∈(OPE)OP andy ∈(CE)C } ≤ n } |
ObjectExactCardinality( n OPE CE ) | {x | #{y | (x ,y ) ∈(OPE)OP andy ∈(CE)C } = n } |
DataSomeValuesFrom( DPE1 ... DPEn DR ) | {x | ∃y1, ... ,yn : (x ,yk ) ∈(DPEk)DP for each 1 ≤k ≤n and (y1 , ... ,yn ) ∈(DR)DT } |
DataAllValuesFrom( DPE1 ... DPEn DR ) | {x | ∀y1, ... ,yn : (x ,yk ) ∈(DPEk)DP for each 1 ≤k ≤n imply (y1 , ... ,yn ) ∈(DR)DT } |
DataHasValue( DPE lt ) | {x | (x ,(lt)LT ) ∈(DPE)DP } |
DataMinCardinality( n DPE ) | {x | #{y | (x ,y ) ∈(DPE)DP} ≥ n } |
DataMaxCardinality( n DPE ) | {x | #{y | (x ,y ) ∈(DPE)DP } ≤ n } |
DataExactCardinality( n DPE ) | {x | #{y | (x ,y ) ∈(DPE)DP } = n } |
DataMinCardinality( n DPE DR ) | {x | #{y | (x ,y ) ∈(DPE)DP andy ∈(DR)DT } ≥ n } |
DataMaxCardinality( n DPE DR ) | {x | #{y | (x ,y ) ∈(DPE)DP andy ∈(DR)DT } ≤ n } |
DataExactCardinality( n DPE DR ) | {x | #{y | (x ,y ) ∈(DPE)DP andy ∈(DR)DT } = n } |
An axiom or an ontology issatisfied in an interpretationI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) if the appropriate condition from the following sections holds.
Satisfaction of OWL 2 class expression axioms inI is defined as shown in Table 5.
Axiom | Condition |
---|---|
SubClassOf( CE1 CE2 ) | (CE1)C ⊆(CE2)C |
EquivalentClasses( CE1 ... CEn ) | (CEj)C =(CEk)C for each 1 ≤j ≤n and each 1 ≤k ≤n |
DisjointClasses( CE1 ... CEn ) | (CEj)C ∩(CEk)C = ∅ for each 1 ≤j ≤n and each 1 ≤k ≤n such thatj ≠k |
DisjointUnion( C CE1 ... CEn ) | (C)C =(CE1)C ∪ ... ∪(CEn)C and (CEj)C ∩(CEk)C = ∅ for each 1 ≤j ≤n and each 1 ≤k ≤n such thatj ≠k |
Satisfaction of OWL 2 object property expression axioms inI is defined as shown in Table 6.
Axiom | Condition |
---|---|
SubObjectPropertyOf( OPE1 OPE2 ) | (OPE1)OP ⊆(OPE2)OP |
SubObjectPropertyOf( ObjectPropertyChain( OPE1 ... OPEn ) OPE ) | ∀y0 , ... ,yn : (y0 ,y1 ) ∈(OPE1)OP and ... and (yn-1 ,yn ) ∈(OPEn)OP imply (y0 ,yn ) ∈(OPE)OP |
EquivalentObjectProperties( OPE1 ... OPEn ) | (OPEj)OP =(OPEk)OP for each 1 ≤j ≤n and each 1 ≤k ≤n |
DisjointObjectProperties( OPE1 ... OPEn ) | (OPEj)OP ∩(OPEk)OP = ∅ for each 1 ≤j ≤n and each 1 ≤k ≤n such thatj ≠k |
ObjectPropertyDomain( OPE CE ) | ∀x ,y : (x ,y ) ∈(OPE)OP impliesx ∈(CE)C |
ObjectPropertyRange( OPE CE ) | ∀x ,y : (x ,y ) ∈(OPE)OP impliesy ∈(CE)C |
InverseObjectProperties( OPE1 OPE2 ) | (OPE1)OP = { (x ,y ) | (y ,x ) ∈(OPE2)OP } |
FunctionalObjectProperty( OPE ) | ∀x ,y1 ,y2 : (x ,y1 ) ∈(OPE)OP and (x ,y2 ) ∈(OPE)OP implyy1 =y2 |
InverseFunctionalObjectProperty( OPE ) | ∀x1 ,x2 ,y : (x1 ,y ) ∈(OPE)OP and (x2 ,y ) ∈(OPE)OP implyx1 =x2 |
ReflexiveObjectProperty( OPE ) | ∀x :x ∈ΔI implies (x ,x ) ∈(OPE)OP |
IrreflexiveObjectProperty( OPE ) | ∀x :x ∈ΔI implies (x ,x ) ∉(OPE)OP |
SymmetricObjectProperty( OPE ) | ∀x ,y : (x ,y ) ∈(OPE)OP implies (y ,x ) ∈(OPE)OP |
AsymmetricObjectProperty( OPE ) | ∀x ,y : (x ,y ) ∈(OPE)OP implies (y ,x ) ∉(OPE)OP |
TransitiveObjectProperty( OPE ) | ∀x ,y ,z : (x ,y ) ∈(OPE)OP and (y ,z ) ∈(OPE)OP imply (x ,z ) ∈(OPE)OP |
Satisfaction of OWL 2 data property expression axioms inI is defined as shown in Table 7.
Axiom | Condition |
---|---|
SubDataPropertyOf( DPE1 DPE2 ) | (DPE1)DP ⊆(DPE2)DP |
EquivalentDataProperties( DPE1 ... DPEn ) | (DPEj)DP =(DPEk)DP for each 1 ≤j ≤n and each 1 ≤k ≤n |
DisjointDataProperties( DPE1 ... DPEn ) | (DPEj)DP ∩(DPEk)DP = ∅ for each 1 ≤j ≤n and each 1 ≤k ≤n such thatj ≠k |
DataPropertyDomain( DPE CE ) | ∀x ,y : (x ,y ) ∈(DPE)DP impliesx ∈(CE)C |
DataPropertyRange( DPE DR ) | ∀x ,y : (x ,y ) ∈(DPE)DP impliesy ∈(DR)DT |
FunctionalDataProperty( DPE ) | ∀x ,y1 ,y2 : (x ,y1 ) ∈(DPE)DP and (x ,y2 ) ∈(DPE)DP implyy1 =y2 |
Satisfaction of datatype definitions inI is defined as shown in Table 8.
Axiom | Condition |
---|---|
DatatypeDefinition( DT DR ) | (DT)DT =(DR)DT |
Satisfaction of keys inI is defined as shown in Table 9.
Axiom | Condition |
---|---|
HasKey( CE ( OPE1 ... OPEm ) ( DPE1 ... DPEn ) ) | ∀x ,y ,z1 , ... ,zm ,w1 , ... ,wn : ifx ∈(CE)C andx ∈NAMED and y ∈(CE)C andy ∈NAMED and (x ,zi ) ∈(OPEi)OP and (y ,zi ) ∈(OPEi)OP andzi ∈NAMED for each 1 ≤i ≤m and (x ,wj ) ∈(DPEj)DP and (y ,wj ) ∈(DPEj)DP for each 1 ≤j ≤n then x = y |
Satisfaction of OWL 2 assertions inI is defined as shown in Table 10.
Axiom | Condition |
---|---|
SameIndividual( a1 ... an ) | (aj)I =(ak)I for each 1 ≤j ≤n and each 1 ≤k ≤n |
DifferentIndividuals( a1 ... an ) | (aj)I ≠(ak)I for each 1 ≤j ≤n and each 1 ≤k ≤n such thatj ≠k |
ClassAssertion( CE a ) | (a)I ∈(CE)C |
ObjectPropertyAssertion( OPE a1 a2 ) | ((a1)I ,(a2)I ) ∈(OPE)OP |
NegativeObjectPropertyAssertion( OPE a1 a2 ) | ((a1)I ,(a2)I ) ∉(OPE)OP |
DataPropertyAssertion( DPE a lt ) | ((a)I ,(lt)LT ) ∈(DPE)DP |
NegativeDataPropertyAssertion( DPE a lt ) | ((a)I ,(lt)LT ) ∉(DPE)DP |
An OWL 2 ontologyO issatisfied in an interpretationI if all axioms in theaxiom closure ofO (with anonymous individuals standardized apart as described in Section 5.6.2 of the OWL 2 Specification [OWL 2 Specification]) are satisfied inI.
Given a datatype mapD, an interpretationI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) forD is amodel of an OWL 2 ontologyO w.r.t.D if an interpretationJ = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ J ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) forD exists such that⋅ J coincides with⋅ I on all named individuals andJ satisfiesO.
Thus, an interpretationI satisfyingO is also a model ofO. In contrast, a modelI ofO may not satisfyO directly; however, by modifying the interpretation of anonymous individuals,I can always be coerced into an interpretationJ that satisfiesO.
LetD be a datatype map andV a vocabulary overD. Furthermore, letO andO1 be OWL 2 ontologies,CE,CE1, andCE2 class expressions, anda a named individual, such that all of them refer only to the vocabulary elements inV. Furthermore,variables are symbols that are not contained inV. Finally, aBoolean conjunctive queryQ is a closed formula of the form
∃ x1 , ... , xn , y1 , ... , ym : [ A1 ∧ ... ∧ Ak ]
where eachAi is anatom of the formC(s),OP(s,t), orDP(s,u) withC a class,OP an object property,DP a data property,s andt individuals or some variablexj, andu a literal or some variableyj.
The following inference problems are often considered in practice.
Ontology Consistency:O isconsistent (orsatisfiable) w.r.t.D if a model ofO w.r.t.D andV exists.
Ontology Entailment:OentailsO1 w.r.t.D if every model ofO w.r.t.D andV is also a model ofO1 w.r.t.D andV.
Ontology Equivalence:O andO1 areequivalent w.r.t.D ifO entailsO1 w.r.t.D andO1 entailsO w.r.t.D.
Ontology Equisatisfiability:O andO1 areequisatisfiable w.r.t.D ifO is satisfiable w.r.t.D if and only ifO1 is satisfiable w.r.tD.
Class Expression Satisfiability:CE is satisfiable w.r.t.O andD if a modelI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) ofO w.r.t.D andV exists such that(CE)C ≠ ∅.
Class Expression Subsumption:CE1 issubsumed by a class expressionCE2 w.r.t.O andD if(CE1)C ⊆(CE2)C for each modelI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) ofO w.r.t.D andV.
Instance Checking:a is aninstance ofCE w.r.t.O andD if(a)I ∈(CE)C for each modelI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) ofO w.r.t.D andV.
Boolean Conjunctive Query Answering:Q is ananswer w.r.t.O andD ifQ is true in each model ofO w.r.t.D andV according to the standard definitions of first-order logic.
In order to ensure that ontology entailment, class expression satisfiability, class expression subsumption, and instance checking are decidable, the following restriction w.r.t.O needs to be satisfied:
Each class expression of typeMinObjectCardinality,MaxObjectCardinality,ExactObjectCardinality, andObjectHasSelf that occurs inO1,CE,CE1, andCE2 can contain only object property expressions that aresimple in theaxiom closureAx ofO.
For ontology equivalence to be decidable,O1 needs to satisfy this restriction w.r.t.O and vice versa. These restrictions are analogous to the first condition from Section 11.2 of the OWL 2 Specification [OWL 2 Specification].
OWL 2 DL has been defined so that the consequences of an OWL 2 DL ontologyO do not depend on the choice of a datatype map, as long as the datatype map chosen contains all the datatypes occurring inO. This statement is made precise by the following theorem, and it has several useful consequences:
Theorem DS1. LetO1 andO2 be OWL 2 DL ontologies over a vocabularyV andD = (NDT ,NLS ,NFS ,⋅ DT ,⋅ LS ,⋅ FS ) a datatype map such that each datatype mentioned inO1 andO2 isrdfs:Literal, a datatype defined in the respective ontology, or it occurs inNDT. Furthermore, letD' = (NDT' ,NLS' ,NFS' ,⋅ DT ' ,⋅ LS ' ,⋅ FS ' ) be a datatype map such thatNDT ⊆NDT',NLS(DT) =NLS'(DT), andNFS(DT) =NFS'(DT) for eachDT ∈NDT, and⋅ DT ',⋅ LS ', and⋅ FS ' are extensions of⋅ DT,⋅ LS, and⋅ FS, respectively. Then,O1 entailsO2 w.r.t.D if and only ifO1 entailsO2 w.r.t.D'.
Proof. Without loss of generality, one can assumeO1 andO2 to be in negation-normal form [Description Logics]. Furthermore, since datatype definitions inO1 andO2 are acyclic, one can assume that each defined datatype has been recursively replaced with its definition; thus, all datatypes inO1 andO2 are fromNDT ∪ {rdfs:Literal }. The claim of the theorem is equivalent to the following statement: an interpretationI w.r.t.D andV exists such thatO1 is andO2 is not satisfied inI if and only if an interpretationI' w.r.t.D' andV exists such thatO1 is andO2 is not satisfied inI'. The (⇐) direction is trivial since each interpretationI w.r.t.D' andV is also an interpretation w.r.t.D andV. For the (⇒) direction, assume that an interpretationI = (ΔI ,ΔD ,⋅ C ,⋅ OP ,⋅ DP ,⋅ I ,⋅ DT ,⋅ LT ,⋅ FA ,NAMED ) w.r.t.D andV exists such thatO1 is andO2 is not satisfied inI. LetI' = (ΔI ,ΔD' ,⋅ C ' ,⋅ OP ,⋅ DP ' ,⋅ I ,⋅ DT ' ,⋅ LT ' ,⋅ FA ' ,NAMED ) be an interpretation such that
Clearly,DataComplementOf( DR )DT ⊆DataComplementOf( DR )DT ' for each data rangeDR that is either a datatype, a datatype restriction, or an enumerated data range. Theowl:topDataProperty property can occur inO1 andO2 only in tautologies. The interpretation of all other data properties is the same inI andI', so(CE)C =(CE)C ' for each class expressionCE occurring inO1 andO2. Therefore,O1 is andO2 is not satisfied inI'. QED
This section summarizes the changes to this document since theRecommendation of 27 October, 2009.
No changes have been made to this document since theProposed Recommendation of 22 September, 2009.
This section summarizes the changes to this document since theCandidate Recommendation of 11 June, 2009.
This section summarizes the changes to this document since theLast Call Working Draft of 21 April, 2009.
The starting point for the development of OWL 2 was theOWL1.1 member submission, itself a result of user and developer feedback, and in particular of information gathered during theOWL Experiences and Directions (OWLED) Workshop series. The working group also consideredpostponed issues from theWebOnt Working Group.
This document has been produced by the OWL Working Group (see below), and its contents reflect extensive discussions within the Working Group as a whole.The editors extend special thanks toMarkus Krötzsch (FZI),Michael Schneider (FZI) andThomas Schneider (University of Manchester)for their thorough reviews.
The regular attendees at meetings of the OWL Working Group at the time of publication of this document were:Jie Bao (RPI),Diego Calvanese (Free University of Bozen-Bolzano),Bernardo Cuenca Grau (Oxford University Computing Laboratory),Martin Dzbor (Open University),Achille Fokoue (IBM Corporation),Christine Golbreich (Université de Versailles St-Quentin and LIRMM),Sandro Hawke (W3C/MIT),Ivan Herman (W3C/ERCIM),Rinke Hoekstra (University of Amsterdam),Ian Horrocks (Oxford University Computing Laboratory),Elisa Kendall (Sandpiper Software),Markus Krötzsch (FZI),Carsten Lutz (Universität Bremen),Deborah L. McGuinness (RPI),Boris Motik (Oxford University Computing Laboratory),Jeff Pan (University of Aberdeen),Bijan Parsia (University of Manchester),Peter F. Patel-Schneider (Bell Labs Research, Alcatel-Lucent),Sebastian Rudolph (FZI),Alan Ruttenberg (Science Commons),Uli Sattler (University of Manchester),Michael Schneider (FZI),Mike Smith (Clark & Parsia),Evan Wallace (NIST),Zhe Wu (Oracle Corporation), andAntoine Zimmermann (DERI Galway).We would also like to thank past members of the working group:Jeremy Carroll,Jim Hendler, andVipul Kashyap.