Home » Semantic technologies » OWL
Category Archives: OWL
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.
Key differences
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
rdfs:domain/rdfs:range
toschema:domainIncludes/schema:rangeIncludes
. The benefit of usingrdfs:domain/rdfs:range
is that they have precise defined mathematical logic meaning, whereasschema:domainIncludes/schema:rangeIncludes
do 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:Person
and 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.
- Add
rdfs:domain
andrdfs:range
restrictions rather than replacingschema:domainIncludes
andschema:rangeIncludes
. Replacingschema:domainIncludes
andschema:rangeIncludes
could result in search engines not finding information. - Add
owl:disjointWith
andowl:disjointObjectProperties
respectively 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:Person
has an attributeschema:givenName
. However, there is nothing in the definition ofschema:Person
that enforces that theschema:Person
class must have aschema:givenName
attribute. I describe here, here and here how to define “attributes” for classes in a way that can be used by OWL reasoners.
Conclusion
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 EquivalentTo
and 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 EquivalentTo
and SubClassOf
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 C
and D
are exactly the same set. We say they are equivalent.
Note that if I know that the classes C1
and 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
versus SubClassOf
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.
Conclusion
In this post I explained the difference between EquivalentTo
versus 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.
Understanding OWL min vs max vs exactly Property Restrictions
The open world assumption trips people up in many ways. In this post we will be looking at how the open world assumption affects the semantics of the property restrictions min
, max
and exactly
.
The example we will use throughout this post is that of a product that may have no price, 1 price, exactly 1 price, or many prices. We will firstly assume a product must have at least 1 price, then that it can have a maximum of 1 price, and finally we will assume that it must have exactly 1 price. We therefore assume that we have a hasPrice
data property that is defined as follows:
DataProperty: hasPrice Range: xsd:decimal
The example ontology can be found on GitHub. To be able to distinguish the different product types having different rules regarding how many prices they have, we will create 3 different classes called ProductWith_Min_1_Price
, ProductWith_Max_1_Price
and ProductWith_Exactly_1_Price
respectively.
Before we look at examples and the semantics of the min
, max
, exactly
property restrictions, let us briefly recall what is meant by the open world assumption.
Open World Assumption versus Closed World Assumption
OWL has been designed with the explicit intention to be able to deal with incomplete information. Consequently, OWL intentionally does not make any assumptions with regards to information that is not known. In particular, no assumption is made about the truth or falsehood of facts that cannot be deduced from the ontology. This approach is known as the open world assumption. This approach is in contrast with the closed world assumption typically used in information systems. With the closed world assumption facts that cannot be deduced from a knowledge base (i.e. database) are implicitly understood as being false [1, 2, 3].
As an example, in a database when a product does not have a price, the general assumption is that the product does not have price. Moreover, in a database if a product has 1 price, the assumption is that the product has only 1 price and no other prices. This in stark contrast to OWL. If an OWL ontology defines a product for which no explicit price is given, the assumption is not that the product has no price. Rather, no assumption is made as to whether the product has a price, has many prices or whether it has no price. Futhermore, if a product has a price, the assumption is not that this is necessarily the only price for that product. Rather, it allows for the possibility that no other price may exist, or that many other prices may exist, which is merely not known. The only information that holds in an ontology is information that is either explicitly stated, or that can be derived form explicit information.
The min
Property Restriction
To define a product that must have at least 1 price we define it as follows:
Class: ProductWith_Min_1_Price SubClassOf: hasPrice min 1 xsd:decimal Individual: productWithoutPrice Types: ProductWith_Min_1_Price
If we now create an individual of type ProductWith_Min_1_Price
, say productWithoutPrice
, which has no price information, we will find that the reasoner will not give an inconsistency. The reason for this is that the reasoner has no information with regards to whether productWithoutPrice
has any price information. Hence, it is possible
that productWithoutPrice
has a price (or prices) that is merely unknown. To make explicit that productWithoutPrice
has no price information, we can define it as follows:
Individual: productWithoutPrice Types: ProductWith_Min_1_Price, hasPrice max 0 xsd:decimal
This revised definition of productWithoutPrice
will now result in the reasoner detecting an inconsistency. However, note that ProductWith_Min_1_Price
allows for products
that have more than 1 price. Hence, the following will not result in an inconsistency.
Individual: productWithManyPrices Types: ProductWith_Min_1_Price Facts: hasPrice 2.5, hasPrice 3.25
The max
Property Restriction
To define a product that cannot have more than 1 price, we can define it as
follows:
Class: ProductWith_Max_1_Price SubClassOf: hasPrice max 1 xsd:decimal
If we now define an individual productWithMoreThan1Price
with more than 1 price (as shown in the example below), the reasoner will detect an inconsistency.
Individual: productWithMoreThan1Price Types: ProductWith_Max_1_Price Facts: hasPrice 2.5, hasPrice 3.25
Note that individuals of type ProductWith_Max_1_Price
can also have no price information without resulting in the reasoner giving an inconsistency. I.e., if we define the individual productWithoutPrice
as
Individual: productWithoutPrice Types: ProductWith_Max_1_Price, hasPrice max 0 xsd:decimal
it will not give an inconsistency.
The exactly
Property Restriction
Let us now define ProductWith_Exactly_1_Price
with the individual productWithExactly1Price
as follows:
Class: ProductWith_Exactly_1_Price SubClassOf: hasPrice exactly 1 xsd:decimal Individual: productWithExactly1Price Types: ProductWith_Exactly_1_Price Facts: hasPrice 7.1
The exactly property is essentially syntactical shorthand for specifying both the min and max restrictions using the same cardinality. Thus, we could just as well have defined ProductWith_Exactly_1_Price
as:
Class: ProductWith_Exactly_1_Price SubClassOf: hasPrice min 1 xsd:decimal, hasPrice max 1 xsd:decimal
or, given the classes we have already defined in the ontology, we can define it as:
Class: ProductWith_Exactly_1_Price SubClassOf: ProductWith_Max_1_Price, ProductWith_Min_1_Price
Prefer exactly
Given that the exactly property restriction is syntactical sugar, should we prefer using the combination of min and max directly as shown above? My answer to this is no. My motivation for this is that the semantics of exactly
is only equivalent to the intersection of min
and max
if the cardinalities are the same and the data/object types are the same. As such specifying
Class: ProductWith_Exactly_1_Price SubClassOf: hasPrice exactly 1 xsd:decimal
has less opportunities for mistakes than specifying
Class: ProductWith_Exactly_1_Price SubClassOf: hasPrice min 1 xsd:decimal, hasPrice max 1 xsd:decimal
Conclusion
In this post we looked at some of the ways in which the min
, max
and exactly
property restrictions can trip people up due to the open world assumption. Please feel free to leave a comment if you have questions or suggestions about this post.
References
1. F. Baader and W. Nutt, Basic Description Logics, The Description Logic Handbook: Theory, Implementation and Applications (F. Baader, D. Calvanese, D. L. McGuinness, D. Nardi, and P. Patel-Schneider, eds.), Cambridge University Press, New York, USA, 2007, pp. 45–104.
2. M. Krötzsch, F. Simančı́k, and I. Horrocks, A Description Logic Primer, Computing Research Repository (CoRR) abs/1201.4089 (2012).
3. S. Rudolph, Foundations of Description Logics, Proceedings of the 7th International Conference on Reasoning Web: Semantic Technologies for the Web of Data (A. Polleres, C. d’Amato, M. Arenas, S. Handschuh, P. Kroner, S. Ossowski, and P. F. Patel-Schneider, eds.), Lecture Notes in Computer Science, vol. 6848, Springer, 2011, pp. 76–136.