├── images ├── annotation.png ├── node-literal.png ├── node-terminal.png ├── raw │ ├── axioms.graffle │ ├── data-ranges.graffle │ ├── basic-drawings.graffle │ ├── change-history.graffle │ ├── class-expressions.graffle │ └── property-expressions.graffle ├── axiom-annotation.png ├── node-data-range.png ├── node-individual.png ├── axiom-subclass-of.png ├── data-ranges-union.png ├── node-entity-class.png ├── node-non-terminal.png ├── axiom-class-assertion.png ├── axiom-same-individual.png ├── node-class-expression.png ├── node-entity-datatype.png ├── axiom-dataproperty-range.png ├── axiom-disjoint-classes.png ├── axiom-entity-declaration.png ├── axiom-equivalent-classes.png ├── axiom-subdataproperty-of.png ├── data-ranges-complement.png ├── data-ranges-intersection.png ├── axiom-annotation-assertion.png ├── axiom-dataproperty-domain.png ├── axiom-objectproperty-range.png ├── axiom-subobjectproperty-of.png ├── node-annonymous-individual.png ├── node-entity-data-property.png ├── axiom-dataproperty-assertion.png ├── axiom-different-individuals.png ├── axiom-disjoint-dataproperties.png ├── axiom-functional-dataproperty.png ├── axiom-hasvalue-dataproperties.png ├── axiom-objectproperty-domain.png ├── class-expression-object-union.png ├── node-data-property-expression.png ├── node-entity-named-individual.png ├── node-entity-object-property.png ├── axiom-annotationproperty-domain.png ├── axiom-annotationproperty-range.png ├── axiom-asymmetric-objectproperty.png ├── axiom-disjoint-objectproperties.png ├── axiom-equivalent-dataproperties.png ├── axiom-functional-objectproperty.png ├── axiom-inverse-objectproperties.png ├── axiom-objectproperty-assertion.png ├── axiom-reflexive-objectproperty.png ├── axiom-subannotationproperty-of.png ├── axiom-symmetric-objectproperty.png ├── axiom-transitive-objectproperty.png ├── class-expression-data-has-value.png ├── class-expression-object-one-of.png ├── node-entity-annotation-property.png ├── node-object-property-expression.png ├── axiom-equivalent-objectproperties.png ├── axiom-irreflexive-objectproperty.png ├── class-expression-data-all-values.png ├── class-expression-data-some-values.png ├── class-expression-object-all-values.png ├── class-expression-object-complement.png ├── class-expression-object-has-self.png ├── class-expression-object-has-value.png ├── data-ranges-datatype-restriction.png ├── class-expression-object-intersection.png ├── class-expression-object-some-values.png ├── data-ranges-enumeration-of-literals.png ├── axiom-inversefunctional-objectproperty.png ├── axiom-negative-dataproperty-assertion.png ├── axiom-negative-objectproperty-assertion.png ├── class-expression-data-exact-cardinality.png ├── class-expression-data-max-cardinality.png ├── class-expression-data-min-cardinality.png ├── class-expression-object-max-cardinality.png ├── class-expression-object-min-cardinality.png ├── class-expression-object-exact-cardinality.png ├── property-expression-inverse-objectproperty.png ├── change-history-ontology-change.svg ├── change-history-description.svg ├── change-history-axiom-change.svg ├── change-history-annotation-change.svg └── change-history.svg ├── README.md ├── LICENSE ├── mapping.md └── index.md /images/annotation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/annotation.png -------------------------------------------------------------------------------- /images/node-literal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-literal.png -------------------------------------------------------------------------------- /images/node-terminal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-terminal.png -------------------------------------------------------------------------------- /images/raw/axioms.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/axioms.graffle -------------------------------------------------------------------------------- /images/axiom-annotation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-annotation.png -------------------------------------------------------------------------------- /images/node-data-range.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-data-range.png -------------------------------------------------------------------------------- /images/node-individual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-individual.png -------------------------------------------------------------------------------- /images/axiom-subclass-of.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-subclass-of.png -------------------------------------------------------------------------------- /images/data-ranges-union.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/data-ranges-union.png -------------------------------------------------------------------------------- /images/node-entity-class.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-class.png -------------------------------------------------------------------------------- /images/node-non-terminal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-non-terminal.png -------------------------------------------------------------------------------- /images/raw/data-ranges.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/data-ranges.graffle -------------------------------------------------------------------------------- /images/axiom-class-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-class-assertion.png -------------------------------------------------------------------------------- /images/axiom-same-individual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-same-individual.png -------------------------------------------------------------------------------- /images/node-class-expression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-class-expression.png -------------------------------------------------------------------------------- /images/node-entity-datatype.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-datatype.png -------------------------------------------------------------------------------- /images/axiom-dataproperty-range.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-dataproperty-range.png -------------------------------------------------------------------------------- /images/axiom-disjoint-classes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-disjoint-classes.png -------------------------------------------------------------------------------- /images/axiom-entity-declaration.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-entity-declaration.png -------------------------------------------------------------------------------- /images/axiom-equivalent-classes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-equivalent-classes.png -------------------------------------------------------------------------------- /images/axiom-subdataproperty-of.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-subdataproperty-of.png -------------------------------------------------------------------------------- /images/data-ranges-complement.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/data-ranges-complement.png -------------------------------------------------------------------------------- /images/data-ranges-intersection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/data-ranges-intersection.png -------------------------------------------------------------------------------- /images/raw/basic-drawings.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/basic-drawings.graffle -------------------------------------------------------------------------------- /images/raw/change-history.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/change-history.graffle -------------------------------------------------------------------------------- /images/axiom-annotation-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-annotation-assertion.png -------------------------------------------------------------------------------- /images/axiom-dataproperty-domain.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-dataproperty-domain.png -------------------------------------------------------------------------------- /images/axiom-objectproperty-range.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-objectproperty-range.png -------------------------------------------------------------------------------- /images/axiom-subobjectproperty-of.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-subobjectproperty-of.png -------------------------------------------------------------------------------- /images/node-annonymous-individual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-annonymous-individual.png -------------------------------------------------------------------------------- /images/node-entity-data-property.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-data-property.png -------------------------------------------------------------------------------- /images/raw/class-expressions.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/class-expressions.graffle -------------------------------------------------------------------------------- /images/axiom-dataproperty-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-dataproperty-assertion.png -------------------------------------------------------------------------------- /images/axiom-different-individuals.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-different-individuals.png -------------------------------------------------------------------------------- /images/axiom-disjoint-dataproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-disjoint-dataproperties.png -------------------------------------------------------------------------------- /images/axiom-functional-dataproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-functional-dataproperty.png -------------------------------------------------------------------------------- /images/axiom-hasvalue-dataproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-hasvalue-dataproperties.png -------------------------------------------------------------------------------- /images/axiom-objectproperty-domain.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-objectproperty-domain.png -------------------------------------------------------------------------------- /images/class-expression-object-union.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-union.png -------------------------------------------------------------------------------- /images/node-data-property-expression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-data-property-expression.png -------------------------------------------------------------------------------- /images/node-entity-named-individual.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-named-individual.png -------------------------------------------------------------------------------- /images/node-entity-object-property.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-object-property.png -------------------------------------------------------------------------------- /images/raw/property-expressions.graffle: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/raw/property-expressions.graffle -------------------------------------------------------------------------------- /images/axiom-annotationproperty-domain.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-annotationproperty-domain.png -------------------------------------------------------------------------------- /images/axiom-annotationproperty-range.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-annotationproperty-range.png -------------------------------------------------------------------------------- /images/axiom-asymmetric-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-asymmetric-objectproperty.png -------------------------------------------------------------------------------- /images/axiom-disjoint-objectproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-disjoint-objectproperties.png -------------------------------------------------------------------------------- /images/axiom-equivalent-dataproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-equivalent-dataproperties.png -------------------------------------------------------------------------------- /images/axiom-functional-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-functional-objectproperty.png -------------------------------------------------------------------------------- /images/axiom-inverse-objectproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-inverse-objectproperties.png -------------------------------------------------------------------------------- /images/axiom-objectproperty-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-objectproperty-assertion.png -------------------------------------------------------------------------------- /images/axiom-reflexive-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-reflexive-objectproperty.png -------------------------------------------------------------------------------- /images/axiom-subannotationproperty-of.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-subannotationproperty-of.png -------------------------------------------------------------------------------- /images/axiom-symmetric-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-symmetric-objectproperty.png -------------------------------------------------------------------------------- /images/axiom-transitive-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-transitive-objectproperty.png -------------------------------------------------------------------------------- /images/class-expression-data-has-value.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-has-value.png -------------------------------------------------------------------------------- /images/class-expression-object-one-of.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-one-of.png -------------------------------------------------------------------------------- /images/node-entity-annotation-property.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-entity-annotation-property.png -------------------------------------------------------------------------------- /images/node-object-property-expression.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/node-object-property-expression.png -------------------------------------------------------------------------------- /images/axiom-equivalent-objectproperties.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-equivalent-objectproperties.png -------------------------------------------------------------------------------- /images/axiom-irreflexive-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-irreflexive-objectproperty.png -------------------------------------------------------------------------------- /images/class-expression-data-all-values.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-all-values.png -------------------------------------------------------------------------------- /images/class-expression-data-some-values.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-some-values.png -------------------------------------------------------------------------------- /images/class-expression-object-all-values.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-all-values.png -------------------------------------------------------------------------------- /images/class-expression-object-complement.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-complement.png -------------------------------------------------------------------------------- /images/class-expression-object-has-self.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-has-self.png -------------------------------------------------------------------------------- /images/class-expression-object-has-value.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-has-value.png -------------------------------------------------------------------------------- /images/data-ranges-datatype-restriction.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/data-ranges-datatype-restriction.png -------------------------------------------------------------------------------- /images/class-expression-object-intersection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-intersection.png -------------------------------------------------------------------------------- /images/class-expression-object-some-values.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-some-values.png -------------------------------------------------------------------------------- /images/data-ranges-enumeration-of-literals.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/data-ranges-enumeration-of-literals.png -------------------------------------------------------------------------------- /images/axiom-inversefunctional-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-inversefunctional-objectproperty.png -------------------------------------------------------------------------------- /images/axiom-negative-dataproperty-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-negative-dataproperty-assertion.png -------------------------------------------------------------------------------- /images/axiom-negative-objectproperty-assertion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/axiom-negative-objectproperty-assertion.png -------------------------------------------------------------------------------- /images/class-expression-data-exact-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-exact-cardinality.png -------------------------------------------------------------------------------- /images/class-expression-data-max-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-max-cardinality.png -------------------------------------------------------------------------------- /images/class-expression-data-min-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-data-min-cardinality.png -------------------------------------------------------------------------------- /images/class-expression-object-max-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-max-cardinality.png -------------------------------------------------------------------------------- /images/class-expression-object-min-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-min-cardinality.png -------------------------------------------------------------------------------- /images/class-expression-object-exact-cardinality.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/class-expression-object-exact-cardinality.png -------------------------------------------------------------------------------- /images/property-expression-inverse-objectproperty.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/protegeproject/owl2lpg/HEAD/images/property-expression-inverse-objectproperty.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # OWL2LPG GitHub Page 2 | 3 | Specification of a mapping between OWL 2 ontologies and Labeled Property Graphs (LPGs). 4 | 5 | The specification webpage is https://protegeproject.github.io/owl2lpg. 6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 2-Clause License 2 | 3 | Copyright (c) 2020, The Board of Trustees of Leland Stanford Junior University 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 20 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | The views and conclusions contained in the software and documentation are those of the 28 | authors and should not be interpreted as representing official policies, either expressed 29 | or implied, of The Board of Trustees of Leland Stanford Junior University. -------------------------------------------------------------------------------- /images/change-history-ontology-change.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | Produced by OmniGraffle 6.6.2 2020-04-08 00:45:47 +0000Canvas 4ClassAssertion:OntologyChange:Change:OntologyIdontology 4 | -------------------------------------------------------------------------------- /images/change-history-description.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | Produced by OmniGraffle 6.6.2 2020-03-19 22:14:49 +0000Canvas 4ClassAssertion:CreateClass:HighLevelDescription:OwlClassclassparentClass 4 | -------------------------------------------------------------------------------- /images/change-history-axiom-change.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | Produced by OmniGraffle 6.6.2 2020-04-08 00:45:47 +0000Canvas 4ClassAssertion:AxiomChange:OntologyChange:Change:Axiomaxiom:OntologyIdontology 4 | -------------------------------------------------------------------------------- /images/change-history-annotation-change.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | Produced by OmniGraffle 6.6.2 2020-04-08 00:45:47 +0000Canvas 4ClassAssertion:OntologyAnnotationChange:OntologyChange:Change:AnnotationontologyAnnotation:OntologyIdontology 4 | -------------------------------------------------------------------------------- /images/change-history.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | Produced by OmniGraffle 6.6.2 2020-03-19 22:14:49 +0000Canvas 4ClassAssertion:Project:Branch:ChangeHistory:Revisiontimestamp:ChangerevisionschangeschangeHistorybranch:Userauthorprevious/next:HighLevelDescriptiondescription 4 | -------------------------------------------------------------------------------- /mapping.md: -------------------------------------------------------------------------------- 1 | # Mapping of OWL 2 Web Ontology Language to Labeled Property Graphs 2 | 3 | 4 | 5 | ## 1 Translation of Axioms without Annotations 6 | 7 | The table below presents the operator T that maps an OWL 2 ontology *O* into a LPG graph *T(O)*, provided that no axiom in *O* is annotated. The mapping is defined recursively; that is, the mapping of a construct depends on the mappings of its subconstructs in the following way: if the mapping of a construct refers to the mapping of a subconstruct, then the graph generated by the recursive invocation of the mapping on the subconstruct is added to the graph under construction, and the *main node* (denoted by a **bold-faced** variable) of the mapping of the subconstruct is used in place of the recursive invocation itself. 8 | 9 | The following conventions are used in this section to denote different parts of OWL 2 ontologies: 10 | 11 | * `OP` denotes an object property; 12 | * `OPE` denotes an object property expression; 13 | * `DP` denotes a data property; 14 | * `DPE` denotes a data property expression; 15 | * `AP` denotes an annotation property; 16 | * `C` denotes a class; 17 | * `CE` denotes a class expression; 18 | * `DT` denotes a datatype; 19 | * `DR` denotes a data range; 20 | * `U` denotes an IRI; 21 | * `F` denotes a constraining facet; 22 | * `a` denotes an individual (named or anonymous); 23 | * `*:a` denotes a named individual; 24 | * `_:a` denotes an anonymous individual; 25 | * `lt` denotes a literal; 26 | * `as` denotes an annotation source; and 27 | * `av` denotes an annotation value. 28 | 29 | In this section, T(`SEQ` `y1` ... `yn`) denotes the translation of a sequence of objects from the structural specification into a linked-list graph. 30 | 31 | 32 | 33 | **Table 1**: Translation of axioms without annotations. 34 | 35 | | Element *E* of the OWL Structural Specification | Graph Generated in an Invocation of *T(E)* | 36 | | ------------------------------------------------------------ | ------------------------------------------------------------ | 37 | | `y1` ... `yn` | ***nodes*** = { n \| T(`y1`) ... T(`yn`) } | 38 | | `SEQ` `y1` ... `yn` | **node** = T(`y1`)
EDGE(*node*, T(`SEQ` `y2` ... `yn`), "next", {}) | 39 | | Ontology(
`ontologyIRI`
[`versionIRI`]
Import(`ontologyIRI1`) ...
Import(`ontologyIRIk`)
`annotation1` ... `annotationm`
`axiom1` ... `axiomn`) | ***ontologyNode*** = T(`ontologyIRI`)
*importOntologyNodes* = T(`ontologyIRI1` ... `ontologyIRIk`)
*axiomAnnotationNodes* = TANN(`annotation1` ... `annotationm`)
*axiomNodes* = T(`axiom1` ... `axiomn`)
EDGES( *ontologyNode*, *importOntologyNodes*, "importOntology", {})
EDGES( *ontologyNode*, *axiomAnnotationNodes*, "axiomAnnotation", {})
EDGES( *ontologyNode*, *axiomNodes*, "axiom", {}) | 40 | | `C` | ***entityNode*** = NODE(["Class", "ClassExpression", "Entity"], { iri: IRI(`C`) })
*iriNode* = T(IRI(`C`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 41 | | `DT` | ***entityNode*** = NODE(["Datatype", "Entity"], { iri: IRI(`DT`) })
*iriNode* = T(IRI(`DT`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 42 | | `OP` | ***entityNode*** = NODE(["ObjectProperty", "ObjectPropertyExpression", "Entity"], { iri: IRI(`OP`) })
*iriNode* = T(IRI(`OP`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 43 | | `DP` | ***entityNode*** = NODE(["DataProperty", "DataPropertyExpression", "Entity"], { iri: IRI(`DP`) })
iriNode = T(IRI(`DP`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 44 | | `AP` | ***entityNode*** = NODE(["AnnotationProperty", "Entity"], { iri: IRI(`AP`) })
*iriNode* = T(IRI(`AP`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 45 | | `*:a` | ***entityNode*** = NODE(["NamedIndividual", "Individual", "Entity"], { iri: IRI(`*:a`) })
*iriNode* = T(IRI(`*:a`))
EDGE(*entityNode*, *iriNode*, "entityIri", {}) | 46 | | `_:a` | ***anonNode*** = NODE(["AnonymousIndividual"], { nodeID:`blank_node_label` }) | 47 | | `U` | ***iriNode*** = NODE(["IRI"], { iri:`U` }) | 48 | | `F lt` | ***restrictionNode*** = NODE(["FacetRestriction"], {})
*constrainingFacetNode* = T(`F`)
*literalNode* = T(`lt`)
EDGE(*restrictionNode*, *constraintFacetNode*, "constrainingFacet", {})
EDGE(*restrictionNode*, *literalNode*, "restrictionValue", {}) | 49 | | `F` | **facetNode** = NODE(["Facet"], { iri: IRI(`F`) }) | 50 | | "abc@"^^*rdf:PlainLiteral* | ***literalNode*** = NODE(["Literal"], { lexicalForm: "abc", language: "", datatype: T(rdf:PlainLiteral) }) | 51 | | "abc@`langTag`"^^*rdf:PlainLiteral* | ***literalNode*** = NODE(["Literal"], { lexicalForm: "abc", language: `langTag`, datatype: T(rdf:PlainLiteral) }) | 52 | | "abc"^^`datatype` { where `datatype` is different than *rdf:PlainLiteral* } | ***literalNode*** = NODE(["Literal"], { lexicalForm: "abc", datatype: T(`datatype`) }) | 53 | | Declaration(Datatype(`DT`)) | ***axiomNode*** = NODE(["Declaration", "Axiom"], {})
*datatypeNode* = T(`DT`)
EDGE(*axiomNode*, *datatypeNode*, "entity", {}) | 54 | | Declaration(Class(`C`)) | ***axiomNode*** = NODE(["Declaration", "Axiom"], {})
*classNode* = T(`C`)
EDGE(*axiomNode*, *classNode*, "entity", {}) | 55 | | Declaration(ObjectProperty(`OP`)) | ***axiomNode*** = NODE(["Declaration", "Axiom"], {})
*objectPropertyNode* = T(`OP`)
EDGE(*axiomNode*, *objectPropertyNode*, "entity", {}) | 56 | | Declaration(DataProperty(`DP`)) | **axiomNode** = NODE(["Declaration", "Axiom"], {})
dataPropertyNode = T(`DP`)
EDGE(axiomNode, dataPropertyNode, "entity", {}) | 57 | | Declaration(AnnotationProperty(`AP`)) | ***axiomNode*** = NODE(["Declaration", "Axiom"], {})
*annotationPropertyNode* = T(`AP`)
EDGE(*axiomNode*, *annotationPropertyNode*, "entity", {}) | 58 | | Declaration(NamedIndividual(`*:a`)) | ***axiomNode*** = NODE(["Declaration", "Axiom"], {})
*namedIndividualNode* = T(`*:a`)
EDGE(*axiomNode*, *namedIndividualNode*, "entity", {}) | 59 | | DataIntersectionOf(`DR1` ... `DRn`) | ***intersectionNode*** = NODE(["DataIntersectionOf", "DataRange"], {})
*dataRangeNodes* = T(`DR1` ... `DRn`)
EDGES( *intersectionNode*, *dataRangeNodes*, "dataRange", {}) | 60 | | DataUnionOf(`DR1` ... `DRn`) | ***unionNode*** = NODE(["DataUnionOf", "DataRange"], {})
*dataRangeNodes* = T(`DR1` ... `DRn`)
EDGES( *unionNode*, *dataRangeNodes*, "dataRange", {}) | 61 | | DataComplementOf(`DR`) | ***complementNode*** = NODE(["DataComplementOf", "DataRange"], {})
*dataRangeNode* = T(`DR`)
EDGE( *complementNode*, *dataRangeNode*, "dataRange", {}) | 62 | | DataOneOf(`lt1` ... `ltn`) | ***enumerationNode*** = NODE(["DataOneOf", "DataRange"], {})
*literalNodes* = T(`lt1` ... `ltn`)
EDGES( *enumerationNode*, literalNodes, "literal", {}) | 63 | | DatatypeRestriction(
`DT` `F1 lt1` ... `Fn ltn`) | ***dataRangeNode*** = NODE(["DatatypeRestriction", "DataRange"], {})
*datatypeNode* = T(`DT`)
*restrictionNodes* = T(`F1 lt1` ... `Fn ltn`)
EDGE(*dataRangeNode*, *datatypeNode*, "datatype", {})
EDGES( *dataRangeNode*, *restrictionNodes*, "restriction", {}) | 64 | | ObjectIntersectionOf(`CE1` ... `CEn`) | ***intersectionNode*** = NODE(["ObjectIntersectionOf", "ClassExpression"], {})
*classExpressionNodes* = T(`CE1` ... `CEn`)
EDGES( *intersectionNode*, *classExpressionNodes*, "classExpression", {}) | 65 | | ObjectUnionOf(`CE1` ... `CEn`) | ***unionNode*** = NODE(["ObjectUnionOf", "ClassExpression"], {})
*classExpressionNodes* = T(`CE1` ... `CEn`)
EDGES( *unionNode*, *classExpressionNodes*, "classExpression", {}) | 66 | | ObjectComplementOf(`CE`) | ***complementNode*** = NODE(["ObjectComplementOf", "ClassExpression"], {})
*classExpressionNode* = T(`CE`)
EDGE(*complementNode*, *classExpressionNode*, "classExpression", {}) | 67 | | ObjectOneOf(`a1` ... `an`) | ***enumerationNode*** = NODE(["ObjectOneOf", "ClassExpression"], {})
*individualNodes* = T(`a1` ... `an`)
EDGES( *enumerationNode*, *individualNodes*, "individual", {}) | 68 | | ObjectSomeValuesFrom(`OPE` `CE`) | ***quantifierNode*** = NODE(["ObjectSomeValuesFrom", "ClassExpression"], {})
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*quantifierNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*quantifierNode*, *classExpressionNode*, "classExpression", {}) | 69 | | ObjectAllValuesFrom(`OPE` `CE`) | ***quantifierNode*** = NODE(["ObjectAllValuesFrom", "ClassExpression"], {})
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*quantifierNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*quantifierNode*, *classExpressionNode*, "classExpression", {}) | 70 | | ObjectHasValue(`OPE` `a`) | ***restrictionNode*** = NODE(["ObjectHasValue", "ClassExpression"], {})
*objectPropertyNode* = T(`OPE`)
*individualNode* = T(`a`)
EDGE(*restrictionNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*restrictionNode*, *individualNode*, "individual", {}) | 71 | | ObjectHasSelf(`OPE`) | ***restrictionNode*** = NODE(["ObjectHasSelf", "ClassExpression"], {})
*objectPropertyNode* = T(`OPE`)
EDGE(*restrictionNode*, *objectPropertyNode*, "objectPropertyExpression", {}) | 72 | | ObjectMinCardinality(`n` `OPE`) | ***cardinalityNode*** = NODE(["ObjectMinCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(owl:Thing)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 73 | | ObjectMinCardinality(`n` `OPE` `CE`) | ***cardinalityNode*** = NODE(["ObjectMinCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 74 | | ObjectMaxCardinality(`n` `OPE`) | ***cardinalityNode*** = NODE(["ObjectMaxCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(owl:Thing)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 75 | | ObjectMaxCardinality(`n` `OPE` `CE`) | ***cardinalityNode*** = NODE(["ObjectMaxCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 76 | | ObjectExactCardinality(`n` `OPE`) | **cardinalityNode** = NODE(["ObjectExactCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(owl:Thing)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 77 | | ObjectExactCardinality(`n` `OPE` `CE`) | ***cardinalityNode*** = NODE(["ObjectExactCardinality", "ClassExpression"], { cardinality=`n` })
*objectPropertyNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*cardinalityNode*, *objectPropertyNode*, "objectPropertyExpression", {})
EDGE(*cardinalityNode*, *classExpressionNode*, "classExpression", {}) | 78 | | DataSomeValuesFrom(`DPE` `DR`) | ***quantifierNode*** = NODE(["DataSomeValuesFrom", "ClassExpression"], {})
*dataPropertyNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*quantifierNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*quantifierNode*, *dataRangeNode*, "dataRange", {}) | 79 | | DataAllValuesFrom(`DPE` `DR`) | ***quantifierNode*** = NODE(["DataAllValuesFrom", "ClassExpression"], {})
*dataPropertyNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*quantifierNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*quantifierNode*, *dataRangeNode*, "dataRange", {}) | 80 | | DataHasValue(`DPE` `lt`) | ***restrictionNode*** = NODE(["DataHasValue", "ClassExpression"], {})
*dataPropertyNode* = T(`DPE`)
*literalNode* = T(`lt`)
EDGE(*restrictionNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*restrictionNode*, *literalNode*, "literal", {}) | 81 | | DataMinCardinality(`n` `DPE`) | ***cardinalityNode*** = NODE(["DataMinCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {}) | 82 | | DataMinCardinality(`n` `DPE` `DR`) | ***cardinalityNode*** = NODE(["DataMinCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*cardinalityNode*, *dataRangeNode*, "dataRange", {}) | 83 | | DataMaxCardinality(`n` `DPE`) | ***cardinalityNode*** = NODE(["DataMaxCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {}) | 84 | | DataMaxCardinality(`n` `DPE` `DR`) | ***cardinalityNode*** = NODE(["DataMaxCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*cardinalityNode*, *dataRangeNode*, "dataRange", {}) | 85 | | DataExactCardinality(`n` `DPE`) | ***cardinalityNode*** = NODE(["DataExactCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {}) | 86 | | DataExactCardinality(`n` `DPE` `DR`) | ***cardinalityNode*** = NODE(["DataExactCardinality", "ClassExpression"], { cardinality=`n` })
*dataPropertyNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*cardinalityNode*, *dataPropertyNode*, "dataPropertyExpression", {})
EDGE(*cardinalityNode*, *dataRangeNode*, "dataRange", {}) | 87 | | ObjectInverseOf(`OP`) | ***inverseNode*** = NODE(["ObjectInverseOf", "ObjectPropertyExpression"], {})
*objectPropertyNode* = T(`OP`)
EDGE(*inverseNode*, *objectPropertyNode*, "objectProperty", {}) | 88 | | SubClassOf(`CE1` `CE2`) | ***axiomNode*** = NODE(["SubClassOf", "ClassAxiom", "Axiom"], {})
*subClassExpressionNode* = T(`CE1`)
*superClassExpressionNode* = T(`CE2`)
EDGE(*axiomNode*, *subClassExpressionNode*, "subClassExpression", {})
EDGE(*axiomNode*, *superClassExpressionNode*, "superClassExpression", {}) | 89 | | EquivalentClasses(`CE1` ... `CEn`) | ***equivalentNode*** = NODE(["EquivalentClasses", "ClassAxiom", "Axiom"], {})
*classExpressionNodes* = T(`CE1` ... `CEn`)
EDGES( *equivalentNode*, *classExpressionNodes*, "classExpression", {}) | 90 | | DisjointClasses(`CE1` ... `CEn`) | **disjointNode** = NODE(["DisjointClasses", "ClassAxiom", "Axiom"], {})
*classExpressionNodes* = T(`CE1` ... `CEn`)
EDGES( *disjointNode*, *classExpressionNodes*, "classExpression", {}) | 91 | | DisjointUnion(`C` `CE1` ... `CEn`) | ***unionNode*** = NODE(["DisjointUnion", "ClassAxiom", "Axiom"], {})
*classNode* = T(`C`)
*classExpressionNodes* = T(`CE1` ... `CEn`)
EDGE(*unionNode*, *classNode*, "class", {})
EDGES( *unionNode*, *classExpressionNodes*, "disjointClassExpression", {}) | 92 | | SubObjectPropertyOf(`OPE1` `OPE2`) | ***axiomNode*** = NODE(["SubObjectPropertyOf", "ObjectPropertyAxiom", "Axiom"], {})
*subPropertyNode* = T(`OPE1`)
*superPropertyNode* = T(`OPE2`)
EDGE(*axiomNode*, *subPropertyNode*, "subObjectPropertyExpression", {})
EDGE(*axiomNode*, *superPropertyNode*, "superObjectPropertyExpression", {}) | 93 | | SubObjectPropertyOf(
ObjectPropertyChain(`OPE1` ... `OPEn`)
`OPE`) | ***axiomNode*** = NODE(["SubObjectPropertyOf", "ObjectPropertyAxiom", "Axiom"], {})
*subPropertyNode* = T(`SEQ` `OPE1` ... `OPEn`)
*superPropertyNode* = T(`OPE`)
EDGE(*axiomNode*, *subPropertyNode*, "subObjectPropertyExpression", {})
EDGE(*axiomNode*, *superPropertyNode*, "superObjectPropertyExpression", {}) | 94 | | EquivalentObjectProperties(`OPE1` ... `OPEn`) | ***equivalentNode*** = NODE(["EquivalentObjectProperties", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNodes* = T(`OPE1` ... `OPEn`)
EDGES( *equivalentNode*, *propertyExpressionNodes*, "objectPropertyExpression", {}) | 95 | | DisjointObjectProperties(`OPE1` ... `OPEn`) | ***disjointNode*** = NODE(["DisjointObjectProperties", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNodes* = T(`OPE1` ... `OPEn`)
EDGES( *disjointNode*, *propertyExpressionNodes*, "objectPropertyExpression", {}) | 96 | | ObjectPropertyDomain(`OPE` `CE`) | ***axiomNode*** = NODE(["ObjectPropertyDomain", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*axiomNode*, *propertyExpressionNode*, "objectPropertyExpression", {})
EDGE(*axiomNode*, *classExpressionNode*, "domain", {}) | 97 | | ObjectPropertyRange(`OPE` `CE`) | ***axiomNode*** = NODE(["ObjectPropertyRange", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
*classExpressionNode* = T(`CE`)
EDGE(*axiomNode*, *propertyExpressionNode*, "objectPropertyExpression", {})
EDGE(*axiomNode*, *classExpressionNode*, "range", {}) | 98 | | InverseObjectProperties(`OPE1` `OPE2`) | ***inverseNode*** = NODE(["InverseObjectProperties", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionOneNode* = T(`OPE1`)
*propertyExpressionTwoNode* = T(`OPE2`)
EDGE(*inverseNode*, *propertyExpressionOneNode*, "objectPropertyExpression", {})
EDGE(*inverseNode*, *propertyExpressionTwoNode*, "inverseObjectPropertyExpression", {}) | 99 | | FunctionalObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["FunctionalObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 100 | | InverseFunctionalObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["InverseFunctionalObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 101 | | ReflexiveObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["ReflexiveObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 102 | | IrreflexiveObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["IrreflexiveObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 103 | | SymmetricObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["SymmetricObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 104 | | AsymmetricObjectProperty(`OPE`) | **characteristicNode** = NODE(["AsymmetricObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 105 | | TransitiveObjectProperty(`OPE`) | ***characteristicNode*** = NODE(["TransitiveObjectProperty", "ObjectPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "objectPropertyExpression", {}) | 106 | | SubDataPropertyOf(`DPE1` `DPE2` ) | ***axiomNode*** = NODE(["SubDataPropertyOf", "DataPropertyAxiom", "Axiom"], {})
*subPropertyNode* = T(`DPE1`)
*superPropertyNode* = T(`DPE2`)
EDGE(*axiomNode*, *subPropertyNode*, "subDataPropertyExpression", {})
EDGE(*axiomNode*, *superPropertyNode*, "superDataPropertyExpression", {}) | 107 | | EquivalentDataProperties(`DPE1`... `DPEn`) | ***equivalentNode*** = NODE(["EquivalentDataProperties", "DataPropertyAxiom", "Axiom"], {})
*propertyExpressionNodes* = T(`DPE1` ... `DPEn`)
EDGES( *equivalentNode*, *propertyExpressionNodes*, "dataPropertyExpression", {}) | 108 | | DisjointDataProperties(`DPE1`... `DPEn`) | ***disjointNode*** = NODE(["DisjointDataProperties", "DataPropertyAxiom", "Axiom"], {})
*propertyExpressionNodes* = T(`DPE1` ... `DPEn`)
EDGES( *disjointNode*, *propertyExpressionNodes*, "dataPropertyExpression", {}) | 109 | | DataPropertyDomain(`DPE` `CE`) | ***axiomNode*** = NODE(["DataPropertyDomain", "DataPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`DPE`)
*classExpressionNode* = T(`CE`)
EDGE(*axiomNode*, *propertyExpressionNode*, "dataPropertyExpression", {})
EDGE(*axiomNode*, *classExpressionNode*, "domain", {}) | 110 | | DataPropertyRange(`DPE` `DR`) | ***axiomNode*** = NODE(["DataPropertyRange", "DataPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`DPE`)
*dataRangeNode* = T(`DR`)
EDGE(*axiomNode*, *propertyExpressionNode*, "objectPropertyExpression", {})
EDGE(*axiomNode*, *dataRangeNode*, "range", {}) | 111 | | FunctionalDataProperty(`DPE`) | ***characteristicNode*** = NODE(["FunctionalDataProperty", "DataPropertyAxiom", "Axiom"], {})
*propertyExpressionNode* = T(`DPE`)
EDGE(*characteristicNode*, *propertyExpressionNode*, "dataPropertyExpression", {}) | 112 | | DatatypeDefinition(`DT` `DR`) | ***axiomNode*** = NODE(["DatatypeDefintion", "Axiom"], {})
*datatypeNode* = T(`DT`)
*dataRangeNode* = T(`DR`)
EDGE(*axiomNode*, *datatypeNode*, "datatype", {})
EDGE(*axiomNode*, *dataRangeNode*, "dataRange", {}) | 113 | | HasKey(`CE` `(OPE1` ... `OPEm)` `(DPE1`... `DPEn)`) | ***axiomNode*** = NODE(["HasKey", "Axiom"], {})
*classExpressionNode* = T(`CE`)
*objectExpressionPropertyNodes* = T(`OPE1` ... `OPEm`)
*dataPropertyExpressionNodes* = T(`DPE1` ... `DPEn`)
EDGE(*axiomNode*, *classExpressionNode*, "classExpression", {})
EDGES( *axiomNode*, *objectExpressionPropertyNodes*, "objectPropertyExpression", {})
EDGES( *axiomNode*, *dataPropertyExpressionNodes*, "dataPropertyExpression", {}) | 114 | | SameIndividual(`a1` ... `an`) | ***equalityNode*** = NODE(["SameIndividual", "Assertion", "Axiom"], {})
*individualNodes* = T(`a1` ... `an`)
EDGES( *equalityNode*, *individualNodes*, "individual", {}) | 115 | | DifferentIndividuals(`a1` ... `an`) | ***inequalityNode*** = NODE(["DifferentIndividuals", "Assertion", "Axiom"], {})
*individualNodes* = T(`a1` ... `an`)
EDGES( *inequalityNode*, *individualNodes*, "individual", {}) | 116 | | ClassAssertion(`CE` `a`) | ***assertionNode*** = NODE(["ClassAssertion", "Assertion", "Axiom"], {})
*classExpressionNode* = T(`CE`)
*individualNode* = T(`a`)
EDGE(*assertionNode*, *classExpressionNode*, "classExpression", {})
EDGE(*assertionNode*, *individualNode*, "individual", {}) | 117 | | ObjectPropertyAssertion(`OPE` `a1` `a2`) | ***assertionNode*** = NODE(["ObjectPropertyAssertion", "Assertion", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
*sourceIndividualNode* = T(`a1`)
*targetIndividualNode* = T(`a2`)
EDGE(*assertionNode*, *propertyExpressionNode*, "objectPropertyExpression", {})
EDGE(*assertionNode*, *sourceIndividualNode*, "sourceIndividual", {})
EDGE(*assertionNode*, *targetIndividualNode*, "targetIndividual", {}) | 118 | | NegativeObjectPropertyAssertion(`OPE` `a1` `a2`) | ***assertionNode*** = NODE(["NegativeObjectPropertyAssertion", "Assertion", "Axiom"], {})
*propertyExpressionNode* = T(`OPE`)
*sourceIndividualNode* = T(`a1`)
*targetIndividualNode* = T(`a2`)
EDGE(*assertionNode*, *propertyExpressionNode*, "objectPropertyExpression", {})
EDGE(*assertionNode*, *sourceIndividualNode*, "sourceIndividual", {})
EDGE(*assertionNode*, *targetIndividualNode*, "targetIndividual", {}) | 119 | | DataPropertyAssertion(`DPE` `a` `lt`) | ***assertionNode*** = NODE(["DataPropertyAssertion", "Assertion", "Axiom"], {})
*propertyExpressionNode* = T(`DPE`)
*sourceIndividualNode* = T(`a`)
*targetLiteralNode* = T(`lt`)
EDGE(*assertionNode*, *propertyExpressionNode*, "dataPropertyExpression", {})
EDGE(*assertionNode*, *sourceIndividualNode*, "sourceIndividual", {})
EDGE(*assertionNode*, *targetLiteralNode*, "targetValue", {}) | 120 | | NegativeDataPropertyAssertion(`DPE` `a` `lt`) | ***assertionNode*** = NODE(["NegativeDataPropertyAssertion", "Assertion", "Axiom"], {})
*propertyExpressionNode* = T(`DPE`)
*sourceIndividualNode* = T(`a`)
*targetLiteralNode* = T(`lt`)
EDGE(*assertionNode*, *propertyExpressionNode*, "dataPropertyExpression", {})
EDGE(*assertionNode*, *sourceIndividualNode*, "sourceIndividual", {})
EDGE(*assertionNode*, *targetLiteralNode*, "targetValue", {}) | 121 | | AnnotationAssertion(`AP` `as` `av`) | ***assertionNode*** = NODE(["AnnotationAssertion", "AnnotationAxiom", "Axiom"], {})
*annotationPropertyNode* = T(`AP`)
*annotationSubjectNode* = T(`as`)
*annotationValueNode* = T(`av`)
EDGE(*assertionNode*, *annotationPropertyNode*, "annotationProperty", {})
EDGE(*assertionNode*, *annotationSubjectNode*, "annotationSubject", {})
EDGE(*assertionNode*, *annotationValueNode*, "annotationValue", {}) | 122 | | SubAnnotationPropertyOf(`AP1` `AP2`) | ***axiomNode*** = NODE(["SubAnnotationPropertyOf", "AnnotationAxiom", "Axiom"], {})
*subPropertyNode* = T(`AP1`)
*superPropertyNode* = T(`AP2`)
EDGE(*axiomNode*, *subPropertyNode*, "subAnnotationProperty", {})
EDGE(*axiomNode*, *superPropertyNode*, "superAnnotationProperty", {}) | 123 | | AnnotationPropertyDomain(`AP` `U`) | ***axiomNode*** = NODE(["AnnotationPropertyDomain", "AnnotationAxiom", "Axiom"], {})
*propertyNode* = T(`AP`)
*iriNode* = T(`U`)
EDGE(*axiomNode*, *propertyNode*, "annotationProperty", {})
EDGE(*axiomNode*, *iriNode*, "domain", {}) | 124 | | AnnotationPropertyRange(`AP` `U`) | ***axiomNode*** = NODE(["AnnotationPropertyRange", "AnnotationAxiom", "Axiom"], {})
*propertyNode* = T(`AP`)
iriNode = T(`U`)
EDGE(*axiomNode*, *propertyNode*, "annotationProperty", {})
EDGE(*axiomNode*, *iriNode*, "range", {}) | 125 | 126 | 127 | 128 | ## 2 Translation of Annotations 129 | 130 | **Table 2**: Translation of annotations. 131 | 132 | | Annotation A | Graph Generated in an Invocation of *TANN(A)* | 133 | | ------------------------------------------------------------ | ------------------------------------------------------------ | 134 | | `annotation1` ... `annotationn` | ***nodes*** = { n \| TANN(`annotation1`) ... TANN(`annotationn`) } | 135 | | Annotation(`AP` `av`) | ***annotationNode*** = NODE(["Annotation"], {})
*annotationPropertyNode* = T(`AP`)
*annotationValueNode* = T(`av`)
EDGE(*annotationNode*, *annotationPropertyNode*, "annotationProperty", {})
EDGE(*annotationNode*, *annotationValueNode*, "annotationValue", {}) | 136 | | Annotation(
`annotation1` ... `annotationn`
`AP` `av`) | ***annotationNode*** = NODE(["Annotation"], {})
*annotationPropertyNode* = T(`AP`)
*annotationValueNode* = T(`av`)
*annotationAnnotationsNode* = TANN(`annotation` ... `annotationn`)
EDGES(*annotationNode*, *annotationAnnotationsNode*, "annotationAnnotation", {})
EDGE(*annotationNode*, *annotationPropertyNode*, "annotationProperty", {})
EDGE(*annotationNode*, *annotationValueNode*, "annotationValue", {}) | 137 | 138 | 139 | 140 | ## 3 Translation of Axioms with Annotations 141 | 142 | If an axiom `ax` is annotated with annotations `annotation1` ... `annotationm`, its mapping to LPG is obtained by translating `ax` using **Table 1** and invoking TANN(`annotation1` ... `annotatiom`) using **Table 2** to translate the annotations. An annotated axiom `ax` is translated as follows: 143 | 144 | ***axiomNode*** = T(`ax`)
axiomAnnotationNodes = TANN(`annotation1` ... `annotationm`)
EDGES( *axiomNode*, *axiomAnnotationNodes*, "axiomAnnotation", {}) 145 | 146 | 147 | 148 | ## 4 Augmenting Edges 149 | 150 | In this section we describe a collection of augmenting edges that are used in conjunction with the rest of the mapping above. The additional edges in **Table 3** are designed to facilitate such tasks as building entity hierarchies out of labeled property graphs generated with this mapping. 151 | 152 | **Table 3**: Additional edges that augment LPGs obtained using the translation functions described in previous sections. 153 | 154 | | **OWL Axiom `ax`** | **Edge(s) generated** | 155 | | ------------------------------------------------------------ | ------------------------------------------------------------ | 156 | | SubClassOf(`CE1` `CE2`) | EDGE(T(`CE1`), T(`CE2`), "subClassOf", {}) | 157 | | SubClassOf(`CE1` ObjectIntersectionOf(`CE2` ... `CEn`)) | EDGE(T(`CE1`), T(`CE2`), "subClassOf", {})
...
EDGE(T(`CE1`), T(`CEn`), "subClassOf", {}) | 158 | | EquivalentClasses(`CE1` ... `CEn`) | EDGE(T(`CE1`), T(`CE2`), "subClassOf", {})
EDGE(T(`CE2`), T(`CE1`), "subClassOf", {})
...
EDGE(T(`CEn-1`), T(`CEn`), "subClassOf", {})
EDGE(T(`CEn`), T(`CEn-1`), "subClassOf", {}) | 159 | | EquivalentClasses(`CE1`ObjectIntersectionOf(`CE2` ... `CEn`)) | EDGE(T(`CE1`), T(`CE2`), "subClassOf", {})
...
EDGE(T(`CE1`), T(`CEn`), "subClassOf", {}) | 160 | | SubObjectPropertyOf(`OPE1` `OPE2`) | EDGE(T(`OPE1`), T(`OPE2`), "subObjectPropertyOf", {}) | 161 | | EquivalentObjectProperties(`OPE1` ... `OPEn`) | EDGE(T(`OPE1`), T(`OPE2`), "subObjectPropertyOf", {})
EDGE(T(`OPE2`), T(`OPE1`), "subObjectPropertyOf", {})
...
EDGE(T(`OPEn-1`), T(`OPEn`), "subObjectPropertyOf", {})
EDGE(T(`OPEn`), T(`OPEn-1`), "subObjectPropertyOf", {}) | 162 | | SubDataPropertyOf(`DPE1` `DPE2`) | EDGE(T(`DPE1`), T(`DPE2`), "subDataPropertyOf", {}) | 163 | | EquivalentDataProperties(`DPE1`... `DPEn`) | EDGE(T(`DPE1`), T(`DPE2`), "subDataPropertyOf", {})
EDGE(T(`DPE2`), T(`DPE1`), "subDataPropertyOf", {})
...
EDGE(T(`DPEn-1`), T(`DPEn`), "subDataPropertyOf", {})
EDGE(T(`DPEn`), T(`DPEn-1`), "subDataPropertyOf", {}) | 164 | | ClassAssertion(`CE` `a`) | EDGE(T(`a`), T(`CE`), "type", {}) | 165 | | SameIndividual(`a1` ... `an`) | EDGE(T(`a1`), T(`a2`), "sameIndividual", {})
EDGE(T(`a2`), T(`a1`), "sameIndividual", {})
...
EDGE(T(`an-1`), T(`an`), "sameIndividual", {})
EDGE(T(`an`), T(`an-1`), "sameIndividual", {}) | 166 | | SubAnnotationPropertyOf(`AP1` `AP2`) | EDGE(T(`AP1`), T(`AP2`), "subAnnotationPropertyOf", {}) | 167 | 168 | -------------------------------------------------------------------------------- /index.md: -------------------------------------------------------------------------------- 1 | # Mapping of OWL 2 Web Ontology Language to Labeled Property Graphs 2 | 3 | Working Draft, Updated: 21 January 2021 4 | 5 | **Document Source Control**: 6 | 7 | ​ [GitHub](https://github.com/protegeproject/owl2lpg/) 8 | 9 | **Issue Tracking**: 10 | 11 | ​ [GitHub](https://github.com/protegeproject/owl2lpg/issues/) 12 | 13 | **Editors**: 14 | 15 | ​ [Rafael Gonçalves](https://rsgoncalves.com) (Stanford University) 16 | 17 | ​ [Josef Hardi](https://profiles.stanford.edu/josef-hardi) (Stanford University) 18 | 19 | ​ [Matthew Horridge](https://web.stanford.edu/~horridge) (Stanford University) 20 | 21 | **Contributors**: 22 | 23 | ​ [Alexander García Castro](mailto:alexander.garcia-castro@basf.com) (BASF) 24 | 25 | ​ [José Antonio Bernabé Díaz](mailto:jose-antonio.bernabe-diaz@basf.com) (BASF) 26 | 27 | ​ [Juergen Mueller](mailto:juergen.a.mueller@basf.com) (BASF) 28 | 29 | --- 30 | 31 | 32 | 33 | ## Abstract 34 | 35 | This document specificies a mapping of the OWL 2 Web Ontology Language to Labeled Property Graphs (LPGs), and vice versa. 36 | 37 | 38 | 39 | ## Status of this document 40 | 41 | This is a public copy of the editors’ draft. It is provided for discussion only and may change at any moment. Do not cite this document other than as work in progress. 42 | 43 | 44 | 45 | --- 46 | 47 | **Table of Content** 48 | 49 | * [1 Introduction](#1-introduction) 50 | * [1.1 Main Requirements](#11-main-requirements) 51 | * [1.2 Design Choices](#12-design-choices) 52 | * [1.3 Document Conventions](#13-document-conventions) 53 | * [2 Entities, Literals, and Anonymous Individuals](#2-entities-literals-and-anonymous-individuals) 54 | * [2.1 Entities](#21-entities) 55 | * [2.1.1 Class](#211-class) 56 | * [2.1.2 Object Property](#212-object-property) 57 | * [2.1.3 Data Property](#213-data-property) 58 | * [2.1.4 Annotation Property](#214-annotation-property) 59 | * [2.1.5 Named Individual](#215-named-individual) 60 | * [2.1.6 Datatype](#216-datatype) 61 | * [2.1.7 Entity Declaration Axiom](#217-entity-declaration-axiom) 62 | * [2.2 Literals](#22-literals) 63 | * [2.3 Annonymous Individuals](#23-annonymous-individuals) 64 | * [3 Class Expressions](#3-class-expressions) 65 | * [3.1 Propositional Connectives and Enumeration of Individuals](#31-propositional-connectives-and-enumeration-of-individuals) 66 | * [3.1.1 Intersection of Class Expressions](#311-intersection-of-class-expressions) 67 | * [3.1.2 Union of Class Expressions](#312-union-of-class-expressions) 68 | * [3.1.3 Complement of Class Expressions](#313-complement-of-class-expressions) 69 | * [3.1.4 Enumeration of Individuals](#314-enumeration-of-individuals) 70 | * [3.2 Object Property Restrictions](#32-object-property-restrictions) 71 | * [3.2.1 Existential Quantification](#321-existential-quantification) 72 | * [3.2.2 Universal Quantification](#322-universal-quantification) 73 | * [3.2.3 Individual Value Restriction](#323-individual-value-restriction) 74 | * [3.2.4 Self-Restriction](#324-self-restriction) 75 | * [3.3 Object Property Cardinality Restrictions](#33-object-property-cardinality-restrictions) 76 | * [3.3.1 Minimum Cardinality](#331-minimum-cardinality) 77 | * [3.3.2 Maximum Cardinality](#332-maximum-cardinality) 78 | * [3.3.3 Exact Cardinality](#333-exact-cardinality) 79 | * [3.4 Data Property Restrictions](#34-data-property-restrictions) 80 | * [3.4.1 Existential Quantification](#341-existential-quantification) 81 | * [3.4.2 Universal Quantification](#342-universal-quantification) 82 | * [3.4.3 Literal Value Restriction](#343-literal-value-restriction) 83 | * [3.5 Data Property Cardinality Restrictions](#35-data-property-cardinality-restrictions) 84 | * [3.5.1 Minimum Cardinality](#351-minimum-cardinality) 85 | * [3.5.2 Maximum Cardinality](#352-maximum-cardinality) 86 | * [3.5.3 Exact Cardinality](#353-exact-cardinality) 87 | * [4 Property Expressions](#4-property-expressions) 88 | * [4.1 Inverse Object Properties](#41-inverse-object-properties) 89 | * [5 Data Ranges](#5-data-ranges) 90 | * [5.1 Intersection of Data Ranges](#51-intersection-of-data-ranges) 91 | * [5.2 Union of Data Ranges](#52-union-of-data-ranges) 92 | * [5.3 Complement of Data Ranges](#53-complement-of-data-ranges) 93 | * [5.4 Enumeration of Literals](#54-enumeration-of-literals) 94 | * [5.5 Datatype Restrictions](#55-datatype-restrictions) 95 | * [6 Axioms](#6-axioms) 96 | * [6.1 Class Expression Axioms](#61-class-expression-axioms) 97 | * [6.1.1 Subclass](#611-subclass) 98 | * [6.1.2 Equivalent Classes](#612-equivalent-classes) 99 | * [6.1.3 Disjoint Classes](#613-disjoint-classes) 100 | * [6.2 Object Property Axioms](#62-object-property-axioms) 101 | * [6.2.1 Object Subproperties](#621-object-subproperties) 102 | * [6.2.2 Equivalent Object Properties](#622-equivalent-object-properties) 103 | * [6.2.3 Disjoint Object Properties](#623-disjoint-object-properties) 104 | * [6.2.4 Inverse Object Properties](#624-inverse-object-properties) 105 | * [6.2.5 Object Property Domain](#625-object-property-domain) 106 | * [6.2.6 Object Property Range](#626-object-property-range) 107 | * [6.2.7 Functional Object Property](#627-functional-object-property) 108 | * [6.2.8 Inverse Functional Object Property](#628-inverse-functional-object-property) 109 | * [6.2.9 Reflexive Object Property](#629-reflexive-object-property) 110 | * [6.2.10 Irreflexive Object Property](#6210-irreflexive-object-property) 111 | * [6.2.11 Symmetric Object Property](#6211-symmetric-object-property) 112 | * [6.2.12 Asymmetric Object Property](#6212-asymmetric-object-property) 113 | * [6.2.13 Transitive Object Property](#6213-transitive-object-property) 114 | * [6.3 Data Property Axioms](#63-data-property-axioms) 115 | * [6.3.1 Data Subproperties](#631-data-subproperties) 116 | * [6.3.2 Equivalent Data Properties](#632-equivalent-data-properties) 117 | * [6.3.3 Disjoint Data Properties](#633-disjoint-data-properties) 118 | * [6.3.4 Data Property Domain](#634-data-property-domain) 119 | * [6.3.5 Data Property Range](#635-data-property-range) 120 | * [6.3.6 Functional Data Properties](#636-functional-data-properties) 121 | * [6.4 Assertions](#64-assertions) 122 | * [6.4.1 Class Assertions](#641-class-assertions) 123 | * [6.4.2 Positive Object Property Assertions](#642-positive-object-property-assertions) 124 | * [6.4.3 Negative Object Property Assertions](#643-negative-object-property-assertions) 125 | * [6.4.4 Positive Data Property Assertions](#644-positive-data-property-assertions) 126 | * [6.4.5 Negative Data Property Assertions](#645-negative-data-property-assertions) 127 | * [6.4.6 Individual Equality](#646-individual-equality) 128 | * [6.4.7 Individual Inequality](#647-individual-inequality) 129 | * [7 Annotations](#7-annotations) 130 | * [7.1 Annotation of Ontologies, Axioms, and other Annotations](#71-annotation-of-ontologies-axioms-and-other-annotations) 131 | * [7.2 Annotation Axioms](#72-annotation-axioms) 132 | * [7.2.1 Annotation Assertions](#721-annotation-assertions) 133 | * [7.2.2 Annotation Subproperties](#722-annotation-subproperties) 134 | * [7.2.3 Annotation Property Domain](#723-annotation-property-domain) 135 | * [7.2.4 Annotation Property Range](#724-annotation-property-range) 136 | 137 | --- 138 | 139 | 140 | 141 | ## 1 Introduction 142 | 143 | This document describes a mapping of OWL 2 ontologies to a Labeled Property Graph (LPG) representation, and vice-versa. The full specification of the mapping is given in the [MAPPING](https://protegeproject.github.io/owl2lpg/mapping) document (e.g., for implementation). 144 | 145 | 146 | 147 | ### 1.1 Main Requirements 148 | 149 | Here we enumerate illustrative examples of the kinds of queries that should be both easily expressible (in [Cypher](https://neo4j.com/developer/cypher-query-language)) and well performant for large knowledge bases. We use the [WebProtégé cloud-based ontology editor](https://webprotege.stanford.edu) as the baseline for performance. The goal is to achieve a query performance that is superior to the performance of executing the same queries in WebProtégé 4.0 (non-LPG). 150 | 151 | Example queries: 152 | 1. Get the axioms in a frame for class `A`. 153 | 2. Get the axioms that mention class `A`. 154 | 3. Get the revisions for an ontology `O`. 155 | 4. Get the revisions that alter the frame for class `A`. 156 | 5. Get the authors of changes to class `A`. 157 | 6. Get the last changes for class `A`. 158 | 7. Get the axioms in the latest revision of ontology `O`. 159 | 160 | ### 1.2 Design Choices 161 | 162 | Our overarching design principle is to prioritize representational **consistency over convenience** (of query writing, of query response time, etc.). Below we describe some key design choices: 163 | 164 | - **The types of OWL objects are specified by the labels on nodes in a LPG**. The types of each OWL object are specified as labels on the nodes that represent those objects, using *reserved keywords* drawn from the OWL 2 specification (see [1.3 Document Conventions](#13-document-conventions)). For example, a node labeled `:Class:Entity:ClassExpression` represents an OWL class entity, which is an atomic class expression. Giving the most specific type along with the more generic type(s) allows us to retrieve, for example, all OWL entities in a LPG, or all OWL class expressions. 165 | 166 | - **OWL axioms are mapped to a LPG using a unique node to represent the axiom type with outgoing edges to its elements**. Each OWL axiom is assigned a unique node in a LPG, with at least one outgoing edge to a node representing an entity expression. For example, an OWL SubClassOf axiom is mapped to a LPG using one `:SubClassOf:Axiom` (multi-label) node and two outgoing edges labeled `subClassExpression` and `superClassExpression` that link to `:ClassExpression` nodes. Representing each OWL axiom with a unique node in a LPG allows the following: 167 | 168 | 1. Encoding OWL axiom annotations in a manner that is consistent with our overall representation of OWL annotations (as `:Literal` or `:IRI` nodes linked to the node that represents the annotation subject). 169 | 2. Attaching versioning information about the axiom (see [Change History](#change-history) for details). 170 | 171 | Similarly, other OWL constructs such as class expressions and data ranges are mapped to a LPG using a node to represent the construct type (e.g., SomeValuesFrom class expression) with outgoing edges to its elements. 172 | 173 | - **Each named OWL entity is mapped to a unique `:Entity` node in a LPG.** Every named OWL 2 entity (class, object property, data property, annotation property, individual or datatype) maps to a unique node in a LPG, which is reused whenever the entity is mentioned in axioms. For example, consider the axioms: 174 | 175 | ``` 176 | AX1: A SubClassOf p some B 177 | AX2: A SubClassOf p some C 178 | AX3: B SubClassOf D 179 | ``` 180 | 181 | The node for class `A` will be reused (and shared) by `AX1` and `AX2`, and the node for class `B` will be reused (and shared) by `AX1` and `AX3`. 182 | 183 | 184 | 185 | 186 | ### 1.3 Document Conventions 187 | 188 | OWL axioms are written out using [OWL Functional-Style syntax](https://www.w3.org/TR/owl2-syntax) , similar to the OWL 2 specification. 189 | 190 | A Labeled Property Graph diagram consists of nodes and edges. A node is depicted as a rectangle with rounded corners. An edge is depicted as either a uni-directional arrow or a bi-directional arrow. 191 | 192 | **Non-Terminal Node** 193 | 194 | node-non-terminal 195 | 196 | **Terminal Node** 197 | 198 | node-terminal 199 | 200 | 201 | 202 | | Non-Terminal Node | Terminal Node | 203 | | ------------------------------------------------------------ | ------------------------------------------------------------ | 204 | | node-class-expression | 1) **Named Class**. See [Section 2.1.1 Class](#211-class).
2) **Complex Class Expressions**. See [Section 3 Class Expressions](#3-class-expressions). | 205 | | node-object-property-expression | 1) **Named Object Property**. See [Section 2.1.2 Object Property](#212-object-property)
2) **Complex Object Property Expressions**. See [Section 4 Property Expressions](#4-property-expressions). | 206 | | node-data-property-expression | **Named Data Property**. See [Section 2.1.3 Data Property](#213-data-property). | 207 | | node-individual | 1) **Named Individual**. See [Section 2.1.5 Named Individual](#215-named-individual).
2) **Annonymous Individual**. See [Section 2.3 Annonymous Individuals](#23-annonymous-individuals). | 208 | | node-data-range | **Data Range Expressions**. See [Section 5 Data Ranges](#5-data-ranges). | 209 | 210 | 211 | 212 | ## 2 Entities, Literals, and Anonymous Individuals 213 | 214 | ### 2.1 Entities 215 | 216 | #### 2.1.1 Class 217 | 218 | *Classes* can be understood as sets of individuals. 219 | 220 | LPG Diagram: 221 | 222 | node-entity-class 223 | 224 | 225 | 226 | #### 2.1.2 Object Property 227 | 228 | *Object properties* connect pairs of individuals. 229 | 230 | LPG Diagram: 231 | 232 | node-entity-object-property 233 | 234 | 235 | 236 | #### 2.1.3 Data Property 237 | 238 | *Data properties* connect individuals with literals. In some knowledge representation systems, functional data properties are called *attributes*. 239 | 240 | LPG Diagram: 241 | 242 | node-entity-data-property 243 | 244 | 245 | 246 | #### 2.1.4 Annotation Property 247 | 248 | *Annotation properties* can be used to provide an annotation for an ontology, axiom, or an IRI. The structure of annotations is further described in [Annotations](#7-annotations). 249 | 250 | LPG Diagram: 251 | 252 | node-entity-annotation-property 253 | 254 | 255 | 256 | #### 2.1.5 Named Individual 257 | 258 | *Individuals* represent actual objects from the domain. There are two types of individuals in the syntax of OWL 2. *Named individuals* are given an explicit name that can be used in any ontology to refer to the same object. *Named individuals* are identified using an IRI. 259 | 260 | LPG Diagram: 261 | 262 | node-entity-named-individual 263 | 264 | 265 | 266 | #### 2.1.6 Datatype 267 | 268 | *Datatypes* are entities that refer to sets of data values. Thus, datatypes are analogous to classes, the main difference being that the former contain data values such as strings and numbers, rather than individuals. Datatypes are a kind of data range, which allows them to be used in restrictions. As explained in [Data Ranges](#5-data-ranges), each data range is associated with an arity; for datatypes, the arity is always one. 269 | 270 | The built-in datatype *rdfs:Literal* denotes any set of data values that contains the union of the value spaces of all datatypes. 271 | 272 | LPG Diagram: 273 | 274 | node-entity-datatype 275 | 276 | 277 | 278 | #### 2.1.7 Entity Declaration Axiom 279 | 280 | In OWL 2, declarations are a type of axiom; thus, to declare an entity in an ontology, one can simply include the appropriate axiom in the ontology. These axioms are nonlogical in the sense that they do not affect the consequences of an OWL 2 ontology. 281 | 282 | LPG Diagram: 283 | 284 | axiom-entity-declaration 285 | 286 | 287 | 288 | ### 2.2 Literals 289 | 290 | *Literals* represent data values such as particular strings or integers. Each literal consists of a lexical form, which is a string, a datatype and an optional language tag. A literal consisting of a lexical form "abc" and a datatype identified by the IRI *datatypeIRI* is written as "abc"^^*datatypeIRI*. Furthermore, literals whose datatype is *rdf:PlainLiteral* can be abbreviated as plain RDF literals. 291 | 292 | LPG Diagram: 293 | 294 | node-literal 295 | 296 | 297 | 298 | ### 2.3 Annonymous Individuals 299 | 300 | If an individual is not expected to be used outside a particular ontology, one can use an *anonymous individual*, which is identified by a local node ID rather than a global IRI. 301 | 302 | LPG Diagram: 303 | 304 | node-annonymous-individual 305 | 306 | 307 | 308 | ## 3 Class Expressions 309 | 310 | ### 3.1 Propositional Connectives and Enumeration of Individuals 311 | 312 | #### 3.1.1 Intersection of Class Expressions 313 | 314 | An *intersection* class expression `ObjectIntersectionOf( CE1 ... CEn )` contains all individuals that are instances of all class expressions `CEi` for 1 ≤ i ≤ n. 315 | 316 | OWL 2 Notation: 317 | 318 | ​ **ObjectIntersectionOf** := 'ObjectIntersectionOf' '(' **ClassExpression** **ClassExpression** ')' 319 | 320 | LPG Diagram: 321 | 322 | class-expression-object-intersection 323 | 324 | 325 | 326 | #### 3.1.2 Union of Class Expressions 327 | 328 | A *union* class expression `ObjectUnionOf( CE1 ... CEn )` contains all individuals that are instances of at least one class expression `CEi` for 1 ≤ i ≤ n. 329 | 330 | OWL 2 Notation: 331 | 332 | ​ **ObjectUnionOf** := 'ObjectUnionOf' '(' **ClassExpression** **ClassExpression** ')' 333 | 334 | LPG Diagram: 335 | 336 | class-expression-object-union 337 | 338 | 339 | 340 | #### 3.1.3 Complement of Class Expressions 341 | 342 | A complement class expression `ObjectComplementOf( CE )` contains all individuals that are not instances of the class expression `CE`. 343 | 344 | OWL 2 Notation: 345 | 346 | ​ **ObjectComplementOf** := 'ObjectComplementOf' '(' **ClassExpression** ')' 347 | 348 | LPG Diagram: 349 | 350 | class-expression-object-complement 351 | 352 | 353 | 354 | #### 3.1.4 Enumeration of Individuals 355 | 356 | An enumeration of individuals `ObjectOneOf( a1 ... an )` contains exactly the individuals `ai` with 1 ≤ i ≤ n. 357 | 358 | OWL 2 Notation: 359 | 360 | ​ **ObjectOneOf** := 'ObjectOneOf' '(' **Individual** { **Individual** }')' 361 | 362 | LPG Diagram: 363 | 364 | class-expression-object-one-of 365 | 366 | 367 | 368 | ### 3.2 Object Property Restrictions 369 | 370 | #### 3.2.1 Existential Quantification 371 | 372 | An *existential* class expression `ObjectSomeValuesFrom( OPE CE )` consists of an object property expression `OPE` and a class expression `CE`, and it contains all those individuals that are connected by `OPE` to an individual that is an instance of `CE`. 373 | 374 | OWL 2 Notation: 375 | 376 | ​ **ObjectSomeValuesFrom** := 'ObjectSomeValuesFrom' '(' **ObjectPropertyExpression** **ClassExpression** ')' 377 | 378 | LPG Diagram: 379 | 380 | class-expression-object-some-values 381 | 382 | 383 | 384 | #### 3.2.2 Universal Quantification 385 | 386 | A *universal* class expression `ObjectAllValuesFrom( OPE CE )` consists of an object property expression `OPE` and a class expression `CE`, and it contains all those individuals that are connected by `OPE` only to individuals that are instances of `CE`. 387 | 388 | OWL 2 Notation: 389 | 390 | ​ **ObjectAllValuesFrom** := 'ObjectAllValuesFrom' '(' **ObjectPropertyExpression** **ClassExpression** ')' 391 | 392 | LPG Diagram: 393 | 394 | class-expression-object-all-values 395 | 396 | 397 | 398 | #### 3.2.3 Individual Value Restriction 399 | 400 | A has-value class expression `ObjectHasValue( OPE a )` consists of an object property expression `OPE` and an individual a, and it contains all those individuals that are connected by `OPE` to `a`. 401 | 402 | OWL 2 Notation: 403 | 404 | ​ **ObjectHasValue** := 'ObjectHasValue' '(' **ObjectPropertyExpression** **Individual** ')' 405 | 406 | LPG Diagram: 407 | 408 | class-expression-object-has-value 409 | 410 | 411 | 412 | #### 3.2.4 Self-Restriction 413 | 414 | A self-restriction `ObjectHasSelf( OPE )` consists of an object property expression `OPE`, and it contains all those individuals that are connected by `OPE` to themselves. 415 | 416 | OWL 2 Notation: 417 | 418 | ​ **ObjectHasSelf** := 'ObjectHasSelf' '(' **ObjectPropertyExpression** ')' 419 | 420 | LPG Diagram: 421 | 422 | class-expression-object-has-self 423 | 424 | 425 | 426 | ### 3.3 Object Property Cardinality Restrictions 427 | 428 | #### 3.3.1 Minimum Cardinality 429 | 430 | A *minimum cardinality* expression `ObjectMinCardinality( n OPE CE )` consists of a nonnegative integer `n`, an object property expression `OPE`, and a class expression `CE`, and it contains all those individuals that are connected by `OPE` to at least `n` different individuals that are instances of `CE`. If `CE` is missing, it is taken to be *owl:Thing*. 431 | 432 | OWL 2 Notation: 433 | 434 | ​ **ObjectMinCardinality** := 'ObjectMinCardinality' '(' **nonNegativeInteger** **ObjectPropertyExpression** [ **ClassExpression** ] ')' 435 | 436 | LPG Diagram: 437 | 438 | class-expression-object-min-cardinality 439 | 440 | 441 | 442 | #### 3.3.2 Maximum Cardinality 443 | 444 | A *maximum cardinality* expression `ObjectMaxCardinality( n OPE CE )` consists of a nonnegative integer `n`, an object property expression `OPE`, and a class expression `CE`, and it contains all those individuals that are connected by `OPE` to at most `n` different individuals that are instances of `CE`. If `CE` is missing, it is taken to be *owl:Thing*. 445 | 446 | OWL 2 Notation: 447 | 448 | ​ **ObjectMaxCardinality** := 'ObjectMaxCardinality' '(' **nonNegativeInteger** **ObjectPropertyExpression** [ **ClassExpression** ] ')' 449 | 450 | LPG Diagram: 451 | 452 | class-expression-object-max-cardinality 453 | 454 | 455 | 456 | #### 3.3.3 Exact Cardinality 457 | 458 | An *exact cardinality* expression `ObjectExactCardinality( n OPE CE )` consists of a nonnegative integer `n`, an object property expression `OPE`, and a class expression `CE`, and it contains all those individuals that are connected by `OPE` to exactly `n` different individuals that are instances of `CE`. If `CE` is missing, it is taken to be *owl:Thing*. 459 | 460 | OWL 2 Notation: 461 | 462 | ​ **ObjectExactCardinality** := 'ObjectExactCardinality' '(' **nonNegativeInteger** **ObjectPropertyExpression** [ **ClassExpression** ] ')' 463 | 464 | LPG Diagram: 465 | 466 | class-expression-object-exact-cardinality 467 | 468 | 469 | 470 | ### 3.4 Data Property Restrictions 471 | 472 | #### 3.4.1 Existential Quantification 473 | 474 | An *existential* class expression `DataSomeValuesFrom( DPE1 ... DPEn DR )` consists of `n` data property expressions `DPEi`, 1 ≤ i ≤ n, and a data range `DR` whose arity *must* be `n`. Such a class expression contains all those individuals that are connected by `DPi` to literals `lti`, 1 ≤ i ≤ n, such that the tuple `( lt1 , ..., ltn )` is in `DR`. 475 | 476 | OWL 2 Notation: 477 | 478 | ​ **DataSomeValuesFrom** := 'DataSomeValuesFrom' '(' **DataPropertyExpression** { **DataPropertyExpression** } **DataRange** ')' 479 | 480 | LPG Diagram: 481 | 482 | class-expression-data-some-values 483 | 484 | 485 | 486 | #### 3.4.2 Universal Quantification 487 | 488 | A *universal* class expression `DataAllValuesFrom( DPE1 ... DPEn DR )` consists of `n` data property expressions `DPEi`, 1 ≤ i ≤ n, and a data range `DR` whose arity *must* be `n`. Such a class expression contains all those individuals that are connected by `DPi` only to literals `lti`, 1 ≤ i ≤ n, such that each tuple `( lt1 , ..., ltn )` is in `DR`. 489 | 490 | OWL 2 Notation: 491 | 492 | ​ **DataAllValuesFrom** := 'DataAllValuesFrom' '(' **DataPropertyExpression** { **DataPropertyExpression** } **DataRange** ')' 493 | 494 | LPG Diagram: 495 | 496 | class-expression-data-all-values 497 | 498 | 499 | 500 | #### 3.4.3 Literal Value Restriction 501 | 502 | A has-value class expression `DataHasValue( DP lt )` consists of a data property `DP` and a literal `lt`, and it contains all those individuals that are connected by `DP` to `lt`. 503 | 504 | OWL 2 Notation: 505 | 506 | ​ **DataHasValue** := 'DataHasValue' '(' **DataProperty** **Literal** ')' 507 | 508 | LPG Diagram: 509 | 510 | class-expression-data-has-value 511 | 512 | 513 | 514 | ### 3.5 Data Property Cardinality Restrictions 515 | 516 | #### 3.5.1 Minimum Cardinality 517 | 518 | A *minimum cardinality* expression `DataMinCardinality( n DPE DR )` consists of a nonnegative integer `n`, a data property expression `DPE`, and a unary data range `DR`, and it contains all those individuals that are connected by `DPE` to at least `n` different literals in `DR`. If `DR` is not present, it is taken to be *rdfs:Literal*. 519 | 520 | OWL 2 Notation: 521 | 522 | ​ **DataMinCardinality** := 'DataMinCardinality' '(' **nonNegativeInteger** **DataPropertyExpression** [ **DataRange** ] ')' 523 | 524 | LPG Diagram: 525 | 526 | class-expression-data-cardinalities 527 | 528 | 529 | 530 | #### 3.5.2 Maximum Cardinality 531 | 532 | A *maximum cardinality* expression `DataMaxCardinality( n DPE DR )` consists of a nonnegative integer `n`, a data property expression `DPE`, and a unary data range `DR`, and it contains all those individuals that are connected by `DPE` to at most `n` different literals in `DR`. If `DR` is not present, it is taken to be *rdfs:Literal*. 533 | 534 | OWL 2 Notation: 535 | 536 | ​ **DataMaxCardinality** := 'DataMaxCardinality' '(' **nonNegativeInteger** **DataPropertyExpression** [ **DataRange** ] ')' 537 | 538 | LPG Diagram: 539 | 540 | class-expression-data-max-cardinality 541 | 542 | 543 | 544 | #### 3.5.3 Exact Cardinality 545 | 546 | An *exact cardinality* expression `DataExactCardinality( n DPE DR )` consists of a nonnegative integer `n`, a data property expression `DPE`, and a unary data range `DR`, and it contains all those individuals that are connected by `DPE` to exactly `n` different literals in `DR`. If `DR` is not present, it is taken to be *rdfs:Literal*. 547 | 548 | OWL 2 Notation: 549 | 550 | ​ **DataExactCardinality** := 'DataExactCardinality' '(' **nonNegativeInteger** **DataPropertyExpression** [ **DataRange** ] ')' 551 | 552 | LPG Diagram: 553 | 554 | class-expression-data-exact-cardinality 555 | 556 | 557 | 558 | ## 4 Property Expressions 559 | 560 | ### 4.1 Inverse Object Properties 561 | 562 | An inverse object property expression ObjectInverseOf( P ) connects an individual I1 with I2 if and only if the object property P connects I2 with I1. 563 | 564 | OWL 2 Notation: 565 | 566 | ​ **InverseObjectProperty** := 'ObjectInverseOf' '(' **ObjectProperty** ')' 567 | 568 | LPG Diagram: 569 | 570 | property-expression-inverse-objectproperty 571 | 572 | 573 | 574 | ## 5 Data Ranges 575 | 576 | ### 5.1 Intersection of Data Ranges 577 | 578 | An *intersection* data range `DataIntersectionOf( DR1 ... DRn )` contains all tuples of literals that are contained in each data range `DRi` for 1 ≤ i ≤ n. All data ranges `DRi` *must* be of the same arity, and the resulting data range is of that arity as well. 579 | 580 | OWL 2 Notation: 581 | 582 | **DataIntersectionOf** := 'DataIntersectionOf' '(' **DataRange** **DataRange** { **DataRange** } ')' 583 | 584 | LPG Diagram: 585 | 586 | data-ranges-intersection 587 | 588 | ### 5.2 Union of Data Ranges 589 | 590 | A *union* data range `DataUnionOf( DR1 ... DRn )` contains all tuples of literals that are contained in the at least one data range `DRi` for 1 ≤ i ≤ n. All data ranges `DRi` *must* be of the same arity, and the resulting data range is of that arity as well. 591 | 592 | OWL 2 Notation: 593 | 594 | **DataUnionOf** := 'DataUnionOf' '(' **DataRange** **DataRange** { **DataRange** } ')' 595 | 596 | LPG Diagram: 597 | 598 | data-ranges-union 599 | 600 | ### 5.3 Complement of Data Ranges 601 | 602 | A complement data range `DataComplementOf( DR )` contains all tuples of literals that are not contained in the data range `DR`. The resulting data range has the arity equal to the arity of `DR`. 603 | 604 | OWL 2 Notation: 605 | 606 | **DataComplementOf** := 'DataComplementOf' '(' **DataRange** ')' 607 | 608 | LPG Diagram: 609 | 610 | data-ranges-complement 611 | 612 | 613 | 614 | ### 5.4 Enumeration of Literals 615 | 616 | An enumeration of literals `DataOneOf( lt1 ... ltn )` contains exactly the explicitly specified literals `lti` with 1 ≤ i ≤ n. The resulting data range has arity one. 617 | 618 | OWL 2 Notation: 619 | 620 | **DataOneOf** := 'DataOneOf' '(' **Literal** { **Literal** } ')' 621 | 622 | LPG Diagram: 623 | 624 | data-ranges-enumeration-of-literals 625 | 626 | 627 | 628 | ### 5.5 Datatype Restrictions 629 | 630 | A datatype restriction `DatatypeRestriction( DT F1 lt1 ... Fn ltn )` consists of a unary datatype `DT` and `n` pairs `( Fi , lti )`. The resulting data range is unary and is obtained by restricting the value space of `DT` according to the semantics of all `( Fi , vi )` (multiple pairs are interpreted conjunctively), where `vi` are the data values of the literals `lti`. 631 | 632 | In an OWL 2 DL ontology, each pair `( Fi , vi )` *must* be contained in the facet space of `DT` (see [Datatype Maps](https://www.w3.org/TR/owl2-syntax/#Datatype_Maps) from the OWL 2 specification document). 633 | 634 | OWL 2 Notation: 635 | 636 | **DatatypeRestriction** := 'DatatypeRestriction' '(' **Datatype** **constrainingFacet** **restrictionValue** { **constrainingFacet** **restrictionValue** } ')' 637 | 638 | **constrainingFacet** := **IRI** 639 | 640 | **restrictionValue** := **Literal** 641 | 642 | LPG Diagram: 643 | 644 | data-ranges-datatype-restriction 645 | 646 | 647 | 648 | ## 6 Axioms 649 | 650 | ### 6.1 Class Expression Axioms 651 | 652 | #### 6.1.1 Subclass 653 | 654 | A subclass axiom `SubClassOf( CE1 CE2 )` states that the class expression `CE1` is a subclass of the class expression `CE2`. Roughly speaking, this states that `CE1` is more specific than `CE2`. 655 | 656 | OWL 2 Notation: 657 | 658 | ​ **SubClassOf** := 'SubClassOf' '(' { **Annotation** } **subClassExpression** **superClassExpression** ')' 659 | 660 | ​ **subClassExpression** := **ClassExpression** 661 | 662 | ​ **superClassExpression** := **ClassExpression** 663 | 664 | LPG Diagram: 665 | 666 | axiom-subclass-of 667 | 668 | 669 | 670 | #### 6.1.2 Equivalent Classes 671 | 672 | An equivalent classes axiom `EquivalentClasses( CE1 ... CEn )` states that all of the class expressions `CEi`, 1 ≤ i ≤ n, are semantically equivalent to each other. This axiom allows one to use each `CEi` as a synonym for each `CEj` — that is, in any expression in the ontology containing such an axiom, `CEi` can be replaced with `CEj` without affecting the meaning of the ontology. 673 | 674 | OWL 2 Notation: 675 | 676 | ​ **EquivalentClasses** := 'EquivalentClasses' '(' { **Annotation** } **ClassExpression** **ClassExpression** { **ClassExpression** } ')' 677 | 678 | LPG Diagram: 679 | 680 | axiom-equivalent-classes 681 | 682 | 683 | 684 | #### 6.1.3 Disjoint Classes 685 | 686 | A disjoint classes axiom `DisjointClasses( CE1 ... CEn )` states that all of the class expressions `CEi`, 1 ≤ i ≤ n, are pairwise disjoint; that is, no individual can be at the same time an instance of both `CEi` and `CEj` for i ≠ j. 687 | 688 | OWL 2 Notation: 689 | 690 | ​ **DisjointClasses** := 'DisjointClasses' '(' { **Annotation** } **ClassExpression** **ClassExpression** { **ClassExpression** } ')' 691 | 692 | LPG Diagram: 693 | 694 | axiom-disjoint-classes 695 | 696 | 697 | 698 | ### 6.2 Object Property Axioms 699 | 700 | #### 6.2.1 Object Subproperties 701 | 702 | An object subproperty axiom `SubObjectPropertyOf( OPE1 OPE2 )`. This axiom states that the object property expression `OPE1` is a subproperty of the object property expression `OPE2` — that is, if an individual `x` is connected by `OPE1` to an individual `y`, then`x` is also connected by `OPE2` to `y`. 703 | 704 | OWL 2 Notation: 705 | 706 | ​ **SubObjectPropertyOf** := 'SubObjectPropertyOf' '(' { **Annotation** } **subObjectPropertyExpression** **superObjectPropertyExpression** ')' 707 | 708 | ​ **subObjectPropertyExpression** := **ObjectPropertyExpression** 709 | 710 | ​ **superObjectPropertyExpression** := **ObjectPropertyExpression** 711 | 712 | LPG Diagram: 713 | 714 | axiom-subobjectproperty-of 715 | 716 | 717 | 718 | #### 6.2.2 Equivalent Object Properties 719 | 720 | An equivalent object properties axiom `EquivalentObjectProperties( OPE1 ... OPEn )` states that all of the object property expressions `OPEi`, 1 ≤ i ≤ n, are semantically equivalent to each other. This axiom allows one to use each `OPEi` as a synonym for each `OPEj` — that is, in any expression in the ontology containing such an axiom, `OPEi` can be replaced with `OPEj` without affecting the meaning of the ontology. 721 | 722 | OWL 2 Notation: 723 | 724 | ​ **EquivalentObjectProperties** := 'EquivalentObjectProperties' '(' { **Annotation** } **ObjectPropertyExpression** **ObjectPropertyExpression** { **ObjectPropertyExpression** } ')' 725 | 726 | LPG Diagram: 727 | 728 | axiom-equivalent-objectproperties 729 | 730 | 731 | 732 | #### 6.2.3 Disjoint Object Properties 733 | 734 | A disjoint object properties axiom `DisjointObjectProperties( OPE1 ... OPEn )` states that all of the object property expressions `OPEi`, 1 ≤ i ≤ n, are pairwise disjoint; that is, no individual `x` can be connected to an individual `y` by both `OPEi` and `OPEj` for i ≠ j. 735 | 736 | OWL 2 Notation: 737 | 738 | ​ **DisjointObjectProperties** := 'DisjointObjectProperties' '(' { **Annotation** } **ObjectPropertyExpression** **ObjectPropertyExpression** { **ObjectPropertyExpression** } ')' 739 | 740 | LPG Diagram: 741 | 742 | axiom-disjoint-objectproperties 743 | 744 | 745 | 746 | #### 6.2.4 Inverse Object Properties 747 | 748 | An inverse object properties axiom `InverseObjectProperties( OPE1 OPE2 )` states that the object property expression `OPE1` is an inverse of the object property expression `OPE2`. Thus, if an individual `x` is connected by `OPE1` to an individual `y`, then `y` is also connected by `OPE2` to `x`, and vice versa. 749 | 750 | OWL 2 Notation: 751 | 752 | ​ **InverseObjectProperties** := 'InverseObjectProperties' '(' { **Annotation** } **ObjectPropertyExpression** **ObjectPropertyExpression** ')' 753 | 754 | LPG Diagram: 755 | 756 | axiom-inverse-objectproperties 757 | 758 | 759 | 760 | #### 6.2.5 Object Property Domain 761 | 762 | An object property *domain* axiom `ObjectPropertyDomain( OPE CE )` states that the domain of the object property expression `OPE` is the class expression `CE` — that is, if an individual `x` is connected by `OPE` with some other individual, then `x` is an instance of `CE`. 763 | 764 | OWL 2 Notation: 765 | 766 | ​ **ObjectPropertyDomain** := 'ObjectPropertyDomain' '(' { **Annotation** } **ObjectPropertyExpression** **ClassExpression** ')' 767 | 768 | LPG Diagram: 769 | 770 | axiom-objectproperty-domain 771 | 772 | 773 | 774 | #### 6.2.6 Object Property Range 775 | 776 | An object property *range* axiom `ObjectPropertyRange( OPE CE )` states that the range of the object property expression `OPE` is the class expression `CE` — that is, if some individual is connected by `OPE` with an individual `x`, then `x` is an instance of `CE`. 777 | 778 | OWL 2 Notation: 779 | 780 | ​ **ObjectPropertyRange** := 'ObjectPropertyRange' '(' { **Annotation** } **ObjectPropertyExpression** **ClassExpression** ')' 781 | 782 | LPG Diagram: 783 | 784 | axiom-objectproperty-range 785 | 786 | 787 | 788 | #### 6.2.7 Functional Object Property 789 | 790 | An object property *functionality* axiom `FunctionalObjectProperty( OPE )` states that the object property expression `OPE` is functional — that is, for each individual `x`, there can be at most one distinct individual `y` such that `x` is connected by `OPE` to `y`. 791 | 792 | OWL 2 Notation: 793 | 794 | ​ **FunctionalObjectProperty** := 'FunctionalObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 795 | 796 | LPG Diagram: 797 | 798 | axiom-functional-objectproperty 799 | 800 | 801 | 802 | #### 6.2.8 Inverse Functional Object Property 803 | 804 | An object property *inverse functionality* axiom `InverseFunctionalObjectProperty( OPE )` states that the object property expression `OPE` is inverse-functional — that is, for each individual `x`, there can be at most one individual `y` such that `y` is connected by `OPE` with `x`. 805 | 806 | OWL 2 Notation: 807 | 808 | ​ **InverseFunctionalObjectProperty** := 'InverseFunctionalObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 809 | 810 | LPG Diagram: 811 | 812 | axiom-inverse-functional-objectproperty 813 | 814 | 815 | 816 | #### 6.2.9 Reflexive Object Property 817 | 818 | An object property *reflexivity* axiom `ReflexiveObjectProperty( OPE )` states that the object property expression `OPE` is reflexive — that is, each individual is connected by `OPE` to itself. 819 | 820 | OWL 2 Notation: 821 | 822 | ​ **ReflexiveObjectProperty** := 'ReflexiveObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 823 | 824 | LPG Diagram: 825 | 826 | axiom-reflexive-objectproperty 827 | 828 | 829 | 830 | #### 6.2.10 Irreflexive Object Property 831 | 832 | An object property *irreflexivity* axiom `IrreflexiveObjectProperty( OPE )` states that the object property expression `OPE` is irreflexive — that is, no individual is connected by `OPE` to itself. 833 | 834 | OWL 2 Notation: 835 | 836 | ​ **IrreflexiveObjectProperty** := 'IrreflexiveObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 837 | 838 | LPG Diagram: 839 | 840 | axiom-irreflexive-objectproperty 841 | 842 | 843 | 844 | #### 6.2.11 Symmetric Object Property 845 | 846 | An object property *symmetry* axiom `SymmetricObjectProperty( OPE )` states that the object property expression `OPE` is symmetric — that is, if an individual `x` is connected by `OPE` to an individual `y`, then `y` is also connected by `OPE` to `x`. 847 | 848 | OWL 2 Notation: 849 | 850 | ​ **SymmetricObjectProperty** := 'SymmetricObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 851 | 852 | LPG Diagram: 853 | 854 | axiom-symmetric-objectproperty 855 | 856 | 857 | 858 | #### 6.2.12 Asymmetric Object Property 859 | 860 | An object property *asymmetry* axiom `AsymmetricObjectProperty( OPE )` states that the object property expression `OPE` is asymmetric — that is, if an individual `x` is connected by `OPE` to an individual `y`, then `y` cannot be connected by `OPE` to `x`. 861 | 862 | OWL 2 Notation: 863 | 864 | ​ **AsymmetricObjectProperty** := 'AsymmetricObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 865 | 866 | LPG Diagram: 867 | 868 | axiom-asymmetric-objectproperty 869 | 870 | 871 | 872 | #### 6.2.13 Transitive Object Property 873 | 874 | An object property *transitivity* axiom `TransitiveObjectProperty( OPE )` states that the object property expression `OPE` is transitive — that is, if an individual `x` is connected by `OPE` to an individual `y` that is connected by `OPE` to an individual `z`, then `x` is also connected by `OPE` to `z`. 875 | 876 | OWL 2 Notation: 877 | 878 | ​ **TransitiveObjectProperty** := 'TransitiveObjectProperty' '(' { **Annotation** } **ObjectPropertyExpression** ')' 879 | 880 | LPG Diagram: 881 | 882 | axiom-transitive-objectproperty 883 | 884 | 885 | 886 | ### 6.3 Data Property Axioms 887 | 888 | #### 6.3.1 Data Subproperties 889 | 890 | A data subproperty axiom `SubDataPropertyOf( DP1 DP2 )` states that the data property `DP1` is a subproperty of the data property `DP2` — that is, if an individual `x` is connected by `DP1` to a literal `y`, then `x` is connected by `DP2` to `y` as well. 891 | 892 | OWL 2 Notation: 893 | 894 | ​ **SubDataPropertyOf** := 'SubDataPropertyOf' '(' { **Annotation** } **subDataProperty** **superDataProperty** ')' 895 | 896 | ​ **subDataProperty** := **DataProperty** 897 | 898 | ​ **superDataProperty** := **DataProperty** 899 | 900 | LPG Diagram: 901 | 902 | axiom-subdataproperty-of 903 | 904 | 905 | 906 | #### 6.3.2 Equivalent Data Properties 907 | 908 | An equivalent data properties axiom `EquivalentDataProperties( DP1 ... DPn )` states that all the data property `DPi`, 1 ≤ i ≤ n, are semantically equivalent to each other. This axiom allows one to use each `DPi` as a synonym for each `DPj` — that is, in any expression in the ontology containing such an axiom, `DPi` can be replaced with `DPj` without affecting the meaning of the ontology. 909 | 910 | OWL 2 Notation: 911 | 912 | ​ **EquivalentDataProperties** := 'EquivalentDataProperties' '(' { **Annotation** } **DataProperty** **DataProperty** { **DataProperty** } ')' 913 | 914 | LPG Diagram: 915 | 916 | axiom-equivalent-dataproperties 917 | 918 | 919 | 920 | #### 6.3.3 Disjoint Data Properties 921 | 922 | A disjoint data properties axiom `DisjointDataProperties( DP1 ... DPn )` states that all of the data property `DPi`, 1 ≤ i ≤ n, are pairwise disjoint; that is, no individual `x` can be connected to a literal `y` by both `DPi` and `DPj` for i ≠ j. 923 | 924 | OWL 2 Notation: 925 | 926 | ​ **DisjointDataProperties** := 'DisjointDataProperties' '(' { **Annotation** } **DataProperty** **DataProperty** { **DataProperty** } ')' 927 | 928 | LPG Diagram: 929 | 930 | axiom-disjoint-dataproperties 931 | 932 | 933 | 934 | #### 6.3.4 Data Property Domain 935 | 936 | A data property domain axiom `DataPropertyDomain( DP CE )` states that the domain of the data property `DP` is the class expression `CE` — that is, if an individual `x` is connected by `DP` with some literal, then `x` is an instance of `CE`. 937 | 938 | OWL 2 Notation: 939 | 940 | ​ **DataPropertyDomain** := 'DataPropertyDomain' '(' { **Annotation** } **DataProperty** **ClassExpression** ')' 941 | 942 | LPG Diagram: 943 | 944 | axiom-dataproperty-domain 945 | 946 | 947 | 948 | #### 6.3.5 Data Property Range 949 | 950 | A data property range axiom `DataPropertyRange( DP DR )` states that the range of the data property `DP` is the data range `DR` — that is, if some individual is connected by `DP` with a literal `x`, then `x` is in `DR`. The arity of `DR` *must* be one. 951 | 952 | OWL 2 Notation: 953 | 954 | ​ **DataPropertyRange** := 'DataPropertyRange' '(' { **Annotation** } **DataProperty** **DataRange** ')' 955 | 956 | LPG Diagram: 957 | 958 | axiom-dataproperty-range 959 | 960 | 961 | 962 | #### 6.3.6 Functional Data Properties 963 | 964 | A data property functionality axiom `FunctionalDataProperty( DP )` states that the data property `DP` is functional — that is, for each individual `x`, there can be at most one distinct literal `y` such that `x` is connected by `DP` with `y`. 965 | 966 | OWL 2 Notation: 967 | 968 | ​ **FunctionalDataProperty** := 'FunctionalDataProperty' '(' { **Annotation** } **DataProperty** ')' 969 | 970 | LPG Diagram: 971 | 972 | axiom-functional-dataproperty 973 | 974 | 975 | 976 | ### 6.4 Assertions 977 | 978 | #### 6.4.1 Class Assertions 979 | 980 | A class assertion `ClassAssertion( CE a )` states that the individual `a` is an instance of the class expression `CE`. 981 | 982 | OWL 2 Notation: 983 | 984 | ​ **ClassAssertion** := 'ClassAssertion' '(' { **Annotation** } **ClassExpression** **Individual** ')' 985 | 986 | LPG Diagram: 987 | 988 | axiom-class-assertion 989 | 990 | 991 | 992 | #### 6.4.2 Positive Object Property Assertions 993 | 994 | A positive object property assertion `ObjectPropertyAssertion( OPE a1 a2 )` states that the individual `a1` is connected by the object property expression `OPE` to the individual `a2`. 995 | 996 | OWL 2 Notation: 997 | 998 | ​ **ObjectPropertyAssertion** := 'ObjectPropertyAssertion' '(' { **Annotation** } **ObjectPropertyExpression** **sourceIndividual** **targetIndividual** ')' 999 | 1000 | LPG Diagram: 1001 | 1002 | axiom-objectproperty-assertion 1003 | 1004 | 1005 | 1006 | #### 6.4.3 Negative Object Property Assertions 1007 | 1008 | A negative object property assertion `NegativeObjectPropertyAssertion( OPE a1 a2 )` states that the individual `a1` is not connected by the object property expression `OPE` to the individual `a2`. 1009 | 1010 | OWL 2 Notation: 1011 | 1012 | ​ **NegativeObjectPropertyAssertion** := 'NegativeObjectPropertyAssertion' '(' { **Annotation** } **ObjectPropertyExpression** **sourceIndividual** **targetIndividual** ')' 1013 | 1014 | LPG Diagram: 1015 | 1016 | axiom-negative-objectproperty-assertion 1017 | 1018 | 1019 | 1020 | #### 6.4.4 Positive Data Property Assertions 1021 | 1022 | A positive data property assertion `DataPropertyAssertion( DP a lt )` states that the individual a is connected by the data property `DP` to the literal `lt`. 1023 | 1024 | OWL 2 Notation: 1025 | 1026 | ​ **DataPropertyAssertion** := 'DataPropertyAssertion' '(' { **Annotation** } **DataPropertyExpression** **sourceIndividual** **targetValue** ')' 1027 | 1028 | LPG Diagram: 1029 | 1030 | axiom-dataproperty-assertion 1031 | 1032 | 1033 | 1034 | #### 6.4.5 Negative Data Property Assertions 1035 | 1036 | A negative data property assertion `NegativeDataPropertyAssertion( DP a lt )` states that the individual a is not connected by the data property `DP` to the literal `lt`. 1037 | 1038 | OWL 2 Notation: 1039 | 1040 | ​ **NegativeDataPropertyAssertion** := 'NegativeDataPropertyAssertion' '(' { **Annotation** } **DataPropertyExpression** **sourceIndividual** **targetValue** ')' 1041 | 1042 | LPG Diagram: 1043 | 1044 | axiom-negative-dataproperty-assertion 1045 | 1046 | 1047 | 1048 | #### 6.4.6 Individual Equality 1049 | 1050 | An individual equality axiom `SameIndividual( a1 ... an )` states that all of the individuals `ai`, 1 ≤ i ≤ n, are equal to each other. This axiom allows one to use each `ai` as a synonym for each `aj` — that is, in any expression in the ontology containing such an axiom, `ai` can be replaced with `aj` without affecting the meaning of the ontology. 1051 | 1052 | OWL 2 Notation: 1053 | 1054 | ​ **SameIndividual** := 'SameIndividual' '(' { **Annotation** } **Individual** **Individual** { **Individual** } ')' 1055 | 1056 | LPG Diagram: 1057 | 1058 | axiom-same-individual 1059 | 1060 | #### 6.4.7 Individual Inequality 1061 | 1062 | An individual inequality axiom `DifferentIndividuals( a1 ... an )` states that all of the individuals `ai`, 1 ≤ i ≤ n, are different from each other; that is, no individuals `ai` and `aj` with i ≠ j can be derived to be equal. This axiom can be used to axiomatize the *unique name assumption* — the assumption that all different individual names denote different individuals. 1063 | 1064 | OWL 2 Notation: 1065 | 1066 | ​ **DifferentIndividuals** := 'DifferentIndividuals' '(' { **Annotation** } **Individual** **Individual** { **Individual** } ')' 1067 | 1068 | LPG Diagram: 1069 | 1070 | axiom-different-individuals 1071 | 1072 | 1073 | 1074 | ## 7 Annotations 1075 | 1076 | ### 7.1 Annotation of Ontologies, Axioms, and other Annotations 1077 | 1078 | Ontologies, axioms, and annotations themselves can be annotated using annotations. Such annotations consist of an annotation property and an annotation value, where the latter can be anonymous individuals, IRIs, and literals. 1079 | 1080 | OWL 2 Notation: 1081 | 1082 | ​ **Annotation** := 'Annotation' '(' **annotationAnnotations** **AnnotationProperty** **AnnotationValue** ')' 1083 | 1084 | ​ **annotationAnnotations** := { **Annotation** } 1085 | 1086 | ​ **AnnotationValue** := **AnonymousIndividual** | **IRI** | **Literal** 1087 | 1088 | LPG Diagram: 1089 | 1090 | annotation 1091 | 1092 | ### 7.2 Annotation Axioms 1093 | 1094 | #### 7.2.1 Annotation Assertions 1095 | 1096 | An annotation assertion `AnnotationAssertion( AP as av )` states that the annotation subject `as` — an IRI or an anonymous individual — is annotated with the annotation property `AP` and the annotation value `av`. 1097 | 1098 | OWL 2 Notation: 1099 | 1100 | ​ **AnnotationAssertion** := 'AnnotationAssertion' '(' { **Annotation** } **AnnotationProperty** **AnnotationSubject** **AnnotationValue** ')' 1101 | 1102 | ​ **AnnotationSubject** := **IRI** | **AnonymousIndividual** 1103 | 1104 | ​ **AnnotationValue** := **AnonymousIndividual** | **IRI** | **Literal** 1105 | 1106 | LPG Diagram: 1107 | 1108 | axiom-annotation-assertion 1109 | 1110 | #### 7.2.2 Annotation Subproperties 1111 | 1112 | An annotation subproperty axiom `SubAnnotationPropertyOf( AP1 AP2 )` states that the annotation property `AP1` is a subproperty of the annotation property `AP2`. 1113 | 1114 | OWL 2 Notation: 1115 | 1116 | ​ **SubAnnotationPropertyOf** := 'SubAnnotationPropertyOf' '(' { **Annotation** } **subAnnotationProperty** **superAnnotationProperty** ')' 1117 | 1118 | ​ **subAnnotationProperty** := **AnnotationProperty** 1119 | 1120 | ​ **superAnnotationProperty** := **AnnotationProperty** 1121 | 1122 | LPG Diagram: 1123 | 1124 | axiom-subannotationproperty-of 1125 | 1126 | 1127 | 1128 | #### 7.2.3 Annotation Property Domain 1129 | 1130 | An annotation property domain axiom `AnnotationPropertyDomain( AP U )` states that the domain of the annotation property `AP` is the IRI `U`. 1131 | 1132 | OWL 2 Notation: 1133 | 1134 | ​ **AnnotationPropertyDomain** := 'AnnotationPropertyDomain' '(' **axiomAnnotations** **AnnotationProperty** **IRI** ')' 1135 | 1136 | LPG Diagram: 1137 | 1138 | axiom-annotationproperty-domain 1139 | 1140 | 1141 | 1142 | #### 7.2.4 Annotation Property Range 1143 | 1144 | An annotation property range axiom `AnnotationPropertyRange( AP U )` states that the range of the annotation property `AP` is the IRI `U`. 1145 | 1146 | OWL 2 Notation: 1147 | 1148 | ​ **AnnotationPropertyRange** := 'AnnotationPropertyRange' '(' **axiomAnnotations** **AnnotationProperty** **IRI** ')' 1149 | 1150 | LPG Diagram: 1151 | 1152 | axiom-annotationproperty-range 1153 | 1154 | --------------------------------------------------------------------------------