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 … 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”, {}) |
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(CE1 ObjectIntersectionOf(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”, {}) |