=Paper=
{{Paper
|id=Vol-66/paper-2
|storemode=property
|title=Greeks and Trojans Together
|pdfUrl=https://ceur-ws.org/Vol-66/oas02-8.pdf
|volume=Vol-66
|authors=Luís Miguel Botelho,Nelson Antunes,Mohmed Ebrahim and Pedro Ramos
}}
==Greeks and Trojans Together==
https://ceur-ws.org/Vol-66/oas02-8.pdf
Greeks and Trojans Together
Luís Botelho Nelson Antunes Mohmed Ebrahim Pedro Ramos
Luís.Botelho@iscte.pt Nelson.Antunes@iscte.pt Mohmed.Ebrahim@iscte.pt Pedro.Ramos@iscte.pt
Communicating Intelligent Systems Group of ADETTI
Av. das Forças Armadas, Edifício ISCTE, 1600 Lisboa, Portugal
FIPA SL and KIF fit into a logic-based framework, DAML+OIL
ABSTRACT fits into an object-oriented framework.
This paper describes a comprehensive solution for the integration The choice of FIPA ACL (and, in general, any other agent
of object oriented ontology representation frameworks with communication language based on speech acts [10]) entails the
logic-based agent communication frameworks. The proposed use of a logic-based message content language because the
solution addresses the problem at both the agent communication contents of ACL messages must be combinations of propositions
level and the agent implementation level. At the agent and terms. Information and closed query messages take
communication level, we propose to extend logic content propositions as content; open query messages take referential
languages with some domain independent operators that allow expressions as content; and request, negotiation and error
building logic constructs as propositions from domain dependent messages take combinations of actions and propositions as
entities defined in an object oriented ontology. At the content. FIPA SL and KIF are logic-based languages capable of
implementation level, we propose to use object-oriented databases representing propositions and terms, as implied by the choice of
as the support for the agent information. Finally, we propose an FIPA ACL language.
automatic mechanism for translating agent messages using the
extended content language into ODMG OQL commands, which The paper presents an approach for the integration of
are then used to interact with the object-oriented database. This object-oriented and logic-based frameworks both at the
binding mechanism relies on a special purpose data dictionary communication level and at the implementation level. At the
representing the mapping between the domain ontology and the communication level (section 2), the paper proposes four new
agent internal database. relational, functional and action operators that may be used to
build logic-based communication constructs such as terms and
propositions from classes, objects, attributes and methods. At the
Keywords implementation level (section 3), information agents are
Ontology, Agent Communication, Content Language implemented on top of object databases, which are well suited to
directly maintain the information of the domain, which is formed
1. INTRODUCTION by instances of the object-oriented domain ontology. Received
messages are translated to commands of the object-oriented
In agent communication, a message can be understood only if the
database query language.
vocabulary used in the message content belongs to the ontology
used by the agent. If the vocabulary contained in the ontology is Section 4 presents three approaches that can be considered
described in terms of classes, objects, attributes and methods, but alternatives to the current proposal. In one, [2] proposes the
the message content uses predicates, functions, constants, and extension of FIPA ACL with new performatives taking objects as
actions, the agent becomes helpless unless it can use some way of contents. In another alternative [4], we discuss the possibility of
integrating the two different representation frameworks. using classes of the domain ontology to represent propositions
and other entities used in communication. Finally [9], we analyse
The paper presents an approach to integrate object-oriented
the use of transposition rules to convert the object-oriented
ontologies with logic-based communication. In the scope of this
ontology into a relational model.
paper, the expression “object-oriented ontology” refers to
ontologies in which the domain is represented in terms of classes,
objects, attributes, and methods. The expression “logic-based 2. AGENT-COMMUNICATION LEVEL
communication” refers to communication frameworks in which This section describes four general-purpose operators that can be
the contents of the messages are built form predicates, functions, used in the communication for creating propositions and terms
constants, variables and actions. (including action propositions and action terms) from domain
In the Agentcities project [1], FIPA ACL [5] is used as the agent classes, objects, properties and methods.
communication language; FIPA SL [6] and KIF [8] may be used The explanation considers two possible modelling scenarios. In
as message content languages; and DAML+OIL [11] is used to one scenario, domain predicates are represented by methods;
represent ontologies. These choices were driven by a set of well domain actions are represented by methods; and domain functions
founded reasons including project management reasons, current are represented by methods. In the other scenario, domain
industrial and standardisation trends, and existing technological predicates are represented by classes; domain actions are
support. In spite of being well justified, these choices are not free represented by classes; and domain functions are represented by
of problems. Namely, they imply the harmonisation of the methods. The system designer is free to choose his/her preferred
logic-based agent communication framework and the object modelling approach.
oriented ontology representation framework. Whereas FIPA ACL,
2.1 Extending Logic-Based Content apply/3 is an action operator used to represent the application of a
certain method with the specified set of parameters to an object.
Languages (apply Object MethodName Arguments) represents
Some of the proposed new operators are relational operators (i.e., the application of method named MethodName with the
predicates), others are functional operators, and others are action arguments specified by Arguments to Object. Arguments may be
operators. either the sequence containing the values of the method
The proposed extension assumes objects may be represented in a arguments or a set of named arguments. apply/3 should be used
logic-based content language as proposed in [2]. That is, an object with methods that change the sate of the world.
is a functional expression in which the functor is the name of the execute/1 is an action operator to be used to represent the
object class, playing the role of a class constructor. The functional execution of an action represented by an object expression.
expression arguments are the attributes of the object to be created. (execute ActionDesignator) represents the execution of
Using this convention, the following functional expression the action represented by ActionDesignator. ActionDesignator
represents a restaurant named "Encher a Mula" with several other must be an object expression. That is, it must be an expression
attributes including restaurantAddress whose value is an object of whose evaluation returns an object, for instance a referential
class Address having attributes publicPlace, number, city, and expression or a functional expression representing an object.
zone.
(Restaurant
2.2 Information Message
:name "Encher a Mula" This section shows an interaction in which a restaurant agent
:phone 219999999 receives the information that there is a traditional food restaurant
:restaurantAddress (Address named "Encher a Mula" with phone number 219999999, located
:publicPlace "Rua Associado Dias" in Lisbon, downtown, street "Associado Dias", number 1. In FIPA
:number 1 ACL, information messages use the inform performative.
:city Lisboa
:zone downtown) (inform
:type traditional) :sender Some restaurant SME access agent
Figure 1. Object instance representation :receiver Lisbon restaurant agent
:content "(
The new added operators enable the manipulation of classes, (instance
objects, attributes and methods. (Restaurant
New relational operator :name \"Encher a Mula\"
:phone 219999999
instance/2 is a new relational operator used to access instances of :restaurantAddress (Address
specified classes. (instance Object ClassName) means :publicPlace \"Rua Assoc. Dias\"
that Object is an instance of the class named ClassName. :number 1
Operationally, instance/2 can be used to check whether an object :city Lisboa
is an instance of a class and also to access the different instances :zone downtown)
of a class. instance/2 was originally proposed in [2]. :type traditional)
Restaurant)
New functional operators )"
value/2 is a new functional operator used to access the value of an :language extended-FIPA-SL
attribute of an object. (value Object AttributeName) is )
the value of the attribute named AttributeName of Object. Figure 2. Information Message
value/3 is used to apply a certain method with the specified set of The message in figure 3 is expressed in the FIPA ACL
parameters to an object. (value Object MethodName communication language and FIPA SL content language.
ArgumentSequence) is the value returned by the application
of method named MethodName with the arguments specified by 2.3 Closed Query Example
ArgumentSequence to Object. value/3 can be used only with
This section presents an example in which an agent receives a
methods that do not return void.
closed query. In FIPA ACL, closed queries are expressed by the
If the attribute specified in value/2 or the method specified in query-if performative.
value/3 has multiple values, then value-expressions will represent
In this example, the restaurant information agent receives a query
sets.
representing the question "Is there a traditional restaurant
Value expressions may also be used with class methods and class located downtown?".
attributes instead of object methods and attributes. In those cases,
the first argument of the operator must be a class name.
value/2 was originally proposed in [2] as a relational operator.
New action operators
Action operators represent the execution of the specified action.
Our proposal has two action operators: apply/3 and execute/1.
(query-if (query-ref
:sender Some Personal Assistant :sender Some personal assistant
:receiver Lisbon Restaurant Agent :receiver Lisbon Restaurant Agent
:content "( :content "(
(exists ?r (exists ?a (all
(and (sequence
(instance ?r Restaurant) (value ?r1 name)
(= (value ?r type) traditional) (value ?r1 restaurantAddress))
(= (value ?r restaurantAddress) ?a) (exists ?r1 (exists ?r2
(= (value ?a zone) downtown)))) (and
)" (instance?r2 Restaurant)
:language extended-FIPA-SL (=
:ontology AgentcitiesRestaurantOntology (value ?r2 name)
:reply-with query01 \"Encher a Mula\")
) (=
Figure 3. Closed Query Message (value
?r2
betterThan
2.4 Opened Query Using a Relation (sequence ?r1))
This section describes two approaches to represent relations true)))))
between objects. In the first case, the relation is represented by a )"
class of the domain ontology. In the second case, the relation is :language extended-FIPA-SL
represented by a method. :reply-with query03
)
Figures 4 and 5 show the two ways of representing the query Figure 5. Opened Query Message
"What are the names and addresses of downtown traditional
In the second example (figure 5), the Restaurant class has a
restaurants that are better than 'Encher a Mula'?".
method called betterThan that is used to check whether or not the
In the first case, we assume the existence of a domain class named object to which it is applied is better than the method single
Better with two attributes: worse and best, which are restaurants. argument. betterThan returns true or false. Actually, betterThan
Actually, the class should also take another argument specifying should receive a second argument specifying the comparison
the comparison criterion but, for the sake of simplicity, we omit criterion but, for the sake of simplicity, we won't consider it here.
such details here. The instances of this class represent pairs of
restaurants in which one is better than the other (according to
2.5 Request to Perform an Action
some criterion).
The FIPA ACL request performative is used for an agent to ask
(query-ref another one to perform a given action. In this section we consider
:sender Some personal assistant two scenarios. In the first scenario, the requested action is
:receiver Lisbon Restaurant Agent represented in the receiver's ontology by a class. In the second
:content "( scenario, the requested action is represented by a method.
(all (sequence (value ?r1 name) ?address)
(exists ?r1 (exists ?r2 In both cases, some personal assistant asks a restaurant
(and representative agent to book a table for 10 people to have dinner
(instance at 8 PM.
(Better :best ?r1 :worse ?r2)
Better) (request
(=(value ?r2 name)\"Encher a Mula\") :sender Some personal assistant
(= :receiver The restaurant representative
(value ?r1 restaurantAddress) :content "(
?address))))) (action
)" The restaurant representative
:language extended-FIPA-SL (execute
:reply-with query02 (BookTable
) :number_of_people 10
:dinner_time 8PM)))
Figure 4. Opened Query Message )"
:language extended-FIPA-SL)
Figure 6. Request to perform an action.
In the following case, we assume that the booking action is
represented by the class called BookTable, which has two
attributes: number of people and dinner starting hour.
In the second example, we assume the ontology used by the
restaurant representative agent has the class Table, which contains
the method book taking two arguments: the number of people and
the dinner starting time.
(request queries. Those are easily introduced by the agent designer through
:sender Some personal assistant the GUI.
:receiver The restaurant representative
:content "( The translation of ACL/SL messages into OQL commands is a
(action four-step process. In the first step, the message string, which is an
The restaurant representative S-Expression, is converted into a parse tree representing the
(apply structure of the S-Expression. In the second step, the parse tree
(any ?table representing the S-Expression is converted into an object structure
(and representing the ACL message and its extended SL content. SL
(instance ?table Table) expressions are validated during the first two steps.
(>=
(value ?table num-of-seats) In the third step, the object structure representing the ACL/SL
10 message is converted into another object structure, representing
) the OQL query. Finally, in the fourth step, the method
(member toString() of the created objects is applied to produce the
8PM final string format of the OQL command, which is passed to the
(value ?table free-slots)))) object database.
book
(sequence 10 8PM)) One of the advantages of having a stepwise translation process is
)" that it allows the agent designer to use only the steps found
:language extended-FIPA-SL appropriate in each situation. In some circumstances it may be
) useful to be able of using only the third step of the translation.
There are messages, such as request-when,
Figure 7. Request to perform an action.
request-whenever, cfp, and propose that cannot be
In the above message, the first argument of the apply/3 operator is translated to OQL because they are not queries. However, some of
a referential expression that represents any table with more than the translation steps may be used to process parts of the message.
10 seats that is not reserved for 8 PM. The second argument is the The first and second steps can always be used to decompose the
name of the method used to book the selected table. The third message and its contents in its several parts. For instance, steps 1
argument is the sequence of arguments of the book method: and 2 can be used to isolate the condition part of action-condition
number of people and dinner starting time. expressions. Once the condition part has been isolated, the agent
can then use steps 3 and 4 to determine whether or not the
3. FROM AGENT MESSAGES TO OBJECT condition is true. It may also be possible, at least in the cases of
database actions, to use the translator to create the database
DATABASE INTERACTIONS
command that implements the action.
In our proposal, agents are built on top of an object database. The
object database management system has an interface compatible Another advantage of the stepwise translation is that it is easier to
with the ODMG 3.0 object model therefore the best way to trace the origin of possible errors and hence to determine reason
interact with it is through OQL, the ODMG Object Query part of the contents of failure messages.
Language [3]. Usually, the translation from ACL/SL to OQL is straightforward.
Since our agents communicate through the exchange of FIPA Domain independent constructs such as conjunction, negation and
ACL messages with extended FIPA SL contents, ACL/SL disjunction are directly mapped onto OQL conjunction, negation
messages are translated to OQL commands. This section describes and disjunction. Domain entities such as class names and
the translation of ACL/SL messages to OQL commands. attributes are easily converted using the Data Dictionary, which
contains a one-to-one mapping from the ontology to the internal
The same approach could easily be used for other content and database. However, some aspects of the translation are not as
query languages, such as KIF and XQuery. straightforward as applying the mapping represented by the Data
As the agent internal database doesn't have exactly the same Dictionary.
model as the domain ontology, the translation process uses a Data 1. Extended SL structures with format "(instance Object
Dictionary that maps from the domain ontology classes and Class)" are converted into OQL from-clauses with pattern "from
attributes to the internal database classes and attributes. This way Object in i(Class)", in which i(Class) is the internal representation
the generated OQL command uses the internal database classes, of the class Class of the domain ontology.
attributes and data types. Besides mapping from the domain
ontology to the internal data model, the Data Dictionary allows 2. Extended SL structures with format
the agent designer to define his or her own database actions, such "(value Object Attribute)" are converted into OQL object
as create_new_restaurant. Finally, the Data Dictionary is used to expressions with pattern "Object.i(Attribute)", in which
check attribute and method types. This is important, for instance, i(Attribute) is the internal representation of the attribute Attribute
to know when to use commas around string values. of the domain ontology.
In order to facilitate the creation of the Data Dictionary for an 3. Extended SL structures with format
agent, we have developed a Graphical User Interface that looks "(value Object MethodName Arguments)" are converted into
into the database, and automatically creates part of the dictionary. OQL method invocation expressions with pattern
However, it is not possible to automatically create the whole "Object.i(Attribute)(i(Arguments))", in which i(MethodName) and
dictionary content, such as database actions and pre-defined i(Arguments) are the internal representation of MethodName and
Arguments of the domain ontology. In these mappings, some of Unsuccessfully processed queries are replied with failure
the arguments such as constants are not subject to translation. messages.
4. Extended SL structures with format "(apply Object In the following example, it is assumed that the domain ontology
MethodName Arguments)" are also translated to method and the internal data model are identical and include the class
invocation expressions exactly as value/3 expressions. Restaurant with attributes name, restaurantMenu (set of
5. The translation of extended SL structures with format instances of the class MenuItem) and restaurantAddress;
(execute ActionDesignator) makes intensive use of the Data and the class MenuItem with attributes dish and price.
Dictionary, which contains the explicit parameterised templates of The message that is translated in the example (see Figure 8) is the
this kind of action-expressions. The translator just has to use an query "I want the names and the prices of the dishes cheaper than
instantiation of the translated parameterised template stored in the 10 Euro available in the restaurant named Encher a Mula".
Data Dictionary.
(query-ref
Some SL content expressions are not directly translated to OQL.
:sender Some personal assistant
First they are converted to an equivalent format, which is more :receiver Lisbon restaurant agent
easily translated to OQL. Universally quantified questions are :content “(
converted to equivalent existentially quantified expressions, using (all
the definitional equivalence ∀xP ≡ ¬∃x¬P. Implications are (sequence (value ?item dish) ?price)
converted to equivalent disjunctions by the definitional (exists ?restaurant (exists ?item
equivalence P⇒Q ≡ ¬P∨Q. Equivalence is also converted to (and
another format using the relation P⇔Q ≡ (P⇒Q)∧(Q⇒P) ≡ (instance ?restaurant Restaurant)
(=
(¬P∧¬Q)∨(P∧Q). Double negations are also simplified before \”Encher a Mula\”
translation to OQL. (value ?restaurant name)
In FIPA ACL there are two kinds of querying messages: query-if )
and query-ref, used for closed and open queries respectively. The (member ?item (value
?restaurant restaurantMenu)
content of a query-if message is a proposition. The equivalent
)
OQL command must determine whether or not that proposition is (= ?price (value ?item price))
true. The content of a query-ref message is an identifying (< ?price 10)))))
referential expression. The equivalent OQL command must return )”
the set of values that satisfy the specified condition. :language extended-FIPA-SL
6. SL structures with format "(ReferentialOperator ?var )
Proposition)” are converted into OQL commands with pattern Figure 8. Query-ref message
"select OQLVar[.AttributeName] from OQLVar in VarDomain
where OQLConditions", in which VarDomain can be a class The result of translating the above message to an OQL command
name, or an attribute represented by a nested select. is shown bellow.
This rule is just a simplification of the actual rule, since the first select item.dish item.price
argument of a referential operator can be any term, for instance a from item in select r.restaurantMenu
sequence of variables. from r in Restaurant where r.name =
“Encher a Mula”
The translation of referential expressions is independent of the where item.price < 10
specific referential operator. The differences between referential Figure 9. OQL command
operators are handled when the result set returned by the database
is converted into a message. If the used referential operator is It has been suggested that object oriented databases are not as
iota, the result set must contain exactly one record. If it contains popular as they used to be, hence an XML query language should
more or less than one record, a failure message is generated. If the be used instead. XQuery could certainly be an alternative. In that
used referential operator is any, the result set must contain at case, we would have to translate the received messages to XQuery
least one record. If the result set is empty, a failure message is instead of OQL.
generated. Otherwise, the reply will contain the first record
contained in the result set. If the used referential operator is all, 4. ALTERNATIVE APPROACHES
the result set is sent in the reply message, even if it is the empty In this section we describe three alternative approaches to the
set. proposal presented in this paper. In the first alternative, the
When the received query is successfully processed, the receiver communication language is extended with new performatives so
replies with an inform message. In the case of open queries , the reply is , in which i-1(ResultSet) is In the second alternative approach, it is assumed that certain
the domain ontology representation of the internal result set. In ontology entities represent appropriate types of communication
the case of closed queries , the reply entities. For instance, class C of the ontology plays the role of a
is if the result set is not empty and if the result set is empty. Finally, the third alternative approach considers the
implementation of the agent on top of a relational database instead
of an object database. Then it uses transposition rules to map from assumptions. We need the means to specify which communication
queries addressing an object database into queries addressing a entity types are played by each ontology entities.
relational database. In [4], Cranefield and Purvis present an approach for the
integration of logic-based communication with object-oriented
4.1 Extending ACL to Handle Objects ontologies. The approach defines a meta-model of general content
In [2], Botelho and Ramos present an extension of the FIPA ACL languages. This meta-model defines entities as propositions,
language with three new performatives to be used with objects: definite descriptions and ground terms, and specifies several
present-object, ask-object, and subscribe-object. relations among them. The approach defines the communication
role played by each class in the domain ontology. For instance,
present-object takes an object as content. It is used when the
the instances of a certain class may play the role of propositions
receiver wants to present an object to the receiver. The sender
used in the content language while the instances of another class
may reasonably assume that, upon receiving the message, the
may play the role of definite descriptions used in the content
sender will believe the message content to be an existing object of
language and so forth.
the specified class. present-object is similar to the InformRef
performative proposed in [4]. This is a very promising approach but it does not solve all
problems yet. First of all, it does not handle all kinds of
ask-object is used when the sender wants the receiver to send it
object-descriptions (it handles only definite descriptions and
the object that satisfies a given condition. ask-object takes a
functional expressions representing value type terms). Second, it
referential expression as content, as is the case with query-ref.
does not handle action terms. Finally, and possibly more
However, query-ref is used when the sender wants the reply to use
importantly, it does not specify the semantics of propositions
the inform performative, whereas ask-object is used when the
represented by objects. How does an agent know that such a
sender wants to receive a present-object message.
proposition is true? However the authors are working on some of
subscribe-object is the persistent version of ask-object. these issues.
According to [2], agents receiving information messages At least while the approach described in [4] does not solve the
containing objects would create beliefs about the class and the referred problems, the proposal presented in this paper seems to
attributes of the received objects. Those beliefs could be used to be preferable since it does not exhibit any of the mentioned
answer questions about the received objects. limitations.
The approach described in this section involves extending the McDermott and co-authors [7] present an object-oriented
FIPA ACL language with three new performatives. Additionally, ontology (using DAML+OIL) of PDDL, a language of the first
it involves extending the first order predicate calculus with a set order predicate calculus1.
of operators and new inference rules directed at reasoning about
That ontology defines entities such as propositions, functional
objects.
expressions, predicates, and functions. This work suggests yet an
The approach presented in this paper involves only the extension alternative approach. This would use the ontology defined by
of the content language with new operators, preserving the McDermott and others as an ontology representation framework.
general semantics and properties of the language. If simpler Using the new framework, the domain could be modelled in terms
solutions are preferred to more complex ones, then the proposal of predicates, functions, functional expressions and propositions.
presented in this paper would be preferred. We have two objections against this approach. First we would not
be using an object-oriented framework for representing the
4.2 Representation Assumptions domain ontology, as decided by the Agentcities project. The
model of the domain would be treated as a second category
A possible approach would be to assume that all classes in the
component among agent technologies. Second, if we are
ontology would represent predicates in the agent communication.
modelling the domain using a logic-based framework, we should
If this assumption could be made, the name of an ontology class
use an existing logic-based ontology representation framework
would be mapped into the name of a communication predicate.
such as Ontolingua, instead of creating a new one on top of
The attributes of an ontology class would be mapped into the
DAML+OIL.
arguments of a predicate used in the communication.
This approach has severe problems though. For instance, we may 4.3 Transposition Rules
want to use objects (that is, class instances) as arguments of
predicates therefore some ontology classes would have to be Sections 4.1 and 4.2 presented two alternative approaches at the
mapped into communication classes while some other ontology level of the integration of object-oriented ontologies with logic
classes would have to be mapped into communication functions based agent communication. This section presents an alternative
(e.g., class constructors). at the implementation level. In our proposal, the agent domain
information is stored in an object database. In the alternative
Even if the above problem could be surpassed, what about the approach described in this section, the agent information is stored
representation of functions and actions? If classes always in a relational database. This approach has the advantage of using
represent predicates, then functions and actions must both be a more stable and well-supported technology.
represented by methods. Therefore we must be able of saying
which methods represent functions and which ones represent
actions. The conclusion is that, in the general case, the
harmonisation of object-oriented ontologies with logic-based
1
communication cannot be handled by general implicit www.cs.yale.edu/~dvm/daml/drsonto.daml
Given this alternative, received messages must be translated into approach does not require an explicit mapping between the
SQL queries, instead of the OQL queries of our approach. Since domain ontology and the communication. Classes, objects,
the domain ontology is an object-oriented ontology, the attributes and methods of the ontology are all handled as terms in
communication will refer to the classes, objects, attributes and the communication.
methods of the ontology (see section 2), while the agent database The integration of logic-based messages with internal
is organised around relations, fields and tuples. Therefore, object-oriented databases is achieved by a translation process,
translating messages into SQL commands is not a straightforward which relies in a Data Dictionary representing a one-to-one
process since the models do not directly match. First, we have to mapping from the domain ontology entities into the internal
understand the translation between the two models. database entities. Since agent communication directly refers to
In order to automate the process of translating messages object-oriented entities and the agent internal information is also
containing classes, objects and attributes, two kinds of rules are stored in an object-oriented database, the translation is not
necessary: difficult. The main difficulties are due to expressiveness
1. Ontology Mapping Rules: map an object oriented differences between logic content languages and object oriented
ontology representation framework into a relational model; and database query languages.
2. Query Mapping Rules: map queries containing classes, Our proposal grants agent designers considerable modelling
objects, attributes and methods into SQL queries. The Query freedom. They may chose to represent domain relations, functions
Mapping Rules are derived from the Ontology Mapping Rules. and actions both by objects and by methods.
Some ontology mapping rules have already been defined using a This paper contributes an elegant, comprehensive, robust,
computational formalism [9], in the context of the UML (Unified flexible, and simple approach to gather together the Greeks and
Modelling Language) object model [1]. Below, we informally Trojans of the modelling arena. Domain models do not loose their
present three examples. object-oriented lineage, agent communication also preserves its
logic-based background, and none is treated as a second category
a) Each class is mapped into a relational table; component among agent technologies as it would be the case in
b) If class C has been mapped into table T, a scalar attribute approaches such as [7]. Our current proposal is simpler, less
of C is mapped into an attribute of the relational table T; restricted, or fairer than other related approaches.
c) If class C has been mapped into table T, a collection We envisage yet two ontology-related future problems.
attribute of C is mapped into a new relational table that Sometimes the domain ontology is so large that it is not practical
inherits, as foreign key, the primary key of table T. to have a single agent responsible for maintaining all the
described information. Sometimes, it is covenant that the domain
From a complete set of ontology mapping rules like the above
ontology is divided into smaller ontologies, each one maintained
three examples, it would be possible to create a set of query
by a specific agent. In this case, we need to find a systematic way
mapping rules that could be used to automatically translate
to provide an integrating interface between the several agents
received query messages into SQL commands.
maintaining parts of the ontology and the remaining of the
The alternative approach briefly sketched in this section could in multi-agent system, which is only prepared to handle the domain
principle be used, however only the model mapping rules for as whole.
mapping object-oriented models into relational models have been
Since agent societies will be constantly growing, new services
formalised. To the best of our knowledge, there is no documented
being created by different agent development teams, it will be
set the rules for mapping queries addressing object-oriented
impossible and undesirable to ensure that there will not exist
databases into queries addressing relational databases. Therefore,
agents with different underlying domain ontologies. The second
the approach presented in this paper seems to be more reliable
and also more difficult future problem will be overcoming such
than the hypothetical alternative approach briefly described in this
ontology mismatches.
section.
5. CONCLUSIONS AND FUTURE WORK 6. AKNOWLEDGEMENTS
The research described in this paper is partly supported by the EC
In this paper, we have presented a comprehensive approach that
project Agentcities.RTD, reference IST-2000-28385 and partly by
allows the integration of object-oriented ontologies, logic-based
UNIDE/ISCTE. The opinions expressed in this paper are those of
agent communication, and object-oriented internal databases. The
the authors and are not necessarily those of the Agentcities.RTD
proposal comprises two levels. The first level handles the
partners. The authors are also indebted to all other past and
integration of object oriented domain ontologies with logic-based
current members of the Agentcities ADETTI team.
agent communication. The second level deals with the integration
of communication with internal object-oriented databases.
7. REFERENCES
The integration of object oriented domain ontologies with
logic-based agent communication was achieved through [1] Booch, G.; Rumbaugh, J.; and Jacobson, I. The Unified
extending logic content languages such as KIF and FIPA SL in Modeling Language User Guide. Addison-Wesley
order to enable expressing propositions from object-oriented Publishing Company. 1999
domain ontologies. The key for this was to use only general- [2] Botelho, L.M.; and Ramos, P. Extending the FIPA ACL
purpose predicates, functions and actions. All the domain Language. From Object Based Descriptions to Relational
dependent concepts are represented by classes, objects, attributes, Representations. Proc. of the Workshop on Distributed
and methods. Contrarily to the proposal described in [4], our
Artificial Intelligence and Multi-Agent Systems [8] National Committee for Information Technology Standards.
(DAIMAS2000) 2000 Knowledge Interchange Format: Draft proposed American
[3] Cattell, R.G.G; and Barry, D. The Object Data Standard: National Standards. Technical Report NCITS.T2/98-004.
ODMG 3.0. Morgan Kaufman Publishers. London. 2000 1998. http://logic.stanford.edu/kif/dpans.html
[4] Cranefield, S.; and Purvis, M. A UML profile and mapping [9] Rio, L.; and Ramos, P. Mapping Object Oriented Models
for the generation of ontology-specific content languages. into Relational Models: a formal approach. In Proc. of
Submitted. 2002 International Conference on Infrastructure for E-Business,
E-Education, E-Science, and E-Medicine. Forthcoming.
[5] Foundation for Intelligent Physical Agents. FIPA 2002
Communicative Act Library Specification. Specification
Document XC00037H. 2001 [10] Searle, J.R. Speech Acts. Cambridge University Press. 1969
[6] Foundation for Intelligent Physical Agents. FIPA SL Content [11] van Harmelen, F.; Patel-Schneider, P.F.; and Horrocks, I.
Language Specification. Specification Document Reference Description of the DAML+OIL (March 2001)
XC00008G. 2001 Ontology Markup Language. DAML+OIL Document, URL
2001. http://www.daml.org/2000/12/reference.html
[7] McDermott, D.; and Dou, D. 2002. Representing Disjunction
and Quantifiers in RDF. In Proc. of the Semantic Web [12] Willmott, S.; Dale, J.; Burg, B.; Charlton, P; and O'Brien, P.
Conference. Forthcoming. 2002. Agentcities: a worldwide open agent network. Agentlink
News, 2001. 8:13-15