In this paper, we describe a content ontology design pattern to represent objects that can be simple or aggregated. The aggregation relation refers to several objects gathered in another object acting as a whole; all these objects should belong to the same concept in the model.
We usually have the need of representing objects that are made up
of other types of object. In these situations, we can use the part-of
[
However, sometimes we need to represent objects that can be made up of objects that belong to the same concept. In these cases it is also need to distinguish objects into simple or aggregated ones. For this reason, we have created the SimpleOrAggregated pattern to represent aggregation relationships, both transitive and non transitive, between objects that belong to the same concept in the model. An example of this situation can be “aggregated service provider is formed by simple or aggregated service providers”.
The goal of this pattern is to represent objects that can be simple or aggregated (that is, several objects gathered in another object acting as a whole). 28660 Boadilla del Monte, Spain
+34 913363672 The main difference between the aggregation relation and other mereological relationships (such as part-of or componency) is that the aggregated object and its aggregated members should belong to the same concept.
As it can be observed in Figure 1 the class "ObjectByCardinality" has been created to classify simple and aggregated objects into its subclasses "SimpleObject" and "AggregatedObject", respectively. These subclasses are disjoint among them.
ObjectByCardinality <<owl::equivalentClass>> Object
U
<<owl::equivalentClass>> SimpleObject <<owl::disjointWith>> AggregatedObject hasAggregatedMember <<owl::equivalentClass>>
<<owl::someValuesFrom>> AggregatedObject Object Object AggregatedObject <<rdfs::domain>> <<rdfs::range>> <<rdfs::domain>> <<rdfs::range>> <<owl::ObjectProperty>> <<owl::TransitiveProperty>> hasAggregatedMember <<owl::ObjectProperty>> hasDirectAggregatedMember <<owl::inverseOf>> <<owl::inverseOf>> <<owl::ObjectProperty>> <<owl::TransitiveProperty>> isAggregatedMemberOf <<owl::ObjectProperty>> isDirectAggregatedMemberOf
The aggregation relationship between objects means that objects of a class can be composed by other objects of the same class. This relationship is represented by the transtive property "hasAggregatedMember" and its inverse property "isAggregatedMemberOf". These properties have as subproperties the non transitive properties "hasDirectAggregatedMember" and its inverse "isDirectAggregatedMemberOf", respectively. By means of this structure of properties, we provide a mechanism (a) to represent transitive aggregation relationships (that is, if A has B as aggregated member and B has C as aggregated member then A has C as aggregated member) and (b) to link each aggregated member just to the next level (that is, A has B as direct aggregated member).
Finally, the class "AggregatedObject" has been defined as equivalent to those things that have some values for the property "hasAggregatedMember". This modelling allows the automatic classification of aggregated objects in this class when a reasoner is applied.
This content pattern allows designers to represent both simple individuals of a given concept (that is, an individual that is made up of itself) and aggregated individuals of a given concept (that is, an individual that is made up of several individuals of the same concept). In summary, this pattern allows to represent both simple objects and aggregated objects and their members.
In addition, this pattern can be used to detect the following contradictory situation by means of applying a reasoner: 'to instantiate the relationship "hasAggregatedMember" for an Object that belongs to "SimpleObject"'. This situation represents a consistency error and it is detected when a resoner is applied due to the following modelling decisions included in the pattern: (a) "AggregatedObject" class represents the "hasAggregatedMember" domain and (b) "AggregatedObject" is disjoint with "SimpleObject".
This pattern has been applied to different domains such as service providers and context sources during the mIO! ontology network1 development.
As an example, we show in Figure 2 the application of the SimpleOrAggegrated pattern to represent that a service provider can be classified as simple or aggregated. Each service provider can be also classified with respect to the type of service it provides (e.g. cultural, entertainment, food, health, etc.).
The origin of this pattern is the modelling of service providers and
context sources into the mIO! ontology network [
CulturalServiceProvider SimpleServiceProvider <<owl::disjointWith>> AggregatedServiceProvider hasAggregatedMember EntertainmentServiceProvider <<owl::equivalentClass>> FHoeoadltShCeravriecPerPorvoivdiedrer <<owl::someValuesFrom>> HostingServiceProvider
InformationServiceProvider ReligiousServiceProvider SecurityServicesProvider Shop SportServiceProvider TransportationServiceProvider
The SimpleOrAggregated pattern provides a mechanism to classify objects as simple or aggregated objects depending on whether they are an aggregation of some objects. This classification is compatible with another possible classification of objects.
This work has been partially supported by the Spanish project mIO! (CENIT-2008-1019).