owl2lpg

Mapping of OWL 2 Web Ontology Language to Labeled Property Graphs

1 Translation of Axioms without Annotations

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.

The following conventions are used in this section to denote different parts of OWL 2 ontologies:

In this section, T(SEQ y1yn) denotes the translation of a sequence of objects from the structural specification into a linked-list graph.

Table 1: Translation of axioms without annotations.

Element E of the OWL Structural Specification Graph Generated in an Invocation of T(E)
y1yn nodes = { n | T(y1) … T(yn) }
SEQ y1yn node = T(y1)
EDGE(node, T(SEQ y2yn), “next”, {})
Ontology(
ontologyIRI
[versionIRI]
Import(ontologyIRI1) …
Import(ontologyIRIk)
annotation1annotationm
axiom1axiomn)
ontologyNode = T(ontologyIRI)
importOntologyNodes = T(ontologyIRI1ontologyIRIk)
axiomAnnotationNodes = TANN(annotation1annotationm)
axiomNodes = T(axiom1axiomn)
EDGES( ontologyNode, importOntologyNodes, “importOntology”, {})
EDGES( ontologyNode, axiomAnnotationNodes, “axiomAnnotation”, {})
EDGES( ontologyNode, axiomNodes, “axiom”, {})
C entityNode = NODE([“Class”, “ClassExpression”, “Entity”], { iri: IRI(C) })
iriNode = T(IRI(C))
EDGE(entityNode, iriNode, “entityIri”, {})
DT entityNode = NODE([“Datatype”, “Entity”], { iri: IRI(DT) })
iriNode = T(IRI(DT))
EDGE(entityNode, iriNode, “entityIri”, {})
OP entityNode = NODE([“ObjectProperty”, “ObjectPropertyExpression”, “Entity”], { iri: IRI(OP) })
iriNode = T(IRI(OP))
EDGE(entityNode, iriNode, “entityIri”, {})
DP entityNode = NODE([“DataProperty”, “DataPropertyExpression”, “Entity”], { iri: IRI(DP) })
iriNode = T(IRI(DP))
EDGE(entityNode, iriNode, “entityIri”, {})
AP entityNode = NODE([“AnnotationProperty”, “Entity”], { iri: IRI(AP) })
iriNode = T(IRI(AP))
EDGE(entityNode, iriNode, “entityIri”, {})
*:a entityNode = NODE([“NamedIndividual”, “Individual”, “Entity”], { iri: IRI(*:a) })
iriNode = T(IRI(*:a))
EDGE(entityNode, iriNode, “entityIri”, {})
_:a anonNode = NODE([“AnonymousIndividual”], { nodeID:blank_node_label })
U iriNode = NODE([“IRI”], { iri:U })
F lt restrictionNode = NODE([“FacetRestriction”], {})
constrainingFacetNode = T(F)
literalNode = T(lt)
EDGE(restrictionNode, constraintFacetNode, “constrainingFacet”, {})
EDGE(restrictionNode, literalNode, “restrictionValue”, {})
F facetNode = NODE([“Facet”], { iri: IRI(F) })
“abc@”^^rdf:PlainLiteral literalNode = NODE([“Literal”], { lexicalForm: “abc”, language: “”, datatype: T(rdf:PlainLiteral) })
“abc@langTag”^^rdf:PlainLiteral literalNode = NODE([“Literal”], { lexicalForm: “abc”, language: langTag, datatype: T(rdf:PlainLiteral) })
“abc”^^datatype { where datatype is different than rdf:PlainLiteral } literalNode = NODE([“Literal”], { lexicalForm: “abc”, datatype: T(datatype) })
Declaration(Datatype(DT)) axiomNode = NODE([“Declaration”, “Axiom”], {})
datatypeNode = T(DT)
EDGE(axiomNode, datatypeNode, “entity”, {})
Declaration(Class(C)) axiomNode = NODE([“Declaration”, “Axiom”], {})
classNode = T(C)
EDGE(axiomNode, classNode, “entity”, {})
Declaration(ObjectProperty(OP)) axiomNode = NODE([“Declaration”, “Axiom”], {})
objectPropertyNode = T(OP)
EDGE(axiomNode, objectPropertyNode, “entity”, {})
Declaration(DataProperty(DP)) axiomNode = NODE([“Declaration”, “Axiom”], {})
dataPropertyNode = T(DP)
EDGE(axiomNode, dataPropertyNode, “entity”, {})
Declaration(AnnotationProperty(AP)) axiomNode = NODE([“Declaration”, “Axiom”], {})
annotationPropertyNode = T(AP)
EDGE(axiomNode, annotationPropertyNode, “entity”, {})
Declaration(NamedIndividual(*:a)) axiomNode = NODE([“Declaration”, “Axiom”], {})
namedIndividualNode = T(*:a)
EDGE(axiomNode, namedIndividualNode, “entity”, {})
DataIntersectionOf(DR1DRn) intersectionNode = NODE([“DataIntersectionOf”, “DataRange”], {})
dataRangeNodes = T(DR1DRn)
EDGES( intersectionNode, dataRangeNodes, “dataRange”, {})
DataUnionOf(DR1DRn) unionNode = NODE([“DataUnionOf”, “DataRange”], {})
dataRangeNodes = T(DR1DRn)
EDGES( unionNode, dataRangeNodes, “dataRange”, {})
DataComplementOf(DR) complementNode = NODE([“DataComplementOf”, “DataRange”], {})
dataRangeNode = T(DR)
EDGE( complementNode, dataRangeNode, “dataRange”, {})
DataOneOf(lt1ltn) enumerationNode = NODE([“DataOneOf”, “DataRange”], {})
literalNodes = T(lt1ltn)
EDGES( enumerationNode, literalNodes, “literal”, {})
DatatypeRestriction(
DT F1 lt1Fn ltn)
dataRangeNode = NODE([“DatatypeRestriction”, “DataRange”], {})
datatypeNode = T(DT)
restrictionNodes = T(F1 lt1Fn ltn)
EDGE(dataRangeNode, datatypeNode, “datatype”, {})
EDGES( dataRangeNode, restrictionNodes, “restriction”, {})
ObjectIntersectionOf(CE1CEn) intersectionNode = NODE([“ObjectIntersectionOf”, “ClassExpression”], {})
classExpressionNodes = T(CE1CEn)
EDGES( intersectionNode, classExpressionNodes, “classExpression”, {})
ObjectUnionOf(CE1CEn) unionNode = NODE([“ObjectUnionOf”, “ClassExpression”], {})
classExpressionNodes = T(CE1CEn)
EDGES( unionNode, classExpressionNodes, “classExpression”, {})
ObjectComplementOf(CE) complementNode = NODE([“ObjectComplementOf”, “ClassExpression”], {})
classExpressionNode = T(CE)
EDGE(complementNode, classExpressionNode, “classExpression”, {})
ObjectOneOf(a1an) enumerationNode = NODE([“ObjectOneOf”, “ClassExpression”], {})
individualNodes = T(a1an)
EDGES( enumerationNode, individualNodes, “individual”, {})
ObjectSomeValuesFrom(OPE CE) quantifierNode = NODE([“ObjectSomeValuesFrom”, “ClassExpression”], {})
objectPropertyNode = T(OPE)
classExpressionNode = T(CE)
EDGE(quantifierNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(quantifierNode, classExpressionNode, “classExpression”, {})
ObjectAllValuesFrom(OPE CE) quantifierNode = NODE([“ObjectAllValuesFrom”, “ClassExpression”], {})
objectPropertyNode = T(OPE)
classExpressionNode = T(CE)
EDGE(quantifierNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(quantifierNode, classExpressionNode, “classExpression”, {})
ObjectHasValue(OPE a) restrictionNode = NODE([“ObjectHasValue”, “ClassExpression”], {})
objectPropertyNode = T(OPE)
individualNode = T(a)
EDGE(restrictionNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(restrictionNode, individualNode, “individual”, {})
ObjectHasSelf(OPE) restrictionNode = NODE([“ObjectHasSelf”, “ClassExpression”], {})
objectPropertyNode = T(OPE)
EDGE(restrictionNode, objectPropertyNode, “objectPropertyExpression”, {})
ObjectMinCardinality(n OPE) cardinalityNode = NODE([“ObjectMinCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(owl:Thing)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
ObjectMinCardinality(n OPE CE) cardinalityNode = NODE([“ObjectMinCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(CE)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
ObjectMaxCardinality(n OPE) cardinalityNode = NODE([“ObjectMaxCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(owl:Thing)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
ObjectMaxCardinality(n OPE CE) cardinalityNode = NODE([“ObjectMaxCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(CE)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
ObjectExactCardinality(n OPE) cardinalityNode = NODE([“ObjectExactCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(owl:Thing)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
ObjectExactCardinality(n OPE CE) cardinalityNode = NODE([“ObjectExactCardinality”, “ClassExpression”], { cardinality=n })
objectPropertyNode = T(OPE)
classExpressionNode = T(CE)
EDGE(cardinalityNode, objectPropertyNode, “objectPropertyExpression”, {})
EDGE(cardinalityNode, classExpressionNode, “classExpression”, {})
DataSomeValuesFrom(DPE DR) quantifierNode = NODE([“DataSomeValuesFrom”, “ClassExpression”], {})
dataPropertyNode = T(DPE)
dataRangeNode = T(DR)
EDGE(quantifierNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(quantifierNode, dataRangeNode, “dataRange”, {})
DataAllValuesFrom(DPE DR) quantifierNode = NODE([“DataAllValuesFrom”, “ClassExpression”], {})
dataPropertyNode = T(DPE)
dataRangeNode = T(DR)
EDGE(quantifierNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(quantifierNode, dataRangeNode, “dataRange”, {})
DataHasValue(DPE lt) restrictionNode = NODE([“DataHasValue”, “ClassExpression”], {})
dataPropertyNode = T(DPE)
literalNode = T(lt)
EDGE(restrictionNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(restrictionNode, literalNode, “literal”, {})
DataMinCardinality(n DPE) cardinalityNode = NODE([“DataMinCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
DataMinCardinality(n DPE DR) cardinalityNode = NODE([“DataMinCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
dataRangeNode = T(DR)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(cardinalityNode, dataRangeNode, “dataRange”, {})
DataMaxCardinality(n DPE) cardinalityNode = NODE([“DataMaxCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
DataMaxCardinality(n DPE DR) cardinalityNode = NODE([“DataMaxCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
dataRangeNode = T(DR)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(cardinalityNode, dataRangeNode, “dataRange”, {})
DataExactCardinality(n DPE) cardinalityNode = NODE([“DataExactCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
DataExactCardinality(n DPE DR) cardinalityNode = NODE([“DataExactCardinality”, “ClassExpression”], { cardinality=n })
dataPropertyNode = T(DPE)
dataRangeNode = T(DR)
EDGE(cardinalityNode, dataPropertyNode, “dataPropertyExpression”, {})
EDGE(cardinalityNode, dataRangeNode, “dataRange”, {})
ObjectInverseOf(OP) inverseNode = NODE([“ObjectInverseOf”, “ObjectPropertyExpression”], {})
objectPropertyNode = T(OP)
EDGE(inverseNode, objectPropertyNode, “objectProperty”, {})
SubClassOf(CE1 CE2) axiomNode = NODE([“SubClassOf”, “ClassAxiom”, “Axiom”], {})
subClassExpressionNode = T(CE1)
superClassExpressionNode = T(CE2)
EDGE(axiomNode, subClassExpressionNode, “subClassExpression”, {})
EDGE(axiomNode, superClassExpressionNode, “superClassExpression”, {})
EquivalentClasses(CE1CEn) equivalentNode = NODE([“EquivalentClasses”, “ClassAxiom”, “Axiom”], {})
classExpressionNodes = T(CE1CEn)
EDGES( equivalentNode, classExpressionNodes, “classExpression”, {})
DisjointClasses(CE1CEn) disjointNode = NODE([“DisjointClasses”, “ClassAxiom”, “Axiom”], {})
classExpressionNodes = T(CE1CEn)
EDGES( disjointNode, classExpressionNodes, “classExpression”, {})
DisjointUnion(C CE1CEn) unionNode = NODE([“DisjointUnion”, “ClassAxiom”, “Axiom”], {})
classNode = T(C)
classExpressionNodes = T(CE1CEn)
EDGE(unionNode, classNode, “class”, {})
EDGES( unionNode, classExpressionNodes, “disjointClassExpression”, {})
SubObjectPropertyOf(OPE1 OPE2) axiomNode = NODE([“SubObjectPropertyOf”, “ObjectPropertyAxiom”, “Axiom”], {})
subPropertyNode = T(OPE1)
superPropertyNode = T(OPE2)
EDGE(axiomNode, subPropertyNode, “subObjectPropertyExpression”, {})
EDGE(axiomNode, superPropertyNode, “superObjectPropertyExpression”, {})
SubObjectPropertyOf(
ObjectPropertyChain(OPE1OPEn)
OPE)
axiomNode = NODE([“SubObjectPropertyOf”, “ObjectPropertyAxiom”, “Axiom”], {})
subPropertyNode = T(SEQ OPE1OPEn)
superPropertyNode = T(OPE)
EDGE(axiomNode, subPropertyNode, “subObjectPropertyExpression”, {})
EDGE(axiomNode, superPropertyNode, “superObjectPropertyExpression”, {})
EquivalentObjectProperties(OPE1OPEn) equivalentNode = NODE([“EquivalentObjectProperties”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNodes = T(OPE1OPEn)
EDGES( equivalentNode, propertyExpressionNodes, “objectPropertyExpression”, {})
DisjointObjectProperties(OPE1OPEn) disjointNode = NODE([“DisjointObjectProperties”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNodes = T(OPE1OPEn)
EDGES( disjointNode, propertyExpressionNodes, “objectPropertyExpression”, {})
ObjectPropertyDomain(OPE CE) axiomNode = NODE([“ObjectPropertyDomain”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
classExpressionNode = T(CE)
EDGE(axiomNode, propertyExpressionNode, “objectPropertyExpression”, {})
EDGE(axiomNode, classExpressionNode, “domain”, {})
ObjectPropertyRange(OPE CE) axiomNode = NODE([“ObjectPropertyRange”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
classExpressionNode = T(CE)
EDGE(axiomNode, propertyExpressionNode, “objectPropertyExpression”, {})
EDGE(axiomNode, classExpressionNode, “range”, {})
InverseObjectProperties(OPE1 OPE2) inverseNode = NODE([“InverseObjectProperties”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionOneNode = T(OPE1)
propertyExpressionTwoNode = T(OPE2)
EDGE(inverseNode, propertyExpressionOneNode, “objectPropertyExpression”, {})
EDGE(inverseNode, propertyExpressionTwoNode, “inverseObjectPropertyExpression”, {})
FunctionalObjectProperty(OPE) characteristicNode = NODE([“FunctionalObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
InverseFunctionalObjectProperty(OPE) characteristicNode = NODE([“InverseFunctionalObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
ReflexiveObjectProperty(OPE) characteristicNode = NODE([“ReflexiveObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
IrreflexiveObjectProperty(OPE) characteristicNode = NODE([“IrreflexiveObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
SymmetricObjectProperty(OPE) characteristicNode = NODE([“SymmetricObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
AsymmetricObjectProperty(OPE) characteristicNode = NODE([“AsymmetricObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
TransitiveObjectProperty(OPE) characteristicNode = NODE([“TransitiveObjectProperty”, “ObjectPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(OPE)
EDGE(characteristicNode, propertyExpressionNode, “objectPropertyExpression”, {})
SubDataPropertyOf(DPE1 DPE2 ) axiomNode = NODE([“SubDataPropertyOf”, “DataPropertyAxiom”, “Axiom”], {})
subPropertyNode = T(DPE1)
superPropertyNode = T(DPE2)
EDGE(axiomNode, subPropertyNode, “subDataPropertyExpression”, {})
EDGE(axiomNode, superPropertyNode, “superDataPropertyExpression”, {})
EquivalentDataProperties(DPE1DPEn) equivalentNode = NODE([“EquivalentDataProperties”, “DataPropertyAxiom”, “Axiom”], {})
propertyExpressionNodes = T(DPE1DPEn)
EDGES( equivalentNode, propertyExpressionNodes, “dataPropertyExpression”, {})
DisjointDataProperties(DPE1DPEn) disjointNode = NODE([“DisjointDataProperties”, “DataPropertyAxiom”, “Axiom”], {})
propertyExpressionNodes = T(DPE1DPEn)
EDGES( disjointNode, propertyExpressionNodes, “dataPropertyExpression”, {})
DataPropertyDomain(DPE CE) axiomNode = NODE([“DataPropertyDomain”, “DataPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(DPE)
classExpressionNode = T(CE)
EDGE(axiomNode, propertyExpressionNode, “dataPropertyExpression”, {})
EDGE(axiomNode, classExpressionNode, “domain”, {})
DataPropertyRange(DPE DR) axiomNode = NODE([“DataPropertyRange”, “DataPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(DPE)
dataRangeNode = T(DR)
EDGE(axiomNode, propertyExpressionNode, “objectPropertyExpression”, {})
EDGE(axiomNode, dataRangeNode, “range”, {})
FunctionalDataProperty(DPE) characteristicNode = NODE([“FunctionalDataProperty”, “DataPropertyAxiom”, “Axiom”], {})
propertyExpressionNode = T(DPE)
EDGE(characteristicNode, propertyExpressionNode, “dataPropertyExpression”, {})
DatatypeDefinition(DT DR) axiomNode = NODE([“DatatypeDefintion”, “Axiom”], {})
datatypeNode = T(DT)
dataRangeNode = T(DR)
EDGE(axiomNode, datatypeNode, “datatype”, {})
EDGE(axiomNode, dataRangeNode, “dataRange”, {})
HasKey(CE (OPE1OPEm) (DPE1DPEn)) axiomNode = NODE([“HasKey”, “Axiom”], {})
classExpressionNode = T(CE)
objectExpressionPropertyNodes = T(OPE1OPEm)
dataPropertyExpressionNodes = T(DPE1DPEn)
EDGE(axiomNode, classExpressionNode, “classExpression”, {})
EDGES( axiomNode, objectExpressionPropertyNodes, “objectPropertyExpression”, {})
EDGES( axiomNode, dataPropertyExpressionNodes, “dataPropertyExpression”, {})
SameIndividual(a1an) equalityNode = NODE([“SameIndividual”, “Assertion”, “Axiom”], {})
individualNodes = T(a1an)
EDGES( equalityNode, individualNodes, “individual”, {})
DifferentIndividuals(a1an) inequalityNode = NODE([“DifferentIndividuals”, “Assertion”, “Axiom”], {})
individualNodes = T(a1an)
EDGES( inequalityNode, individualNodes, “individual”, {})
ClassAssertion(CE a) assertionNode = NODE([“ClassAssertion”, “Assertion”, “Axiom”], {})
classExpressionNode = T(CE)
individualNode = T(a)
EDGE(assertionNode, classExpressionNode, “classExpression”, {})
EDGE(assertionNode, individualNode, “individual”, {})
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”, {})
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”, {})
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”, {})
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”, {})
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”, {})
SubAnnotationPropertyOf(AP1 AP2) axiomNode = NODE([“SubAnnotationPropertyOf”, “AnnotationAxiom”, “Axiom”], {})
subPropertyNode = T(AP1)
superPropertyNode = T(AP2)
EDGE(axiomNode, subPropertyNode, “subAnnotationProperty”, {})
EDGE(axiomNode, superPropertyNode, “superAnnotationProperty”, {})
AnnotationPropertyDomain(AP U) axiomNode = NODE([“AnnotationPropertyDomain”, “AnnotationAxiom”, “Axiom”], {})
propertyNode = T(AP)
iriNode = T(U)
EDGE(axiomNode, propertyNode, “annotationProperty”, {})
EDGE(axiomNode, iriNode, “domain”, {})
AnnotationPropertyRange(AP U) axiomNode = NODE([“AnnotationPropertyRange”, “AnnotationAxiom”, “Axiom”], {})
propertyNode = T(AP)
iriNode = T(U)
EDGE(axiomNode, propertyNode, “annotationProperty”, {})
EDGE(axiomNode, iriNode, “range”, {})

2 Translation of Annotations

Table 2: Translation of annotations.

Annotation A Graph Generated in an Invocation of TANN(A)
annotation1annotationn nodes = { n | TANN(annotation1) … TANN(annotationn) }
Annotation(AP av) annotationNode = NODE([“Annotation”], {})
annotationPropertyNode = T(AP)
annotationValueNode = T(av)
EDGE(annotationNode, annotationPropertyNode, “annotationProperty”, {})
EDGE(annotationNode, annotationValueNode, “annotationValue”, {})
Annotation(
annotation1annotationn
AP av)
annotationNode = NODE([“Annotation”], {})
annotationPropertyNode = T(AP)
annotationValueNode = T(av)
annotationAnnotationsNode = TANN(annotationannotationn)
EDGES(annotationNode, annotationAnnotationsNode, “annotationAnnotation”, {})
EDGE(annotationNode, annotationPropertyNode, “annotationProperty”, {})
EDGE(annotationNode, annotationValueNode, “annotationValue”, {})

3 Translation of Axioms with Annotations

If an axiom ax is annotated with annotations annotation1annotationm, its mapping to LPG is obtained by translating ax using Table 1 and invoking TANN(annotation1annotatiom) using Table 2 to translate the annotations. An annotated axiom ax is translated as follows:

axiomNode = T(ax)
axiomAnnotationNodes = TANN(annotation1annotationm)
EDGES( axiomNode, axiomAnnotationNodes, “axiomAnnotation”, {})

4 Augmenting Edges

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.

Table 3: Additional edges that augment LPGs obtained using the translation functions described in previous sections.

OWL Axiom ax Edge(s) generated
SubClassOf(CE1 CE2) EDGE(T(CE1), T(CE2), “subClassOf”, {})
SubClassOf(CE1 ObjectIntersectionOf(CE2CEn)) EDGE(T(CE1), T(CE2), “subClassOf”, {})

EDGE(T(CE1), T(CEn), “subClassOf”, {})
EquivalentClasses(CE1CEn) 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”, {})
EquivalentClasses(CE1ObjectIntersectionOf(CE2CEn)) EDGE(T(CE1), T(CE2), “subClassOf”, {})

EDGE(T(CE1), T(CEn), “subClassOf”, {})
SubObjectPropertyOf(OPE1 OPE2) EDGE(T(OPE1), T(OPE2), “subObjectPropertyOf”, {})
EquivalentObjectProperties(OPE1OPEn) 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”, {})
SubDataPropertyOf(DPE1 DPE2) EDGE(T(DPE1), T(DPE2), “subDataPropertyOf”, {})
EquivalentDataProperties(DPE1DPEn) 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”, {})
ClassAssertion(CE a) EDGE(T(a), T(CE), “type”, {})
SameIndividual(a1an) 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”, {})
SubAnnotationPropertyOf(AP1 AP2) EDGE(T(AP1), T(AP2), “subAnnotationPropertyOf”, {})