Common formalisms to represent knowledge, such as Description Logics, are insu cient to represent the dynamic aspects of language when it is used in communication. However, this information can be helpful to describe the semantics of terms in interactions, and in particular to obtain useful alignments that can be used as translations between heterogeneous interlocutors. We propose to consider the speci cation of interactions as contexts for ontologies. To this aim, the ontology language needs to be extended with a temporal layer that allows to express properties about the possible message exchanges between agents in an interaction. We present a simple preliminary extension for taxonomies, and discuss directions to investigate.
The problem of specifying interactions for arti cial agents has been extensively
studied in the past decades. These e orts resulted in di erent formalisms to
describe interactions, such as agent communication languages [
One approach to overcome these di culties is the one presented in [
In this position paper we propose to consider interaction speci cations as
contexts for ontologies, extending the ontology representation language with a
temporal layer that allows to describe properties of a dialogue. This leads to
a formalism that is useful to reason about language in use, by modelling
pragmatic aspects of meaning that depend directly on the particular interaction
taking place, and the way in which they relate to the underlying ontology. A
language relating ontological and pragmatic information could be useful to perform
ontology matching for the particular application of agent communication, since
the information on the interaction context can be very valuable when building an
alignment to be used by agents that interact to perform a particular task. In [
Unlike the context as a box approach to contextualizing ontologies [
2Pitt and Mandami include a third layer, which corresponds to the intention of communicating of each agent. We will focus on the rst two.
We consider interactions between agents that communicate to perform a particular task together (for example, ordering drinks ). The messages that agents send to each other are predicates in a content language that may allow to describe properties about the domain of the conversation. In this position paper, for simplicity, we will only consider a simple taxonomy of concepts with an inclusion (v) relation, but extensions to more complex formalisms (such as Description Logics) should be considered.
Interaction contexts are speci cations of possible message exchanges between
agents. The question of how it is best to model interaction protocols has been
extensively discussed in the multi-agent community, and many options with
different expressive power were proposed [
Example 1. The FSA in Figure 1 speci es an interaction for a waiter that communicates with a customer (c) who wants to order. State transitions should be read as (sender; receiver) : message. Suppose also that the waiter represents information about the domain with a taxonomy that includes the relations Beer v Drink, Water v Drink, Wine v Drink. 2 4 3 (c, w): Pint
10 (w, c): Size
(c, w): Half pint 8 5 (c, w): Red 6 7 9 start 0 (w, c): Drink (c, w): Wine (w, c): Color
(c, w): White (c, w): Beer
1 (c, w): Water
A language to talk about interaction contexts should allow to express properties about the temporal structure of the automaton. In our example, one could want to say that if the waiter asks the customer what she wants to drink, the customer can answer that she wants a beer. More generally, we are interested in expressing properties like the following ones: - something is a possible answer in a particular state - something can or must be said eventually from a particular state To this aim, it is necessary to de ne a context language that extends the content language describing these aspects of a particular interaction. A natural way to express properties about Finite State Automata is to use the -calculus formalism, but we do not need all its expressive power. For properties like the ones above, it is enough to consider only the CTL operators that express necessity (A) and possibility (E), together with the ones for next state ( d) and eventually (3). We also need to include in the signature a set of agent names A and a predicate utter, that relates two agents with a term in the ontology. If C is a concept in the content language and a; a0 2 A, well-formed terms in the context language are E d utter(a; a0; C); E 3 utter(a; a0; C); A 3 utter(a; a0; C); A d utter(a; a0; C); utter(a; a0; C). We consider a very simple semantics for the utter predicate: utter(a; a0; C) is true if agent a has sent message C to a0. More complex underlying languages may need other predicates. For example, for rst-order logics it would be desirable to identify a query from an answer, for which two predicates (commonly ask and tell) are necessary.
With the context language de ned in this way, we can now express the fact that Beer is a proper answer to Drink with the following predicate: utter(w; c; Drink) =)
E d utter(c; w; Beer)
The language allows for interesting combinations with description logics that should be analysed. For example, by introducing a new concept name D playing the role of a fresh variable, we can express properties such as if the waiter asks to the customer what she wants to drink, the customer will answer specifying a drink in the following way: utter(w; c; Drink) =)
A d utter(c; w; D) ^ D v Drink
Note that, unlike previous work, we do not apply temporal operators directly
to elements of the underlying domain language, but rather to a predicate that
states who utters a message to whom. Therefore the results presented in [
While our interaction models only describe who sends messages and when,
other kinds of information, such as preconditions and e ects of utterances, are
also relevant in a conversation. However, this information can be encoded in the
underlying logics, if one uses, for example, a combination of description logics and
action formalisms [
One prominent application of using interaction speci cations as context is to
build alignments between vocabularies of di erent agents that are adequate for
particular tasks. As argued in [
1 (c, w): Aqua start 0 (w, c): Bibita (c, w): Vino (w, c): Tipo
(c, w): Bianco 2 4 3 (c, w): Media (w, c): Quantita
(c, w): Piccola
8
5
(c, w): Rosso
6
7
9
for agent communication, and therefore do not take into account the second layer
of meaning [
To illustrate the problem of aligning vocabularies in the context of a particular interaction, consider again the ordering drinks example, but we now suppose that, while the waiter speaks English, the customer is Italian and follows the interaction model in Figure 2. We consider agents that speak di erent languages but share a basic knowledge of how to perform the task, which is represented as having interaction protocols with similar structure (or equal in this case, for simplicity). This gives place to an alignment between their vocabularies that allows agents to interact successfully, for example, the term Piccola should be in this case interpreted as Half Pint. While this equivalence is reasonable in the context of ordering drinks, general ontology matchers would likely never nd it without additional information, such as the fact that Piccola is a proper answer to Quantita and Half pint to Size. Our approach to contextualizing ontologies by describing properties of a particular interaction can be used, on one side, to specify this kind of pragmatic properties that can be clues for the alignment, and on the other, to describe the contexts for which an alignment is valid. Acknowledgements This research has been funded by the European Communitys Seventh Framework Programme (FP7/2007-2013) under grant agreement no. 567652 /ESSENCE: Evolution of Shared Semantics in Computational Environments/.