# 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.

# Setting up Virtuoso on Ubuntu 18.04

I recently needed to setup a local instance of Virtuoso on my Ubuntu 18.04 laptop. In particular I needed to be able to specify the directory that Virtuoso is installed. This meant that using a Linux package manager was not an option. I therefore opted to install Virtuoso from source.

1. Here are the steps I followed to do this:
2. Then I followed the instructions to build Virtuoso from Building from Upstream Source.
1. Check build environment by running the following commands:
```sudo apt-get install dpkg-dev build-essential
sudo apt-get install autoconf automake libtool flex bison gperf gawk m4 make odbcinst libxml2-dev libssl-dev libreadline-dev
```
2. Extract the file:
`tar xvpfz virtuoso-opensource-7.2.2.tar.gz`
3. Now to configure Virtuoso to install to a directory of your choice, in the directory you extracted the `.tar.gz`, run the following:
```./configure --prefix=directory_of_choice
```
4. To build Virtuoso, run:
```make nice
```

This step failed for me with an error message that looks something like the following

``````make[3]: Entering directory '~/virtuoso-opensource/libsrc/Wi'
/bin/bash ../../libtool  --tag=CC   --mode=compile gcc -DHAVE_CONFIG_H -I. -I../../libsrc/Dk    -fno-strict-aliasing -O2  -Wall  -DNDEBUG -DPOINTER_64   -I/home/klimek/virtuoso-opensource/libsrc/Xml.new  -DOPENSSL_NO_KRB5 -Dlinux -D_GNU_SOURCE -DFILE64 -D_LARGEFILE64_SOURCE   -I../../libsrc -I../../libsrc/Dk -I../../libsrc/zlib -I. -I../../libsrc/langfunc -I../../libsrc/plugin -I../../libsrc/Tidy -I../../libsrc/Xml.new -I../../libsrc/odbcsdk/include -DVAD -DDBP -DBIF_XPER -DOPSYS=\"Linux\" -DHOST=\"x86_64-unknown-linux-gnu\" -g -O2 -MT libwi_la-bif_crypto.lo -MD -MP -MF .deps/libwi_la-bif_crypto.Tpo -c -o libwi_la-bif_crypto.lo `test -f 'bif_crypto.c' || echo './'`bif_crypto.c
libtool: compile:  gcc -DHAVE_CONFIG_H -I. -I../../libsrc/Dk -fno-strict-aliasing -O2 -Wall -DNDEBUG -DPOINTER_64 -I/home/klimek/virtuoso-opensource/libsrc/Xml.new -DOPENSSL_NO_KRB5 -Dlinux -D_GNU_SOURCE -DFILE64 -D_LARGEFILE64_SOURCE -I../../libsrc -I../../libsrc/Dk -I../../libsrc/zlib -I. -I../../libsrc/langfunc -I../../libsrc/plugin -I../../libsrc/Tidy -I../../libsrc/Xml.new -I../../libsrc/odbcsdk/include -DVAD -DDBP -DBIF_XPER -DOPSYS=\"Linux\" -DHOST=\"x86_64-unknown-linux-gnu\" -g -O2 -MT libwi_la-bif_crypto.lo -MD -MP -MF .deps/libwi_la-bif_crypto.Tpo -c bif_crypto.c  -fPIC -DPIC -o .libs/libwi_la-bif_crypto.o
bif_crypto.c: In function ‘box_hmac’:
bif_crypto.c:184:12: error: storage size of ‘ctx’ isn’t known
HMAC_CTX ctx;
^~~
bif_crypto.c:190:3: warning: ‘HMAC_Init’ is deprecated [-Wdeprecated-declarations]
HMAC_Init (&ctx, key, box_length (key) - DV_STRINGP (key) ? 1 : 0, md);
...``````

which I fixed by installing `libssl1.0-dev` with

```sudo apt-get install libssl1.0-dev
```

You can read more on this error here.
After this re-run `make nice`.

5. Lastly, I ran
```make install
```

because I installed Virtuoso in my `home` directory. If you are not installing it in you `home` directory, you will need to run

```sudo make install
```
3. To test your installation, go to `localhost:8890`.

# 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.