Home » Posts tagged 'semantic web'
Tag Archives: semantic web
The difference between Schema.org and OWL
In this blog post I describe some of the main differences between Schema.org vocabularies and OWL ontologies, the implications of these differences and the kind of steps you will need to take to translate Schema.org vocabularies to OWL ontologies.
Overall I keep this discussion at a high-level. For in-depth reviews of the differences between Schema.org and OWL I provide relevant links at the end of this post.
There are 2 main differences between OWL and Schema.org.
- Intended purpose: The primary purpose of Schema.org is to enable sharing of structured data on the internet. The primary purpose of OWL is to enable sophisticated reasoning across the structure of your data.
- Difference in language: Due to the difference in purpose, there are substantial differences in language. The main reason being that the language for OWL can be translated into precise mathematical logic axioms, which allows for much richer inferences to be drawn. This is the reason for OWL preferring
schema:domainIncludes/schema:rangeIncludes. The benefit of using
rdfs:domain/rdfs:rangeis that they have precise defined mathematical logic meaning, whereas
schema:domainIncludes/schema:rangeIncludesdo not have mathematical meaning.
What does this mean?
Using Schema.org you could draw some limited inferences. For example a reasoner can determine that the SNOMED concept
http://purl.bioontology.org/ontology/SNOMEDCT/116154003 is a
schema:Patient which is a
schema:Person. But the language used in Schema.org by itself is not rich enough to detect inconsistencies. I.e., there is no way to say that
schema:Person is disjoint from
schema:Product. This allows for stating
myexample:john a schema:Person and
myexample:john a schema:Product without a reasoner being able to detect the inconsistency. Using OWL it is possible to state that
schema:Product are disjoint.
Does this mean you should prefer OWL to Schema.org? No, not if your intended purpose of your ontology is to share data. Then it is best to use concepts from Schema.org and add the axioms that will provide the inferences you need. If reasoning is not your reason for wanting to use Schema.org/OWL, then just use Schema.org.
Can you translate Schema.org to OWL?
Strictly speaking, since RDF & RDFS is a subset of OWL, Schema.org is an OWL definition already, albeit one with limited reasoning capability. Any “translation” to OWL will mean adding axioms to Schema.org to increase the inferences that can be drawn from Schema.org documents. It is a pity that Schema.org does not (the current link to the OWL file is dead) provide an OWL file with the additional axioms that will enable richer reasoning.
rdfs:rangerestrictions rather than replacing
schema:rangeIncludescould result in search engines not finding information.
owl:disjointObjectPropertiesrespectively for all classes and properties that do not share individuals.
- By looking at the documentation of Schema.org it gives the impression that classes have attributes. I.e.,
schema:Personhas an attribute
schema:givenName. However, there is nothing in the definition of
schema:Personthat enforces that the
schema:Personclass must have a
schema:givenNameattribute. I describe here, here and here how to define “attributes” for classes in a way that can be used by OWL reasoners.
Schema.org is mainly for sharing structured data on the Internet. OWL is used mainly to reason over structured data to determine inconsistencies in the schema.
For in-depth discussions on the differences between Schema.org and OWL I highly recommend reading the papers by Patel-Schneider and Hernich et al.
EquivalentTo versus SubClassOf
In creating their first OWL ontology, there are at least two aspects of
SubClassOf that perplex users. The first is when to use
EquivalentTo and when to use
SubClassOf. The second problem is best illustrated by the following example:
ObjectProperty: a_to_b Class: A1 EquivalentTo: (a_to_b some B) Class: A2 SubClassOf: (a_to_b some B) Class: B Individual: b1 Types: B Individual: x Facts: a_to_b b1
When running a reasoner on this example, the individual
x is inferred to be of type
A1. What perplex users sometimes is that
x is not inferred to be of type
A2 as well. This is shown in the next figure.
The difference between
The first thing to be aware of wrt
equivalentTo is that
Class: C EquivalentTo: D
is an abbreviation for
Class: C SubClassOf: D Class: D SubClassOf: C
The semantics of
SubClassOf is subset. Thus, the above states that the set
C is a subset of the set
D and the set
D is a subset of the set
C. Which means that the sets
D are exactly the same set. We say they are equivalent.
Note that if I know that the classes
C2 are both subclasses of class
C, there is nothing more I can say about how class
C1 relates to class
C2. This is a bit like knowing that bicycles and trucks are both vehicles – I can say nothing more about how bicycles relate to trucks beyond knowing that they are both vehicles.
Back to our initial example
Understanding the semantics of
EquivalentTo we can see that indeed the individual
x is an instance of
A1. Understanding the semantics of
SubClassOf helps us to understand why
x is not inferred to be of type
A2. We know that
A2 is a subclass of
a_to_b some B and that
x is an instance of
a_to_b some B, but there is nothing that can force the reasoner to infer that
x is necessarily an instance of the class
A2. This is illustrated in the next figure.
When to use
EquivalentTo is used for definitions. That is when you want to state the necessary and sufficient conditions for a concept.
SubClassOf is used when you want to define a hierarchy from the most general to the most specific. I.e., it is typically what you see in taxonomies or in object oriented programming languages where one can define class hierarchies. In fact there is a strong relation between OWL 2 ontologies and object orientation which I explore here in more detail.
In this post I explained the difference between
SubClassOf and how they are used, as well as some inferences thatmay be confusing to new users. You can find the example ontology on GitHub.
Rule Execution with SHACL
In my previous post, Using Jena and SHACL to validate RDF Data, I have looked at how RDF data can be validated using SHACL. A closely related concern to that of constraints checking, is rule execution, for which SHACL can also be used.
A SHACL Rule Example
We will again use an example from the SHACL specification. Assume we have the a
file rectangles.ttl that contains the following data:
Assuming we want to infer that when the height and width of a rectangle are equal, the rectangle represents a square, the following SHACL rule specification can be used (which we will store in
A Code Example using Jena
Naturally you will need to add SHACL to your Maven pom dependencies. Then the following code will execute your SHACL rules:
Running the Code
Running the code will cause an
inferences.ttl file to be written out to
$Project/src/main/resources/. It contains the following output:
ex:InvalidRectangle has been ignored because it does not adhere to
sh:condition ex:Rectangle, since it does not have
ex:width properties. Also,
ex:NonSquareRectangle is a rectangle, not a square.
In this post I gave a brief overview of how SHACL can be used to implement rules on RDF data. This code example is available at shacl tutorial.