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:
OP denotes an object property;OPE denotes an object property expression;DP denotes a data property;DPE denotes a data property expression;AP denotes an annotation property;C denotes a class;CE denotes a class expression;DT denotes a datatype;DR denotes a data range;U denotes an IRI;F denotes a constraining facet;a denotes an individual (named or anonymous);*:a denotes a named individual;_:a denotes an anonymous individual;lt denotes a literal;as denotes an annotation source; andav denotes an annotation value.In this section, T(SEQ y1 … yn) 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) |
|---|---|
y1 … yn |
nodes = { n | T(y1) … T(yn) } |
SEQ y1 … yn |
node = T(y1)EDGE(node, T( SEQ y2 … yn), “next”, {}) |
Ontology(ontologyIRI[ versionIRI]Import( ontologyIRI1) … Import( ontologyIRIk)annotation1 … annotationmaxiom1 … 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”, {}) |
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(DR1 … DRn) |
intersectionNode = NODE([“DataIntersectionOf”, “DataRange”], {}) dataRangeNodes = T( DR1 … DRn)EDGES( intersectionNode, dataRangeNodes, “dataRange”, {}) |
DataUnionOf(DR1 … DRn) |
unionNode = NODE([“DataUnionOf”, “DataRange”], {}) dataRangeNodes = T( DR1 … DRn)EDGES( unionNode, dataRangeNodes, “dataRange”, {}) |
DataComplementOf(DR) |
complementNode = NODE([“DataComplementOf”, “DataRange”], {}) dataRangeNode = T( DR)EDGE( complementNode, dataRangeNode, “dataRange”, {}) |
DataOneOf(lt1 … ltn) |
enumerationNode = NODE([“DataOneOf”, “DataRange”], {}) literalNodes = T( lt1 … ltn)EDGES( enumerationNode, literalNodes, “literal”, {}) |
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”, {}) |
ObjectIntersectionOf(CE1 … CEn) |
intersectionNode = NODE([“ObjectIntersectionOf”, “ClassExpression”], {}) classExpressionNodes = T( CE1 … CEn)EDGES( intersectionNode, classExpressionNodes, “classExpression”, {}) |
ObjectUnionOf(CE1 … CEn) |
unionNode = NODE([“ObjectUnionOf”, “ClassExpression”], {}) classExpressionNodes = T( CE1 … CEn)EDGES( unionNode, classExpressionNodes, “classExpression”, {}) |
ObjectComplementOf(CE) |
complementNode = NODE([“ObjectComplementOf”, “ClassExpression”], {}) classExpressionNode = T( CE)EDGE(complementNode, classExpressionNode, “classExpression”, {}) |
ObjectOneOf(a1 … an) |
enumerationNode = NODE([“ObjectOneOf”, “ClassExpression”], {}) individualNodes = T( a1 … an)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(CE1 … CEn) |
equivalentNode = NODE([“EquivalentClasses”, “ClassAxiom”, “Axiom”], {}) classExpressionNodes = T( CE1 … CEn)EDGES( equivalentNode, classExpressionNodes, “classExpression”, {}) |
DisjointClasses(CE1 … CEn) |
disjointNode = NODE([“DisjointClasses”, “ClassAxiom”, “Axiom”], {}) classExpressionNodes = T( CE1 … CEn)EDGES( disjointNode, classExpressionNodes, “classExpression”, {}) |
DisjointUnion(C CE1 … CEn) |
unionNode = NODE([“DisjointUnion”, “ClassAxiom”, “Axiom”], {}) classNode = T( C)classExpressionNodes = T( CE1 … CEn)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( OPE1 … OPEn)OPE) |
axiomNode = NODE([“SubObjectPropertyOf”, “ObjectPropertyAxiom”, “Axiom”], {}) subPropertyNode = T( SEQ OPE1 … OPEn)superPropertyNode = T( OPE)EDGE(axiomNode, subPropertyNode, “subObjectPropertyExpression”, {}) EDGE(axiomNode, superPropertyNode, “superObjectPropertyExpression”, {}) |
EquivalentObjectProperties(OPE1 … OPEn) |
equivalentNode = NODE([“EquivalentObjectProperties”, “ObjectPropertyAxiom”, “Axiom”], {}) propertyExpressionNodes = T( OPE1 … OPEn)EDGES( equivalentNode, propertyExpressionNodes, “objectPropertyExpression”, {}) |
DisjointObjectProperties(OPE1 … OPEn) |
disjointNode = NODE([“DisjointObjectProperties”, “ObjectPropertyAxiom”, “Axiom”], {}) propertyExpressionNodes = T( OPE1 … OPEn)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(DPE1… DPEn) |
equivalentNode = NODE([“EquivalentDataProperties”, “DataPropertyAxiom”, “Axiom”], {}) propertyExpressionNodes = T( DPE1 … DPEn)EDGES( equivalentNode, propertyExpressionNodes, “dataPropertyExpression”, {}) |
DisjointDataProperties(DPE1… DPEn) |
disjointNode = NODE([“DisjointDataProperties”, “DataPropertyAxiom”, “Axiom”], {}) propertyExpressionNodes = T( DPE1 … DPEn)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 (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”, {}) |
SameIndividual(a1 … an) |
equalityNode = NODE([“SameIndividual”, “Assertion”, “Axiom”], {}) individualNodes = T( a1 … an)EDGES( equalityNode, individualNodes, “individual”, {}) |
DifferentIndividuals(a1 … an) |
inequalityNode = NODE([“DifferentIndividuals”, “Assertion”, “Axiom”], {}) individualNodes = T( a1 … an)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”, {}) |
Table 2: Translation of annotations.
| Annotation A | Graph Generated in an Invocation of TANN(A) |
|---|---|
annotation1 … annotationn |
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(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”, {}) |
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:
axiomNode = T(ax)
axiomAnnotationNodes = TANN(annotation1 … annotationm)
EDGES( axiomNode, axiomAnnotationNodes, “axiomAnnotation”, {})
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(CE2 … CEn)) |
EDGE(T(CE1), T(CE2), “subClassOf”, {})… EDGE(T( CE1), T(CEn), “subClassOf”, {}) |
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”, {}) |
EquivalentClasses(CE1ObjectIntersectionOf(CE2 … CEn)) |
EDGE(T(CE1), T(CE2), “subClassOf”, {})… EDGE(T( CE1), T(CEn), “subClassOf”, {}) |
SubObjectPropertyOf(OPE1 OPE2) |
EDGE(T(OPE1), T(OPE2), “subObjectPropertyOf”, {}) |
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”, {}) |
SubDataPropertyOf(DPE1 DPE2) |
EDGE(T(DPE1), T(DPE2), “subDataPropertyOf”, {}) |
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”, {}) |
ClassAssertion(CE a) |
EDGE(T(a), T(CE), “type”, {}) |
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”, {}) |
SubAnnotationPropertyOf(AP1 AP2) |
EDGE(T(AP1), T(AP2), “subAnnotationPropertyOf”, {}) |