=Paper=
{{Paper
|id=Vol-52/paper-6
|storemode=property
|title=Generating Ontology-Specific Content Languages
|pdfUrl=https://ceur-ws.org/Vol-52/oas01-cranefield-2.pdf
|volume=Vol-52
}}
==Generating Ontology-Specific Content Languages==
https://ceur-ws.org/Vol-52/oas01-cranefield-2.pdf
Generating ontology-specific content languages
Stephen Cranefield and Martin Purvis
Department of Information Science
University of Otago
PO Box 56, Dunedin, New Zealand
fscranefield,mpurvisg@infoscience.otago.ac.nz
ABSTRACT 2. INCLUDING OBJECTS IN MESSAGES
This paper examines a recent trend amongst software agent appli- Traditionally ontologies are used in agent systems “by reference”.
cation and platform developers to desire the ability to send domain- An agent is not required to explicitly reason with the ontology, or
specific objects within inter-agent messages. If this feature is to be even to have an online copy available. The names of ontologies
supported without departing from the notion that agents communi- can simply be used as a contract between agents undertaking a di-
cate in terms of knowledge, it is important that the meaning of such alogue: they each claim to be using an interpretation of the terms
objects be well understood. Using an object-oriented metamod- used in the conversation that conforms to the ontology. The content
elling approach, the relationships between ontologies and agent language uses a string-based syntax to represent sentences in the
communication and content languages in FIPA-style agent systems language which are constructed using constants and function and
are examined. It is shown how object structures in messages can be predicate symbols from the ontology as well as built-in language
considered as expressions in ontology-specific extensions of stan- symbols such as “and” and “or”.
dard content languages. It is also argued that ontologies must dis-
tingish between objects with and objects without identity. However, the popularity of the Java programming language for
agent development, as well as the increasing use of XML-based
formats for serialising structured data, appear to be causing agent
1. INTRODUCTION developers to look for ways of creating outgoing messages and
Agent communication languages (ACLs) in the style of the Knowl- analysing incoming ones that are more in line with the object-
edge Query and Manipulation Language (KQML) [15] and FIPA oriented paradigm than the traditional approach of building and
ACL [17] are based around the idea that “Communication can be parsing strings. This is evidenced by conversations between the
best modelled as the exchange of declarative statements” [19]. Un- authors and local agent researchers, messages on the FIPA agentc-
der this paradigm, agents send, receive and reply to requests for ser- ities mailing list, and the feature introduced into the JADE agent
vices and information with the intent of the message specified by platform allowing application-specific Java classes to be associated
a performative (such as ‘inform’ or ‘request’) describing the way with concepts in an ontology.
in which an inner content expression should be interpreted. The
content is encoded using a declarative knowledge representation JADE [14] allows ontologies to be defined using a frame-based
language such as the Knowledge Interchange Format (KIF) [21] or language. An ontology is defined at run time by constructing an
FIPA’s Semantic Language (SL) [18]. In addition, the ACL spec- ontology object and adding frames to it. A Java class can be asso-
ifies any ‘ontologies’ that define the terminology used to denote ciated with a frame so that an application can create instances of
domain-specific concepts inside the message content. the frame as Java objects and insert them in the message content.
The JADE messaging system then handles the serialisation of the
This paper examines a recent trend amongst software agent appli- objects, which can be customised by users for particular content
cation and platform developers to desire the ability to send domain- languages.
specific objects within inter-agent messages. If this feature is to be
supported without departing from the notion that agents communi- Even in the traditional string-based model of message creation and
cate in terms of knowledge, it is important that the meaning of such decomposition there are signs that agent programmers desire an
objects be well understood. To clarify this issue, this paper uses ability to send ‘objects’ within messages. The FIPA SL grammar
the Unified Modeling Language [4] and an object-oriented meta- includes a production for “functional terms”. In addition to some
modelling approach to examine the relationships between ontolo- built-in function symbols for arithmetic and for constructing and
gies and agent communication and content languages. It is shown performing operations on sets and sequences, functional terms can
how object structures in messages can be considered as expressions be built using function symbols from an ontology. The SL specifi-
in ontology-specific extensions of standard declarative content lan- cation describes two uses for ontology-specific functional terms.
guages. In particular, domain-specific ‘objects’ within messages
can be viewed as object-oriented encodings of terms, propositions The first use applies when an ontology defines function symbols
or definite descriptions. To make the discussion more concrete, specific to its domain. Objects can then be referred to “via a func-
the proposed approach is illustrated in terms of a particular model tional relation . . . with other objects . . . rather than using the di-
of agent communication: that defined by the Foundation for In- rect name of that object, for example, (fatherOf Jesus) rather
telligent Agents (FIPA) specifications [16]. However, this account than God”. This can be interpreted using the standard semantics
of domain objects within messages is applicable to other styles of for first-order logic—terms of this form correspond to descriptions
declarative-message-passing agent systems as well.
of particular pre-existing objects. In a first order logic without an Query Language [5]. Our account of agent messaging does not al-
equality symbol, a functional term denotes a particular object in low for objects with identity to be transported within messages—it
the domain of discourse that is distinct from the object denoted by is only meaningful for objects without identity (i.e. complex data
any other term. Adding an equality symbol introduces the possi- values) to be denoted by functional terms in a content language.
bility of making assertions that distinct terms in the language are For concepts representing classes of objects with identity, we re-
equal, meaning that they denote the same domain object. The usual gard functional expressions such as the vehicle one above to be
semantic models used to define first order logics with equality inter- invalid as a term denoting a domain object. Instead, we propose
pret terms by equivalence classes in the ‘term algebra’ with respect that this type of functional expression should be meaningful only
to the equality predicate. These equivalence classes can be consid- as a form of proposition (describing some or all of an object’s at-
ered to be an abstract representation of the actual domain objects tributes) or as a definite description (identifying an object in terms
represented by terms in the language. of the values of attributes). In both cases, the notation can be gen-
eralised to include networks of objects and (in the case of definite
The second use for ontology-specific functional expressions in- descriptions) variables.
volves “descriptions where the function symbol should be inter-
preted as the constructor of an object, while the parameters repre- The key difference between objects with and without identity is
sent the attributes of the object”. The following example is given: that it is possible to refer to the former by reference. We make
no assumptions about the form of object references, but to be in-
cluded within an agent message, a reference must be expressible
(vehicle as a ground term within some content language. Many different
:colour red reference schemes could be used for referring to objects: names,
:max-speed 100 CORBA interoperable object references (IORs), World Wide Web
:owner (Person :name Luis Uniform Resource Identifiers (URIs), etc. This is discussed further
:nationality Portuguese)) in Section 4.1. Note that we do not explicitly address the possibility
of a reference being used to refer to different objects by different
agents or at different times. Sufficient namespace or context infor-
The SL specification describes this usage as one where “the func-
mation to resolve this problem is assumed to be included as part of
tion symbol should be interpreted as the constructor of an object,
a reference.
while the parameters represent the attributes of the object”. How-
ever, this notion of constructor is not explained, nor is any guidance
Whether or not instances of a given concept are considered to have
given on when a term of this form is considered to be well-formed.
identity will depend on the range of applications for which the on-
A number of questions are raised with this notation:
tology is designed. To be completely general, any object could
potentially be referred to in an assertion—this is one of the de-
What constitutes a constructor in an ontology? For frame- sign criteria for the Semantic Web where “anyone can say anything
based and object-oriented ontology modelling languages the about anything” [3]. However, for purposes of simplicity and ef-
answer is fairly clear, but is there a set of requirements that ficiency, it may sometimes be advantageous to declare concepts to
could be used to identify constructors in other types of on- be “value types”.
tology modelling language? This paper focuses on the use of
object-oriented ontologies and does not address this question The difference between objects with and without identity can be
for other modelling paradigms. seen in the following example. The FIPA agentcities project [1] is
building a test-bed for the large-scale deployment of FIPA agent-
Does each appearance of a given constructor term denote the based services by forming a global network of agents providing
same object, or does every use of a constructor create a new information relating to particular cities. One of the ontologies un-
object? Allowing the universe of discourse to grow dynami- der development in this project describes the concept of weather
cally departs from the usual semantics of first order logic and reports. A weather report is an example of a plausible value type.
would require a thorough investigation of its implications on Although it is possible to imagine scenarios where agents may wish
the semantics of SL. This paper therefore attempts to classify to refer to a weather report by reference (e.g. to disagree with it),
the possible uses of ontology-specific functional terms with- in many common cases it would be sufficient to have the ability
out abandoning the usual closed (but possibly infinite) world to include weather report structures within messages. Note that
model underlying first-order logic. this would not mean that weather reports could not be recorded in
an agent’s knowledge base—another object such as an array could
Can a meaning be given for such a functional term repre- hold weather reports internally as part of its own structure.
senting an object with identity? One possible interpreta-
tion is that objects can be passed from one agent to another. In contrast, a city is a clear example of an object that has identity
However, this requires additional theory and infrastructure and which could not be meaningfully included within a message.
to model the dynamic association of objects to the agents re-
sponsible for them and to ensure the preservation of objects’
uniqueness or to account for their duplication and possible 3. A METAMODELLING VIEWPOINT
destruction. This is left for future work. For the present we To analyse the relationship between ontologies and content lan-
prefer to retain the traditional view that the message content guages expressions, this paper extends a metamodelling account
is a declarative representation of knowledge about the world. of agent systems and models presented previously [13]. Figure 1
shows three levels of a metamodelling hierarchy. Level 0 comprises
the objects that exist at run time: agents, domain objects and mes-
We address these issues by proposing that a distinction be made sages and their content expressions. Level 1 contains models of the
between objects with and objects without identity, as in the Object concepts that are instantiated in Level 0, i.e. ontologies and defini-
UML meta-model Level 2
(extended with ‘valuetype’ and ‘resource’ stereotypes) (meta-model)
Abstract Abstract
Message Other message
Domain refine refine elements and
Agent models and concrete and concrete Level 1 sender : String specialised subclasses
ontologies (models)
content lang. models ACL models receiver : String have been omitted
ontology [1..*] : String
Content language
Domain objects Message Level 0
Agents expressions and
and data values contain objects (objects)
knowledge objects
describe
InformRef QueryRef Inform Request
1 1 1 1 1
Figure 1: A metamodelling view of agent systems and models 1 1 1 1 1
<> <> <> <>
CL::RefTerm CL::DefDescriptor CL::Proposition CL::ActionDescription
tions of the abstract and concrete syntax for agent communication
and content languages. The relationship between a Level 0 object
and the corresponding Level 1 object is instantiation (or equiva- Figure 2: A partial UML model of an ACL
lently set membership if concepts are viewed semantically as sets
of instances).
Note that analysing agent systems using the metamodelling view-
point does not presuppose that agents are implemented using object- CL::Proposition
oriented technology. The same relationships between and across
levels hold no matter how agents and languages are modelled and
instantiated. Furthermore, Figure 1 could be extended to account {ordered} 2..*
self.term->size =
self.predicate.arity
for other multi-agent system concepts, such as conversations, which Wff
could be explicitly represented at Level 0 with conversation models
1
at Level 1. 1 Predicate
AtomicFormula name : String
Conjunction ontology : String
The Level 1 models must be expressed in some language. In this 1
1 1 arity : Integer
work, the Unified Modeling Language (UML) [4] is used as a uni-
{ordered} 0..*
fying representation language for all agent-related models at Level
1. It has been argued elsewhere that this industry-standard object- Term
oriented modelling language is a good candidate for representing
ontologies [11, 12, 2, 9] and the abstract syntax of agent commu- 1
nication languages [13, 10]. Level 2 therefore contains the UML DefiniteDescription Variable Constant
name : String name : String
metamodel: a model of the concepts in UML. Other “metameta- 1 1 ontology : String
models” could also be included at this level to allow for different
representation languages to be used at Level 1.
CL::DefDescriptor
Figures 2 and 3 illustrate fragments of an agent communication CL::RefTerm
language and a content language (respectively) modelled as UML
class diagrams. The UML ‘lollipop’ symbol is used to indicate that Figure 3: A partial UML model of an SL-like content language
particular classes implement interfaces from another model: the
CL package shown in Figure 4. This package uses ‘marker’ inter-
faces (ones with no operations) to name the abstract concepts that
any content language must implement in order to be used with the
FIPA ACL. This abstraction provides a strongly typed way for ex-
«interface» «interface»
pressions in any content language to be included within an ACL Term DefDescriptor
expression. For example the Object Query Language could be
used as a form of definite description simply by defining a class «interface» «interface» «interface»
OQLDescriptor with a string-valued attribute query and declar- GroundTerm NonGroundTerm AgentDefDescriptor
ing it to implement CL::DefDescriptor.
«interface» «interface» «interface» «interface»
ValueTerm RefTerm Act Variable «interface»
The CL package (Figure 4) models abstract content language con- Proposition
cepts that are required by the semantics of the FIPA ACL and its
communicative act library, but otherwise makes no commitment «interface» «interface»
«interface»
AgentRefTerm CommunicativeAct
LambdaTermProposition
about how particular content languages might be structured. For
example, the concept of a variable is included because this seems
«interface» «interface» «interface»
to be intrinsic to the semantics of definite descriptions [23]. How- ActionDescription LambdaAgentCommAct LambdaAgentProposition
ever, the concept of a predicate is not included. Although some
FIPA communicative acts require propositions as parameters, the
ACL is neutral about how propositions are represented—a content Figure 4: The CL package: generic content language concepts
language is free to represent propositions in non-standard ways,
e.g. as object structures asserting the attribute values [13].
In the figure, the dashed lines represent dependencies: for example, CL SL
an action description requires descriptions of an act and an agent, «refine»
but at this abstract level it is not appropriate to make any decisions
about how the implementation structure of these three concepts
should be related. A dependency is shown from DefDescriptor
SpecialisedSL
to NonGroundTerm because a definite description comprises two
non-ground terms linked by common free variables: a query ex- Ontology
WeatherReport CL::ValueTerm
pression and a template for the result. «valuetype»
WeatherReport
Some of the content language concepts shown are not explicitly City CL::Proposition
«resource»
named in the FIPA specifications: for example, some communica- City
tive acts (such as proxy) require content expressions representing {refscheme = URI} CityDescriptor CL::NonGroundTerm
communicative acts with the receiver (an agent) omitted. This is
modelled by the interface LambdaAgentCommAct. The interface
LambdaTermProposition represents a function that produces a
proposition when a single parameter is supplied (used in the ‘call Figure 5: An ontology-specific content language
for proposals’ communicative act) and LambdaAgentProposition
is a specialisation of this where the parameter is an agent reference
(this concept is not currently used by FIPA ACL, but seems likely the metamodel. Model elements can be endorsed with the names of
to be useful). stereotypes within guillemets (French quotation marks) to indicate
that they have a different intent or additional semantics beyond that
normally associated with that type of model element.
4. ONTOLOGIES AND OBJECT IDENTITY
In Section 2 it was argued that a distinction should be made be- For modelling classes of objects with identity we have introduced a
tween objects with and objects without identity. The approach stereotype . This represents a specialised subtype of the
taken in this paper is to make this distinction on a per-concept basis, class concept in the UML metamodel, one whose instances (partic-
with the ontology declaring for each concept whether its instances ular classes in a model) are constrained to include a one to many
have identity or not, and how references to instances of that concept relationship with a Reference abstract class that is assumed to ex-
can be expressed. In this section we show how the extension mech- ist at the model level (Level 1) and to implement the CL::RefTerm
anisms of UML can be used to model these aspects of an ontology. interface. In an ontology, adorning a class with this stereotype is
the same as manually adding the association between that class and
4.1 Modelling references the Reference class. It is therefore possible for any instances of
The object model underlying UML does not take a position on the that class to be linked to instances of particular reference classes
nature of object identity and reference. UML assumes that ob- such as URI (note that we do not assume there is a unique reference
jects have an identity that is implicitly provided by the underly- to each object). To provide more information about the particu-
ing implementation infrastructure and which does not need to be lar type of reference, another UML extension mechanism, a tagged
included as an attribute of the corresponding class in the model. value, is used to name the type of reference used for objects of that
UML makes no commitment about the nature of this identity or class. The tag name is “refscheme”. The value of this tag should
the way in which links between objects are implemented. This be the name of an predefined class extending Reference.
is too agnostic a stance for use in the description of multi-agent
systems, at least for those based on the Foundation for Intelligent The bottom left side of Figure 5 illustrates the use of these mech-
Physical Agents (FIPA) [16] specifications. One of the FIPA com- anisms to specify that the class City represents resources having
municative acts is query-ref which is used to ask an agent for a URIs (in the style of the Semantic Web where URIs can be used to
reference to the object that uniquely satisfies a given “definite de- refer to physical objects as well as Web documents). The rest of
scription” (a quantified propositional expression, where the bound the figure will be explained in the following sections.
variable represents the object of interest). The semantics of definite
descriptions assume each object (taken in a broad sense to mean an
identifiable entity) is identified by constants representing “standard 4.2 Modelling data values
names”. This is sufficient for agent systems that are disconnected To represent value types another stereotype, is intro-
from the real world and observe it without interacting with any of duced. Model concepts defined with this stereotype are not mod-
its entities. However, when agents are integrated into today’s per- elled as classes, but as instances of a different child of the Class
vasive network infrastructure, which includes telephone networks, concept’s parent class in the UML metamodel: ValueType. This
distributed CORBA and Java objects and Web resources, this is is not a standard concept in UML but an extension that is required
no longer sufficient. Objects can be identified by phone numbers, to adequately model objects without identity. UML has a similar
CORBA interoperable object references (IORs), World Wide Web concept DataType, but this has restrictions that seem to be un-
uniform resource identifiers (URIs), etc., and agents are free to de- necessary for value types: a data type may not have any outgoing
part from ACL-level communication to interact with these objects associations with other types. However, it seems reasonable for a
using the appropriate protocols for these references. We therefore value type to have composition relationships with other value types
propose an extension to the UML metamodel to allow classes to be as these do not require references for their implementation—they
annotated with their appropriate reference types. can be interpreted as defining a nested structure.
Although the metamodel for UML is fixed, there is a way to de- In Figure 5, the WeatherReport class is annotated with the stereo-
fine a ‘virtual’ extension of the metamodel by defining stereotypes: type to indicate that this represents a type of object
named specialisations of particular concepts (such as ‘class’) from without identity.
PersonVar
CL::Variable CL::Term
/parent child { ordered } varName : String
2 * 2 2
2 2 * *
«resource» PersonTerm
Person { ordered }
parent 2 * child
{refscheme = URI} 2
*
name : String * PersonDescriptor
{ ordered } * { ordered }
*
/son father mother /daughter 1 name
* 1 1 * ST::StringTerm
CL::Variable
Man Woman
ST:StringObject ST:StringVar
father mother
value : String varName : String
1 1
{ parent = Set { mother, father } * *
son = child->select(oclIsTypeOf(Man)) ManTerm WomanTerm
son daughter
daughter = child->select(oclIsTypeOf(Woman)) } { ordered } CL::Variable
{ ordered }
ManDescriptor ManVar WomanVar WomanDescriptor
Figure 6: A class diagram representing a family ontology
Figure 7: Generated descriptor classes for Person objects
5. ONTOLOGY-SPECIFIC CONTENT
A class with the resource stereotype maps to a structurally identi-
LANGUAGES cal class that implements the CL::Proposition interface—this indi-
Figure 1 showed a number of relationships between different types cates that objects of this sort can be used as descriptions of corre-
of object: messages contain content language expressions, which sponding domain entities (by describing their attribute values and
describe domain objects and agents. At the model level, ACL links). In addition, a corresponding descriptor class is generated to
and content language concrete syntaxes (e.g. models of XML en- allow an object-oriented structure to be used as the query part of
codings) refine abstract syntaxes. However, there is currently no a definite descriptor, therefore this class implements the interface
clear account of the relationship between ontologies and content CL::NonGroundTerm.
languages that explains how and when it makes sense to include
domain-specific objects within messages. Strictly speaking, there A class with no stereotype has a corresponding proposition class
is no direct connection between concepts in ontologies and those generated, but no definite descriptor class is generated as nothing
in content languages: as discussed in the introduction, content ex- is known about whether or not objects of this type have identity. It
pressions traditionally refer to ontological entities by reference (i.e. may therefore be impossible to return a reference in response to a
by name) only. query-ref message containing a definite description referring to
an instance of this class.
The inclusion of domain-specific objects within messages can be
considered either to be semantically incoherent, or (more charita- Figure 7 shows the structure of the generated descriptor classes cor-
bly) as representing an object-oriented encoding of values, proposi- responding to a simple family ontology (expressed as a UML class
tions and definite descriptions. This paper takes the latter approach, diagram in Figure 6). Each attribute and navigable association end
which can be explained as the use of an ontology-specific content must be capable of taking a variable object as a value. Therefore,
language. Given an ontology, a specialised content language can for each class an interface is defined and two subclasses that imple-
be generated either as a simple application-specific representation ment it: a descriptor class and a variable class. All association ends
or as an extension of an existing general-purpose content language are directed at the interfaces instead of the classes. The package ST
(so that generic concepts like conjunction are available). is assumed to hold variable and object types corresponding to each
primitive type.
Figure 5 illustrates our approach to generating ontology-specific
content languages. The dashed arrows are dependencies and there-
fore are directed from the generated classes back to the correspond- 6. IMPLEMENTATION
ing concepts in the ontology. The generalisation relationship be- The previous section presented a scheme by which extensions of
tween the generated Specialised SL package and the pre-existing content languages like FIPA SL can be automatically augmented
SL one indicates that all concepts defined for SL (such as con- with ontology-specific representations for propositions, definite de-
junction and negation) are (optionally) included in the generated scriptions and (for valuetypes) terms. It remains to formally de-
package. fine and implement these mappings. In previous work, a “UML
data binding scheme” has been developed [7, 8]. This allows agent
A valuetype declared in an ontology maps to an equivalent decla- messages to be visualised as object diagrams and serialised using
ration (without the valuetype stereotype) in a new package corre- the XML-based Resource Description Framework [20]. The se-
sponding to the generated language. This is because objects of that rialisation is performed with reference to RDF schemas that are
type can meaningfully be embedded in messages. generated from the UML definitions of the ontologies used and the
Marshalling Abstract
package RDF API Syntax
.. { uses .. {
source AS<->CS1
...(.) { ...(.) {
..... ..... Class
} }
1
} } target 1 * Class Association
* Association * *
uses javac
* *
Java Java Box Connector
source files class files
Concrete
.. {
javac
100110
loads context c:Class inv:
UML-based ...(.) { 101001 Syntax1
..... 011011 c.box->size=c.box.diagram->size
design tool } 000110 Applications context a:Association inv:
} 101101
a.connector.source->forAll(b |
XSLT Diagram a.connector->select(c|c.diagram=b.diagram).source=b)
1
references and a.connector.target->forAll(b |
references 1 a.connector->select(c|c.diagram=b.diagram).target=b)
<....> * context c:Class inv:
<....> XSLT references source
1 c.box->forAll(b | let n=b.compartment->size in
<...>
Box
<.> 1 n>=1 and n<=2)
<..> *
target 1 *
RDF schema Knowledge Connector
XMI document (in XML) (in RDF/XML)
*
Compartment
*
Figure 8: The UML data binding framework
Figure 9: The pUML approach to mapping between abstract
and concrete language models (modified from Clark et al. [6])
ACL and content language. A set of Java classes corresponding
to the concepts in these models are also generated, and these in-
clude marshalling support so that object diagrams can be converted stract and concrete syntaxes for a language. This technique may
between in-memory networks of Java objects and RDF serialisa- provide a formal way to define the relationship between ontologies
tions with a single method call. The generation of RDF schemas and ontology-specific content languages described in this paper.
and Java classes is performed using the Extensible Stylesheet Lan-
guage Transformations language [24] starting from encodings of
the UML models in the XML Model Interchange format (XMI). 7. CONCLUSION
The UML data binding scheme is illustrated in Figure 8. This paper has analysed the relationship between ontologies and
content languages and, based on a desire from agent programmers
At present, classes in ontologies are mapped directly to RDF re- to include ‘objects’ within messages, has clarified when this can
sources with properties that correspond directly to the attributes be considered to be meaningful. This ability can be provided in
and association ends associated with the classes. Extending this to a principled way by generating an ontology-specific content lan-
implement the mappings described in the previous section would guage from an ontology.
provide agents with an automatically generated Java application
programmer interface for including domain-specific objects within It has also been argued that ontologies should distinguish between
messages—but only when they represent propositions, definite de- object types having an identity and those without. Two UML stereo-
scriptions or values of value types. types have been proposed to indicate this distinction, which also
affects whether domain-specific object structures in an ontology-
There is one feature of the UML data binding scheme that has not specific content language can be used to represent propositions,
yet been addressed in the present work. If propositions are to be values or definite descriptions.
encoded as object structures, it must be possible to omit the values
of some attributes and association ends if these are not of relevance Acknowledgements
to the discussion—otherwise an agent may have to send a network Thanks to the members of the FIPA agentcities mailing list for stim-
representing all its knowledge every time it answers a question. ulating our thoughts on this topic, especially Federico Bergenti who
If a value is not present for a role of an optional association then espoused the need for a “metamodel” for content languages and
the agent receiving the information must be able to distinguish be- thereby inspired the design of the abstract content language model
tween the case where there whether there really is no value and shown in Figure 4.
the case where this information has been omitted. This is handled
by declaring in the RDF serialisation of a message the property–
resource pairs for which incomplete or no information is provided
8. REFERENCES
[1] agentcities.org. The Agentcities project Web site.
[8]. This, or an alternative mechanism, needs to be accounted for in
http://www.agentcities.org, 2001.
the conceptualisation of knowledge as a UML object diagram. One
possible approach would be to use a stereotype or tagged value to [2] F. Bergenti and A. Poggi. Exploiting UML in the design of
indicate potentially incomplete knowledge. multi-agent systems. In A. Omicini, R. Tolksdorf, and
F. Zambonelli, editors, Engineering Societies in the Agents
Although XSLT provides a convenient language for implementing World, Lecture Notes in Computer Science 1972, pages
transformations on XML-based data, it is debatable whether an 106–113. Springer, 2000. (an earlier version is available at
XSLT stylesheet can be considered to be a definition of a map- http://lia.deis.unibo.it/confs/ESAW00/pdf/ESAW13.pdf).
ping. One possible way in which the mapping from ontologies
to specialised content languages could be defined is based on re- [3] T. Berners-Lee. Metadata architecture. World Wide Web
search from the Precise UML group [22]. Figure 9 shows hows Consortium Discussion Document, 1997.
OCL constraints can be used to define the mapping between ab- http://www.w3.org/2000/01/sw/.
[4] G. Booch, I. Jacobson, and J. Rumbaugh. The Unified [15] T. Finin, Y. Labrou, and J. Mayfield. KQML as an agent
Modeling Language User Guide. Addison-Wesley, 1998. communication language. In J. M. Bradshaw, editor,
Software Agents. MIT Press, 1997. Also available at
[5] R. Cattell, D. Barry, M. Berler, J. Eastman, D. Jordan, http://www.cs.umbc.edu/kqml/papers/kqmlacl.pdf.
S. Gamerman, C. Russell, O. Schadow, T. Stanienda, and
F. Velez, editors. The Object Data Standard: ODMG 3.0. [16] Foundation for Intelligent Physical Agents. FIPA Web site.
Morgan Kaufmann, 2000. http://www.fipa.org.
[17] Foundation for Intelligent Physical Agents. FIPA ACL
[6] T. Clark, A. Evans, R. France, S. Kent, and B. Rumpe.
message representation in string specification.
Response to UML 2.0 request for information.
http://www.fipa.org/specs/fipa00070/, 2000.
http://www.cs.york.ac.uk/puml/papers/RFIResponse.PDF,
1999. [18] Foundation for Intelligent Physical Agents. FIPA SL content
language specification. http://www.fipa.org/specs/fipa00008/,
[7] S. Cranefield. Networked knowledge representation and 2000.
exchange using UML and RDF. Journal of Digital
Information, 1(8), 2001. http://jodi.ecs.soton.ac.uk/. [19] M. R. Genesereth and S. P. Ketchpel. Software agents.
Communications of the ACM, 37(7):48–53, July 1994.
[8] S. Cranefield. UML and the Semantic Web. Proceedings of the
Semantic Web Working Symposium (SWWS), 2001 (to appear). [20] O. Lassila and R. R. Swick. Resource Description
Earlier version available at http://www.otago.ac.nz/ Framework (RDF) model and syntax specification. Technical
informationscience/publctns/complete/papers/dp2001-04.pdf.gz. report, World Wide Web Consortium, 1999.
http://www.w3.org/TR/1999/REC-RDF-SYNTAX-
[9] S. Cranefield, S. Haustein, and M. Purvis. UML-based 19990222.
ontology modelling for software agents. In Proceedings of [21] National Committee for Information Technology Standards.
the Workshop on Ontologies in Agent Systems, 5th Draft proposed American national standard for Knowledge
International Conference on Autonomous Agents, 2001. Interchange Format. http://logic.stanford.edu/kif/dpans.html,
http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/. 1998.
[10] S. Cranefield, M. Nowostawski, and M. Purvis. [22] Precise UML Group. The Precise UML Group home page.
Implementing agent communication languages directly from http://www.puml.org, 2001.
UML specifications. Discussion Paper 2001/03, Department
of Information Science, University of Otago, PO Box 56, [23] B. Russell. On denoting. In R. C. Marsh, editor, Logic and
Dunedin, New Zealand, 2001. Knowledge: Essays, 1901-1950. Allen and Unwin, 1956.
http://www.otago.ac.nz/informationscience/publctns/ http://www.santafe.edu/˜shalizi/Russell/denoting/.
complete/papers/dp2001-03.pdf.gz.
[24] World Wide Web Consortium. XSL Transformations (XSLT)
version 1.0. http://www.w3.org/TR/xslt, 1999.
[11] S. Cranefield and M. Purvis. UML as an ontology modelling
language. In Proceedings of the Workshop on Intelligent
Information Integration, 16th International Joint Conference
on Artificial Intelligence (IJCAI-99), 1999. http://sunsite.
informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-23/
cranefield-ijcai99-iii.pdf.
[12] S. Cranefield and M. Purvis. Extending agent messaging to
enable OO information exchange. In R. Trappl, editor,
Cybernetics and Systems 2000: Proceedings of the 2nd
International Symposium “From Agent Theory to Agent
Implementation” (AT2AI-2) at the 5th European Meeting on
Cybernetics and Systems Research (EMCSR 2000), Vienna,
2000. Austrian Society for Cybernetic Studies. An earlier
version is available at http://www.otago.ac.nz/
informationscience/publctns/complete/papers/dp2000-
07.pdf.gz.
[13] S. Cranefield, M. Purvis, and M. Nowostawski. Is it an
ontology or an abstract syntax? Modelling objects,
knowledge and agent messages. In Proceedings of the
Workshop on Applications of Ontologies and
Problem-Solving Methods, 14th European Conference on
Artificial Intelligence (ECAI 2000), 2000.
http://delicias.dia.fi.upm.es/WORKSHOP/ECAI00/16.pdf.
[14] CSELT. The JADE agent platform Web site.
http://sharon.cselt.it/projects/jade/, 2001.