Conceptual blending is understood to be a process that serves a variety of cognitive purposes, including creativity, and has been highly influential in cognitive linguistics. In this line of thinking, human creativity is modeled as a blending process that takes different mental spaces as input and combines them into a new mental space, called a blend. According to this form of combinatorial creativity, a blend is constructed by taking the existing commonalities among the input mental spaces-known as the generic space-into account, and by projecting their structure in a selective way. Since input spaces for interesting blends are often initially incompatible, a generalisation step is needed before they can be blended. In this paper, we apply this idea to blend input spaces specified in the description logic EL ++ and propose an upward refinement operator for generalising EL ++ concepts. We show how the generalisation operator is translated to Answer Set Programming (ASP) in order to implement a search process that finds possible generalisations of input concepts. We exemplify our approach in the domain of computer icons.
The upward refinement-or generalisation-of concepts plays a crucial role in creative processes for analogical reasoning and concept invention, in particular conceptual blending (Fauconnier and Turner 2002). In blending, one combines two input concepts to invent a new one. In general, however, this cannot be done because the combination of two concepts may generate an unsatisfiable one due to contradiction. However, by slightly generalising input concepts we might be able to find a novel and useful combination of both. For instance, a 'red French sedan' and a 'blue German minivan' can be blended to a 'red German sedan' by generalising the first concept to a 'red European sedan' and the second one to a 'coloured German car'. The least general generalisation of our input concepts-a 'coloured European car'-serves as an upper bound of the generalisation space to be explored, and, in a certain sense, plays the role of the so call generic space in conceptual blending, which states the shared structure of both concepts.
This paper addresses the formalisation of such a generalisation process and tackles the following question: How can we define and implement a generalisation operator for description logics (DLs) and what are its desired or necessary properties in order to use it in the blending process?
We focus on the particular case of the description logic EL ++ (Baader, Brandt, and Lutz 2005;Baader, Brandt, and Lutz 2008). This is an excellent starting point for our investigation for several reasons. First, EL ++ is the underpinning logic of the OWL 2 EL Profile, a recommendation of the W3C. Second, EL ++ offers a good tradeoff between expressivity and efficiency of reasoning. Indeed, the EL ++ syntax and axioms are considered to be sufficiently expressive to model large real-world ontologies. Finally, subsumption in an EL ++ TBox is computable in polynomial time (Baader, Brandt, and Lutz 2005).
The generalisation of EL ++ concepts has been studied both in the DLs and in the Inductive Logic Programming (ILP) literature, although from different perspectives. Whilst approaches in DL focus on formalising the computation of a least general generalisation (LGG) (also known as least common subsumer) among different concepts as a nonstandard reasoning task (Baader 2005;Baader, Sertkaya, and Turhan 2007;Turhan and Zarrieß 2013), approaches in ILP are concerned on learning DL descriptions from examples (Lehmann and Hitzler 2010). In both cases, however, finding a LGG is a challenging task. Its computability depends on the type of DL adopted and on the assumptions made over the structure of concept definitions.
Our work relates to these approaches, but our main motivation for generalising DL concepts is intrinsically different. Although we do need to be aware of what concepts share in order to blend them, it is not necessary (though desirable) to find a generic space that is also a LGG. A sufficiently specific common subsumer will suffice. With this objective in mind, we propose an upward refinement operator for generalising EL ++ concepts which is inductively defined over the structure of concept descriptions. We discuss some of the properties typically used to characterise refinement operators; namely, finiteness, properness and completeness (van der Laag and Nienhuys-Cheng 1998). Briefly, a refinement operator is said to be finite when it generates a finite set of refinements; proper, when its refinements are not equivalent to the original concept, and complete, when it produces all possible refinements of a given concept.
Particularly, the generalisations produced by our operator are finite, but they can be sometimes equivalent to the concept being generalised (thus, the operator is not proper), and they are not all the possible ones (thus, the operator is not complete). As we shall discuss, we sacrifice completeness for finiteness (since we do not need to compute a LGG, strictly speaking), but we need the successive applications of the operator to always terminate. We point out, however, how the properness property can be achieved.
We show how part of the upward refinement operator is implemented in Answer Set Programming (ASP) (Gelfond and Kahl 2014) and how we employ the search capabilities of ASP to find a generic space among two EL ++ input concepts. The ASP search is part of an amalgamation process (Ontañón and Plaza 2010) that models conceptual blending. Throughout the paper, we use an example in the domain of computer icon design.
The Description Logic EL ++ In DLs, concept and role descriptions are defined inductively by means of concept and role constructors over a finite set N C of concept names, a finite set N r of role names, and (possibly) a finite set N I of individual names. As is common practice, we shall write A, B for concept names, C, D for concept descriptions, r, s for role names, and a, b, for individual names.
The semantics of concept and role descriptions is defined in terms of an interpretation I = (∆ I , • I ), where ∆ I is a non-empty domain and • I is an interpretation function assigning a set A I ⊆ ∆ I to each concept name A ∈ N C , a set r I ⊆ ∆ I × ∆ I to each role name r ∈ N r , and an element a I ∈ ∆ I for each individual name a ∈ N I , which is extended to general concept and role descriptions. Table 1 shows the constructors of the description logic EL ++ that are relevant for this paper, together with their interpretation. For a complete presentation of EL ++ we refer to (Baader, Brandt, and Lutz 2005;Baader, Brandt, and Lutz 2008).
A knowledge base usually consists of a finite set T of terminological axioms, called TBox, which contains intensional knowledge defining the main notions relevant to the domain of discourse; and a finite set A of assertional axioms, called ABox, which contains extensional knowledge about individual objects of the domain. In this paper, we shall focus only on terminological axioms of the form C D, i.e. general concept inclusions (GCIs), and r 1 • • • • • r n r, i.e. role inclusions (RIs), as well as axioms specifying domain and range restrictions for roles. Table 1 shows the form of these axioms, together with the condition for these to be satisfied by an interpretation I. By L(T ) we refer to the set of all EL ++ concept descriptions we can form with the concept and role names occurring in T .
RIs allow one to specify role hierarchies (r s) and role transitivity (r • r r). The bottom concept ⊥, in combination with GCIs, allows one to express disjointness of concept descriptions, e.
To exemplify our approach, we take the domain of computer icons into account. We consider computer icons as combinations of signs (e.g., Document, MagnifyingGlass, Hard-Disk, Pen, etc.) (Confalonieri et al. 2015). Signs are related by qualitative spatial relations such as above, behind, etc.
In the ontology below, concept names are capitalised (e.g. Sign) and role names are written in lower-case (e.g. hasSign). We assume that a TBox T consists of two parts: one part that contains the background knowledge about the icon domain T bk , and another part that contains the domain knowledge about icon definitions T dk .
Generally, an icon is related to different signs by means of the hasSign role. In the paper, we will show how we can create new EL ++ concepts by blending existing concepts in the domain knowledge of a TBox. Specifically, we will see how to generate the following concept representing a new blended icon:
Intuitively, given two input concepts, a new concept is created by taking the commonalities and some specific parts of the input concepts into account (Figure 1). For instance, both SearchHardDisk and EditDocument are icons that consist of two signs with one sign above the other one (the generic space). Then, if we keep the MagnifyingGlass sign from SearchHardDisk and the Document sign from EditDocument, and we 'relax' the HardDisk and Pen signs, we can blend the generalised input concepts of SearchHardDisk and EditDocument into a new concept representing a preview-document icon. 1 The process of conceptual blending is characterised in terms of amalgamation (Ontañón and Plaza 2010), an approach that has its root in case-based reasoning and focuses on the problem of combining solutions coming from multiple cases. According to this approach, input concepts are generalised until a generic space is found, and pairs of generalised versions of the input concepts are 'combined' to create blends.
Formally, the notion of amalgam can be defined in any representation language L for which a subsumption relation between formulas (or descriptions) of L can be defined, and 1 Of course, there are some combinations of generalised input concepts that are not interesting. For instance, a concept such as Icon ∃hasSign.MagnifyingGlass ∃hasSign.(Pen ∃isAbove. MagnifyingGlass) should be discarded. This issue relates to blend evaluation and it is not addressed in this paper. We refer the interested reader to (Confalonieri et al. 2015) where a discussion about the use of argumentation to evaluate conceptual blends is presented. Intuitively, a MGS is a description that has all the information in both the original descriptions C 1 and C 2 , while a LGG contains that which is common to them.
An amalgam of two descriptions is a new description that contains parts from these original descriptions. For instance, an amalgam of 'a red French sedan' and 'a blue German minivan' is 'a red German sedan;' clearly there are always multiple possibilities for amalgams, like 'a blue French minivan'.
For the purposes of this paper we can define an amalgam of two descriptions as follows: Definition 1 (Amalgam). Let T be a Tbox in EL ++ . A description C am ∈ L(T ) is an amalgam of two descriptions C 1 and C 2 (with LGG C lgg ) if there exist two descriptions C 1 and C 2 such that:
In the next section, we define an upward refinement operator that allows us to find generalisations of EL ++ concept descriptions needed for computing the amalgams as described above, although we may generalise concepts C 1 and C 2 beyond the LGG C lgg . We do this to guarantee termination, as we shall explain below.
Refinement operators are a well known notion in Inductive Logic Programming where they are used to structure a search process for learning concepts from examples. In this setting, two types of refinement operators exist: specialisation (or downward) refinement operators and generalisation (or upward) refinement operators. While the former constructs specialisations of hypotheses, the latter contructs generalisations. 2 Generally speaking, refinement operators are defined over quasi-ordered sets. A quasi-ordered set is a pair S, where S is a set and is a binary relation among elements of S that is reflexive (a a) and transitive (if a b and b c then a c). If a b, we say that b is more general than a, and if also b a we say that a and b are equivalent. A generalisation refinement operator is defined as follows.
Definition 2. A generalisation refinement operator γ over a quasi-ordered set S, is a function such that ∀a ∈ S : γ(a) ⊆ {b ∈ S | a b}.
A refinement operator γ can be classified according to some desirable properties (van der Laag and Nienhuys-Cheng 1998). We say that γ is:
• locally finite if the number of generalisations generated for any given element by the operator is finite, that is, ∀a ∈ S : γ(a) is finite;
• proper if an element is not equivalent to any of its generalisations, i.e., ∀a, b ∈ S, if b ∈ γ(a), then a and b are not equivalent;
• complete if there are no generalisations which are not generated by the operator, i.e., ∀a, b ∈ S it holds that if a b, then b ∈ γ * (a) (where γ * (a) denotes the set of all elements which can be reached from a by means of γ in a finite number of steps).
When a refinement operator is locally finite, proper, and complete it is said to be ideal.
An ideal specialisation refinement operator for EL has been explored in (Lehmann and Haase 2010). In what follows, we will define a generalisation refinement operator for EL ++ and discuss its properties.
In any description logic the set of (complex) concept descriptions are ordered under the subsumption relation forming a quasi-ordered set. For EL ++ in particular they form a bounded meet-semilattice with conjunction as meet operation and as greatest element as well as ⊥ as least element.
In order to define a generalisation refinement operator for EL ++ we will need some auxiliary definitions. Definition 3. Let T be a TBox in EL ++ . The set of subconcepts of T is given as
where sub is inductively defined over the structure of con-2 A deeper analysis of refinement operators can be found in (van der Laag and Nienhuys-Cheng 1998).
cept descriptions as follows:
Based on sub(T ), we define the upward cover set of atomic concepts and roles. sub(T ) guarantees the following upward cover set to be finite.
Definition 4. Let T be a Tbox in EL ++ (with concept names from N C ). The set of upward covers3 of an atomic concept A ∈ N C ∪ { , ⊥} and of a role r ∈ N r with respect to T is given as:
and there is no C ∈ sub(T )
and there is no s ∈ N r such that r T s T s}
We can now define our generalisation refinement operator for EL ++ as follows:
Definition 5. Let T be a TBox in EL ++ . We define the generalisation operator γ inductively over the structure of concept descriptions as shown in Figure 2.
Given a refinement operator γ, EL ++ concepts are related by refinement paths as follows:
D can be reached from C by γ if there exists a refinement path from C to D. γ * (C) denotes the set of all concepts that can be reached from C by means of γ. Sometimes we write
That γ is indeed a generalisation refinement operator as defined in Definition 2 can be proven by applying structural induction on EL ++ concepts to show that C γ D implies C D, in a similar way as in the proof of Proposition 11 from (Lehmann and Hitzler 2010).
As far as the properties of γ are concerned, we can observe the following. Our definition of UpCov for concepts and roles only considers the set of subconcepts present in a Tbox T . On the one hand, this guarantees that γ is finite, since at each generalisation step, the set of possible generalisations is finite. On the other hand, however, this implies
Figure 2: A generalisation refinement operator for EL ++ . range(r) is defined in Table 1.
that γ is not complete, since it cannot find all possible upward covers of a concept w.r.t. subsumption in EL ++ . 4Regarding the properness property, γ is not proper since there exist cases in which the generalisations produced by γ are equivalent to the concept being generalised. One way to guarantee the properness of γ is by rewriting the concept that we want to generalise into equivalent normal forms before and after each generalisation steps. We will investigate how normalisation can be done as future research.
For the blending, we are interested in finding a common generalisation G (generic space) between two concepts. It is worth to discuss that since γ is not complete, we cannot guarantee that the generic space between two EL ++ concepts is a least general generalisation. Nevertheless, since the concepts and generalisations that γ finds form a bounded semilattice, we can ensure that we can always find a generic space between two concepts. We believe that not finding a least general generalisation is not a weakness of our approach since we are interested in finding a generic space that allow us to create new EL ++ concepts from existing ones by conceptual blending.
We consider two TBoxes T 1 and T 25 and we assume that T 1 and T 2 have the same background knowledge about icon domain but different domain knowledge which, in our case, contain icon definitions.
In order to find a generic space between two icons, we generalise their definitions using the upward refinement operator in Figure 2 implemented in ASP.
The current status of the implementation considers two types of generalisation: γ(A) that generalises an atomic concept by its upward cover and γ C (∃r.C) that generalises a concept that fills the range of a role. We reserve the complete implementation of γ as future work. In this setting, the domain knowledge of a TBox T is generalised in a step-wise transition process. In the following, t denotes a step-counter that represents the number of modifications made to the domain knowledge part of T . Table 2 shows the main EDB and IDB predicates used in the ASP implementation.
For each concept name A ∈ N C in a TBox T , we state the facts:
For each role r ∈ N r in a TBox T , with domain(r) C and range(r) D, we state the facts:
For each inclusion axiom A B ∈ T and A, B are atomic concepts, we state the fact:
Similarly, for each role inclusion axiom r s ∈ T , we state the fact:
For each inclusion axiom A C ∈ T , in which A is an atomic concept and C is a complex concept, we call C the concept definition of A and denote it as ADef within the following ASP facts:
For each C i in the complex concept C = C 1 . . . C n , we make a case distinction and state the following facts:
EDB predicates Description spec(T )
A reference to a TBox T hasConcept(T , C, t)
A concept C belongs to a TBox T at step t hasP arentConcept(T , A, B, t)
A concept B subsumes A in a TBox T at step t isComplexConcept(T , C, t)
A concept C is a complex concept in a TBox T at step t complexCInvolvesCon(T , C, A, t)
A concept C contains a concept A in a TBox T at step t complexCInvolvesRole(T , C, r, A, t)
A concept C contains a role r whose range is filled by A in a TBox T at step t IDB predicates Description notEqual (T1, T2, t)
The TBoxes T1, T2 are not equivalent at step t conceptsNotEquivalent(T1 , T2 ,, t)
The concepts in the TBoxes T1, T2 are not equivalent at step t complexCConceptNotEq(T1, T2, C, A, t)
A concept A in C is not equivalent in the TBoxes T1, T2 at step t complexCRoleConceptNotEq(T1, T2, C, r, A, t) A concept A filling the role r of C is not equivalent in the TBoxes T1, T2 at step t poss(a, T , t)
An upward refinement step a is executable in a TBox T at step t exec(a, T , t)
An upward refinement step a is executed in a TBox T at step t Table 2: Overview of the main EDB and IDB predicates used to formalise the upward refinement process in ASP.
The concepts belonging to the domain knowledge part T dk of a TBox T are modeled in a similar way but without the isBackgroundConcept/3 facts. Besides, we model the concept as the fact hasConcept(T , Thing, t), and for each concept name A ∈ N C , which is not already subsumed by other concept names, we add a fact hasParentConcept(T , A, Thing, t). We check for (in)equality of TBoxes by a rule notEqual (T 1 , T 2 , t) ← conceptsNotEquivalent(T 1 , T 2 , , t). The rule is triggered by additional rules if, for T 1 and T 2 , at step t, atomic concepts, roles and complex concepts are not equal.
In what follows, we refer to the upward operator types we implemented as γ A and γ C . γ A stands for the generalisation of an atomic concept (first row in Fig. 2) and γ C for the generalisation of a concept filling the range of a role. Each upward refinement operator type is an action; to this end, we model each operator type via a precondition rule, an inertia rule, and an effect rule. Preconditions are modelled with a predicate poss/3 that states when it is possible to execute an operator type. Inertia is modelled with a predicate noninertial /3 that states when an element of a concept in T remains unchanged after the execution of a refinement operator type. Effect rules model how a refinement operator type changes a concept in the domain knowledge. We represent the execution of an upward refinement operator type with atoms exec(γ x , T , t), to denote that a generalisation operator type γ x ∈ {γ A , γ C } is applied to T at a step t.
Upward refinement of atomic concepts. A fact exec(genConcept(C , A, B ), T , t) denotes the generalisation of a concept A to a concept B in a complex concept C of a TBox T at step t using γ A . The precondition rule for generalising A is:
There are several preconditions for generalising an atomic concept in a complex concept C. First, C must not be a background concept since we do not want to modify the background knowledge of a TBox T . Second, the concept C involves a concept A that has a parent concept B in the subsumption hierarchy defined by the axioms of the TBox. Third, the definition of C in the TBoxes is not equivalent (complexCConceptNotEq/4 ). The atom complexCConceptNotEq/4 is true either when one of the TBoxes does not contain C or when the definitions of (the structure of) C are different. Another condition is that C has not been generalised in the other TBox.
We also need a simple inertia rule for generalising a concept in a complex concept. This is as follows:
noninertial atoms will cause a concept A to remain in the complex concept C in a TBox T , as defined via rule (15a).
Upward refinement of range concepts. A fact exec(genConceptInRole(C , r , A, B ), T , t) denotes the generalisation of a concept A to a concept B when A fills the range of a role r in a complex concept C of a TBox T at step t using γ C . The precondition rule for generalising a concept A is: poss(genConceptInRole(C, r, A, B), T1, t) ← (13) not isBackgroundConcept(T1, C), complexCInvolvesRole(T1, C, r, A, t) hasParentConcept(T1, A, B, t), complexCRoleConceptNotEq(T1, T2, C, r, A, t), not isNotInRoleRange(T1, r, B), spec(T2), not exec(genConceptInRole(C, r, A, B), T2, t), spec(T2)
The preconditions for generalising a concept filling the role of a complex concept C are similar to the case of generalising an atomic concept. First, C must not be a background concept. Second, C involves a role in which the concept to be generalised has a parent concept in the subsumption hierarchy of the TBox. Then, the definitions of the concept to be generalised must not be equivalent in the TBoxes. (complexCRoleConceptNotEq/4 ). Another condition is needed in the case of this generalisation, that is, the concept that we want to use to generalise the range of a role, must be in the range of r. This is checked by means of the atom isNotInRoleRange/3 . Finally, the concept to be generalised must have not been generalised in the other TBox.
The inertia rule for generalising a concept that fills the range of a role in a TBox is analogous to the inertial rule for generalising a concept:
noninertial atoms will cause a concept A to remain in the range of a role as defined via rule (15b).
Inertia. The following rules state which concepts remain in a TBox T when they are inertial. complexCInvolvesCon(T , C, A, t + 1) ← (15a) complexCInvolvesCon(T , C, A, t), not noninertial (T , C, A, t) complexCInvolvesRole(T , C, r, A, t + 1) ← (15b) complexCInvolvesRole(T , C, r, A, t), not noninertial (T , C, A, t)
Besides, other inertia rules are needed for expressing that all the concepts and roles of the background knowledge and their subsumption relations remain in a TBox T . We omit them.
Effects. The following rules state which concepts change in a TBox T when they are generalised. complexCInvolvesCon(T , C, B, t + 1) ← (16a) complexCInvolvesCon(T , C, A, t), exec(genConcept(C, A, B), T , t) complexCInvolvesRole(T , C, r, B, t + 1) ← (16b) complexCInvolvesRole(T , C, r, A, t), exec(genConceptInRole(C, r, A, B), T , t)
We use ASP for finding a generic space and the generalised versions of the concepts in the domain knowledge of T , which can lead to a blend. This is done by successively generalising the concepts in the domain knowledge by means of the upward operator steps we described in the previous subsection. Again, this is a first implementation and does not capture the recursive definition of the upward refinement operator that we leave as future work.
A sequence of generalisation operator types defines a refinement path. Definition 7 (Refinement path). Let T be a TBox, let {γ 1
x , . . . , γ n x } be the set of generalisation steps for T , t 1 < • • • < t n be refinement steps and γ x ∈ {γ A , γ C }. The set of atoms P = {exec(γ 1
x , T , t 1 ),
Refinement paths are generated with the following choice rule, that allows one or zero refinement operators per T at each step t: 0{exec(a, T , t) : poss(a, T , t)}1 ← (17) not genericReached (t), spec(T )
The only generalisations that are executed are those whose preconditions are satisfied. Refinement paths lead from the input TBoxes to a generic space, which is a generalised TBox that contains the commonalities of the concepts in the domain knowledge. A generic space is reached, if the generalised TBoxes are equals. The notEqual predicate is used to determine if a generic space is reached. notGenericReached (t) ←spec(T1), spec(T2), (18a) notEqual (T1, T2, t),
The constraint (18b) ensures that the generic space is reached in all stable models.
In Definition 1, we defined the blends of two EL ++ concepts in terms of amalgams. Once a generic space between two concepts has been determined, blends are created by computing the MGS of pairs of generalised concepts. In EL ++ the MGS of two EL ++ concepts is just their conjunction. Then we will have to normalise this conjunction to obtain the most concise description of the newly created concept. This is just a rough description of conceptual blending in EL ++ , and normalisation for newly created blends still needs to be studied in detail (this also relates to the operator properness). Blending will also need to consider an interleaved evaluation and generation process in order to find the best pairs of generalised concepts for creating interesting blends.
Example Conceptual blending in EL ++ as described in this paper is a special case of blending as modelled in (Bou et al. 2014) and implemented for CASL theories in (Eppe et al. 2015).
There exist several works that relate to ours from different perspectives, that are, approaches to conceptual blending of ontologies, approaches for finding the LGG in the EL family, and approaches that uses ASP for reasoning over DL ontologies.
Conceptual blending of ontologies in DLs has been explored in (Hois et al. 2010;Kutz et al. 2014) where blends are computed as colimits of algebraic specifications. As such, the blending process is not characterised in terms of amalgamation, the input concepts are not generalised, and the generic space is assumed to be given.
Several approaches for generalising ontology concepts in the EL family exist in the DLs and ILP literature.
On the one hand, in DL approaches the LGG is defined in terms of a non-standard reasoning task over a TBox (Baader 2003;2005;Baader, Sertkaya, and Turhan 2007;Zarrießand Turhan 2013;Turhan and Zarrieß 2013). Generally speaking, since the LGG w.r.t. general TBoxes in the EL family does usually not exist, these approaches propose several 'workarounds' for computing it. For instance, (Baader 2003;2005) devises the exact conditions for the existence of the LGG for cyclic EL-TBoxes based on graph-theoretic generalisations. (Baader, Sertkaya, and Turhan 2007) propose an algorithm for computing good LGGs w.r.t. a background terminology. (Zarrießand Turhan 2013;Turhan and Zarrieß 2013) specify the conditions for the existence of the LGG for general ELand EL + -TBoxes based on canonical models. As already commented in the introduction, our work relates to these approaches, but it is different in spirit, since we do not need to find the LGG between (two) EL ++ concepts for the kind of application we are developing.
ILP approaches, on the other hand, study the LGG in terms of generalisation and specialisation refinement operators. Specialisation rsefinement operators have been defined for learning DL ontologies (Lehmann and Hitzler 2008;Lehmann and Haase 2010) and for measuring the similarity of EL concepts (Sánchez-Ruiz et al. 2011;2013).
Finally, some of the approaches that combine ASP for reasoning over DL ontologies are (Swift 2004;Eiter et al. 2008;Ricca et al. 2009).
In this paper, we defined an upward refinement operator for generalising EL ++ concepts for conceptual blending. The operator works by recursively traversing their descriptions. We discussed the properties of the refinement operator. The operator is finite, can be proper (by allowing a normalisation before each refinement step), but it is not complete. We claimed, however, that completeness is not an essential property for our needs, since being able to find a generic space between two EL ++ concepts, although not a LGG, is already a sufficient condition for conceptual blending.
We presented a first implementation of the refinement operator in ASP. We showed how to model the description of EL ++ concepts in ASP and to formalise two refinement operator types for generalising the domain knowledge of a TBox. The stable models of the ASP program contain the generalisation steps needed to be applied in order to generalise two EL ++ concepts until a generic space is reached. We discussed how the blend of two EL ++ concepts, defined in terms of their most general specification, can be obtained by their conjunction. We exemplified our approach in the domain of computer icon design.
As future works, we plan to continue with the implementation of the EL ++ generalisation operator, to investigate the normalisation rules needed for the operator to be proper and for normalising the blends, as well as to implement a conceptual blending algorithm. We also aim at studying the relationship between the category of CASL theories (Mosses 2004) and signature morphisms and the category of EL ++ concept descriptions and subsumption relation.
We consider the work of this paper to be a fundamental step towards the challenging task of defining and implementing an upward refinement operator for more expressive DLs in the context of conceptual blending.
This work is partially supported by the COINVENT project (FET-Open grant number: 611553).