In this work we describe GOCCIOLA (Generating knOwledge by Concept Combination In descriptiOn Logics of typicAlity), a tool for the dynamic generation of novel knowledge by exploiting a recently introduced extension of a Description Logic of typicality able to combine prototypical descriptions of concepts. Given a goal expressed as a set of properties, in case an intelligent agent cannot nd a concept in its initial knowledge base able to ful ll all these properties, GOCCIOLA exploits the Description Logic TCL in order to nd two concepts whose creative combination satis es the goal. The knowledge base of the agent is then extended by the prototype resulting from the concept combination, and the combined concept represents the solution for the initial goal. We have tested GOCCIOLA on some paradigmatic examples in the literature of automatic generation of knowledge, and we have shown that it seems to be a promising instrument to tackle the problem of implementing a dynamic generation of novel knowledge obtained through a process of commonsense reasoning.
A challenging problem in Arti cial Intelligence concerns the capability of an
intelligent agent to achieve its goals when its knowledge base does not contain
enough information to do that. In this line of research, existing goal-directed
systems usually implement a re-planning strategy in order to tackle the
problem. This is systematically performed by either an external injection of novel
knowledge or as the result of a communication with another intelligent agent [
In this work, we propose an alternative approach, consisting in a dynamic and automatic generation of novel knowledge obtained through a process of commonsense reasoning. The idea is as follows: given an intelligent agent and a set of goals, if it is not able to achieve them from an initial knowledge base, then it tries to dynamically generate new knowledge by combining available information. Novel information will be then used to extend the initial knowledge base in order to achieve the goals. As an example, suppose that an intelligent agent is aware of the facts that, normally, co ee contains ca eine and is a hot beverage, that the chocolate with cream is normally sweet and has a taste of milk, whereas Limoncello is not a hot beverage (normally, it is served chilled). Both co ee and Limoncello are after meal drinks. Cold winters in Turin suggest to have a hot after-meal drink, also being sweet and having taste of milk. None of the concepts in the knowledge base of the agent are able to achieve the goal on their own, however, the combination between co ee and chocolate with cream provides a solution.
In this paper we introduce GOCCIOLA, a tool following this approach in
the context of Description Logics (from now on, DLs for short). DLs are one
of the most important formalisms of knowledge representation and are at the
base of the languages for building ontologies such as OWL. In this respect, we
exploit the Description Logic TCL, recently introduced in order to account for
the phenomenon of concept combination of prototypical concepts [
The plan of this short paper is as follows. In Section 2 we brie y recall the DL for concept combination TCL. In Section 3 we provide a formal description of the problem of dynamic knowledge generation in the context of the logic TCL. In Section 4 we introduce the system GOCCIOLA, and we show that it is a promising candidate to tackle such a problem by means of some paradigmatic examples. We conclude in Section 5 with some pointers to future issues. 2
TCL
In [
As a second ingredient, we have considered a distributed semantics
similar to the one of probabilistic DLs known as DISPONTE [
The logic TCL seems to be a promising candidate in order to tackle the
problem of concept combination. Combining the typical knowledge of pre-existing
concepts is among the most creative cognitive abilities exhibited by humans.
This generative phenomenon highlights some crucial aspects of the knowledge
processing capabilities in human cognition and concerns high-level capacities
associated to creative thinking and problem solving. Dealing with this problem
requires, from an AI perspective, the harmonization of two con icting
requirements that are hardly accommodated in symbolic systems (including formal
ontologies [
Given a KB K = hR; T ; Ai, where R is the set of standard (rigid) inclusions of ALC, T is the set of typicality inclusions, and A is the ABox, and given two concepts CH and CM occurring in K, the logic TCL allows de ning a prototype of the compound concept C as the combination of the HEAD CH , the dominant element in the combination, and the MODIFIER CM , where the typical properties of the form T(C) v D (or, equivalently, T(CH u CM ) v D) to ascribe to the concept C are obtained by considering blocks of scenarios with the same probability, in decreasing order starting from the highest one. We rst discard all the inconsistent scenarios, then: { we discard those scenarios considered as trivial, consistently inheriting all the properties from the HEAD from the starting concepts to be combined. This choice is motivated by the challenges provided by task of common-sense conceptual combination itself: in order to generate plausible and creative compounds it is necessary to maintain a level of surprise in the combination. Thus both scenarios inheriting all the properties of the two concepts and all the properties of the HEAD are discarded since prevent this surprise; { among the remaining ones, we discard those scenarios inheriting properties from the MODIFIER in con ict with properties that could be consistently inherited from the HEAD; { if the set of scenarios of the current block is empty, i.e. all the scenarios have been discarded either because trivial or because preferring the MODIFIER, we repeat the procedure by considering the block of scenarios, having the immediately lower probability.
Remaining scenarios are those selected by the logic TCL. The ultimate output of our mechanism is a knowledge base in the logic TCL whose set of typicality properties is enriched by those of the compound concept C. Given a scenario w satisfying the above properties, we de ne the properties of C as the set of inclusions p :: T(C) v D, for all T(C) v D that are entailed from w in the logic TCL. The probability p is such that: { if T(CH ) v D is entailed from w, that is to say D is a property inherited either from the HEAD (or from both the HEAD and the MODIFIER), then p corresponds to the degree of belief of such inclusion of the HEAD in the initial knowledge base, i.e. p : T(CH ) v D 2 T ; { otherwise, i.e. T(CM ) v D is entailed from w, then p corresponds to the degree of belief of such inclusion of a MODIFIER in the initial knowledge base, i.e. p : T(CM ) v D 2 T .
The knowledge base obtained as the result of combining concepts CH and CM into the compound concept C is called C-revised knowledge base, and it is de ned as follows:
KC = hR; T [ fp : T(C) v Dg; Ai;
for all D such that either T(CH ) v D is entailed in w or T(CM ) v D is entailed
in w, and p is de ned as above. In [
We exploit the logic TCL in order to tackle the following problem: given a knowledge base K in the Description Logic TCL, an intelligent agent has to achieve a goal G intended as a set of concepts fD1; D2; : : : ; Dng. More precisely, the agent has to nd a solution for the goal, namely a concept C such that, for all properties Di, it holds that either K j= C v Di or K j= T(C) v Di in the logic of typicality ALC + TRRaCl . If K does not contain any solution for the goal, then the agent tries to generate a new concept by combining two existing ones C1 and C2 by means of the logic TCL: C is then considered a solution for the goal if, considering the (C1 u C2)-revised knowledge base KC extending K, we have that, for all properties Di, it holds that either KC j= C v Di or KC j= T(C) v Di in the logic of typicality ALC + TRRaCl .
This is formally de ned as follows: De nition 1. Given a knowledge base K in the logic TCL, let G be a set of concepts fD1; D2; : : : ; Dng called goal. We say that a concept C is a solution to the goal G if either:
{ for all Di 2 G, either K j= C v Di or K j= T(C) v Di in the logic TCL or { C corresponds to the combination of two concepts C1 and C2 occurring in K, i.e. C C1 u C2, and the C-revised knowledge base KC provided by the logic TCL is such that, for all Di 2 G, either KC j= C v Di or KC j= T(C) v Di in the logic TCL.
Let us conclude this section by formalizing the example of the Introduction. Example 1. In the example of the Introduction, suppose that K contains the information that, normally, co ee contains ca eine and is a hot beverage; moreover, we have that the chocolate with cream is normally sweet and has a taste of milk, whereas Limoncello is not a hot beverage (normally, it is served chilled). Both co ee and Limoncello are after meal drinks. We can represent these information as follows: 0:9 :: T(Co ee) v AfterMealDrink 0:8 :: T(Co ee) v WithCa eine 0:85 :: T(Co ee) v HotBeverage
Cold winters in Turin suggest to have a hot after-meal drink, also being sweet and having taste of milk. We can then de ne a goal G as
G = fAfterMealDrink ; HotBeverage; Sweet ; TasteOfMilk g: None of the concepts in the knowledge base represent a solution for the problem. However, the combination between the concepts Co ee and ChocolateWithCream represents a solution. Indeed, the revised knowledge base obtained by exploiting the logic TCL to combine these concepts allows the agent to extend its knowledge with the following typicality inclusions: 0:9 :: T(Co ee u ChocolateWithCream) v AfterMealDrink 0:85 :: T(Co ee u ChocolateWithCream) v HotBeverage 0:65 :: T(Co ee u ChocolateWithCream) v Sweet 0:95 :: T(Co ee u ChocolateWithCream) v TasteOfMilk providing a solution to the goal corresponding to the famous Turin drink known as Bicer n (little glass). 4
In this Section we describe GOCCIOLA, a preliminary implementation of a system able to extend the knowledge of an agent in order to ful ll a set of properties representing the goal that the agent wants to achieve. GOCCIOLA is implemented in Python and its current version, along with the les for the examples presented in this paper, are available at http://di.unito.it/gocciola. The architecture of the system GOCCIOLA is shown in Figure 1.
As an example, let us consider the goal: object, cutting, graspable, in other words our agent is looking for an object being graspable and which is able to cut. The initial knowledge base is formalized in the language of the logic TCL and it is stored in a suitable le. Rigid properties, holding for all individuals of a given class, are stored as pairs object-property, whereas typical properties are formalized as triples object-property-probability. We have considered an extension with probabilities of a portion of the ontology opencyc1 As an example, the concept Vase is stored as follows (on the right the corresponding knowledge base in TCL): vase, object vase, high convexity vase, ceramic, 0.8 vase, to put plants, 0.9 vase, to contain objects, 0.9 vase, graspable, 0.9
0:8 :: T(Vase) v Ceramic 0:9 :: T(Vase) v ToPutPlants 0:9 :: T(Vase) v ToContainObjects 0:9 :: T(Vase) v Graspable
To run GOCCIOLA, the user has to invoke the Python interpreter on the le main.py, which consults the initial knowledge base and the goal to achieve 1 https://github.com/asanchez 75/opencyc/blob/master/opencyc-latest.owl.gz. (classes ReadKnowledgeBase and Goal, respectively). First of all, the method resolve goal checks whether the knowledge base contains a concept C immediately satisfying it, i.e. exhibiting all the concepts of the goal either as rigid or typical properties: in this case, the system is done, and GOCCIOLA ends its computation by suggesting such a concept C as the solution. In case C does not exist, the system GOCCIOLA tries to extend the knowledge base of the agent by looking for at least two concepts, C1 and C2, whose combination via TCL generates a concept C0 satisfying the goal. More in detail: { GOCCIOLA computes a list of concepts of the initial knowledge base satisfying at least a property of the goal. As an example, suppose that the following inclusions belong to the knowledge base:
0:85 :: T(Spoon) v :Cutting 0:9 :: T(Vase) v Graspable
Both Vase and Spoon are included in the list of candidate concepts to be combined; { for each item in the list of candidate concepts to be combined, GOCCIOLA computes a rank of the concept as the sum of the probabilities of the properties also belonging to the goal, assuming a score of 1 in case of a rigid property. In the example, Vase is ranked as 0:9 + 1 = 1:9, since both Graspable and Object are properties belonging to the goal: for the former we take the probability 0:9 of the typicality inclusion T(Vase) v Graspable, for the latter we provide a score of 1 since the property Vase v Object is rigid. Concerning the concept Spoon, GOCCIOLA computes a rank of 1: indeed, the only inclusion matching the goal is the rigid one Spoon v Graspable; { GOCCIOLA checks whether the concept obtained by combining the two candidate concepts with the highest ranks, C1 and C2, is able to satisfy the initial goal. GOCCIOLA computes a double attempt, by considering rst C1 as the HEAD and C2 as the MODIFIER and, in case of failure, C2 as the HEAD and C1 as the MODIFIER.
In order to combine the two candidate concepts C1 and C2, GOCCIOLA
exploits the system COCOS [
We have tested GOCCIOLA by asking it to solve some well established and paradigmatic examples from the literature. We have considered a knowledge base extending opencyc and including, among others, the following inclusions: Stone v MineralAggregate Shelf v Object 0:7 :: T(Stone) v Roundish 0:8 :: T(Shelf ) v Wood 0:7 :: T(Stone) v Greyish 0:9 :: T(Shelf ) v Rectangular 0:7 :: T(Stone) v BuildingArrowHeads 0:8 :: T(Shelf ) v Containment 0:8 :: T(Stone) v ShapingObjects 0:8 :: T(Shelf ) v Support 0:7 :: T(Stone) v Cutting 0:6 :: T(Stone) v Support 0:8 :: T(Stone) v StrikeAtDistance 0:9 :: T(Stone) v Graspable 0:7 :: T(Stone) v Narrow 0:8 :: T(Stump) v Wood 0:7 :: T(Stump) v Medium 0:8 :: T(Stump) v Linear 0:7 :: T(Stump) v LiftingFromTheGround 0:7 :: T(Stump) v Support
We have rst asked GOCCIOLA to nd a solution for the goal
G1 = fObject ; Cutting; Graspableg; i.e. our intelligent agent is looking for a graspable object able to cut. In this case, GOCCIOLA proposes the combination Stone u Stump as a solution, thus 2 https://pythonhosted.org/Owlready2/ suggesting a combined concept resembling a knife with a wood handle. It is worth noticing that, if the initial knowledge base would have contained the inclusion Stone v Object , then GOCCIOLA would have suggested that the concept Stone is a straightforward solution for G1: indeed, all concepts in G1 would be either rigid or typical properties of such a concept.
We have then queried GOCCIOLA with the goal
G2 = fObject ; Graspable; LaunchingObjectsAtDistanceg; i.e. the agent is looking for a graspable object able to launch at distance. In this case, GOCCIOLA asks COCOS to combine the concepts Stone and RubberBand , being those with the highest rank with respect to G2. The (Stone uRubberBand )revised knowledge base suggested by adopting Stone as the HEAD is such that all the properties of both concepts are considered, with the exception of Support , therefore the knowledge base of the agent is extended (among the others) by the following inclusions: 0:9 :: T(Stone u RubberBand ) v Graspable 0:9 :: T(Stone u RubberBand ) v LaunchingObjectsAtDistance and the combination Stone u RubberBand is a solution for the goal G2 (it is worth noticing that Stone u RubberBand v Object is inherited since Stone u
We have considered a third goal
G3 = fObject ; Support ; LiftingFromTheGround g; for which GOCCIOLA provides a solution corresponding to the concept obtained by combining Shelf and Stump. Notice that also Stump u RubberBand would be a solution: however, GOCCIOLA gives preference to the concept Shelf because it has a higher rank with respect to the goal, being also, normally, a member of the concept Support . 5
In this short paper we have presented GOCCIOLA, a rst implementation of a
procedure whose aim is to dynamically extend a Description Logics knowledge
base by exploiting conceptual combination. GOCCIOLA relies on COCOS, a tool
for combining concepts in the logic TCL. In future research, we aim at studying
the application of optimization techniques in [
The logic TCL underlying GOCCIOLA is also able to combine more than two concepts at a time, as well as to involve compound concepts (and not only atomic ones) in a concept combination. We aim at extending GOCCIOLA in order to also exploit this features. Moreover, in future works, we plan to consider the case in which GOCCIOLA is able to provide a partial solution, satisfying a proper subset of the initial goals.