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{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)

•	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