Focused categorization power of ontologies: General framework and study on simple existential concept expressions

1.1.Working assumptions

Our proposed approach to enhancing web ontology reuse is based on four assumptions:

The first two assumptions are supported, among other, by the findings of a study on competency questions by Ren et al., from 2014 [17]. They collected 168 competency questions (CQ) from two ontology projects, and clustered them into twelve archetypes. Of them, at least three correspond to tasks that can be characterized as sub-categorization of instances of a relatively generic class (here, pizza or software), namely:22

Note that while Assumption #2 gives a value to compound class expressions, we can realistically expect that for certain reuse cases (e.g., when the categories have to be imported into a static hierarchy such as a thesaurus or product catalog on a web page) the compound class expressions have to be structurally and lexically transformed to named classes.

The validity of Assumption #3 obviously depends on the meaning of “(ontology) provides (categories)”. Namely, an ontology is, structurally, a collection of axioms rather than of categories (class expressions). The generation of categories from ontology axioms, allowing for their aggregated ‘counting’ by a metric, will essentially be a heuristic process.

Assumption #4 brings a bottleneck: the respective notion of quality escapes an automatic empirical evaluation, as it depends on the subjective perception of users. We however believe that the direct human perception factor is indispensable for assuring the versatility of the reused schema with respect to different use cases. We could of course imagine some alternative, indirect quality measures, in particular, the distinction whether an expression would fit the expressiveness of the query engine to be used for querying the dataset described with the ontology. There could be however many mutually overlapping queries, and the expressions corresponding to each of them would only mildly contribute to the semantic underpinning of the dataset. Imagine for example two ontologies: ontology A has two relevant atomic concepts (subclasses of the focus class), and ontology B has four of them. Without caring for human perception, we might be tempted to construct the compound categories using the conjunction operator, since conjunctive queries are the cornerstone of ontology-based data access. Ontology B would then probably achieve a far higher value of the aggregating metric, having five times more (15 vs. 3) possible non-empty conjunctions) than ontology A. It could however easily happen that none of the conjunctions would have any special meaning beyond that trivially following from its constituents, which would make this strong degree of preference for ontology B rather inadequate. For these reasons, and also due to the fact that the computational use of the reused ontologies may be rather diverse and unpredictable a priori, we view the metric computation as rather agnostic of this usage.

1.2.Motivating example

Let us now present a concrete motivation example, which we will use throughout the paper to illustrate various components of our approach.

To name some hypothetical applications (in the context of this particular domain) where the category-centric processing of data would make sense:

1.3.Summary of the approach

We will now leverage on the presented example in order to explain the idea of our approach in intuitive terms, prior to formalizing it in Section 2. We will present the basic principles of focus categorization power computation, explain its broader ontology reuse context, and clarify the used terminology.

Focus categorization power computation OWL [27], being a primarily concept-based formal ontology language, allows to create compound class expressions of many kinds using a large collection of constructors. We define the notion of concept expression language33 as a restricted formal sublanguage of OWL that only allows the creation of (certain kinds of) class expressions. The language consists of concept expression patterns (CE patterns), defining the structure of the expression, and of further restrictions (that cannot be conveniently expressed through the patterns themselves).

Depending on the chosen language, we can build, from the signature (i.e., set of classes, properties and individuals) of an ontology, composed class expressions, for example, ∃hasParkingCamera.⊤ (if the language allows the existential restriction, say, through the CE pattern ∃P.C; ⊤ is the top concept, i.e., ‘anything’), for cars with a parking camera, or, Van⊔Limousine (if the language allows the union operator, through the CE pattern C⊔D), for cars that are either a van or a limousine. Expressions that can conform to a language L will be denoted as L-expressions.

These expressions can further subcategorize entities of which we already know their focus class, i.e. Car (or, Vehicle or similar). The conjunction of the focus class FC and the subcategorizing expression will be denoted as an L-category of FC. In our case, one of the L-categories of Car could be Car⊓∃hasParkingCamera.⊤.

A concept expression language and the signature of the ontology alone are not sufficient as input for building ‘meaningful’ categories. In most cases, the vast majority of the combinations of entities (fitting the language structure) would be nonsensical, as the entities would be mutually irrelevant. Therefore, we need one more ingredient: heuristic syntactic patterns relying on templated axioms. Upon successfully matching such a pattern (called FCE pattern) to the ontology as collection of axioms, a class expression will be constructed, with the help of a mapping function specific for the given FCE pattern. An example of an FCE pattern, later formally defined in Section 4, Equation (7)), is that expecting the existence of a domain axiom for a certain property, stating that the subject of this property is the focus class. In our example, an axiom might state that the domain of the hasParkingCamera property is Car. Consequently, under some conditions, the CE ∃hasParkingCamera.⊤ would be generated through the mapping function that is part of the FCE pattern.

The ability of the ontology to subcategorize the focus class, the focus categorization power (FCP), would ideally be expressed as a sum of weights (degrees of ‘meaningfulness’) of all individual class expressions that have been generated. For example, as humans we can judge that Car⊓∃hasParkingCamera.⊤ would be a much more meaningful category of Car than Car⊓∃hasEngine.⊤ (since a car is nearly always sold together with its engine, it is useless to explicitly distinguish it) or Car⊓∃hasSeller.Child (since a car is probably never sold by a child). Such a judgement is however beyond the reach of a machine – at least, unless equipped with cutting-edge common-sense reasoning, which would be a sledgehammer for a nut when merely trying to suggest ontologies for reuse. Therefore we propose to approximate the ‘meaningfulness’ – or, in more practical terms, reusability – of individual class expressions with the ‘average’ reusability of their underlying concept expression patterns (bundled with their corresponding syntactic FCE patterns). In this respect, ∃hasParkingCamera.⊤ and ∃hasEngine.⊤, having the same underlying structure (concept expression pattern), will be counted with the same weight, but ∃hasSeller.Child will be counted with a different weight in the FCP calculation, since it has a specific class (Child) as the restriction filler, instead of the top concept (⊤).

Ontology reuse process Considering the used-cars example as an end-to-end scenario, the (re)usability analysis of a set of ontologies should first seek in them, using lexical methods, classes expressing the general notion of ‘vehicle’. In each ontology, it will make such a class the focus class, and perform the FCP calculation with respect to it. A high value of the FCP will indicate the suitability of the given ontology for becoming a part of the schema of the website’s data. Then the actual reuse will take place, in which the previously generated compound class expressions could become the definitions of new named classes. In the navigation structure of the used-cars website, the compound concepts thus would not have to be served as logical formulas, but could be transformed (ideally, in a partially automated way) into regular noun phrases that would, explicitly or implicitly, correspond to named OWL classes – e.g., Cars that have parking camera.

Terminological note In the context of introducing the terminology to be employed in the rest of the paper, we should also make explicit our usage of (closely related) terms concept, class and category. For the first two, we subscribe to the common practice within the semantic web community, where both are used nearly interchangeably, with ‘concept’ being more prominent within the description logic literature, while ‘class’ being the official term used in OWL specifications. ‘Concept’, in more general terms, can also be the calling for the intension of the class, i.e., for its underlying meaning independent of its extension (set of instances). To maintain the link with OWL specifications, we denote the individual expressions as ‘class expressions’; however, in the newly introduced terms (‘concept expression pattern’, ‘concept expression language’) we use the ‘concept’ alternative, to hint at the important role of human perception in our research. Finally, as regards the term ‘category’, we endow it with particular flavor: as we see, a category is always related to a more general class/concept (i.e., the focus class) which it subcategorizes. Additionally, we associate a category with a certain concept expression language L in which it can be expressed (this is why we will formally introduce it as an L-category in Section 2).

1.4.Research contributions and paper structure

The research presented in this paper aims to bring the following contributions:

The present paper is an evolution of a previous conference paper [22], which provided a brief explanation of the notion of FCP, informally proposed a concept expression language with FCE patterns, and provided the results of a first cognitive experiment. The present paper however extends the previous one along numerous axes, and the majority of its volume consists of entirely new content:

The rest of the paper is structured as follows. Section 2 provides a formalization of the focused categorization power framework (outlined in intuitive terms in Section 1.3). Section 3 introduces a CEL having suitable properties for an initial study. Section 4 complements this language with FCE patterns. Section 5 surveys the occurrence of concept expression patterns in ontology axioms. Section 6, analogously, surveys the occurrence of FCE patterns in the Tbox of ontologies. Section 7 describes a series of cognitive experiments in which humans provided an assessment of ‘meaningfulness’ of class expressions belonging to different patterns. Section 8 provides a comparison of those complementary surveys and experiments and a summarizing discussion. Section 9 describes a tentative operationalization of the results from the analyses, and explains the functionality of the implemented OReCaP prototype. Section 10 reviews some related methods and projects. Finally, Section 11 wraps up the paper and outlines the directions for future work.

2.1.Concept expression language

The use of the syntactic constructors in OWL can be restricted in different ways, producing a formal system in logic often called a fragment or sublanguage. There is a number of decidable fragments of description logics [8]. The so-called OWL Profiles as sublanguages of OWL defined in the current OWL 2 standard are examples of such fragments [26]; however, non-standardized restricted sublanguages of OWL may be also be useful for particular tasks, as here.

The notion of concept expression language, in our terms, is based upon a set of concept expression patterns constructed over a set of variables together with a set of allowed substitutions for those variables. Given a particular ontology signature, a concept expression language generates a set of concept expressions by applying all allowed substitutions to all patterns.

Let us first recall or introduce a few preliminary notions. A signature is a triple S=(CS,PS,IS) of sets of classes CS, properties PS, and individuals IS, collectively called entities. The signature of an ontology O is the signature sig(O)=(CO,PO,IO) where CO, PO, IO are respectively the sets of all classes, properties and individuals occurring in O (cf. [27, Section 5]). Note that the punning feature of OWL 2 allows these sets to be non-disjoint. By PES and CES we denote, respectively, the sets of property expressions and class expressions (CEs) over the signature S, defined in the standard way [27, Sections 6 and 8].

In order to bring in the notions of variable and substitutions, let us introduce a special signature V=(CV,PV,IV) such that the sets CV={C,C1,C2,…}, PV={P,P1,P2,…}, IV={i,i1,i2,…} are countable, infinite, and mutually disjoint. The entities in CV, PV, IV will be, respectively, called class variables, property variables, and individual variables, and collectively we will call them variables. Class expressions CEV and property expressions PEV over V are then called concept expression patterns (CE patterns, for brevity) and property expression patterns, respectively.

Further, given a signature S, any function σ that maps class variables to class expressions over S (i.e., σ(C)∈CES for each C∈CV), property variables to property expressions over S (σ(P)∈PES for each P∈PV), and individual variables to individuals in S (σ(i)∈IS for each i∈IV) is called a substitution. Let ΣS denote the set of all substitutions for a signature S. Substitutions can easily be inductively extended to property and concept expression patterns in the obvious way, e.g., σ(p−)=σ(p)−, σ(c1⊔c2)=σ(c1)⊔σ(c2), σ(∃p.c)=∃σ(p).σ(c), σ({i1,…,in})={σ(i1),…,σ(in)}, etc. (cf., Baader & Narendran [2]).

With preliminaries in place, we may proceed to our definitions.

One example of a CEL may be the trivial language of named concepts Lnam=({C},Rnc) where the subtitution-restricting function Rnc only allows a named (atomic) class to be substituted for C. Thus for every signature S, the set Rnc(S) contains substitutions that map the class variable C to a member of CS.

Another CEL example is the language of existential restrictions to the top concept Lextop=({∃P.⊤},Rnp) where for each signature S the set Rnp(S) contains only substitutions that map the property variable P to a named property of S.

For clarity, we explicitly define the notion of class expressions generated by a CEL:

2.2.L-categories and focused categorization power

Only some of the L-expressions in an ontology signature are relevant for us: those sub-categorizing the given focus class; we denote them as L-categories for this class. This will allow us to formulate the notion of FCP, at the abstract (non-operational) level first.

Within this paper we will sometimes informally refer to a DCE as to the subcategory of the class FC. Note, however, that DCE is a mere syntactic notion, as for some FC and D it would not hold that FC⊓D would ‘differentiate’ among the instances of FC – i.e., as we will discuss later, FC⊓D may not be extensionally a proper subconcept (subcategory) of FC.

The capability of O to finer subcategorize the resources that are already known to belong to FC can be, at an abstract level, expressed in terms of the number as well as ‘quality’ of L-categories for FC in O, for a suitably selected L. We will denote the measure of this capability as focused categorization power (FCP) of O with respect to FC over L; the class FC plays the role of a focus class. Formally:

2.3.Weight function desiderata

Still remaining at the (non-operational) ‘guideline’ level, we should discuss some desiderata of the weight function just introduced. Intuitively, leveraging on some of the assumptions from Section 1.1, an ideal function w(Cat,O,FC) should take into account the following four characteristics of an L-category Cat:

Checking whether the size of a category Cat (whether absolute, or relative vs. FC) is such that leads to w(Cat,O,FC)=0 is to some degree possible via a DL reasoner. This characteristic is thus the only one we will explicitly consider in the FCP computation. Let us provide a preliminary illustration of such a consideration, on the previously introduced language of named classes, Lnam. Each Lnam-category is a conjunction of the given focus class FC and another named class D. Intuitively, w(FC⊓D,O,FC) should be 0 for such D that either FC⊓D=∅ (i.e., for classes disjoint with FC) or FC⊑D (i.e., for superclasses of FC) due to violating the hard constraint on absolute/relative size. On the other hand, w should be high (presumably even equal to 1) for the asserted (even transitive) subclasses of FC, since these are the concepts viewed as proper subcategories of FC by the ontology designer/s. Note however that w might deserve to be non-zero even for some other non-disjoint classes. For example, Student⊓Teacher can be a valid category of the FC Student in an academic ontology, since some graduate students may also have a teacher contract; obviously, none of the classes would be a subclass of the other.

2.4.Focused category extraction pattern

Before proceeding to an operational elaboration of the category weight function in FCP computation, we need to return to the problem of category generation. While the CE patterns defining a given CEL allow for substitutions producing class expressions to be ‘counted’ in the FCP computation, such expressions cannot be directly extracted from the OWL code, which consists of (TBox, and sometimes ABox) axioms and not of standalone expressions. We will thus introduce the general notion of focused category extraction pattern – a pattern for transforming OWL axioms occurring in ontologies to class expressions to be used as the DCE of categories of a focus class.

The definition of a focused category extraction pattern relies on OWL axiom templates (axioms containing variables) that can be matched to an OWL ontology through a unification substitution (returning a set of variable bindings with ontology entities). In order to eliminate undesirableg matches without burdening the axiom templates with complex (negated) descriptions of exceptions, validity constraints are furthermore introduced. Finally, the generation of CEs is carried out by mapping functions.

Considering we have two kinds of patterns (CE and FCE), which both abstract over some OWL structures, a question naturally arises why these two could not be more integrated or based one upon the other, e.g., in the sense that both the LHS and RHS of an FCE pattern axiom template would be CE patterns. There are however two factors that would make such an integration cumbersome or impossible:

2.5.Hypothetical sources of category weight

Assignment of a weight w to a certain L-category Cat=FC⊓D while computing FCP(O,FC,L) in (1) could be hypothetically based on a number of different sources, possibly in combination; note that the sources refer to both CE patterns and FCE patterns, which we have previously distinguished:

Let us demonstrate these sources on the vehicle domain of our motivating example.

2.6.Weight of individual category vs. of CE pattern

As suggested in the previous subsection, the ultimate weight of a category can be influenced both by the factors specific for the particular category and by the CE pattern type of the DCE of this category. The category weight computation (for the sake of FCP computation, see Equation (1), i.e., still at the non-operational level) could be possibly decomposed as

As regards the CE pattern weight wP, we are aware of three empirical sources, in turn, which might provide a quality estimate of a certain CE pattern (and thus, indirectly, the individual categories in which the DCE would match this CE pattern):

Orthogonally, we can also aggregate the occurrence counts of FCE patterns in ontologies. This fourth source, in turn, will indicate the upper bound of the quantity of categories that can be obtained for a focus class using such patterns.

In different sections of the paper we will empirically investigate three of the sources identified in this subsection: the CEs in axioms in Section 5, the FCE patterns in Section 6, and the human assessment of FC+category pairs in Section 7 (thus only deferring the Abox analysis to later research), and discuss their potential and limitations in more detail.

To avoid any mismatch of the presented four ‘weight sources’ list with the (also four) ‘weight sources’ from Section 2.5, note that the sources from Section 2.5 are applied ‘deductively’, to estimate the weight of a particular category, while the sources in this section serve for ‘inductive’ derivation of the (average) weight pertaining to a whole CE pattern.

2.7.FCP approximation via FCE patterns

We will now specifically consider the situation when the Abox information on the usage of a specific category is either unavailable or unreliable, and we thus have to derive the category weight from the ontology alone. Under such conditions, the individual weight function wI is likely to be Boolean: the FCE pattern axiom templates Tpl are either matched or not, and, similarly, the verification of constraints Cons over the ontology inferential closure will typically either judge the category as useless (unsatisfiable, or with a singleton extension, or equivalent to the FC) or not. Under the assumption of a Boolean wI, we can express the overall weight of a category as a simple product:

Let us then assume that we distinguish among k CE patterns allowed in the CEL L, CPL={c1,…,ck}, each associated with a weight via the CE pattern weight function wP. Let each CE pattern ci be also associated with a set of FCE patterns PSi={pi1,…,piji} that allow to construct the corresponding categories from the axioms of ontologies. Then we can express the approximate FCP of an ontology O for a focus class FC over L with respect to the (set of) FCE pattern sets PS={PS1,…,PSk} as the weighted sum of the FCE pattern occurrence counts in O:

Note that in terms of Eq. (3), the multiplication by wP(ci) (the CE pattern weight) is now performed over the counts of FCE pattern occurrences and not over the individual category weights, but the final weighted sum will be the same as if the weights of all individual categories produced by Eq. (3) were summed according to formula Eq. (1). Although the formulas for FCP (Eq. (1)) and FCPˆ (Eq. (4)) appear dissimilar, their intention is the same; FCPˆ=FCP would even hold under the assumptions that

2.8.Pattern-based CE extraction and approximate FCP computation algorithm

The computational process leading to extraction of class expressions using FCE patterns is rather straightforward with respect to the general description of the approach in Section 2.7, see the algorithm pseudo-code in Listing 1. Each call of the function match(O,FC,pij) returns a class expression generated by a new match of pij in O respective to the given focus class FC, and taking into account the constraints Cons in the pattern; when no new CE can be generated, the function returns false. As a result, a set CE of pairs “CE pattern, CE” is returned. The only additional step is the pruning of mutually equivalent CEs, which should be only counted once (lines 14–31). First, for each CE from CE, an auxiliary named class is generated (by function newIRI) and stored, and an axiom defining this auxiliary class as equivalent to the given CE is added to an auxiliary version of the ontology (line 19). In the deductive closure of this auxiliary ontology, equivalence axioms between pairs of auxiliary classes are then sought (line 24), and for each such pair, only one of the CEs is retained. The choice of the CE to be discarded could be based on the weight of the CE patterns:

For completeness, we also include the approximate FCP computation algorithm, as Listing 2. It simply amounts to summation of CE pattern weights wP over the collected class expressions.

Listing 1.

Pattern-based CE extraction algorithm

Listing 2.

Computation of approximate FCP

2.9.Summary and links to the remainder of the paper

With the algorithm, we now have a general operational framework allowing us to approximately calculate the FCP of an ontology with respect to a focus class, relying purely on the axioms from the ontology.

The framework still needs to be instantiated with three components:

4.1.Inventory for LSE FCE pattern axiom templates

In principle, the FCE patterns could feature any OWL constructs within their axiom templates (Tpl). However, since our main target is to support the reuse of ontologies for linked datasets, it is natural to primarily build the patterns from the language primitives that are prominent in such ontologies (or, vocabularies). By querying the LOV portal SPARQL endpoint,1414 we found out that across all (778) vocabularies, the most frequent RDFS/OWL predicates – of those endowed with logical semantics – were rdfs:subClassOf (about 55K), rdfs:domain, and rdfs:range (about 32K each). Then followed rdfs:subPropertyOf (about 15K), the disjointness predicate owl:disjointWith (about 11K), the existential restriction predicate owl:someValuesFrom, and the universal restriction one owl:allValuesFrom (about 10K each1515).

While the construction of the heuristic FCE patterns for LSE – see the rest of this section – was not primarily guided by this frequency statistics but rather by long-term ontology designer experience, the inventory of most patterns indeed reflects the prominent role of rdfs:subClassOf, rdfs:domain and rdfs:range in linked data vocabularies.

Existential restriction is also used, but it is in the constraint part of the FCE patterns rather than in the axiom template part. Therefore, while the pattern setting assumes the presence of both ‘global’ (domain and range) and ‘local’ (existential) restrictions, omission of the latter by the designers does not preclude the generation of CEs but only disables their pruning.

4.2.FCE pattern collection for LSE

We present below five FCE patterns for LSE and illustrate them on our running example of used cars.

Pattern p1 Let us first consider the FCE pattern for the CE pattern c1 of Lnam; the axiom templates are serialized as triples in the Turtle1616 RDF notation:

Also note that even such a simple FCE pattern might not be the only possible for the given CE pattern. If we accept the possibility that not all classes in different hierarchical paths are pairwise disjoint, we could also apply to c1 a pattern for possibly unrelated C and FC, with the axiom template set being, e.g.,

As we move from Lnam to compound CEs of LSE, the FCE patterns are somewhat less obvious. We chose to implement them primarily in RDFS terms, namely, over rdfs:subClassOf, rdf:type, rdfs:domain and rdfs:range axioms, since these prevail in most linked vocabularies that are the prime subject in our ontology reuse setting. We however so far avoided rdfs:subPropertyOf to keep the pattern structure simpler (we will consider adding it in the future).

The relationship between rdfs:domain and the existential restriction will be central in our conception of FCE patterns for LSE. Note that for any C, FC and P holds that from the validity of Prdfs:domainFC we can trivially infer ∃P.C⊑FC. The existential CE will thus necessarily be a subclass of the focus class FC in such a case; the only issue remaining is whether this subclass will have an ‘interesting size’ (neither too large nor too small) as subcategory of FC, in the spirit of the discussion from Section 2.3.

Pattern p2 The FCE pattern for CE pattern c2 assumes that if the focus class FC is the domain of a property P, the instances of FC can be categorized according to whether they appear in the subject position in a triple with this property, whatever the object is (which truly corresponds to the existential restriction with filler ⊤, at the CE level). Again, even cases when FC is inferred as domain of P are considered.

In order to illustrate the application of the two FCE patterns introduced so far together, in the calculation of the approximate FCP (Eq. (4)),we will return to our running example. Unlike in the previous, artificial, examples, we will refer to a real-world ontology.

Let us now proceed to the FCE patterns for the remaining CE patterns included in LSE.

Pattern p3 The CE pattern c3 includes all instances of FC that appear in the subject of a triple with P as predicate and some i as object such that i is an instance of class C. The FCE pattern for c3 then extends p2 such that we also consider the range of P, which is an auxiliary class D. Since D itself would not make a proper distinction (all instances satisfying c2 will by the definition of the rdfs:range predicate be connected by P to an instance of D), we further need to involve a ‘refining’ class C as subclass of D, which is also reflected by the second mapping variable.

As this FCE pattern is already a bit more complex, we will also demonstrate its application (and the added value compared to c2) graphically, in Fig. 1. The upper part of the diagram displays the structure (Tbox) of p3; the bold labels indicate asserted statements, and the italic label indicates an inferred statement (here we show a case where FC only belongs to the domain of P by ‘inheritance’ from its subclass). The bottom part shows example constellations of an instance and non-instance of ∃P.C in the Abox. While both x1 and x2 belong, via inference over the domain axiom, to FC, and both also belong to ∃P.⊤ and (via the inference over the range axiom) to ∃P.D, it is only x1 that also belongs to ∃P.C as the considered category.

Fig. 1.

Tbox of p3 and Abox of instance and non-instance of ∃P.C.

Reliance of FCE patterns on asserted ontology structures might make the pattern vulnerable to ontology versions that would already contain the inferences materialized. However, while the transitive rdfs:subClassOf inference is sometimes materialized in ontologies (transitive superclasses being present for a class, rather than just its direct superclass), are linked to it in the ‘asserted’ ontology), it is very unlikely that this would be the case for the upward propagation of domain/range restrictions.

Pattern p4 The CE pattern c4 includes all instances of FC that appear in the subject of a triple with P as predicate and (the specific individual) i as object. The FCE pattern for c4 then extends p3 with an individual that is instance of C and is also used in the mapping variable sequence (replacing there the class C):

The inferential closure is used as in p3, i.e., with the exception of the range axiom. The constraint in Cons4 states that there must not be (in the inferential closure of O) an existential restriction FC⊑∃P.{i}; for such properties the CE would contain all instances of FC. The mapping function m4 is analogous to m3, except it wraps the individual bound to i in a singleton enumeration.

Pattern p5: SKOS concept as value For the CE pattern c4 we include one more FCE pattern, which goes beyond the RDFS expressiveness and relies on the connection of the ontology to an external resource – a SKOS2020 codelist. This variant thus extends the previous one for a specific source of instance i, which is a code list (also called concept scheme in SKOS):

We can now illustrate the application of all considered FCE patterns on our used cars example.

All five FCE patterns assure (p2–p5 via the domain axiom) that the mapped CE is a specialization of the FC.2222 Therefore, any L-category Cat=FC⊓D generated from an ontology using these patterns is equivalent to its differentiating class expression D. It is also easy to see that the patterns, except p4 vs. p5, are mutually exclusive since they produce structurally different CEs. (Formally, to assure the exclusivity of p2 and p3, D in p3 should not be owl:Thing. We however do not anticipate that explicit range axioms would have the default value Thing.)

As regards the complexity of the FCE patterns in terms of (templated) RDF triples in the template axioms, it is as listed, for the respective CE patterns, in the fifth column of Table 1. p4 is the most complex one of the ‘straightforward’ FCE patterns, with four triples; however, p5 (for the same CE pattern, c4) is even more complex, having eight triples overall, due to the overheads of representing OWL restrictions in RDF.

We have previously stated that the proposed FCE patterns are merely heuristic (approximate) with respect to the optimally chosen set of LSE categories. Let us now briefly elaborate on this statement and summarize its different aspects:

4.3.Named category generation

The generic algorithm in Listing 1 ends by generating a list of CEs (plus their CE patterns) for a given focus class. However, to finalize our schema.org example narrative, we will also consider the subsequent step of named category generation, already briefly mentioned in Example 1.

Vehicles
  Vehicles with special usage
     Vehicles with driving school usage
     Vehicles with rental usage
     Vehicles with taxi usage

4.4.Summary

FCE patterns are a crucial element of the operationalization of FCP computation over the ontology axioms. We therefore described the FCE patterns for LSE in detail in Section 4.2, and discussed the rationale of their construction. As it can be observed, Section 4.3 primarily refers to CE patterns rather than to their associated FCE patterns; it was mainly included here due to Example 5 being a close sequel to the running example in Section 4.2 (Example 4).

5.1.Ontology axiom sources

For our analysis we used three collections of ontologies:

5.2.Motivation of the analysis

The impetus for this empirical analysis was the close relationship between the central motivating task of the research, that of using CEs (either named classes, or compound CEs that can possibly be transformed to named classes) for categorizing individuals, on the one hand, and the task of defining new named2626 classes (using compound CEs) within ontologies on the other hand. We conjecture that the distribution of compound CE structures in both tasks would be to some degree similar. The differences in the relevance of constructs wrt. these tasks are discussed below.

Note that the subsequent use of the constructed CEs is, in some aspects, similar in both tasks, too. Notably, in all cases, an aspect of categorization is present:

Technically, the expected outcomes of the analysis were the following:

The considered list of CE patterns is, essentially, that of first-level constructors in the axiom RHS. However, since we were particularly interested in the compound CE patterns of LSE, we singled them out under the labels ‘ExistThing’ (c2), ‘ExistNamed’ (c3) and ‘ExistIndiv’ (c4). All other variants of existential restrictions not falling under these three are counted under ‘ExistAnon’, since the filler then is a compound CE rather than a named class.2727

The frequency of CE pattern occurrence, in absolute counts, was classified by three dimensions:

5.3.Results and their discussion

The results are in Table 2, however omitting the last dimension (nesting level) for brevity. The most frequent constructors are listed: 10 for LOV and BioPortal, and 5 for OntoFarm (where only the top of the ranking is relevant, due to very low counts). The constructors corresponding to LSE are in italics.

As regards the LSE patterns, we can see that ‘ExistNamed’ (c3) appears very often at top positions, throughout the collections and axiom types; it dominates in subclass axioms, most notably in BioPortal. ‘ExistIndiv’ (c4, i.e. the value restriction) is less frequent but still plays some role in both larger collections. ‘ExistThing’ (c2) appears even less often.

The other constructors appearing at the first level of the axiom RHS nesting are:

5.4.Summary

The contribution of this section was twofold. First, it featured the CE pattern occurrence frequencies as such, which could be of general interest to the ontology design community. Second, specifically in the line of the current paper, it provided intellectual analysis of axiom type roles in FCP.

The analysis suggested that the LSE patterns play a significant role in the family of all compound expressions commonly used in OWL. The design of an FCP formula restricted to this CEL is thus meaningful, considering that we want to investigate the landscape of the whole focused categorization problem within a simple language first. The analysis however also indicated directions for extending the used language in the future – most notably, in relation to the expected complexity of the queries to be applied on data published using the reused ontologies.

6.1.Ontology sources and data aggregation method

In the analysis we made use of our Online Ontology Set Picker framework2828 (a tool allowing to quickly select ontologies according to various metrics) to process ontologies from two collections. One is LOV; we again used its November 2017 snapshot where 617 ontologies were available, of which we could process successfully 568 at syntactical level. The other is OntoFarm, which contains 16 ontologies. We omitted Bioportal in this analysis, since it is on average rather poor in properties, which are a necessary ingredient for generating categories within LSE.

In order to provide aggregate results, we counted the occurrences of FCE patterns from Section 4 across all classes of all ontologies evaluated in the role of FC. We summed up these results at ontology level by identifying ‘categorizable’ classes, i.e. classes for which the pattern occurrence reached some threshold τ (1, 3, and 5) for patterns p1,…,p4;2929 see Table 3. The tables show the percentage of ontologies for which more than a given portion of classes, ctg, is ‘categorizable’ as FCs using the given pattern. The portion of ‘categorizable’ classes is quantized by 0.1, from >0.0 to >0.4; higher values are not so relevant, since, intuitively, not all classes of an ontology but only some proportion of more general ones would likely serve as FCs.

For illustration of the bottom-up calculation steps, let us take the example of an OntoFarm ontology called cmt. This ontology satisfies the parameter thresholds for τ=5, ctg>0.1, for p1, as 4 of its 29 classes (n∼14%>0.1) are ‘categorizable’: each has five or more named subclasses (i.e. its τ is at least 5). As we see in the respective cell of Table 3, cmt thus belongs to the 31.3% of OntoFarm ontologies having such a proportion of ‘categorizable’ FCs.

6.2.Results for patterns p1 to p4

Let us now try to answer the questions posed at the start of the section, by examining the result table.

Unsurprisingly, the percentage of ‘categorizable’ classes is in most cases highest for p1 and p2, which reflects the simplicity of these patterns: many classes have some named subclass (p1), and many also appear in the domain of some property (p2). With increasing ctg, the percentage drops more slowly for p2 than for p1, reflecting the fact that even classes lowest in the subclass hierarchy (i.e. not having named subclasses) do appear in the domain of properties.

For p3 the percentage is generally lower; however, it ‘beats’ p1 when it comes to the setting with higher thresholds for both ctg and τ, i.e., when we want to include even less general (focus) classes and require them to have a higher number of categories. This is apparent even in the much smaller OntoFarm (for ctg>0.2, τ=5), but particularly in LOV; we indicate such values using boldface in the table. Presumably, focus classes down in the hierarchy may be connected (through some properties’ domain and range) to more general classes, thus ‘borrowing’ their subclass hierarchy (note the structure of p3 in Equation (9), where class C from the range of property P ‘lends’ its subclass D for the filler of the existential restriction category).

p4 is least frequent, however, for higher ctg and τ=3 the percentage also gets closer to that of p1 (presumably, through the same mechanism as we discussed for p3).

6.3.Results for pattern p5

For completeness, we performed an analysis of ontologies which use SKOS concepts for entity categorization (pattern p5). While OntoFarm ontologies do not feature this pattern at all, in LOV there were 7 ontologies out of 509 containing its instantiation, to date.

Table 4 presents information about those 7 ontologies in terms of the number of SKOS concepts that can be used as the ‘categorization individual’ and the number of SKOS concept schemes from which those concepts come. Further, we include information about the date of the last modification of the ontology. In two cases, no concept schemes are available. For the other ontologies the number of SKOS concepts (and SKOS schemes, respectively) usable for categorization varied from 11 to 274 (from 1 to 16, respectively). Although the phenomenon captured by p5 (reference to a SKOS code list in an ontology) is currently marginal, we assume that it may have an increasing trend, since those seven ontologies had been last modified, on average, in 2014, while the average of the last update dates for the whole of LOV was in 2012.

6.4.Summary

The findings about p3 and p4 are interesting and potentially relevant for the efficiency of the FCP computation. If we managed to prove that the categories generated by these patterns are often meaningful (which will indeed be hinted by the cognitive experiments in Section 7), these two patterns could yield useful categories even for focus classes positioned lower in the subclass hierarchy, for which p1 does not work well.

7.1.Summer 2016 campaign

Initial sampling As regards the FC+subcategory (from now on, ‘task’) sampling for both threads of analysis (expert/novice), we used the same collections as in the survey from Section 6, i.e. LOV (a 2016 snapshot) and OntoFarm (this collection has remained unaltered for nearly a decade). From each collection 40 tasks were randomly generated while maintaining an approximately even proportion of subcategories for patterns c2, c3 and c4, eventually yielding 80 tasks. After a manual removal of duplicates (for OntoFarm as smaller collection) and tasks involving entities with cryptic names without meaning in natural language, 59 tasks remained (28 from OntoFarm and 31 from LOV); there were 17 tasks for c2, 20 for c3 and 22 for c4.

Expert ontologist assessment and insights In the first stage, the assessment was made by three researchers with 10–20 years of experience in ontology engineering (authors of this paper: VS, OZ and MV). They first examined the 59 tasks independently and assessed them on the 5-point Likert scale: for each task, with a focus class Y and a subcategory X, the question “Is X a meaningful subcategory of Y?” was answered as either ‘certainly’, ‘perhaps’, ‘borderline’, ‘perhaps not’ or ‘certainly not’. Then a consensus was sought in a F2F session. The independent assessment had 76% agreement: in 45 out of 59 cases there was no contradictory assessment (certainly/perhaps yes vs. certainly/perhaps not); we will call these cases clear positives (42 cases) and clear negatives (3 cases), respectively. The consensus session then yielded a complete consensus on the remaining cases; in 12 out of the 14 ‘clash’ cases the final result was ‘yes’ (namely, a conceivable situation was formulated in which the CE would be a meaningful subcategory of the FC), one case was found dubious due to an implausible inference (see the second ‘insight’ below, on the ‘village head chef’) and in one case the subcategory was assumed semantically equivalent to its FC, both resulting into ‘no’. Of the five ultimately negative results, four were of c2 and one of c3. Complete assessments and commentaries are in a supplementary page. Selected general insights into less obvious decisions, with examples, follow:3131

Novice ontologist assessment There were two groups of students involved: Bc-level students in a course on Artificial Intelligence (AI) and MSc-level students in a specialized course on Ontology Engineering (OE). Both courses provided a certain degree of OWL modeling experience (in Protégé and Manchester syntax) prior to this exercise, although OE went into more depth as regards the underlying DL and reasoning. There were 17 AI students and 10 OE students altogether. In both courses the students were first provided with a 30-minute overview of the notions of CE (in LSE) and FC roughly as presented in Sections 2 and 3 of this paper. Then they completed an assignment consisting of 20 atomic tasks, all available in a single sheet of a web questionnaire.3232 In each atomic task the student was required to provide an answer to the question “Is the class CE a meaningful category for categorizing objects of class FC?”, where FC was a named focus class and CE was a class expression in Manchester syntax. The answer was again collected on the 5-point Likert scale, with an additional option ‘no judgment, since I don’t understand the example’.

The 59 tasks from the initial sample were randomly divided into three questionnaire versions (one c4 task was used twice) to eliminate cribbing; the numbers of returned questionnaires per version were 7, 9 and 11, respectively, with a balanced proportion of AI vs. OE students. To avoid protracting and biasing the experiment, the students were instructed to only judge the CEs by the expression itself, i.e. without consulting the respective ontology specification or other external resources. However, specifically for the ‘conference’ domain of OntoFarm, they were provided with a brief domain glossary (since as students they were not expected to have experience with conference organization matters). In both sessions, 30’ sufficed to all students for completing the (20-task) assignment.

We aggregated the results by questionnaire task, and then both by the course and by CE pattern. The aggregation was carried out by simple summation over the answer values rescaled to the [−1;1] interval (i.e. ‘certainly’ turned to 1, ‘perhaps’ to 0.5, both ‘borderline’ and ‘no judgment’ to 0, etc.), and then normalized by dividing by the number of students on the task. The normalized sum of the answer values of the i-th task is then

A short digest of the results follows:

In comparison with the ‘expert ontologist’ assessment:

7.2.Summer 2018 campaign

In the second campaing we tried to modify the setting so as to avoid some biases and gaps appearing in the first campaign, in particular:

There was no a priori expert assessment this time (assuming that the correlation of the expert and novice assessment had been adequately studied in the first campaign).

Initial sampling and task preparation This time, all tasks were generated from the LOV. In contrast to the 2016 campaing, we also added CEs matching the pattern c1, to verify the assumption that named subclasses are by default meaningful categories. We first pre-selected LOV ontologies that satisfied the following two conditions:

Unfortunately, the sampling results exhibited some potentially undesirable features, and we did not have time to redesign the sampling because of the planned experiment dates (within the schedule of both courses) that we were unable to shift. Namely:

The structure of the CEs was verbalized, using simple NLP patterns plus occasional manual tweaking to assure grammatical correctness of the generated sentences. For example, if the property label P in a CE matching the pattern c2 was a noun phrase, the CE was verbalized as “A specific kind of FC: such that has a P”. On the other hand, if the property was labeled by a verb phrase, the verbalization of the CE became “A specific kind of FC: such that P something.” The verbalization for the other compound CE patterns was analogous, e.g., for c3, “…such that has a P that is a C” (for a noun phrase P) and “…such that P a C” (for a verb phrase P), respectively.

Novice ontologist assessment There were, again, two groups of students involved, from the same courses as in 2016 (Bc-level AI and MSc-level OE). The amount of prior training in OWL was also similar as in the 2016 campaign. There were 15 AI students and 16 OE students altogether. In both courses the students were first provided with a 30-minute overview of the notions of CE (in LSE) and FC roughly as presented in Sections 2 and 3 of this paper. Then they completed an assignment consisting of 8 atomic tasks (two for each of the four CE patterns), all available in a single sheet of a web questionnaire.3434 The time allocated to completing the questionnaire was 40 minutes, i.e. 5 minutes per task.

The task question was slightly modified: it explored to what the degree the category is meaningful and reusable. The rationale was that possibly even subcategories with very small absolute or relative frequency might be viewed as meaningful (this term being rather vague and subjective), but undoubtedly their reusability should be perceived as low. Besides, the novelty of the assessment task setting compared to the 2016 campaign was in the following:

In addition to the FCP tasks assessment, the questionnaire also examined the students’ assessment of their own level of written English.

We computed the normalized sum (NS) of the task assessment values, as in the 2016 campaign (using Equation (12)). The core results are as follows:

We also computed the relative frequencies reflecting the impact of the (declared) English writing skills and of the comprehension of entities on the assessment value:

7.3.Summary

The role of the cognitive experiments was to eventually attempt to assess the reusability degree of different individual CEs and thus (indirectly) their patterns, which is tied to the central idea of the whole approach (in which, for example, the FCE patterns are merely instrumental).

Across the different campaigns and settings, the order of the CE patterns according to the average ‘meaningfulness’ of the categories remains stable: (c1 >) c4 > c3 > c2. We can also conjecture that the categories are more likely to be viewed as ‘meaningful’ if the assessor is an expert, or if some of the following holds: more information is available on the entities and context; the categories are better presented (e.g., verbalized); more time is available per category (task).

Data availability The data from both experiments is available on the web through https://bit.ly/FCP_cogex. The page contains, for each of the campaigns, the links to:

8.1.Meta-view of the empirical analyses

In Table 8 we synoptically summarize the three empirical pillars of our research so far, as elaborated in Sections 5, 6 and 7. We see that the surveys/experiments are to a large degree complementary, differing in their features: in the structural type of the data source; in the focus on either direct analysis of CEs or on their underlying patterns that are only indirectly tied to the CEs; in the objectivity/subjectivity of the obtained data; and, finally, in the actual scope of the CE and FCE patterns, and of the focus classes examined. Notably, all data sources currently refer to the Tbox. As mentioned before (esp. in Section 2.1), the fourth pillar of the empirical analysis of the FCP problem should be the analysis of the CEs occurrence in the RDF datasets Abox (which is ongoing but did not fit into the current paper).

The last row in the table attempts to summarize the core findings of each analysis. At the first sight the arrangement of the CE/FCE patterns might look incoherent. Especially, c2 is (by Section 5) very rarely used in the axioms RHS, which contrasts with the fact that we can generate a huge number of matching CEs (by Section 6) through FCE pattern p2 and the proportion of these CEs that are ‘meaningful’ is not dramatically lower than for the other CE patterns (by Section 7). This paradox can however be explained as follows:

8.2.Limitations and open questions

Since the paper explores a substantially novel problem space, the coverage of its different corners is still rather limited. In this section, we discuss five limitations and/or open questions, in turn: the omission of Abox data in the whole process, the simplification made in the empirical analysis of CE pattern frequency, the reliance on particular Tbox design principles in the application of FCE patterns, the negligence of logical considerations when creating the definitions of new named classes, and, eventually, the actual choice of existential restriction as central primitive of the initial CEL.

The presented research currently ignores the role of Abox analysis, both in the actual FCP computation (within a concrete reuse problem) for a specific ontology as well as in the inductive process of CE pattern weight estimation. The former means that the presented approach is tuned towards the ‘cold-start’ setting (new ontologies not yet referenced in data); otherwise the relevance of concrete CEs could be estimated (though with some computational cost) from existing datasets instantiating them. The omission of the latter (which would consist in generating CEs for a given CEL over a representative set of ‘training’ ontologies, measuring their frequency of instantiation in data, and aggregating those frequencies by CE pattern) to date does not have any principled reason, and is only owing to limited human resources on the project.3535

The computation of the CE pattern frequency in axioms from Section 5 targeted the top-level structure in the axiom RHS (with additional distinction of the CE patterns from LSE). How complex are the embedded expressions within this top structure remains undistinguished. For example, for the conjunction, it would make sense to distinguish between a conjunction of two named classes, a conjunction of two property restrictions, a conjunction of a named class and a restriction, and several others. Characterizing the utility of a CE pattern based on the top-level structure alone is obviously superficial, as it would vary according to the embedded levels.

The design of our FCE patterns, where global restrictions (domain+range) are used in the pattern template and local (existential) restrictions in the validity constraints, puts a strong assumption on the engineering approach used in the ontology analyzed. If the ontology lacks global restrictions3636 then the FCP will be under-estimated, since the FCE patterns will not match it at all. On the other hand, if the ontology lacks local restrictions, the FCE patterns will possibly generate many useless categories (those equivalent to the FC, or with empty or singleton extension), which would then have to be manually filtered out. This caveat could be compensated by computing the overall proportions of the number of classes plus local and global restrictions in the examined ontology and then adjusting the FCP accordingly.

The generation of new named classes with their compound definitions in the reuse step, as described in Section 4.3 (as a follow-up technique, less central than the FCP computation, which is the main topic of the paper), is currently conceived rather naïvely from the logical semantics point of view. The definitions are assumed to be generated one by one locally, without taking into consideration the inferential structure of the ontology as a whole. This probably does not harm if the resulting ontology is to be used merely as a schema for data to be processed at the assertional level. However, possible exploitation of such an ontology by reasoners might ask for involving more sophistication in the generation of new definitional axioms.

Finally, even the assumption under which we gave preference to the existential property restriction as the cornerstone of our initially chosen CEL, over the Boolean conjunction (which would have been another simple candidate for a CE pattern), namely, that we cannot rely on proper equipment of ontologies with disjointness axioms, may be considered as potentially arguable. As mentioned in Section 5, in cases where we can (through pruning the ontology using those axioms) single out truly compatible pairs of classes, the consideration of conjunctive categories instead of existential ones would be promising (in other cases it would however lead to explosion of output CEs, which is what we wanted to avoid).

9.1.Tentative operationalization of the empirical results

We understand the obtained insights into the usage of OWL class expressions and their perception by humans in general as a research achievement per se. However, the starting point for the overarching empirical study was an ‘engineering’ goal (possibly modest compared to the extent of the performed surveys and experiments): to propose adequate weights for the CE patterns to be used when computing the FCP in the context of an ontology reuse scenario.

In these terms, based on the cognitive experiments in particular, we can see that c4 (individual value restriction) and to some degree c3 (existential restriction) may successfully complement c1 (named class) when harvesting categories from a reused ontology. The survey of the CEs in axioms, in turn, suggests that the chosen CE language (LSE) covers a decent part of the space of relevant languages and could be applied in the first, albeit rough approximation of an ideal FCP formula. Thus, if a requirement came to design an ontology reuse metric leveraging on the FCP, based on the cognitive experiments we could tentatively set the weights in Equation (4) according to the NS of the assessments in the cognitive experiments. Two simple options of generating weights from the assessment NS are quantified in Table 9: by transforming the average NS from the [−1;1] interval to the [0;1] interval, and by computing the ratio of positive NS values of all NS values for the given CE pattern.

Considering that the lowered average NS values of c1 in the 2018 campaign were presumably caused by randomly sampled highly general classes, which would not normally appear in the focus class role (as in the Feature class in Table 7), we should probably set wP(c1) to 1. The remaining weights can be set, heuristically reflecting both calculation methods and the results of both campaigns in combination, for example as wP(c2)=0.5, wP(c3)=0.7, and wP(c4)=0.8. This would yield the following FCP estimate formula, to be applied on an ontology O and focus class FC, the language L being LSE:

The current version of the OReCaP tool (see the next subsection), when launched, proposes these values, i.e. wP(c2)=0.5, wP(c3)=0.7, and wP(c4)=0.8. The formula should however only be taken as a very first, tentative initial setting (to be adapted by the user as needed) and not as a granted recipe.

9.2.OReCaP prototype

To demonstrate the whole focused categorization framework, specifically for LSE, patterns p1–p4 and in the context of the ontology reuse scenario, as well to make it possible for both us and any interested subjects to perform experiments on various input ontologies and focus classes, we implemented a web-based application named OReCaP.3737 The application is available online at https://fcp.vse.cz/orecap. A demo of its earlier, limited version was already presented at the ISWC 2020 conference [14]. What is novel in the currently available version compared to that in the demo paper is, in particular, the support of actual ontology reuse, mediated by the user’s interaction with different categories constructed using different FCE patterns.

The interaction workflow with the tool consists of several, possibly iterative, phases:

Fig. 2.

OReCaP interface: two ontologies found via keyword search, with focus class and additional match.

Let us assume the user wanting to publish data about business contracts and their payment, and seeking a suitable ontology for their subcategorization. A partial screenshot showing the overall search results together with FCP scores for two ontologies is in Fig. 2. The focus class keywords (here, just one) are entered in the top-left field; their matches are therefore proposed (hightlighted in blue) as focus classes, by the tool. The user has also provided additional keywords, which may improve the result ranking but do not produce further focus classes (unless the user pro-actively highlights them, too).

For the first ontology, PPROC, a snippet of the reuse summary window is then shown in Fig. 3; the numbers (e.g., “(1/5)”) indicate how many categories were chosen in the given sub-tree. The user has chosen two categories, corresponding to ‘contract that has been anyhow modified’ (CE pattern c2) and ‘contract that has been ended by procedure resignation’ (CE pattern c3). The set of axioms defining new named classes based on such compound CEs, with shortnames currently created by trivial concatenation, can then be downloaded; for example:

Fig. 3.

OReCaP interface: the reuse summary, with user’s choices of two CEs.

OReCaP makes use of the Linked Open Vocabulary API3838 for the keyword-based search and for retrieving the ontology metadata. The FCP calculation itself is implemented on top of OWL API, in combination with the jFact reasoner.3939 OWL API is used to load and parse the ontology source codes, and jFact is used to infer class expressions. Both the front-end and back-end implementation of OReCaP are open-source and available on GitHub4040 under the MIT license.

10.1.Abstract notion of focusing or categorization (power) in ontologies

We are unaware of prior work on the same topic of FCP as we coin it in the current paper. We will however reference some related research that overlaps with ours at the abstract level.

The notion of focusing recently appeared in the work of Gogacz et al. [7]. The so-called focusing solution pairs a set of predicate symbols that describe a database schema (that is, a set of predicates) with a set of assumptions on the partial completeness on the data and the ontology (closed and fixed queries). In their approach, focusing is about choosing which parts of the data and ontology are to be declared complete, to allow for efficient reasoning. In our approach, focusing is about choosing ontology classes for whose instances in data we would like to obtain many meaningful categorization options; the categorization itself however need not rely on logical reasoning (never mind using the ontology), but can be based on whatever kind of classification model or even made by humans.

The term classification/categorization power previously appeared in many scientific texts, however, rarely as a rigorously defined notion. For example, on many occasions, automated classifiers (typically, machine-learning-based) are reported to have certain ‘classification power’ with respect to classes from an ontology, which is merely an informal circumscription of measures such as accuracy or error rate. The ‘power’ also clearly pertains to the classifier and not to the ontology. The association of the notions of ‘categorization’ is thus merely verbal.

Partially relevant is the analysis made by Giunchiglia & Zaihrayeu [6], who categorized ‘lightweight’ ontologies with respect to two dimensions: complexity of labels (simple noun phrases vs. use of connectives and prepositions) and use of ‘intersection’ operator allowing to combine atomic entities of different nature (e.g., the atomic concepts ‘Italy’ and ‘vacation’ implicitly combine into ‘vacation in Italy’). Maximal ‘classification power’ is obtained when both explicitly complex labels and implicit concept combinations are allowed. This however only applies to classifying documents extrinsic to the ontology, since ‘intersection’ of concepts of different nature is not coherent with the set-theoretic semantics of DL. Overall, their ‘classification power’ is a global property of the method by which the ontology has been built. In contrast, our notion of FCP applies to individuals intrinsic to the DL world of the ontology and is calculated with respect to a focus class.

A. Rector’s work on entangling hierarchies (normalization) [15] addressed a different problem than us, but to some degree analogously considered the compound concepts as an alternative to named ones. This applies to ‘partitioning’ or ‘refining’ concepts, that only modify the ‘self-standing’ concepts; secondary partitioning aspects should not be expressed through subclassing (yielding a multi-hierarchy) but through existential restrictions filled with classes from separate ‘codelist’ taxonomies. For example, a class SteroidHormone would not have two parents, Steroid and Hormone, but only the first one, while the latter subordination would be made through an existential restriction: SteroidHormone ≡ Steroid ⊓∃ playsRole.Hormone.

Our own ongoing work on the PURO modeling language [21] deals with various options how the same ‘background’ state of affairs can be expressed in OWL. PURO structurally resembles OWL but relaxes some of its modeling constraints. A library of transformation patterns allows to proceed from one PURO model to alternative OWL ontologies in different encoding styles. An example relevant to our case is the notion of entrepreneur, which is likely to be expressed as type in PURO, but could be translated to relationship (insuranceCategory) restricted to the Entrepreneur individual in OWL (i.e. a compound CE), assuming we prefer an encoding style using object properties with ‘codelist individuals’. Analogously, born in may possibly be a relation in PURO but can be translated not only to OWL property restrictions but also to named classes such as PersonBornInUK, assuming we prefer an ‘encapsulating’ encoding style used, e.g., in the DBpedia Ontology.4141 Modeling in PURO and applying the transformation patterns may thus make hidden (compound) relevant concepts explicit in the domain as atomic concepts. A similar account of alternative ‘typecasting’ beyond named classes (but with smaller coverage) has been given by Krisnadhi [9].

Certain research in cognitive psychology might also be relevant wrt. the notion of FCP. In particular, the notion of graded structure of categories [4] can be applied to our concept pattern weighting. The authors suggest that there is “a basic level of abstraction (e.g. CHAIR, DOG), …” which is “further discriminated at the subordinate level (e.g. KITCHEN CHAIR, SPANIEL) and abstracted at the superordinate level (FURNITURE, ANIMAL)” [4]. Presumably, this basic level might often coincide with the focus classes to be subcategorized in practical settings. Furthermore, the graded structure may include “ad hoc, goal derived categories such as GOOD PLACES TO HIDE FROM THE MAFIA” [4], analogous to our CEs defined via an existential restriction.

10.2.Empirical studies of ontology features

As regards the analysis of ontology repositories in terms of various aggregated features and metrics (logical, graph, lexical etc.), there has recently been renewed interest, following up with the early work of Tempich et al. [23] (aiming to build a benchmark for testing ontology tools). A large scale study of OWL ontology metrics was carried out by Matentzoglu et al. [13]. However, the categorization power of ontologies has not been, to our knowledge, studied, never mind with the flavor presented here.

Our study on class expression frequency in axioms from Section 5 looks similar to the recent study carried out in the MontoloStats project [12]. Both studies essentially analyze the same ontology repositories (primarily, LOV and Bioportal), and refer to the suitability of ontologies for reuse. There is however a difference in the restrictions coverage. For an unclear reason, the MontoloStats study does not cover existential restrictions (which are central for our study, and also shown as empirically very frequent) at all, nor the conjunctive concepts. On the other hand, it covers (subclass axioms with) named class in the RHS, and also property axioms such as domain/range or functional property. Notably, even over the common subset of CE patterns in restrictions (such as disjoint, universal and cardinality restriction CEs) that some differences in the computed ranking appear between MontoloStats and our research; these may be due to additional distinct features in the methodology used.

Yet another stream of empirical research aims to study ontologies not on their own but from the point of view of LOD datasets in which they are used. This was the subject of the project by Asprino et al. [1], which produced a condensed representation of the global, virtual, ‘LOD ontology’ in the form of so called equivalent set graphs. Various metrics related to the connectedness and extensional size of ontology entities were computed; while this research does only addresses compound concepts, it is in line with our ongoing activity in analyzing the Abox imprint of (named as well as compound) class expressions.

10.3.Cognitive experiments on assessing ontological structures

Several cognitive studies using ontologies as material have been published in the ontological engineering research. However, they primarily address the capability of humans themselves to carry out the categorization of objects to a set of classes or to understand the structure of OWL expressions. A recent example of the former is a study on classifying domain entities to upper-level ontology classes [20]. An example of the latter is an earlier study on the human capability of deriving useful information from differently verbalized OWL statements [24]. Our research in Section 7 of this paper differs in that the humans were to assess the automatically build concepts as more or less plausible, thus generating ground truth. (Semi-automated) verbalization was present, too, but only played an auxiliary role, the actual subject of assessment being the formal CEs themselves.

10.4.Concept learning in DL

The heuristic construction of compound CEs from the ontology axioms, triggered by the identification of a focus class, bears some resemblance to concept learning in DL [11], which is triggered by the specification of the target concept. However, (supervised) concept learning aims to identify CEs that best approximate a concrete goal concept as whole. In contrast, CEs logically equivalent to the focus class are uninteresting as its subcategories, while categories that only cover a few per cent of the FC instances may be valid means for partitioning its instances. Moreover, concept learning fully depends on presence of instance data for the particular concept to be learned. Yet, for a newly designed ontology such data might not be available (the well-known cold start problem). Finally, the overall goal is different: while concept learning primarily aims at enriching the ontology Tbox with new axioms [10], in our approach the prime task is to reuse the ontology (or its fragments) ‘as it is’, and the formation of new equivalence axioms is an optional, secondary step carried out with human interaction.

10.5.Ontology reuse metrics and methods

The broad context of our research, the task of ontology reuse, was studied by Schaible et al. [18]: the users expressed their preferences on reuse strategy in a survey. The results indicate that reusing multiple entities from the same vocabulary may often be preferred; this corroborates the relevance of our approach to measuring the categorization power of ontologies with respect to focus classes.

Vocabulary reuse techniques similar to the use of FCP-based metrics also appeared in a recent project on combining popularity metrics with the credibility of the vocabulary designers [19]. As regards the designer credibility, this is a feature of the ontology itself similarly to FCP, but it is completely orthogonal.

Reuse support [5] is also systematically sought by the maintainers of LOV [25], primarily at keyword relevance level; we are in contact with them and will seek to integrate our complementary approaches.