Previous topic  Top  Next topic  Print this Topic
 

Ontology Transformation

 

Transforming ObjectLogic into RDF Schema is in most cases straightforward. Basically every ObjectLogic fact is represented as one (or more) RDF triple. Whenever a functional term occurs, it is mapped to an IRI using the predefined namespace 'obl:term#':

<myns:myFunction>(arguments)   <=>   <obl:term#%3Cmyns:myFunction%3E(arguments)>

While ObjectLogic allows constants of every type as object identifiers, RDF imposes several restrictions on the structure of statements. For example, anonymous nodes are not allowed as a predicate in RDF statements. All of the ObjectLogic facts not conforming to this restriction are discarded.

For every transformation a summary log is provided. It shows potential transformation problems like axioms not supported in the target ontology language.

Schema

ObjectLogic concept and property hierarchies are directly transformed into the RDF Schema class hierarchy. For attribute and relation definitions, the RDF Schema elements domain and range are used. This intentional break with the RDF Schema semantics interpreting domain and range as constraints favors a more "information preserving" instead of a semantically correct transformation.

The global definition of properties in RDF, in contrast to concept-bound in ObjectLogic, implies that attributes/relation using the same identifier will be merged during the transformation, i.e. they share the same domain and range definitions.

Finally, properties of attributes/relations like cardinality restrictions, transitivity, symmetry, and inverse-of definitions are not supported by the RDF Schema. If this information needs to be taken into account, an transformation to OWL should be considered. For the RDF Schema only the declaration of the attribute/relation itself is stored.

Person[].                      <=>   :Person a rdfs:Class.

Person::Human.                 <=>   :Person rdfs:subClassOf :Human.

loves<<knows.                  <=>   :loves rdfs:subPropertyOf :knows.

Person[name{1:2}*=>_string].    =>   :name rdfs:domain :Person; rdfs:range xsd:string.

Person[p{symmetric}*=>()].      =>   :p a rdf:Property.

Person[p{transitive}*=>()].     =>   :p a rdf:Property.

Person[p{transitive}*=>()].     =>   :p a rdf:Property.

Person[p{inverseOf(q)}*=>()].   =>   :p a rdf:Property. :q a rdf:Property.

Instances

Assertions, both for instances and concepts, are transformed preserving the datatype.

eve:Person.                             <=>   :eve a :Person.

eve[name->"Eve"].                       <=>   :eve :name "Eve"^^xsd:string.

eve[name->"Eve@"^^_PlainLiteral].       <=>   :eve :name "Eve".

eve[name->"Evita@es"^^_PlainLiteral].   <=>   :eve :name "Evita"@es.

eve[p->true].                           <=>   :eve :p "true"^^xsd:boolean.

eve[p->1].                              <=>   :eve :p "1"^^xsd:int.

eve[p->2.3].                            <=>   :eve :p 2.3e0 .

eve[p->"4.0"^^_decimal].                <=>   :eve :p 4.0 .

eve[p->"11:55:32"^^_time].              <=>   :eve :p "11:55:32"^^xsd:time.

Rules and Queries

Rules, queries, and constraints are not supported by the RDF Schema.

RDF Schema to ObjectLogic

Transforming the RDF Schema into ObjectLogic is, in most cases, analogous to the inverse transformation. IRIs using the reserved namespace 'obl:term#' are mapped to the encoded ObjectLogic term:

<obl:term#%3Cmyns:myFunction%3E(arguments)>   <=>   <myns:myFunction>(arguments)

If a term cannot be encoded due to invalid ObjectLogic syntax the IRI is kept.

A summary log is provided for every transformation. It shows potential transformation problems like issues related to domain/range ambiguity.

Schema

Class and property declarations and concept and property hierarchies are transformed into ObjectLogic equivalent facts.

 :Person a rdfs:Class.               <=>   Person[].

 :Person rdfs:subClassOf :Human.     <=>   Person::Human.

 :knows a rdf:Property.              <=>   _property(knows).

 :loves rdfs:subPropertyOf :knows.   <=>   loves<<knows.

The transformation of domain and range definitions is slightly more complex. All of the related domain/range information is collected for every RDF property. Properties not contained in at least one domain and in one range definition statement are ignored. All other properties are interpreted as schema restrictions, which is semantically not correct, however the best trade-off in terms of round-tripping.

For example, the triples

 :age rdfs:domain :Person.

 :age rdfs:domain :Building.

 :age rdfs:range xsd:double.

 :name rdfs:range xsd:string.

will be transformed into ObjectLogic

Person[age*=>_double].

Building[age*=>_double].

Instances

Instance declarations and general assertions are transformed preserving the datatype.

 :eve a :Person.                 <=>   eve:Person.

 :eve :name "Eve"^^xsd:string.   <=>   eve[name->"Eve"].

 :eve :name "Eve".               <=>   eve[name->"Eve@"^^_PlainLiteral].

 :eve :name "Evita"@es.          <=>   eve[name->"Evita@es"^^_PlainLiteral].

 :eve :p "true"^^xsd:boolean.    <=>   eve[p->true].

 :eve :p 1 .                     <=>   eve[p->1].

 :eve :p 2.3e0 .                 <=>   eve[p->2.3].

 :eve :p 4.0 .                   <=>   eve[p->"4.0"^^_decimal].

 :eve :p "11:55:32"^^xsd:time.   <=>   eve[p->"11:55:32"^^_time].

 :eve :p "foo"^^my:type.         ==>   eve[p->"foo"].

ObjectLogic to OWL

The transformation translates ObjectLogic facts to OWL axioms. P-atoms (literals), queries and constraints are not supported. Axioms which are unsupported or contain unsupported parts are ignored. Rules are are not supported.

Transforming Concepts, Properties and Individuals

ObjectLogic does not explicitly differ between concepts, properties and individuals. Any term can be used as one of these entity types.

On the other hand, OWL strictly typifies entities within axioms; entities are identified by URIs. The axioms to be created can thereby depend on the entity type, e.g. if a domain is specified for a property, it needs to be an ObjectPropertyDomain if the entity is an object property, but a DataPropertyDomain if the property is a data property.

Since ObjectLogic does not explicitly mark the used terms with an entity type, there are ambiguities, e.g. in 'a[p->b]' it is not clear if 'b' is meant to be an individual or a constant, thereby it is not clear if this fact should be translated to an ObjectPropertyAssertion or a DataPropertyAssertion.

The transformation tries to detect the property types for terms and translates the facts accordingly. For example, if the ontology contains a schema fact 'A[p*=>B]' where B does not identify a standard datatype, it assumes that 'p' is an object property. If instead 'A[p*=>_string]' is contained in the ontology, the transformation assumes that 'p' is a data property. If both schema facts are included, there is a conflict and the transformation handles the type of 'p' according to the context.

Transforming ObjectLogic Terms to OWL Entities

A given ObjectLogic term is transformed to an OWL entity as follows:

If the term is an rif:iri constant, the iri is used as entity URI.
Otherwise, the term is formatted as ObjectLogic string L and the URI for the entity is obl:term#E, where E is the URL-encoded version of L.

Constraints versus deriving Knowledge

In ObjectLogic most of the schema facts are handled as constraints and will thereby not affect the derived facts but may just make the ontology inconsistent. E.g. 'A[p{1:1}*=>B]' together with 'a:A', 'a[p->b]' and 'a[p->c]' form an inconsistent ontology, but do not derive that 'b' and 'c' need to be the same.

In OWL on the other hand, from 'SubClassOf(A ObjectExactCardinality(1 p B))' together with 'ClassAssertion(A a)', 'ObjectPropertyAssertion(p a b)' and 'ObjectPropertyAssertion(p a c)' it follows that 'b' and 'c' must be the same individual.

The semantic difference between constraints on the one hand and derived knowledge on the other hand is ignored by the transformation, i.e. the transformation handles the ObjectLogic schema facts as if they would actually add to the knowledge rather than just building constraints.

Property Attributes

ObjectLogic binds property attributes to some concepts, e.g. 'A[p{symmetric}*=>()]' binds 'p' to 'A'. In OWL this is not (directly) possible and the transformation skips the information about the concept, i.e. will just declare 'p' to be symmetric, so 'A' is a domain for 'p' (ObjectPropertyDomain(p A).

Inheritance

Basically A[p=>B] is ignored. Certainly it is asked to appropriate the type of 'p'. In this case 'p' is declared as an ObjectProperty.

Basic Transformations

The following table shows the basic transformation under 'natural' assumptions, ignoring several special cases. For schema facts which contains properties, property domain and property range facts might be created.

 a:A.                             =>   ClassAssertion(A a)

 

 a[p->b].                         =>   ObjectPropertyAssertion(p a b) respectively DataPropertyAssertion(p a b) respectively AnnotationAssertion(p a b)

 a[_comment->"text"{en}].                 =>   AnnotationAssertion(rdfs:comment a "text"@en)

 a[_representation ->"text"{en}]. =>   AnnotationAssertion(rdfs:label a "text"@en)

 a[_synonym("en")->"text"].       =>   AnnotationAssertion(<obl:reserved:synonym> a "text"@en)

 

 A[].                             =>   Declaration(Class(A))

 

 B::A.                            =>   SubClassOf(B A)

 p<<q.                            =>   SubPropertyOf(p q)

 

 A[p{inverseOf(q)}*=>B].          =>   InverseObjectProperties(p q)

 A[p{symmetric}*=>()].            =>   SymmetricObjectProperty(p)

 A[p{transitive}*=>()].           =>   TransitiveObjectProperty(p)

 

 A[p{n:*}*=>()].                  =>   SubClassOf(A ObjectMinCardinality(n p)) respectively SubClassOf(A DataMinCardinality(n p))

 A[p{0:n}*=>()].                  =>   SubClassOf(A ObjectMaxCardinality(n p)) respectively SubClassOf(A DataMaxCardinality(n p))

                                       for n ≠ 1

               .                  =>   FunctionalObjectProperty(p) respectively FunctionalDataProperty(p)

                                       for n = 1

 

 A[p*=>B].                        =>   ObjectPropertyDomain(p A), ObjectPropertyRange(p B)

 A[p*=>_string].                  =>   DataPropertyDomain(p A), DataPropertyRange(p xsd:string)

Domain and Range

 

OWL

OWL-in-ObjectLogic

ObjectLogic

Local Range Specification

SubClassOf(:Person
  ObjectAllValuesFrom(:hasMother :Woman))

Person::_AllValuesFrom(hasMother, Woman)

Person[hasMother*=>Woman]

Comparing Property Type Declarations

SubClassOf(:Person
  ObjectAllValuesFrom(:hasMother :Woman))
Property type declaration by each use
Person::_AllValuesFrom(hasMother, Woman)
_Declaration(hasMother, owl#ObjectProperty)
Property type declaration per ontology
Person[hasMother*=>Woman]
Implicit property type declaration by range only

Global Range Specification

ObjectPropertyDomain(:hasMother :Person),
ObjectPropertyRange(:hasMother :Woman)

ObjectPropertyDomain(:hasMother :Person),
ObjectPropertyRange(:hasMother :Woman)

Person[hasMother*=>Woman]
Implicit property type declaration by range only

One Domain, no Range

ObjectPropertyDomain(:hasMother :Person)
Domain: Person
Range: anything

 

Person[hasMother*=>rdfs#Resource]
Domain: Person
Range: filler rdfs#Resource (without any special meaning)

No Domain, one Range

ObjectPropertyRange(:hasMother :Woman)
Domain: anything
Range: Woman

 

owl#Thing[hasMother*=>Woman]
Domain: filler owl#Thing (without any special meaning)
Range: Woman

One Domain, one Range

ObjectPropertyDomain(:hasMother :Person),
ObjectPropertyRange(:hasMother :Woman)

 

Person[hasMother*=>Woman]

One Domain, multiple Ranges

ObjectPropertyDomain(:hasMother :Person),ObjectPropertyRange(:hasMother :Woman),ObjectPropertyRange(:hasMother :Mother)

 

Person[hasMother*=>Woman],
Person[hasMother*=>Mother]

Union of Domains, one Range

ObjectPropertyDomain(:hasMother
 ObjectUnionOf(:Man :Woman)),
ObjectPropertyRange(:hasMother :Woman)

 

Man[hasMother*=>Woman],
Woman[hasMother*=>Woman]

 

Union of Domains, different local Ranges

ObjectPropertyDomain(:hasMother
 ObjectUnionOf(:Man :Woman)),
SubClassOf(:Man
 ObjectAllValuesFrom(:hasMother :Woman)),
SubClassOf(:Woman
 ObjectAllValuesFrom(:hasMother :Mother))

 

 

Man[hasMother*=>Woman],
Woman[hasMother*=>Mother]

 

Multiple Domains, one Range

ObjectPropertyDomain(:hasMother :Creature),
ObjectPropertyDomain(:hasMother :Person),
ObjectPropertyRange(:hasMother :Woman)
Domain: intersection of Creature and Person
Range: Woman

 

Creature[hasMother*=>Woman],
Person[hasMother*=>Woman]
Domain: union of Creature and Person
Range: Woman
Retransformed like ‘Union of Domains, one Range‘

Multiple Domains, multiple Ranges

ObjectPropertyDomain(:hasMother :Creature),
ObjectPropertyDomain(:hasMother :Person),ObjectPropertyRange(:hasMother :Woman),ObjectPropertyRange(:hasMother :´Mother)
Domain: intersection of Creature and Person
Range: intersection of Woman and Mother

 

Creature[hasMother*=>Woman],
Creature[hasMother*=>Mother],
Person[hasMother*=>Woman],
Person[hasMother*=>Mother]
Domain: union of Creature and Person
Range: intersection of Woman and Mother
Retransformed like ‘Union of Domains, different local Ranges‘

OWL to ObjectLogic

The transformation translates OWL axioms to ObjectLogic facts. SWRL rules are not supported at all. Axioms which are unsupported or contain unsupported parts are ignored.

Transforming named OWL Entities to ObjectLogic Terms

A named OWL entity is translated to an ObjectLogic term by creating a constant of type rif:iri which consists of the URI of the entity. There is one exception: if the URI of the entity starts with 'obl:term#' then the local part of the URI is assumed to be the (URL-encoded) ObjectLogic serialization of a term which will be parsed and used instead of a rif:iri constant.

Object Property Expressions

The inverse object property expression is unsupported.

Data Ranges

Data ranges besides plain datatypes are unsupported.

Complex Class Expressions

A subset of complex class expressions is supported if used as a super description within a sub class axiom, but no where else. Recursive complex class expressions are unsupported.

Basic Transformations

The following table shows the basic transformation under 'natural' assumptions, ignoring several special cases. Axioms not listed here are unsupported.

The transformation requires that A has been detected as an object property domain for the object property p and B as object property domain of the object property r. Unsupported axioms are skipped by the transformation.

ClassAssertion(A a)                           =>   a:A.

 

ObjectPropertyAssertion(q a b)                =>   a[q->b].

DataPropertyAssertion(q a "text"@en)          =>   a[q->"text"{en}.

AnnotationAssertion(q a b)                    =>   a[q->b].

AnnotationAssertion(rdfs:comment a "text"@en) =>   a[_comment->"text"{en}].

AnnotationAssertion(rdfs:label a "text"@en)   =>   a[_representation ->"text"{en}]

AnnotationAssertion(<obl:reserved:synonym> a "text"@en)

                                               =>   a[_synonym("en")->"text"].

 

Declaration(Class(A))                         =>   A[].

 

SubClassOf(B A)                               =>   B::A.

 

 

InverseObjectProperties(p r)                  =>   A[p{inverseOf(r)}*=>B].

SymmetricObjectProperty(p)                    =>   A[p{symmetric}*=>()].

TransitiveObjectProperty(p)                   =>   A[p{transitive}*=>()].

 

SubClassOf(A ObjectMinCardinality(1 p))       =>   A[p{1:*}*=>()].

SubClassOf(A DataMinCardinality(1 p))         =>   A[p{1:*}*=>()].

SubClassOf(A ObjectMaxCardinality(1 p))       =>   A[p{0:1}*=>()].

SubClassOf(A DataMaxCardinality(1 p))         =>   A[p{0:1}*=>()].

 

{A domain of p, B range of p}                 =>   A[p*=>B].

OWL2 (RL) in ObjectLogic

Predefined and Named Classes

Language Feature

OWL2 Functional Syntax1

RDF Syntax2

ObjectLogic Syntax

named class

CN

CN

CN

universal class

owl:Thing

owl:Thing

owl:Thing for ObjectLogic

empty class

owl:Nothing

owl:Nothing

owl:Nothing for ObjectLogic

1 Second column, upper part: OWL2 Functional Syntax

2Second column, lower part: RDF Syntax

Boolean Connectives and Enumeration of Individuals

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

intersection

ObjectIntersectionOf(C1 … Cn)

_:x rdf:type owl:Class.
_:x owl:intersectionOf ( C1 … Cn ).

_IntersectionOf([C1, C2, …,Cn])

union

ObjectUnionOf(C1 … Cn)

_:x rdf:type owl:Class.
_:x owl:unionOf ( C1 … Cn ).

_UnionOf([C1, … Cn])

complement

ObjectComplementOf(C)

_:x rdf:type owl:Class.
_:x owl:complementOf C.

_ComplementOf(C)

enumeration

ObjectOneOf(a1 … an)

_:x rdf:type owl:Class.
_:x owl:oneOf ( a1 … an ).

_OneOf([a1, …, an])

Object Property Restrictions

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

universal

ObjectAllValuesFrom(P C)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:allValuesFrom C

_AllValuesFrom(P, C)

existential

ObjectSomeValuesFrom(P C)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:someValuesFrom C

_SomeValuesFrom(P, C)

individual value

ObjectHasValue(P a)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:hasValue a.

_HasValue(P, a)

local reflexivity

ObjectHasSelf(P)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:hasSelf "true"^^xsd:boolean.

_HasSelf(P)

exact cardinality

ObjectExactCardinality(n P)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:cardinality n.

_ExactCardinality(n, P, owl#Thing)

qualified exact cardinality

ObjectExactCardinality(n P C)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:qualifiedCardinality n.
_:x owl:onClass C.

_ExactCardinality(n, P, C)

maximum cardinality

ObjectMaxCardinality(n P)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:maxCardinality n.

_MaxCardinality(n, P, owl#Thing)

qualified maximum cardinality

ObjectMaxCardinality(n P C)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:maxQualifiedCardinality n.
_:x owl:onClass C.

_MaxCardinality(n, P, C)

minimum cardinality

ObjectMinCardinality(n P)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:minCardinality n.

_MinCardinality(n, P, owl#Thing)

qualified minimum cardinality

ObjectMinCardinality(n P C)

_:x rdf:type owl:Restriction.
_:x owl:onProperty P.
_:x owl:minQualifiedCardinality n.
_:x owl:onClass C.

_MinCardinality(n, P, C)

Data Property Restrictions

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

universal

DataAllValuesFrom(R D)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:allValuesFrom D.

_AllValuesFrom(R, D)

existential

DataSomeValuesFrom(R D)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:someValuesFrom D.

_SomeValuesFrom(R, D)

literal value

DataHasValue(R v)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:hasValue v.

_HasValue(R, v)

exact cardinality

DataExactCardinality(n R)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:cardinality n.

_ExactCardinality(n, R, rdfs#Literal)

qualified exact cardinality

DataExactCardinality(n R D)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:qualifiedCardinality n.
_:x owl:onDataRange D.

_ExactCardinality(n, R, D)

maximum cardinality

DataMaxCardinality(n R)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:maxCardinality n.

_MaxCardinality( n, R, rdfs#Literal)

qualified maximum cardinality

DataMaxCardinality(n R D)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:maxQualifiedCardinality n.
_:x owl:onDataRange D.

_MaxCardinality(n, R, D)

minimum cardinality

DataMinCardinality(n R)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:minCardinality n.

_MinCardinality(n, P, rdfs#Literal)

qualified minimum cardinality

DataMinCardinality(n R D)

_:x rdf:type owl:Restriction.
_:x owl:onProperty R.
_:x owl:minQualifiedCardinality n.
_:x owl:onDataRange D.

_MinCardinality(n, R, D)

Restrictions Using n-ary Data Range

In the following table 'Dn' is an n-ary data range.

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

n-ary universal1

DataAllValuesFrom(R1 … Rn Dn)

_:x rdf:type owl:Restriction.
_:x owl:onProperties ( R1 … Rn ).
_:x owl:allValuesFrom Dn.

not supported

n-ary existential1

DataSomeValuesFrom(R1 … Rn Dn)

_:x rdf:type owl:Restriction.
_:x owl:onProperties ( R1 … Rn).
_:x owl:someValuesFrom Dn.

not supported

1Unsupported by OWL API and thus unsupported in ObjectLogic.

Properties

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

named object property

PN

PN

PN

universal object property

owl:topObjectProperty

owl:topObjectProperty

owl#topObjectProperty

empty object property

owl:bottomObjectProperty

owl:bottomObjectProperty

owl#bottomObjectProperty

inverse property

ObjectInverseOf(PN)

_:x owl:inverseOf PN

_InverseOf(PN)

Data Property Expressions

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

named data property

R

R

R

universal data property

owl:topDataProperty

owl:topDataProperty

owl:#topDataProperty

empty data property

owl:bottomDataProperty

owl:bottomDataProperty

owl:#bottomDataProperty

Individuals & Literals

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

named individual

aN

aN

 

anonymous individual1

_:a

_:a

_#‘a‘

literal (datatype value)

"abc"^^DN

"abc"^^DN

"abc"^^DN

1 The semantics of anonymous individuals is not supported by OntoBroker, instead anonymous individuals are mapped to unique ids on import.

Data Ranges

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

named datatype

DN

DN

DN

data range complement

DataComplementOf(D)

_:x rdf:type rdfs:Datatype.
_:x owl:datatypeComplementOf D.

_ComplementOf(D)

data range intersection

DataIntersectionOf(D1…Dn)

_:x rdf:type rdfs:Datatype.
_:x owl:intersectionOf (D1…Dn).

_IntersectionOf([D1, D2, …,Dn])

data range union

DataUnionOf(D1…Dn)

_:x rdf:type rdfs:Datatype.
_:x owl:unionOf (D1…Dn).

_UnionOf([D1, … ,Dn])

literal enumeration

DataOneOf(v1 … vn)

_:x rdf:type rdfs:Datatype.
_:x owl:oneOf ( v1 … vn ).

_OneOf([v1, … ,vn])

datatype restriction

DatatypeRestriction(DN f1 v1 … fn vn)

_:x rdf:type rdfs:Datatype.
_:x owl:onDatatype DN.
_:x owl:withRestrictions (_:x1 ... _:xn).
_:xj fj vj.      j=1…n

_DatatypeRestriction(DN, [f1, v1, … fn, vn])

Axioms

OWL 2 RL supports all axioms of OWL 2 apart from disjoint unions of classes (DisjointUnion) and reflexive object property axioms (ReflexiveObjectProperty).

Class Expression Axioms

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

subclass

SubClassOf(C1 C2)

C1 rdfs:subClassOf C2.

C1::C2

equivalent classes

EquivalentClasses(C1 C2)

C1 owl:equivalenClass C2.

_EquivalentClasses(C1, C2)

equivalent classes

EquivalentClasses(C1 … Cn)

Cj owl:equivalentClass Cj+1. j=1…n-1

_EquivalentClasses1([C1,…, Cn ])

disjoint classes

DisjointClasses(C1 C2)

C1 owl:disjointWith C2.

_DisjointClasses(C1, C2)

pairwise disjoint classes

DisjointClasses(C1 … Cn)

_:x rdf:type owl:AllDisjointClasses.
_:x owl:members ( C1 … Cn ).

_DisjointClasses1([C1,…, Cn ])

disjoint union

DisjointUnionOf(CN C1 … Cn)

CN owl:disjointUnionOf ( C1 … Cn ).

_DisjointUnionOf(CN, ([C1,…, Cn ])

Object Property Axioms

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

subproperty

SubObjectPropertyOf(P1 P2)

P1 rdfs:subPropertyOf  P2.

P1 << P2

property chain inclusion

SubObjectPropertyOf(ObjectPropertyChain(P1 … Pn) P)

P owl:propertyChainAxiom (P1 … Pn).

_ PropertyChain([P1, P2, …,Pn])

property domain

ObjectPropertyDomain(P C)

P rdfs:domain C.

C[P*=>rdfs#Resource]

property range

ObjectPropertyRange(P C)

P rdfs:range C.

 

equivalent properties

EquivalentObjectProperties(P1 … Pn)

Pj owl:equivalentProperty Pj+1. j=1…n-1

_EquivalentProperties1([P1 … Pn])

disjoint properties

DisjointObjectProperties(P1 P2)

P1 owl:propertyDisjointWith P2.

_DisjointProperties(P1 P2)

pairwise disjoint properties

DisjointObjectProperties(P1 … Pn)

_:x rdf:type owl:AllDisjointProperties.
_:x owl:members ( P1 … Pn ).

_DisjointProperties1([P1 … … Pn])

inverse properties

InverseObjectProperties(P1 P2)

P1 owl:inverseOf P2.

owl#Thing[P1{inverseOf(P2)*=>()]

functional property

FunctionalObjectProperty(P)

P rdf:type owl:FunctionalProperty.

owl#Thing[P{0:1}*=>()]

inverse functional property

InverseFunctionalObjectProperty(P)

P rdf:type owl:InverseFunctionalProperty.

owl#Thing[P{inverseFunctional}*=>()]

reflexive property

ReflexiveObjectProperty(P)

P rdf:type owl:ReflexiveProperty.

Not supported, since not supported in OWL RL

irreflexive property

IrreflexiveObjectProperty(P)

P rdf:type owl:IrreflexiveProperty.

owl#Thing [P {irreflexive} *=> ()].

symmetric property

SymmetricObjectProperty(P)

P rdf:type owl:SymmetricProperty.

owl#Thing [P {symmetric} *=> ()].

asymmetric property

AsymmetricObjectProperty(P)

P rdf:type owl:AsymmetricProperty.

owl#Thing [P {asymmetric} *=> ()].

transitive property

TransitiveObjectProperty(P)

P rdf:type owl:TransitiveProperty.

owl#Thing [P {transitive} *=> ()].

Data Property Axioms

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

subproperty

SubDataPropertyOf(R1 R2)

R1 rdfs:subPropertyOf R2.

R1 << R2

property domain

DataPropertyDomain(R C)

R rdfs:domain C.

C[R*=>rdfs#Resource]

property range

DataPropertyRange(R D)

R rdfs:range D.

owl#Thing[R*=>D]

equivalent properties

EquivalentDataProperties(R1 R2)

_EquivalentProperties(R1,R2)

equivalent properties

EquivalentDataProperties(R1 … Rn)

Rj owl:equivalentProperty Rj+1. j=1…n-1

_EquivalentProperties1([R1 … Rn])

disjoint properties

DisjointDataProperties(R1 R2)

R1 owl:propertyDisjointWith R2.

_DisjointProperties(R1 R2)

pairwise disjoint properties

DisjointDataProperties(R1 … Rn)

_:x rdf:type owl:AllDisjointProperties.
_:x owl:members ( R1 … Rn ).

_DisjointProperties1([R1 … … Rn])

functional property

FunctionalDataProperty(R)

R rdf:type owl:FunctionalProperty.

 

Datatype Definitions

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

datatype definition

DatatypeDefinition(DN D)

DN owl:equivalentClass D.

_DatatypeDefinition(DN, D)

Assertions

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

individual equality

SameIndividual(a1 … an)

aj owl:sameAs aj+1. j=1…n-1

_SameIndividual(a1, a2)

_SameIndividual1([a1 … an])

individual inequality

DifferentIndividuals(a1 a2)

a1 owl:differentFrom a2.

_DifferentIndividuals(a1, a2)

pairwise individual inequality

DifferentIndividuals(a1 … an)

_:x rdf:type owl:AllDifferent.
_:x owl:members (a1 … an).

_DifferentIndividuals1([a1 … an])

class assertion

ClassAssertion(C a)

a rdf:type C.

a:C

positive object property assertion

ObjectPropertyAssertion( PN a1 a2 )

a1 PN a2.

a1[PN ->a2]

positive data property assertion

DataPropertyAssertion( R a v )

a R v.

a[R ->v]

negative object property assertion

NegativeObjectPropertyAssertion(P a1 a2 )

_:x rdf:type owl:NegativePropertyAssertion.
_:x owl:sourceIndividual a1.
_:x owl:assertionProperty P.
_:x owl:targetIndividual a2.

_NegativePropertyAssertion(P, a1, a2 )

negative data property assertion

NegativeDataPropertyAssertion(R a v )

_:x rdf:type owl:NegativePropertyAssertion.
_:x owl:sourceIndividual a.
_:x owl:assertionProperty R.
_:x owl:targetValue v.

_NegativePropertyAssertion(R, a, v )

Keys

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

Key

HasKey(C (P1 … Pm) (R1 … Rn) )

C owl:hasKey (P1 … Pm R1 … Rn).
m+n>0

_HasKey(C, [P1,..,Pm, R1 … Rn] )

Declarations

Language Feature

OWL2 Functional Syntax

RDF Syntax

ObjectLogic Syntax

class

Declaration( Class( CN ) )

 

CN rdf:type owl:Class.

CN[].

datatype

Declaration( Datatype( DN ) )

 

DN rdf:type rdfs:Datatype.

DN:owl#DatatypeProperty

object property

Declaration( ObjectProperty( PN ) )

 

PN rdf:type owl:ObjectProperty.

PN:owl#ObjectProperty

data property

Declaration( DataProperty( R ) )

 

R rdf:type owl:DatatypeProperty.

R:owl#DataProperty

annotation property

Declaration( AnnotationProperty( A ) )

 

A rdf:type owl:AnnotationProperty.

A:owl#AnnotationProperty

named individual

Declaration( NamedIndividual( aN ) )

aN rdf:type owl:NamedIndividual.

aN: owl:NamedIndividual