Metaphor:

Structure and Processes (Resolution and Creation)

by

Adil KABBAJ

 

 

Introduction

Metaphor and metaphor representation

Use of Metaphor in Natural Language Processing (NLP)

Metaphor is an abstraction mechanism

Metaphor Resolution and Metaphor Creation

Dynamic Integration of Metaphor in an Ontology/Memory

Future Work

 

 

Introduction

Several studies [Ortony, Lakoff and Johnson, Carbonell, Indurkhya, Chibout and Vilnat] show the importance of metaphor in human cognition. They show also that metaphor takes root deeply in human cognition and a model of human ontology should consider and integrate this important aspect. Metaphor is no more a taboo subject or a phenomenon that should be avoided (because it is not clearly defined); it is a cognitive element, essential and basic like any other (basic) cognitive element. We introduce in this document a new Conceptual Structure (CS): metaphor, which represents a metaphor in ontology. Then we consider the use of metaphor in NLP. Then we introduce our current modelization of metaphor processes; like metaphor resolution and creation and metaphor integration. Why metaphor is so essential and so basic (that it should be integrated in our model of integrated ontology) ? because metaphor is an abstraction mechanism, similar to type definition. We discuss this important point in a separate section.

Future works include a complete implementation of these processes and development of samples and applications.

 

Metaphor and Metaphor representation

It is difficult to provide a clear and simple description of a metaphor, but we can consider for the moment the following definition: a metaphor is a description that has an intended meaning different from its "litteral" (or expressed) meaning. For example, the description "Karen devours Richard's book" is a metaphor; the intended meaning is that "Karen reads Richard's book with a great motivation, concentration, intensity and without interruption". Metaphor is related very often to analogy. We consider this point in the next section. Questions and processes related to metaphor are:

  1. Metaphor representation

  2. Metaphor and NLP

  3. Metaphor resolution and creation

  4. Metaphor integration in ontology/memory

Metaphor representation is considered below, the other points are considered in the next sections.

In Amine, Metaphor Conceptual Structure (CS) is defined as an extension of Situation CS. Metaphor is implemented as a subclass of the class Situation. It stores all the information needed for a treatment of metaphor: a metaphor has a description, like a Situation, but it has in addition three attributes: a) metaphoricalObject is a reference to an element in the description that is the focus of the metaphor. In our previous example of metaphor, the focus is the action "devours". In the case of CG, the focus will be a concept and metaphoricalObject will corresponds to the designator of this concept; a variable. From metaphoricalObject (the variable), we can locate the focus (a concept in a CG) of the metaphor, b) specifies the source type used in the description (the type Devour in our example), and c) the target type specifies the intended type (the type Read in our example).

public class Metaphor extends Situation implements java.io.Serializable {
  private Object metaphoricalObject;
  private Type sourceType;
  private Type targetType;
  ...
}

For instance, the metaphor "a Person devours a book" will be represented by a Metaphor object M1 with description: [Person]<-agnt-[Devour: v]-obj->[Book], with metaphoricalObject v, sourceType Devour and targetType Read. Also, Metaphor M1 will be indexed under types Devour and Read.

 

Use of Metaphor in Natural Language Processing (NLP)

In several metaphors, the kernel/source of the metaphorical interpreation is the verb used in the description. We restrict our discussion to this type of metaphor. Metaphorical interpretation is required because the canon of the verb is violated. For instance, in our example "Karen devours Richard's book", canon of Devour is violated since the object of Devour should be a consommable object while book is not a consommable object. Canon violation initiates the metaphorical interpretation process which has to produce the intended meaning, if the metaphor was already resolved, or to construct a metaphor that will "freeze" the result of the metaphorical resolution process. Let us consider first the former case: an appropriate metaphor exists already. The structure of a Metaphor in Amine provides all the necessary elements to construct the intended meaning each time it is required: Here is the main steps:

  1. Get the description D of the metaphor,

  2. Locate in the description the concept with designator the metaphoricalObject of the metaphor which is a variable. The located concept C is the kernel (the focus) of the metaphor. Its type is the sourceType.

  3. Perform a copy of the description D. Call the copy D1. Let C1 designates the copy of the concept C in D1.

  4. Replace in D1 the type of C1 with the targetType.

  5. Perform an analogy (i.e. an analogical transfer of information) between the definition of sourceType (the source for the analogy) and D1 (the target for the analogy), with entry points Genus (for the definition) and C1 (for the description D1).

Example: Let us consider Metaphor M1 introduced above: [Person]<-agnt-[Devour: v]-obj->[Book]. The intended meaning of this metaphor will be produced/computed as follow:

  1. The description D of the metaphor: [Person]<-agnt-[Devour: v]-obj->[Book]

  2. The kernel is [Devour: v]. The sourceType is Devour.

  3. copy D1 of D: [Person]<-agnt-[Devour: v]-obj->[Book].

  4. Replace in D1 the type of C1 with the targetType: [Person]<-agnt-[Read: v]-obj->[Book].

  5. Perform analogy between definition of Devour and D1 with entry points Genus and [Read: v] respectively. Assume that the definition of Devour is the following:
    [Person]<-agnt-[Eat:super]-
                            -obj->[ConsumableObject],
                            -manr->[Greediness],
                            -modality->[Continues],
                            -quality->[Gluttony]

      The result of the analogy (using the analogy operation of Amine) will be:

    [Person]<-agnt-[Read]-
                       -obj->[Book],
                       -manr->[Greediness],
                       -modality->[Continues]

Note that the two attributes Greediness and Continues have been transfered because the target CG remains canonic (after the addition of the two attributes). However, the attribute Gluttony was not transfered because Gluttony requires that the action should be Eat (or a subtype of Eat). Read is not a subtype of Eat.

The above example illustrates two important points: the strong and exact relation between metaphor and analogy, and the fact that very often, analogical transfer is partial (i.e. some parts of the definition will be transfered while others not).

 

Implementation. The above treatment is implemented as a method: getIntendedMeaning(Metaphor) of the class ResolveMetaphor (and the full path: aminePlatform.engines.metaphor.ResolveMetaphor):

public static CG getIntendedMeaning(Metaphor metaphor) {
  CG descr = (CG) metaphor.getDescription(); // We assume that the description is in CG
    // Locate in cg the concept that is the focus of the metaphor
  Concept kernel = descr.findConceptWithDesignator(metaphor.getMetaphoricalObject());
  CG descrCopy = descr.copy();
  Concept kernelCopy = descrCopy.findConceptWithDesignator(metaphor.getMetaphoricalObject());
    // replace the type of kernelCopy with the targetType of the metaphor
  kernelCopy.setType(metaphor.getTargetType());
    // perform an analogy between the definition of the sourceType ot the metaphor and descrCopy, with
    // entry points Genus and kernelCopy respectively.
  CG sourceTypeDefinition = (CG) metaphor.getSourceType().getDefinition();
  if (sourceTypeDefinition == null)
    return null;
  Concept genus = (Concept) sourceTypeDefinition.getGenus().nextElement();
  boolean success = descrCopy.analogy(null, null, genus, null, sourceTypeDefinition, null, kernelCopy, null);
  if (success)
    return descrCopy;
  else return null;
}
 

Natural Language Understanding. Assume for instance that the ontology contains already the metaphor M1 with description: [Person]<-agnt-[Devour: v]-obj->[Book], introduced above. Assume also that the sentence to analyze is "Karen devours Richard's book" that can be represented by [Woman:Karen]<-agnt-[Devour]-obj->[Book]-poss->[Man:Richard]. The analyzer will detect canon violation (of Devour) and will initiate a search for an appropriate metaphor. This search corresponds to an information retrieval, where the information (to search) is a metaphor. Hence, to perform this search, we call the information retrieval process (IR) defined on dynamic ontology, with Devour as its pertinent type and as the sourceType of the metaphor. IR will locate the above metaphor M1 since it is indexed under Devour (as a Metaphor) and its description is more general than the content of "Karen devours Richard's book". The latter is recognized as a specialization of metaphor M1 and so, the above treatment (getIntendedMeaning()) is applied except that the initial description will not be the description of the metaphor but the current description:

  1. Start with the current description D:

      [Woman:Karen]<-agnt-[Devour]-obj->[Book]-poss->[Man:Richard]

  1. The kernel is [Devour]. The sourceType is Devour.

  2. copy D1 of D: [Woman:Karen]<-agnt-[Devour]-obj->[Book]-poss->[Man:Richard].

  3. Replace in D1 the type of C1 with the targetType:

            [Woman:Karen]<-agnt-[Read]-obj->[Book]-poss->[Man:Richard].

  1. Perform analogy between definition of Devour and D1 with entry points Genus and [Read] respectively. The result of the analogy is:

    [Woman:Karen]<-agnt-[Read]-
                           -obj->[Book]-poss->[Man:Richard],
                           -manr->[Greediness],
                           -modality->[Continues]

The class ResolveMetaphor provides a variant of the method getIntendedMeaning() that performs the above treatment:  it returns the intended meaning of the specified description descr, instead of the intended meaning of the metaphor. See code of this variant in the class ResolveMetaphor (and the full path: aminePlatform.engines.metaphor.ResolveMetaphor).

public static CG getIntendedMeaning(Metaphor metaphor, CG descr);

 

Natural Language Generation. Our formulation of Metaphor is benefic also for NL generation: assume that we have a CG G formulation for description D: "Karen reads Richard's book with greediness and without interruption" and we want to produce a NL generation from G. One method to perform such generation maybe the following: from type Read in the ontology, we will reach metaphor M1 (that is indexed under Devour and Read) with Read as its targetType. We apply the method getIntendedMeaning(M1) to get the intended meaning of metaphor M1: "Person reads book with greediness and without interruption". Next, we discover that the description D is a specialization of the intended meaning of metaphor M1 and the latter is the closer description to D. So, we decide to adopt metaphor M1 for the formulation of G: to do that, we proceed in reverse to the treatment of getIntendedMeaning(); we proceed from the intended meaning (and from the targetType: Read) to the metaphorical meaning (and the sourceType: Devour). We search the genus of the definition of the sourceType, which is Eat. Then we replace the targetType (Read) by the genus (Eat). Then we contract the definition of Devour from the description D. The result of the contraction will be: "Karen devours Richard's book".

 

Metaphor is an abstraction mechanism

To the question "Why metaphor is so essential and so basic to the modelization of a human-like ontology ?" we suggest that the main reason is that metaphor is an abstraction mechanism, similar to type definition. Metaphor is also an effect of memory organization and an effect of the great flexibility of the system. Basically, the point can be illustrated as follows: instead of creating a new concept type (i.e. a specialization of type Read for instance) with definition "Read with greediness and without interruption", knowing that this definition is part of the definition of another concept type (i.e. Devour), human-like cognitive system creates a metaphor; a "special" Situation (i.e. for Devour) that calls for a "special" interpretation: the role of its main action (i.e. Devour) is to trigger and to invoke an analogical transfer of its definition (i.e. definition of Devour) to the description of the situation.

Figure 1 illustrates this discussion:

            

  (a) a Possible representation without metaphor                         (b) Representation with metaphor

Figure 1: Metaphor as an abstraction mechanism

There is the gain of not defining new categories (new concept types): memory/ontology would be much more dense and overloaded without metaphor than with metaphor. Also and as illustrated by Figures a and b, there is also the gain in storage and a more efficient organization of memory: definition of Devour has common information with the new meaning. Moreover, part of the new meaning can be infered, by analogy, from the the definition of Devour. The new meaning is stored, as a metaphor, in a "compressed form". With metaphor interpretation, it is decompressed !

 

Metaphor Resolution and Metaphor Creation

Let us consider now the second case: no metaphor exists that can match the current description, so we have to contruct a new metaphorical interpretation and to "freeze" this interpretation in a new metaphor. We noted in the introduction that for several metaphors, the kernel/source of the metaphorical interpreation is the verb used in the description and that we restrict our discussion to this type of metaphor.
To construct a metaphor, according to our definition and implementation of Metaphor, is to determine its components: metaphoricalObject, its sourceType, its targetType and its initial description. The description of the metaphor is the specified description D. We illustrate first metaphor resolution and metaphor creation with an example, then we provide a general description of this important operation.

Example: Assume that the description D is: "Karen devours Richard's book", and that no metaphor exists for the interpretation of D. D can be represented by the following CG:

        [Woman:Karen]<-agnt-[Devour]-obj->[Book]-poss->[Man:Richard]

As noted before, description of the new metaphor M (to construct) is D. The sourceType of M is Devour and the kernel of M is the concept [Devour]. To this concept, we assign a designator (a variable v) that will correspond to the metaphoricalObject of the metaphor M. Now, the "big" problem is to determine the sourceType of the metaphor M. We start by a copy of D. Let call it D1. Then, we replace in D1 the type Devour with the most general action type. Let us assume that this type is the type Action. Description D1 becomes:

        [Woman:Karen]<-agnt-[Action:v]-obj->[Book]-poss->[Man:Richard]

Then, we apply an analogical transfer of the definition of Devour to description D1. The result is:

    [Woman:Karen]<-agnt-[Action:v]-
                               -obj->[Book]-poss->[Man:Richard],
                               -manr->[Greediness],
                               -modality->[Continues]

Note that the attribute "Gluttony" specified in the definition of Devour is not transfered since its canon is violated by the above description: Gluttony requires Eat or a subtype of Eat.

Then we call information retrieval operation to locate and situate D1 in the ontology/memory. The goal of this operation is to determine which action types may index D1 (action that can have Woman as agent, Book as object, Greediness as manner, Continues as modality, etc.). The reason for the prior analogical transfer of the definition of Devour to the description D1 is to provide selecting criteria for the determination of the set of action types to consider as candidates of the sourceType of the new metaphor to construct. The set of candidates could be {Write, Read, Edit, Publish, Destroy, Buy, Sell, ...}. Now, one criteria to select the "best" candidate is to determine which one is nearer to Devour: for each element E of the candidates set, determine the minimal common super type of Devour and E. Then select the element E that has the most specific  common super type of Devour. The best candidate would be Read.

Here is the mains steps for the construction of the metaphor:

  1. The initial description of the metaphor M to construct is a copy of the current description D, let call it D1. The sourceType of the metaphor is the (main) action of description D1. Let A refers to the concept in D1 that represents the main action. A represents the source/kernel/focus/center of the metaphor.

  2. Create a variable V and assigns to the designator of the concept A. V is the metaphoricalObject of the metaphor.

  3. Perform the analogical transfer of the definition of the sourceType to description D1.

  4. Locate the most general Type (ActType) of sourceType; the most general type of Action. The ontology will contain (obviously) a type like Action (or Act).

  5. Locate and Replace the type of A; the type of the concept in focus, by the type ActType.

  6. Find in the ontology the most specific action types that subsume D1.

  7. From the list of types found above, determine the type (it will be the targetType of the Metaphor) that has the most specific common super type with sourceType.

  8. Construct and return a new Metaphor with the elements determined above.
     

Here is the method of the class ResolveMetaphor that performs the above treatment:

public static Metaphor resolveMetaphor(Ontology ontology, CG descrOfAction, Concept action) {
  // action is the concept in descrOfAction for which the canon is violated.
  // Thus, the type of the concept action would be the sourceType of the metaphor.
  Type sourceType = (Type) action.getType(); // we assume here that a type is a Type (not a variable).
  CG descrCopy = descrOfAction.copy();
  Concept kernelCopy = descrCopy.findConceptWithType(sourceType);
  Variable v = Variable.generateNewVariable(); // it will be the metaphoricalObject
  kernelCopy.setDesignator(v);
  // perform an analogy between the definition of the sourceType ot the metaphor and descrCopy, with
  // entry points Genus and kernelCopy respectively.
  CG sourceTypeDefinition = (CG) sourceType.getDefinition();
  if (sourceTypeDefinition == null)
    return null;
  Concept genus = (Concept) sourceTypeDefinition.getGenus().nextElement();
  boolean success = descrCopy.analogy(null, null, genus, null, sourceTypeDefinition, null, kernelCopy, null);
  if (!success)
    return null;
  // Locate the most general Type of this action: the Type before the Ontology Root.
  // It will be in general the type Action.
  ArrayList superTypes = sourceType.getArraySuperTypes();
  Type actType = (Type) superTypes.get(superTypes.size() - 2);
  // Locate and Replace the type of the concept by the type actType
  Concept concept = descrCopy.findConceptWithDesignator(v);
  concept.setType(actType);
  // Find in the ontology the most specific types that subsume descrCopy.
  AmineList pertinentTypes = new AmineList();
  pertinentTypes.add(concept.getType());
  ArrayList types = simulateIntegration(ontology, descrCopy, pertinentTypes);
  if (types == null)
    return null;
  Type targetType = actType;
  // From the the list of types found above, determine the type (it will be the
  // targetType) that has the most specific common super type with sourceType.
  Type aType = null;
  Type minCommSuperType = null;
  Type theBestMinCommSuperType = actType;
  for (Iterator i = types.iterator(); i.hasNext();) {
    aType = (Type) i.next();
    minCommSuperType = sourceType.getMinComSuperType(aType);
    if (minCommSuperType.isSubType(theBestMinCommSuperType)) {
      theBestMinCommSuperType = minCommSuperType;
      targetType = aType;
    }
  }
  // Construct and return a new Metaphor with the elements determined above.
  return new Metaphor(v, sourceType, targetType, descrOfAction);
}

Dynamic Integration of Metaphor in an Ontology/Memory

Here we consider the main treatment, that will call the above operations as needed. Indeed, treatment of a metaphor starts with a description (of an action) that violates its canon. This violation initiates the integration, in the ontology/memory, of the description as a metaphor (maybe a metaphor exists already which is identical or similar to the current description). Here is the main decisions and steps of this treatment:

  1. A Metaphor (or a description that is supposed to be a metaphor) can be compared with only other metaphors.

  2. If two metaphors have a common information that share the kernel of the metaphor, then a new metaphor node (not a situation) will be created for this generalization. No other generalization will be considered for metaphor. The target type for the new metaphor, created by a generalization of two metaphors, will be the target type of the metaphor to which it is the more_specific, or it is more_general, or equal, or has a common information.

  3. If no metaphor under the kernel type is comparable to the new description, then the resolution of the metaphor is initiated in order to determine the targetType. If a targetType is found, then a new metaphor is created under the kernel type, otherwise the description is problematic (it violates the canon of its main action and it can not be interpreted as a metaphor).

From the above specification, it becomes clear that the integration process will construct and update a (generalization) hierarchy of metaphors, like the generalization hierarchy of types and the generalization hierarchy of situations, etc. All these hierarchies are merged in one huge multi-layer ontology.

 

Future Work

Some details should be filled and complete examples considered to get a precise assessment of our treatment of metaphor and related processes.

 

References

J. G. Carbonell, Metaphor: An Inescapable Phenomenon in Natural-Language Comprehension, in W; G.      

    Lehnert and M. H. Ringle (Eds.), Strategies for Natural Language Processing, Erlbaum, 1982.

K. Chibout and A. Vilnat, Computational Processing of Verbal Polysemy with Conceptual Structures, in M-L

    Mugnier and M. Chien (Eds.), Conceptual Structures: Theory, Tools and Applications, 6th ICCS,

    ICCS'98, Springer, 1998.

B. Indurkhya, Approximate Semantic Transference: A Computational Theory of Metaphors and Analogies,  

    in Cognitive Science 11, 445-480, 1987.

G. Lakoff and M. Johnson, The Metaphorical Structure of the Human Conceptual System, Cognitive

    Science 4, 195-208, 1980.

G. Lakoff and M. Johnson, Metaphors we live by, University of Chicago Press, 1980.

A. Ortony (Ed.), Metaphor and Thought, Cambridge University Press, 1979.