Sign up & Download
Sign in

A Roadmap to Ontology Specification Languages

by Oscar Corcho, Asunción Gómez-pérez
Knowledge Management (2000)

Abstract

The interchange of ontologies across the World Wide Web (WWW) and the cooperation among heterogeneous agents placed on it is the main reason for the development of a new set of ontology specification languages, based on new web standards such as XML or RDF. These languages (SHOE, XOL, RDF, OIL, etc) aim to represent the knowledge contained in an ontology in a simple and human-readable way, as well as allow for the interchange of ontologies across the web. In this paper, we establish a common framework to compare the expressiveness and reasoning capabilities of traditional ontology languages (Ontolingua, OKBC, OCML, FLogic, LOOM) and web-based ontology languages, and conclude with the results of applying this framework to the selected languages.

Cite this document (BETA)

Available from www.springerlink.com
Page 1
hidden

A Roadmap to Ontology Specification Languages

Lecture Notes in Artificial Intelligence 1937
Subseries of Lecture Notes in Computer Science
Edited by J. G. Carbonell and J. Siekmann
Lecture Notes in Computer Science
Edited by G. Goos, J. Hartmanis and J. van Leeuwen
Page 2
hidden
3Berlin
Heidelberg
New York
Barcelona
Hong Kong
London
Milan
Paris
Singapore
Tokyo
Page 3
hidden
Rose Dieng Olivier Corby (Eds.)
Knowledge Engineering
and Knowledge Management
Methods, Models, and Tools
12th International Conference, EKAW 2000
Juan-les-Pins, France, October 2-6, 2000
Proceedings
13
Page 4
hidden
Series Editors
Jaime G. Carbonell, Carnegie Mellon University, Pittsburgh, PA, USA
Jo¨rg Siekmann, University of Saarland, Saarbru¨cken, Germany
Volume Editors
Rose Dieng
Olivier Corby
INRIA
2004 route des Lucioles, BP 93
06902 Sophia Antipolis Cedex, France
E-mail: {Rose.Dieng, Olivier.Corby}@inria.fr
Cataloging-in-Publication Data applied for
Die Deutsche Bibliothek - CIP-Einheitsaufnahme
Knowledge engineering and knowledge management : methods, models,
and tools ; 12th international conference ; proceedings / EKAW 2000,
Juan-les-Pins, France, October 2 - 6, 2000. Rose Dieng ; Olivier Corby
(ed.). - Berlin ; Heidelberg ; New York ; Barcelona ; Hong Kong ;
London ; Milan ; Paris ; Singapore ; Tokyo : Springer, 2000
(Lecture notes in computer science ; Vol. 1937 : Lecture notes in
artificial intelligence)
ISBN 3-540-41119-4
CR Subject Classification (1998): I.2
ISBN 3-540-41119-4 Springer-Verlag Berlin Heidelberg New York
This work is subject to copyright. All rights are reserved, whether the whole or part of the material is
concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting,
reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication
or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965,
in its current version, and permission for use must always be obtained from Springer-Verlag. Violations are
liable for prosecution under the German Copyright Law.
Springer-Verlag Berlin Heidelberg New York
a member of BertelsmannSpringer Science+Business Media GmbH
c
© Springer-Verlag Berlin Heidelberg 2000
Printed in Germany
Typesetting: Camera-ready by author, data conversion by PTP-Berlin, Stefan Sossna
Printed on acid-free paper SPIN: 10781250 06/3142 5 4 3 2 1 0
Page 5
hidden
Preface
This volume contains the proceedings of EKAW 2000 (12th International Confe-
rence on Knowledge Engineering and Knowledge Management), held in Juan-les-
Pins, on 2–6 October. Previously, EKAW was the European Knowledge Acquisi-
tion Workshop. In 1997, it had evolved towards the European Workshop on Kno-
wledge Acquisition, Modeling and Management. Since 2000, EKAW has become
an open conference, focusing on knowledge engineering and knowledge manage-
ment. It aims at gathering researchers working in any area concerning methods,
techniques and tools for the construction and the exploitation of knowledge-
intensive systems and for knowledge management. EKAW 2000 attracted nume-
rous submissions of papers, from all over the world.
Research in knowledge engineering tries to offer some answers to the following
questions:
– How to build knowledge-intensive systems, such as expert systems, know-
ledge-based systems, or knowledge management systems? In the past years,
strong advances in knowledge engineering consisted of methodologies and
tools for supporting knowledge acquisition from human experts and for sup-
porting knowledge-level modeling of knowledge-based systems. In the last
years, there was a strong emphasis on ontologies and problem-solving me-
thods, with the aim of enhancing knowledge reusability. Knowledge enginee-
ring can also benefit from machine learning techniques that can be helpful for
automatic building of a knowledge base (for example, automatic knowledge
acquisition from textual sources of information).
– How to evaluate knowledge-intensive systems, with both qualitative and
quantitative measures, according to various criteria (user-centered criteria,
quantitative criteria, etc.)?
– How to make knowledge-intensive systems evolve? Cooperation with the sta-
keholders involved and machine learning are examples of approaches helpful
for evolution and refinement of a knowledge base.
We have noticed the following current trends in knowledge engineering:
– There is a growing importance for knowledge management as a privileged
application of knowledge engineering methodologies and techniques. Know-
ledge management aims at capturing and representing individual or collective
knowledge in organizations or communities, in order to enhance knowledge
access, sharing and reuse. Therefore knowledge management is a privileged
potential application of knowledge engineering. But other communities (such
as Computer Supported Cooperative Work (CSCW)) have been involved in
knowledge management for years – even before the knowledge engineering
community. The need for a multidisciplinary approach and other techniques
stemming from these other communities is recognized more and more. Such
Page 6
hidden
VI Preface
communities emphasize the cooperative and organizational approaches for
knowledge management.
– The exploitation of texts and documents either as sources from which a
knowledge base can be built, or as way of materializing organizational me-
mory led to a growing significance of knowledge acquisition from texts or
text mining. This is possible thanks to the recent advances in natural lan-
guage processing techniques, and thanks to cooperation between knowledge
engineering and linguistics communities.
– There is a growing influence of the Web, both as a fabulous source of kno-
wledge and as a fabulous means of knowledge diffusion. It enables a con-
vergence with the research of other communities (e.g. database community,
information retrieval community, and text mining), which try to contribute
to the semantic Web. The Web also raises new problems that are challenging
to the knowledge engineering community.
– Ontology engineering continues to play an essential role in research on know-
ledge engineering, as confirmed by the papers published in these proceedings.
They aim at answering the following questions: What methodology should
be used for building an ontology? In particular, how can it exploit knowledge
acquisition from texts with the support of natural language processing tools?
How can ontologies be specified and exchanged (in particular, through the
Web)? Since standards are important, how can we compare the languages
proposed by the knowledge engineering community for modeling and forma-
lizing knowledge with respect to the existing recommendations of W3C for
the semantic Web, such as resource description framework (RDF) and RDF
Schema? How can we reuse existing ontologies? What influence does reuse
have on ontology life cycle? How can we integrate several ontologies, possibly
cooperatively?
– Cross-fertilization between knowledge engineering and other disciplines such
as software engineering, linguistics, CSCW, and machine learning, is not new
but continues to be promising.
These are the main trends of research in knowledge engineering, as they
appear in the papers accepted at EKAW 2000. These papers are gathered into
the following topics:
– Knowledge modeling languages and tools,
– Ontologies,
– Knowledge acquisition from texts,
– Machine learning,
– Knowledge management and e-commerce,
– Validation, evaluation, certification,
– Problem-solving methods,
– Knowledge representation and
– Methodologies.
The main lesson about these current trends in knowledge engineering is the
confirmation of the need to remain open to other communities, to new techno-
logies or to new kinds of applications.
Page 7
hidden
Preface VII
Acknowledgements
We deeply thank the members of the program committee and the additional
reviewers that gave their time to make thorough and constructive reviews of the
papers. We also thank Monique Simonetti very much for her remarkable orga-
nization. We are grateful to the Conseil Re´gional Provence Alpes Coˆte d’Azur
for its financial support, to INRIA for its significant organizational support and
to the other sponsors of EKAW 2000 (AAAI, AFIA, GRACQ, IIIA, MLNET
and Club CRIN Inge´nierie du Traitement de l’Information).
August 2000 Rose Dieng
Olivier Corby
Page 8
hidden
Conference Chairs
Rose Dieng INRIA Sophia Antipolis
Olivier Corby INRIA Sophia Antipolis
Program Committee
Stuart Aitken University of Glasgow (UK)
Hans Akkermans Free University Amsterdam (The Netherlands)
Nathalie Aussenac-Gilles IRIT–CNRS Toulouse (France)
Richard Benjamins University of Amsterdam (The Netherlands)
Brigitte Bie´bow Universite´ Paris-Nord (France)
Jeff Bradshaw Boeing (USA)
Frances Brazier Free University of Amsterdam (The Netherlands)
Joost Breuker University of Amsterdam (The Netherlands)
Paul Compton University of New South Wales (Austria)
John Domingue Open University (UK)
Dieter Fensel Free University of Amsterdam (The Netherlands)
Jean-Gabriel Ganascia LIP6-University Paris VI (France)
Yolanda Gil ISI, University of Southern California (USA)
Asuncio´n Go´mez Pe´rez Universidad Politecnica de Madrid (Spain)
Nicola Guarino National Research Council (Italy)
Udo Hahn University of Freiburg (Germany)
Knut Hinkelmann Insiders (Germany)
Rob Kremer University of Calgary (Canada)
Franck Maurer University of Calgary (Canada)
Riichiro Mizoguchi Osaka University (Japan)
Martin Molina Technical University of Madrid (Spain)
Hiroshi Motoda Osaka University (Japan)
Enrico Motta Open University (UK)
Mark Musen Stanford University (USA)
Kieron O’Hara University of Nottingham (UK)
Enric Plaza I Cervera Spanish Scientific Research Council, CSIC (Spain)
Ulrich Reimer Swiss Life (Switzerland)
Chantal Reynaud University of Nanterre & University of Paris-Sud
(France)
Franc¸ois Rousselot LIIA-ENSAIS, University of Strasbourg (France)
Marie-Christine Rousset University of Paris-Sud (France)
Franz Schmalhofer DFKI, Kaiserslautern (Germany)
Guus Schreiber University of Amsterdam (The Netherlands)
Nigel Shadbolt University of Southampton (UK)
Derek Sleeman University of Aberdeen (UK)
Rudi Studer University of Karlsruhe (Germany)
Jan Treur Free University Amsterdam (The Netherlands)
Mike Uschold Boeing (USA)
Andre Valente FasTV (USA)
Page 9
hidden
X Organization
Frank Van Harmelen Free University of Amsterdam (The Netherlands)
Gertjan Van Heijst Kenniscentrum CIBIT (The Netherlands)
Thomas Wetter University of Heidelberg (Germany)
Steering Committee
Nathalie Aussenac-Gilles IRIT–CNRS Toulouse (France)
Richard Benjamins University of Amsterdam (The Netherlands)
Joost Breuker University of Amsterdam (The Netherlands)
B. Chandrasekaran Ohio State University (USA)
Dieter Fensel Free University of Amsterdam (The Netherlands)
Brian Gaines University of Calgary (Canada)
Riichiro Mizoguchi Osaka University (Japan)
Enrico Motta Open University (UK)
Mark Musen Stanford University (USA)
Nigel Shadbolt University of Southampton (UK)
Rudi Studer University of Karlsruhe (Germany)
Frank Van Harmelen Free University Amsterdam (The Netherlands)
Additional Referees
Jean-Paul Barthe`s
Ghassan Beydoun
Jim Blythe
Didier Bourigault
Monica Crube´zy
Mehdi Dastani
John Debenham
Je´rome Euzenat
Yolanda Gil
Adil Hameed
Ian Horrocks
Zhisheng Huang
Catholijn Jonker
Gilles Kassel
Jihie Kim
Nada Matta
Tim Menzies
Amedeo Napoli
Claire Nedellec
Borys Omelayenko
Frank Puppe
Hans-Peter Schnurr
Carla Simone
Gerd Stumme
York Sure
Jennifer Tennison
Leon Van der Torre
Yannick Toussaint
Niek J.E. Wijngaards
Manuel Zacklad
Organizing Committee
Olivier Corby INRIA, Sophia Antipolis
Rose Dieng INRIA, Sophia Antipolis
Monique Simonetti INRIA, Sophia Antipolis
Sponsoring Institutions
INRIA, Conseil Re´gional Provence Alpes Coˆte d’Azur, AAAI, AFIA, Club CRIN
Inge´nierie du Traitement de l’Information, GRACQ, IIIA, MLNET
Page 10
hidden
Table of Contents
Knowledge Modelling Languages and Tools
OIL in a Nutshell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Dieter Fensel, Ian Horrocks, Frank Van Harmelen, Stefan Decker,
Michael Erdmann, and Michel Klein
The Knowledge Model of Prote´ge´-2000: Combining Interoperability and
Flexibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Natalya Fridman Noy, Ray W. Fergerson, and Mark A. Musen
A Case Study in Using Prote´ge´-2000 as a Tool for CommonKADS . . . . . . . 33
Guus Schreiber, Monica Crube´zy, and Mark Musen
The MOKA Modelling Language (Short Paper) . . . . . . . . . . . . . . . . . . . . . . . . 49
Richard Brimble and Florence Sellini
Md
ως
: A Modelling Language to Build a Formal Ontology in Either
Description Logics or Conceptual Graphs (Short Paper) . . . . . . . . . . . . . . . . . 57
Je´roˆme Nobe´court and Brigitte Bie´bow
Ontologies
Ontology’s Crossed Life Cycles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Mariano Ferna´ndez Lo´pez, Asuncio´n Go´mez Pe´rez, and
Mar´ıa Dolores Rojas Amaya
A Roadmap to Ontology Specification Languages . . . . . . . . . . . . . . . . . . . . . . 80
Oscar Corcho and Asuncio´n Go´mez Pe´rez
A Formal Ontology of Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Nicola Guarino and Christopher Welty
Construction and Deployment of a Plant Ontology . . . . . . . . . . . . . . . . . . . . . 113
Riichiro Mizoguchi, Kouji Kozaki, Toshinobu Sano, and
Yoshinobu Kitamura
The Role of Ontologies for an Effective and Unambiguous Dissemination
of Clinical Guidelines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Domenico M. Pisanelli, Aldo Gangemi, and Geri Steve
Supporting Inheritance Mechanisms in Ontology Representation . . . . . . . . . 140
Valentina A.M. Tamma and Trevor J.M. Bench-Capon
Page 11
hidden
XII Table of Contents
Conflict Resolution in the Collaborative Design of Terminological
Knowledge Bases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Gilles Falquet and Claire-Lise Mottaz Jiang
Knowledge Acquisition from Texts
Revisiting Ontology Design: A Methodology Based on Corpus Analysis . . . 172
Nathalie Aussenac-Gilles, Brigitte Bie´bow, and Sylvie Szulman
Mining Ontologies from Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Alexander Maedche and Steffen Staab
SVETLAN’ or How to Classify Words Using Their Context . . . . . . . . . . . . . 203
Gae¨l De Chalendar and Brigitte Grau
Machine Learning
KIDS: An Iterative Algorithm to Organize Relational Knowledge . . . . . . . . 217
Isabelle Bournaud, Me´lanie Courtine, and Jean-Daniel Zucker
Informed Selection of Training Examples for Knowledge Refinement . . . . . . 233
Nirmalie Wiratunga and Susan Craw
Experiences with a Generic Refinement Toolkit (Short Paper) . . . . . . . . . . . 249
Robin Boswell and Susan Craw
Knowledge Management & E-Commerce
What’s in an Electronic Business Model? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Jaap Gordijn, Hans Akkermans, and Hans Van Vliet
Chinese Encyclopaedias and Balinese Cockfights - Lessons for Business
Process Change and Knowledge Management . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Antony Bryant
Using Problem-Solving Models to Design Efficient Cooperative Knowledge-
Management Systems Based on Formalization and Traceability of
Argumentation (Short Paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
Myriam Lewkowicz and Manuel Zacklad
Integrating Textual Knowledge and Formal Knowledge for Improving
Traceability (Short Paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Farid Cerbah and Je´roˆme Euzenat
Knowledge Management by Reusing Experience (Short Paper) . . . . . . . . . . . 304
Sabine Delaˆıtre and Sabine Moisan
Page 12
hidden
Table of Contents XIII
Problem-Solving Methods
Integrating Knowledge-Based Configuration Systems by Sharing
Functional Architectures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Alexander Felfernig, Gerhard Friedrich, Dietmar Jannach, and
Markus Zanker
The Nature of Knowledge in an Abductive Event Calculus Planner . . . . . . . 328
Leliane Nunes De Barros and Paulo E. Santos
Adapting Tableaux for Classification (Short Paper) . . . . . . . . . . . . . . . . . . . . . 344
Machiel G. Jansen, Guus Th. Schreiber, and Bob J. Wielinga
Knowledge Representation
Conceptual Information Systems Discussed through an IT-Security Tool . . 352
Klaus Becker, Gerd Stumme, Rudolf Wille, Uta Wille, and
Monika Zickwolff
Translations of Ripple Down Rules into Logic Formalisms . . . . . . . . . . . . . . . 366
Rex B. H. Kwok
Generalising Ripple-Down Rules (Short Paper) . . . . . . . . . . . . . . . . . . . . . . . . 380
Paul Compton and Debbie Richards
Validation, Evaluation and Certification
Monitoring Knowledge Acquisition Instead of Evaluating Knowledge Bases 387
Ghassan Beydoun and Achim Hoffmann
Torture Tests: A Quantitative Analysis for the Robustness of
Knowledge-Based Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Perry Groot, Frank Van Harmelen, and Annette Ten Teije
Certifying KBSs: Using CommonKADS to Provide Supporting Evidence
for Fitness for Purpose of KBSs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
Kieron O’Hara, Nigel Shadbolt, and Jeni Tennison
Methodologies
Kinesys, a Participative Approach to the Design of Knowledge Systems . . . 435
Aurelien Slodzian
An Organizational Semiotics Model for Multi-agent Systems Design
(Short Paper) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Joaquim Filipe
Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
Page 13
hidden
Author Index
Akkermans, Hans, 257
Aussenac-Gilles, Nathalie, 172
Becker, Klaus, 352
Bench-Capon, Trevor, 140
Beydoun, Ghassan, 387
Bie´bow, Brigitte, 57, 172
Boswell, Robin, 249
Bournaud, Isabelle, 217
Brimble, Richard, 49
Bryant, Antony, 274
Cerbah, Farid, 296
Compton, Paul, 380
Corcho, Oscar, 80
Courtine, Me´lanie, 217
Craw, Susan, 233, 249
Crube´zy, Monica, 33
De Chalendar, Gae¨l, 203
Decker, Stefan, 1
Delaˆıtre, Sabine, 304
Erdmann, Michael, 1
Euzenat, Je´roˆme, 296
Falquet, Gilles, 156
Felfernig, Alexander, 312
Fensel, Dieter, 1
Fergerson, Ray, 17
Ferna´ndez Lo´pez, Mariano , 65
Filipe, Joaquim, 449
Fridman Noy, Natalya, 17
Friedrich, Gerhard, 312
Gangemi, Aldo, 129
Go´mez Pe´rez, Asuncio´n, 65, 80
Gordijn, Jaap, 257
Grau, Brigitte, 203
Groot, Perry, 403
Guarino, Nicola, 97
Hoffmann, Achim, 387
Horrocks, Ian, 1
Jannach, Dietmar, 312
Jansen, Machiel, 344
Kitamura, Yoshinobu, 113
Klein, Michel, 1
Kozaki, Kouji, 113
Kwok, Rex, 366
Lewkowicz, Myriam, 288
Maedche, Alexander, 189
Mizoguchi, Riichiro, 113
Moisan, Sabine, 304
Mottaz Jiang, Claire-Lise, 156
Musen, Mark, 17, 33
Nobe´court, Je´roˆme, 57
Nunes De Barros, Leliane, 328
O’Hara, Kieron, 419
Pisanelli, Domenico, 129
Richards, Debbie, 380
Rojas Amaya, Mar´ıa Dolores, 65
Sano, Toshinobu, 113
Santos, Paulo, 328
Schreiber, Guus, 33, 344
Sellini, Florence, 49
Shadbolt, Nigel, 419
Slodzian, Aurelien, 435
Staab, Steffen, 189
Steve, Geri, 129
Stumme, Gerd, 352
Szulman, Sylvie, 172
Tamma, Valentina, 140
Ten Teije, Annette, 403
Tennison, Jeni, 419
Van Harmelen, Frank, 1, 403
Van Vliet, Hans, 257
Welty, Christopher, 97
Wielinga, Bob, 344
Wille, Rudolf, 352
Wille, Uta, 352
Wiratunga, Nirmalie, 233
Zacklad, Manuel, 288
Zanker, Markus, 312
Zickwolff, Monika, 352
Zucker, Jean-Daniel, 217
Page 14
hidden
R. Dieng and O. Corby (Eds.): EKAW 2000, LNAI 1937, pp. 80-96, 2000.
© Springer-Verlag Berlin Heidelberg 2000
A Roadmap to Ontology Specification Languages
Oscar Corcho1 and Asunción Gómez-Pérez1
1Facultad de Informática, Universidad Politécnica de Madrid. Campus de Montegancedo s/n.
Boadilla del Monte, 28660. Madrid. Spain.
ocorcho@delicias.dia.fi.upm.es, asun@fi.upm.es
Abstract. The interchange of ontologies across the World Wide Web (WWW)
and the cooperation among heterogeneous agents placed on it is the main reason
for the development of a new set of ontology specification languages, based on
new web standards such as XML or RDF. These languages (SHOE, XOL, RDF,
OIL, etc) aim to represent the knowledge contained in an ontology in a simple
and human-readable way, as well as allow for the interchange of ontologies
across the web. In this paper, we establish a common framework to compare the
expressiveness and reasoning capabilities of „traditional“ ontology languages
(Ontolingua, OKBC, OCML, FLogic, LOOM) and „web-based“ ontology
languages, and conclude with the results of applying this framework to the
selected languages.
1 Introduction
In the past years, a set of languages have been used for implementing ontologies.
Ontolingua [6] is perhaps the most representative of all of them. Other languages have
also been used for specifying ontologies: LOOM [16], OCML [17], FLogic [12], etc.
Protocols such as OKBC[4] have been also developed to access KR systems. KR
paradigms underlying these languages and protocols are diverse: frame-based,
description logic, first (and second) order predicate calculus and object-oriented.
In the recent years, new languages for the web have been created -XML [2], RDF
[13] and RDF Schema [3]- and are still in a development phase. Other languages for
the specification of ontologies, based on the previous ones, have also emerged: SHOE
[15], XOL [11] and OIL [10]. Preliminary studies exist on the use of web-based
languages for representing ontologies. In [9], an analysis is shown on the role of
HTML, XML and RDF when providing semantics for documents on the Web.
The purpose of this paper is to analyse the tradeoff between expressiveness (what
can be said) and inference (what can be obtained from the information represented)
in traditional and web-based ontology languages. In Section 2, we will present a
framework for evaluating the expressiveness and inference mechanisms of ontology
specification languages. Section 3 will describe both the so-called traditional ontology
languages and the web-based ontology languages. As a conclusion, section 4 presents
a discussion on the results of the study.
Page 15
hidden
A Roadmap to Ontology Specification Languages 81
2 Evaluation Framework
The goal of this section is to set up a framework for comparing the expressiveness and
inference mechanisms of potential ontology languages. We use in our analysis the
CommonKADS framework [18], which distinguishes between domain knowledge and
inference knowledge. Figure 1 summarises the relationship between the KR
components and the reasoning mechanisms of languages.
2.1 Domain Knowledge
The domain knowledge describes the main static information and knowledge objects
in an application domain [18]. We identify the main kind of components used to
describe domain knowledge in ontologies. Accordingly to Gruber [8], knowledge in
ontologies can be specified using five kind of components: concepts, relations,
functions, axioms and instances. Concepts in the ontology are usually organised in
taxonomies. Sometimes the notion of ontology is somewhat diluted, in the sense that
taxonomies are considered to be full ontologies [19]. Other components like
procedures and rules are also identified in some ontology languages (i.e., OCML). For
each one of the components outlined before (except for procedures, as it is very
difficult to find common characteristics for them in all languages) we will select a set
of features that we consider relevant.
Concepts [18], also known as classes, are used in a broad sense. They can be abstract
or concrete, elementary or composite, real or fictious. In short, a concept can be
anything about which something is said, and, therefore, could also be the description
of a task, function, action, strategy, reasoning process, etc. The following questions
identify the expressiveness of a language when defining classes:
œ Is it possible to define metaclasses (classes as instances of other ones)? They are
important in case that a KR ontology exists for the language.
œ Is it possible to define partitions (sets of disjoint classes)?
œ Does the language provide mechanisms to define slots/attributes? For example:
œ Local attributes. Attributes which belong to a specific concept. For instance,
attribute age belongs to concept Person.
œ Instance attributes (template slots). Attributes whose value may be different
for each instance of the concept.
œ Class attributes (own slots). Attributes whose value must be the same for all
instances of the concept.
œ Polymorph attributes. Attributes (slots) with the same name and different
behaviour for different concepts. For instance, the attribute author for concept
Thesis is different from the attribute author for concept Book. Its type for Thesis
is Student, and its type for Book is Person.
œ Does the language provide the following predefined facets for attributes?
œ Default slot value, which will be used to assign a value to the attribute in case
there is no explicit value defined for it.
Page 16
hidden
82 O. Corcho and A. Gómez-Pérez
œ Type, which will be used to constrain the type of the attribute.
œ Cardinality constraints, which will be used to constrain the minimum and
maximum number of values of the attribute.
œ Documentation, which could include a natural language definition for it.
œ Operational definition, which could include the definition or selection of a
formula, a rule, etc to be used, for instance, when obtaining a value for that
attribute.
œ May new facets be created for attributes?
Taxonomies. They are widely used to organise ontological knowledge in the domain
using generalisation/specialisation relationships through which simple/multiple
inheritance could be applied. Since there exists some confusion regarding the
primitives used to build taxonomies, we propose to analyse whether or not the
following primitives (which are based on the definitions provided by the frame
ontology at Ontolingua) are predefined in the languages.
œ Subclass of specialises general concepts in more specific concepts.
œ Disjoint decompositions define a partition as subclass of a class. The
classification does not necessarily have to be complete (there may be instances of
the parent class that are not included in any of the subclasses of the partition).
œ Exhaustive subclass decompositions define a partition as subclass of a class. The
parent class is the union of all the classes that make up the partition.
œ Not subclass of may be used to state that a class is not a specialisation of another
class. This kind of knowledge is usually represented using the denial of the
subclass of primitive.
Some languages have a formal semantics for those primitives, and others must
define their semantics by using axioms or rules.
Fig. 1. Evaluation Framework
Knowledge
Representation
• Classes
• Metaclasses
• Slots/Attributes
• Facets
• Taxonomies
• Procedures
• Relations/Functions
• Instances / Individuals / Facts
• Axioms
• Production Rules
Inference
Mechanisms
• Exceptions
•Automatic classifications
•Inheritance
•Monotonic, Non monotonic
•Simple, Multiple
•Execution of Procedures
•Constraint Checking
•Reasoning with rules
• Backward chaining
• Forward Chaining
Evaluation framework
Page 17
hidden
A Roadmap to Ontology Specification Languages 83
Relations [8] represent a type of interaction between concepts of the domain. They
are formally defined as any subset of a product of n sets. First, we consider the
relationship between relations and other components in the ontology. We will ask if
concepts and attributes are considered, respectively, as unary and binary relations.
Functions [8] are considered as a special kind of relations where the value of the last
argument is unique for a list of values of the n-1 preceding arguments.
Second, we focus on the arguments (both in relations and functions):
œ Is it possible to define arbitrary n-ary relations/functions? If this is not possible,
which is the maximum number of arguments?
œ May the type of arguments be constrained?
œ Is it possible to define integrity constraints in order to check the correctness of
the arguments’ value?
œ Is it possible to define operational definitions to infer values of arguments with
procedures, formulas and rules, or to define its semantic using axioms or rules?
Axioms [8] model sentences that are always true. They are included in an ontology
for several purposes, such as constraining its information, verifying its correctness or
deducting new information. We will focus on the next characteristics:
œ Does the language support building axioms in first order logic?
œ And second order logic axioms?
œ Are axioms defined as independent elements in the ontology (named axioms) or
must they be included inside the definition of other elements, such as relations,
concepts, etc? This feature improves readability and maintenance of ontologies.
Instances/Individuals/Facts/Claims. All these terms are used to represent elements
in the domain. Instances [8] represent elements of a given concept. Facts [17]
represent a relation which holds between elements. Individuals [6] refer to any
element in the domain which is not a class (both instances and facts). Claims [15]
represent assertions of a fact by an instance. It is important to highlight the inclusion
of claims, since people on internet can make whatever claims they want. Hence,
agents shouldn’t interpret them as facts of knowledge, but as claims being made by a
particular instance about itself or about other instances or data, which may prove to be
inconsistent with others [15]. The following questions will be asked in this section:
œ Is it possible to define instances of concepts?
œ Is it possible to define instances of relations (facts)?
œ Does the language provide special mechanisms to define claims?
Production rules. Production rules [16], which follow the structure If ... Then ..., are
used to express sets of actions and heuristics which can be represented independently
from the way they will be used. A set of questions will be asked about them:
œ Is it possible to define disjunctive and conjunctive premises?
œ May the chaining mechanism be defined declaratively?
œ Is it possible to define truth values or certainty values attached to the rule?
Page 18
hidden
84 O. Corcho and A. Gómez-Pérez
œ May procedures be included in the consequent? They are commonly used to
change the values of attributes of a concept, add information to the KB, etc.
œ Does the language support updates of the KB, performed by adding or removing
facts or claims?
2.2 Inference Mechanisms
This dimension describes how the static structures represented in the domain
knowledge can be used to carry out a reasoning process [18]. There is a strong
relationship between both dimensions, as the structures used for representing
knowledge are the basis for the reasoning process, as seen in Figure 1. We analyse
whether the language supports the following features or not:
œ Does the language provide an inference engine that reasons with the knowledge
represented using the language? Is it sound? And complete?
œ Does the inference engine perform automatic classifications?
œ Does the inference engine deal with exceptions? Exceptions are considered when
attribute Attribute1 is defined for concept C1 and concept C2, being C1 subclass of
C2 and we analyse whether the definition of Attribute1 in concept C1 overrides the
definition of Attribute1 in concept C2 or not.
œ Is it possible to use monotonic, non-monotonic, simple and/or multiple
inheritance?
œ Are procedures executable?
œ Do axioms perform any kind of constraint checking?
œ When reasoning with rules, does the language allow forward and backward
chaining?
3 Ontology Specification Languages
In this section, we show an analysis of ontology specification languages which have
been and are widely used by the ontology community (Ontolingua, OKBC, OCML,
FLogic and LOOM), other languages created in the context of Internet, which are
recommendations of the W3C (XML, RDF and RDFS) and, finally, other new
languages for the specification of ontologies (XOL, SHOE and OIL).
3.1 Traditional Ontology Specific ation Languages
Ontolingua [6] is a language based on KIF [7] and on the Frame Ontology (FO) [6],
and it is the ontology-building language used by the Ontolingua Server [6].
KIF (Knowledge Interchange Format) was developed to solve the problem of
heterogeneity of languages for knowledge representation. It provides for the definition
of objects, functions and relations. KIF has declarative semantics and it is based on
Page 19
hidden
A Roadmap to Ontology Specification Languages 85
first-order predicate calculus, with a prefix notation. It also provides for the
representation of meta-knowledge and non-monotonic reasoning rules.
As KIF is an interchange format, it is tedious to use for specification of ontologies
per se. The FO, built on top of KIF, is a knowledge representation ontology that
allows an ontology to be specified following the paradigm of frames, providing terms
such as class, instance, subclass-of, instance-of, etc. The FO does not allow to express
axioms; therefore, Ontolingua allows to include KIF expressions inside of definitions
based on the FO. Summarizing, Ontolingua allows to build ontologies in any of the
following three manners: (1) using exclusively the FO vocabulary (axioms cannot be
represented); (2) using KIF expressions; (3) using both languages simultaneously.
Currently, an inference engine is being developed for Ontolingua. The OKBC API
must be used in case we want to develop a customized one.
OKBC Protocol [4] is an acronym for Open Knowledge Base Connectivity,
previously known as Generic Frame Protocol. It specifies a protocol (not a language).
The protocol makes assumptions about the underlying KR system (frames), and it is
complementary to language specifications developed to support knowledge sharing.
The GFP Knowledge Model, which is the implicit representation formalism
underlying OKBC, supports an object-centered representation of knowledge and
provides a set of representational constructs commonly found in frame representation
systems: constants, frames, slots, facets, classes, individuals and knowledge bases.
It also defines a complete tell&ask interface for knowledge bases accessed using
OKBC protocol, and procedures (with a Lisp-like syntax) in order to describe
complex operations to perform in a knowledge base when accessing it over a network.
Eventually it has been developed the OKBC-Ontology for Ontolingua, which is
fully compatible with the OKBC protocol.
In this study, when referring to OKBC we will mean the API, together with the
maximum expressiveness permitted.
OCML [17] stands for Operational Conceptual Modeling Language, and was
originally developed in the context of the VITAL project.
OCML is a frame-based language that provides mechanisms for expressing items
such as relations, functions, rules (with backward and forward chaining), classes and
instances. In order to make the execution of the language more efficient, it also adds
some extra logical mechanisms for efficient reasoning, such as procedural
attachments. A general tell&ask interface is also implemented, as a mechanism to
assert facts and/or examine the contents of an OCML model.
Several pragmatic considerations were taken into account in the development of
OCML. One of them is the compatibility with standards, such as Ontolingua, so that
OCML can be considered as a kind of „operational Ontolingua“, providing theorem
proving and function evaluation facilities for its constructs.
Page 20
hidden
86 O. Corcho and A. Gómez-Pérez
FLogic [12] is an acronym for Frame Logic. FLogic integrates frame-based
languages and first-order predicate calculus. It accounts in a clean and declarative
fashion for most of the structural aspects of object-oriented and frame-based
languages, such as object identity, complex objects, inheritance, polymorphic types,
query methods, encapsulation, and others. In a sense, FLogic stands in the same
relationship to the object-oriented paradigm as classical predicate calculus stands to
relational programming.
FLogic has a model-theoretic semantics and a sound and complete resolution-based
proof theory.
Applications of FLogic go from object-oriented and deductive databases to
ontologies, and it can be combined with other specialized logics (HiLog, Transaction
Logic), to improve the reasoning with information in the ontologies.
LOOM [16] is a high-level programming language and environment intended for use
in constructing expert systems and other intelligent application programs. It is a
descendent of the KL-ONE family and it is based in description logic, achieving a
tight integration between rule-based and frame-based paradigms.
LOOM supports a "description" language for modeling objects and relationships,
and an „assertion“ language for specifying constraints on concepts and relations, and
to assert facts about individuals. Procedural programming is supported through
pattern-directed methods, while production-based and classification-based inference
capabilities support a powerful deductive reasoning (in the form of an inference
engine: the classifier).
It is important to focus on the description logic approach to ontology modeling,
which differs from the frame-based approach of the previously described languages.
Definitions written using this approach try to exploit the existence of a powerful
classifier in the language, specifying concepts by using a set of restrictions on them.
3.2 Web Standards and Recomm endations
XML [2] stands for eXtended Markup Language deriving from SGML (Standard
General Markup Language). It is being developed by the XML Working Group of the
World Wide Web Consortium (W3C), and it is next to become a standard.
As a language for the World Wide Web, its main advantages are: it is easy to parse,
its syntax is well defined and it is human readable. There are also many software tools
for parsing and manipulating XML. It allows users to define their own tags and
attributes, define data structures (nesting them), extract data from documents and
develop applications which test the structural validity of a XML document.
When using XML as the basis for an ontology specification language, its main
advantages are:
œ The definition of a common syntactic specification by means of a DTD (Document
Type Definition).
œ Information coded in XML is easily readable for humans.
Page 21
hidden
A Roadmap to Ontology Specification Languages 87
œ It can be used to represent distributed knowledge across several web-pages, as it
can be embedded in them.
XML also presents some disadvantages which influence on ontology specification:
œ It is defined in order to allow the lack of structure of information inside XML tags.
This makes it difficult to find the components of an ontology inside the document.
œ Standard tools are available for parsing and manipulating XML documents, but not
for making inferences. These tools must be created in order to allow inferences
with languages which are based on XML.
XML itself has no special features for the specification of ontologies, as it just
offers a simple but powerful way to specify a syntax for an ontology specification
language (this is the reason why XML is not included in the comparison of section 5).
Besides, it can be used for covering ontology exchange needs, exploiting the
communication facilities of the WWW.
RDF [13] stands for Resource Description Framework. It is being developed by the
W3C for the creation of metadata describing Web resources. Examples of the use of
RDF in ontological engineering may be analyzed in [1] and [20].
A strong relationship stands between RDF and XML. In fact, they are defined as
complementary: one of the goals of RDF is to make it possible to specify semantics
for data based on XML in a standardized, interoperable manner. The goal of RDF is
to define a mechanism for describing resources that makes no assumptions about a
particular application domain nor the structure of a document containing information.
The data model of RDF (which is based in semantic networks) consists of three
types: resources (subjects), entities that can be referred to by an address at the
WWW; properties (predicates), which define specific aspects, characteristics,
attributes or relations used to describe a resource; and statements (objects), which
assign a value for a property in a specific resource.
RDF Schema [3] (RDFS) is a declarative language used for the definition of RDF
schemas. The RDFS data model (which is based on frames) provides mechanisms for
defining the relationships between properties (attributes) and resources. Core classes
are class, resource and property; hierarchies and type constraints can be defined (core
properties are type, subclassOf, subPropertyOf, seeAlso and isDefinedBy). Some core
constraints are also defined.
3.3 Web-Based Ontology Specific ation Languages
XOL. [11] stands for XML-Based Ontology Exchange Language. It was designed to
provide a format for exchanging ontology definitions among a set of interested
parties. Therefore, it is not intended to be used for the development of ontologies, but
as an intermediate language for transferring ontologies among different database
systems, ontology-development tools or application programs.
XOL allows to define in a XML syntax a subset of OKBC, called OKBC-Lite. As
OKBC defines a protocol for accessing frame-based representation systems, XOL
Page 22
hidden
88 O. Corcho and A. Gómez-Pérez
may be suitable for exchanging information between different systems, via the
WWW. The main handicap is that frames (defined in OKBC) are excluded from this
language, and only classes (and their hierarchies), slots and facets can be defined.
Many XML editing tools are available which allow to generate XOL documents.
SHOE [15] stands for Simple HTML Ontology Extension. It was developed first as an
extension of HTML, with the aim of incorporating machine-readable semantic
knowledge in HTML or other WWW documents. Recently, it has been adapted in
order to be XML compliant. The intent of this language is to make it possible for
agents to gather meaningful information about web pages and documents, improving
search mechanisms and knowledge-gathering. The two-phase process to achieve it
consists of: (1) defining an ontology describing valid classifications of objects and
valid relationship between them; (2) annotating HTML pages to describe themselves,
other pages, etc.
In SHOE, an ontology is an ISA hierarchy of classes (called categories), plus a set
of atomic relations between them, and inferential rules in the form of simplified horn
clauses. Therefore, classes, relations and inferential rules can be defined. An
important feature included in SHOE is the ability to make claims about information,
as discussed in section 2.
OIL [10], Ontology Interchange Language, is a proposal for a joint standard for
describing and exchanging ontologies. It is still in an early development phase, and
has been designed to provide most of the modelling primitives commonly used in
frame-based and description logic ontologies (it is based on existing proposals, such
as OKBC , XOL and RDF), with a simple, clean and well defined semantics, and an
automated reasoning support.
In OIL, an ontology is a structure made up of several components, organized in three
layers: the object level (which deals with instances), the first meta level or ontology
definition (which contains the ontology definitions) and the second meta level or
ontology container (which contains information about features of the ontology, such
as its author). Concepts, relations and functions and axioms can be defined in OIL.
The syntax of instances, rules and axioms has not yet been defined.
4 Results and Comparison of Languages
The results of applying the evaluation framework described in section 2 are presented
in this section. It is worth mentioning that a common evaluation framework has been
used for different knowledge representation languages (and different knowledge
representation paradigms, such as frame-based, description logic and object-centered),
and that the results have been achieved taking into account the experience of coding,
in all the selected languages, an ontology for electronic commerce, which is not
shown here due to the lack of space.
The trade-off between the degree of expressiveness and the inference engine of a
language (the more expressive, the less inference capabilities) makes it difficult to
establish a scoring of languages. Moreover, we claim that different needs in KR exist
Page 23
hidden
A Roadmap to Ontology Specification Languages 89
nowadays for applications, and some languages are more suitable than others for the
specific needs of a given application.
When developing domain ontologies for an application, it is not only necessary to
study the KR and reasoning needs for the application, but also the KR and reasoning
capabilities provided by the languages. This framework will avoid the developer of
ontologies taking blind decisions on the selection of the ontology language(s) to use.
Information in tables of the next sections will be filled using ‘+’ to indicate that it
is a supported feature in the language, ‘-‘ for non supported features, ‘+/-’ for non
supported features, but could manage to support it by doing something, ‘?’ when no
information is available and ‘N.D.’ for features which are not restricted, but could be
implemented in order to support them. The contents of tables represent the present
situation of languages1 and may change because of the evolution of them.
4.1 Domain Knowledge
Table 1 shows at first glance the main components of the ontology specification
languages selected for this study.
Concepts, n-ary relations and instances can be defined easily in almost all
languages. In OKBC and FLogic, which are frame-based languages, relations can be
represented by using frames, but not as special elements provided by the language. In
OKBC, axioms are only supported in the tell&ask part of the API, although neither
deductive nor storage guarantees are made for all OKBC implementations.
Table 1. Definition of the main components of domain knowledge
Onto OKBC OCML LOO
M
FLogi
c
XOL SHOE RDF(S
)
OIL
Concepts + + + + + + + + +
n-ary relations + +/- + + +/- - + + +
Functions + +/- + + +/- - - - +
Procedures + + + + - - - - -
Instances + + + + + + + + ND
Axioms + +/- + + + - - - ND
Production
Rules
- - + + - - - - ND
Formal semantics + + + + + + - - -
Functions, procedures and axioms cannot be defined using web-based languages,
except for some restricted forms of axioms, such as deductive rules, which are
definable in SHOE.

1
’Onto’ will be used to refer to Ontolingua. RDF(S) is the acronym used to refer to the
combination of RDF and RDFS.
Page 24
hidden
90 O. Corcho and A. Gómez-Pérez
It is worth mentioning that procedures are only definable in Lisp-based languages,
and production rules are just definable in OCML and LOOM.
An additional row has been added to the table, analysing the presence of a formal
semantics: some web-based languages, such as SHOE, RDF(S) and OIL lack of it,
whereas traditional languages and XOL provide it.
Concepts. Table 2 summarizes the most important features to be analyzed when
describing concepts in an ontology. It is divided in 4 sections: metaclasses, partitions,
definition of attributes and definitions of properties of attributes (facets).
Table 2. Definition of concepts
CONCEPTS Ont
o
OKBC OCML LOOM FLogic XOL SHOE RDF(S) OI
L
Metaclasses + + + + + + - + -
Partitions + - - + - - - - -
ATTRIBUTES
Template
(instance attrs)
+ + + + + + + + +
Own (class attrs.) + + + + + + - + +/-
Polymorphic + + + + + - - - +
Local scope + + + + + + + + +
FACETS
Default slot value - + + + + + - - -
Type constraint + + + + + + + + +
Cardinality
constraints
+ + + + +/- + - - +
Documentation + + + + - + + - +
Procedural
knowledge
- - + + - - - - -
Adding new
facets
+ + - + - - - - -
Only SHOE and OIL do not allow to define metaclasses, and partitions can only be
defined in Ontolingua and LOOM.
Instance attributes and type constraints for attributes can be defined using any of
the chosen languages. The results of the rest of the values depend on the languages,
although a glance at the table shows us that traditional ontology languages allow us,
again, to define more features than web-based languages.
Procedural knowledge inside the definition of attributes is only supported by
OCML and LOOM, due to their operational behavior. It must be included in the
definition of the OCML´s attributes by means of special keywords, such as :prove-by
Page 25
hidden
A Roadmap to Ontology Specification Languages 91
or :lisp-fun, not as simple facets, or in the definition of the LOOM’s attributes by
means of keywords such as :sufficient, :is, :is-primitive or :implies.
FLogic just allows to define the maximum cardinality for slots as 1 or N, while the
minimum cardinality is always set to 0.
Table 3. Definition of taxonomies
TAXONOMIES Onto OKB
C
OCM
L
LOO
M
FLogi
c
XOL SHOE RDF(
S)
OIL
Subclass of + + + + + + + + +
Exhaustive subclass
partitions
+ - +/- + +/- - - - -
Disjoint
Decompositions
+ - +/- + +/- - - - +/-
Not subclass of +/- - - +/- - - - - +
Taxonomies. When defining taxonomies, there is just one primitive predefined in all
languages and correctly handled by them: subclass of. Ontolingua and LOOM are the
only languages which have the rest of primitives (except for not subclass of, which
must be declared using the denial of primitve subclass-of). These primitives can be
defined as relations in the rest of languages, but as a consequence, there is no special
treatment for them. In FLogic, axioms must be defined in order to provide the
semantics for them. OIL allows to define the primitive not subclass-of; hence it is also
possible to define disjoint decompositions.
Relations and Functions. Relations are very important components in an ontology
(hence they are supported by almost all the ontology languages), but not every
desirable characteristic of relations is implemented in all languages. Functions are not
included in some languages.
Table 4. Definition of relations and functions
RELATIONS
FUNCTIONS
Onto OKBC OCML LOOM FLogic XOL SHOE RDF(S) OIL
Functions as
relations
+ + - + + - - - +
Concepts: unary
rels.
+ + + + - - + - +
Slots: binary rels. + + + + - + + + +
n-ary rels./functs. + +/- + + +/- - + + +/-
Type constraints + + + + + - + + +
Integrity
constraints
+ + + + + - - - -
Operational defs. - - + + + - - - -
Page 26
hidden
92 O. Corcho and A. Gómez-Pérez
Many languages represent concepts as unary relations. Attributes are usually
considered as binary relations, except for FLogic, where they are considered as
ternary ones.
Great semantic differences are found when analysing the role that functions play in
different languages. Some languages, such as KIF (and consequently, Ontolingua),
consider functions as a special case of relations in which the nth element of the relation
is unique for the n-1 preceding elements. LOOM consider functions as relations
where the result can be calculated given the domain arguments. In OCML, functions
are considered as modelling elements which play a role which is completely different
to the one of relations. In FLogic, functions are considered as methods which are
defined inside a concept. Their value is calculated by using a deductive rule
associated to the method previously declared.
FLogic, OKBC, RDF(S) and OIL cannot define n-ary relations directly. They must
define them as associative classes or by means of several binary relations.
All languages allow the definition of type constraints for arguments, and the main
differences among traditional and web-based ontology languages lay on the definition
of integrity constraints (the last ones don’t allow to define them).
The last comments are on operational definitions for relations: just OCML, LOOM
and FLogic allow to define operations inside relations, although there is a difference
between them: while LOOM provides operational definitions just for an inferential
purpose, OCML also provides non-operational definitions which can be used for
representational purposes [17]. In FLogic, this kind of operations must be defined by
using axioms, which are defined apart. Ontolingua does not support user-defined Lisp
lambda bodies for relations, but it has certain relations that have procedural
attachments which are activated by the tell&ask interface (for instance, asking (+ 3 2
?x) will reply with a single binding of 5 for ?x).
Instances. Instances of concepts and of relations (facts) are supported by all the
languages. Claims, however, are just allowed in some of the web-based ontology
languages. This is due to the fact that the management of information which comes
from different sources is an intrinsic characteristic of the web environment and so
these languages have specialised ways to treat this information.
Table 5. Definition of instances
INSTANCES Onto OKBC OCML LOOM FLogic XOL SHOE RDF(S) OIL
Instances of
concepts
+ + + + + + + + ND
Facts + + + + + + + + ND
Claims - - - - - - + + ND
Page 27
hidden
A Roadmap to Ontology Specification Languages 93
Axioms. This is a good measure of expressiveness. The richest the axioms defined,
the more expressive the language is. Ontolingua allows the definition of first-order
and second-order logic axioms. OCML and FLogic also allow to define first-order
logic axioms independently of the rest of components of the ontology.
LOOM just allows to define first-order logic axioms inside the definitions of
relations, concepts and functions.
The rest of languages, except for XOL, only allow restricted types of axioms. So,
OKBC just supports a subset of the axioms which can be represented with KIF (and
they must be included as a frame or by using the tell&ask interface), and SHOE just
allows to define deductive rules. In OIL, the syntax of axioms has not yet been
defined, while in RDF(S) several studies are currently trying to specify the syntax and
semantics for the most commonly used axioms.
Table 6. Definition of axioms
AXIOMS Onto OKBC OCML LOOM FLogic XOL SHOE RDF(S) OIL
1st-order logic + +/- + + + - +/- +/- ND
2nd order logic + +/- - - - - - - -
Named axioms + + + - - - - - -
Production rules. Production rules are components of an ontology in OCML and
LOOM. LOOM distinguishes between purely deductive rules and side-effecting,
procedural rules (production rules). OCML makes the same distinction, defining
„backward“ and „forward“ ones. Therefore, OCML and LOOM allow to define the
chaining when performing the reasoning with knowledge defined in the ontology.
As far as OIL is concerned, rules are just a weak form of general inclusion axioms.
Finally, SHOE does not allow to define production rules, but inference rules, as
stated in the previous section.
Table 7. Definition of rules
PRODUCTION
RULES
Onto OKBC OCML LOOM FLogic XOL SHOE RDF(S) OIL
PREMISES
Conjunctive - - + + - - - - ND
Disjunctive - - + + - - - - ND
CONSEQUENT
Truth values - - - - - - - - ND
Execution of
procedures
- - +/- + - - - - ND
Updating the KB - - + + - - - - ND
Page 28
hidden
94 O. Corcho and A. Gómez-Pérez
4.2 Reasoning
A clear distinction between KR and reasoning exists for all languages, except for
OCML. For instance, Ontolingua is maybe the most expressive of all the languages
chosen for this study, but there is no inference engine implemented for it. OCML
allows to define some features concerning reasoning inside representational elements
(for instance, rules can be defined as backward rules or forward ones, so that the
chaining is explicitly defined).
Just FLogic and OIL inference engines are sound and complete, which is a
desirable feature, although it can make representation in the language more difficult.
Automatic classifications are performed by description logic-based languages
(LOOM and OIL).
The exception handling mechanism is not addressed, in general, by language
developers (FLogic is the only one handling exceptions). Works have been carried out
in other languages, such as LOOM, to support them.
Table 8. Reasoning mechanisms of the language
REASONING Onto OKBC OCML LOOM FLogic XOL SHOE RDF(S) OI
L
INFERENCE ENG.
Sound - - + + + - - - +
Complete - - - - + - - - +
CLASSIFICATION
Automatic classif. - - - + - - - - +
EXCEPTIONS
Exception handling - - - - + - - - -
INHERITANCE
Monotonic + + + + + ND + ND +
Non-monotonic +/- + +/- + + ND - ND -
Single Inheritance + + + + + ND + + +
Multiple inheritance + + + + + ND + + +
PROCEDURES
Execution of
procedures
+ + + + - - - - -
CONSTRAINTS
Constraint checking + + + + + - - - -
CHAINING
Forward - - + + + - ND - -
Backward - - + + + - ND - -
Single and multiple inheritance is also supported by most of the languages (except
for XOL), but conflicts in multiple inheritance are not resolved. All languages are
basically monotonic, although they usually include some non-monotonic capabilities.
Page 29
hidden
A Roadmap to Ontology Specification Languages 95
For instance, the only non-monotonic capabilities present in both Ontolingua and
OCML are related to default values for slots and facets. In XOL and RDF
specifications there is no explicit definition of the behaviour of inherited values.
All the languages which allow to define procedures, allow to execute them.
Constraint checking is performed in all the traditional ontology languages.
Information about constraint checking in XOL is not available. In OKBC, constraint
checking is guaranteed to be included in all implementations of it. However, it can be
parameterised and even switched off. Constraint checking in SHOE is not performed
because conflicts are thought to be frequent in the Web, and resolving them will be
problematic. However, type constraint checking is performed when necessary.
Chaining used in SHOE is not defined in the language: freedom exists so that each
implementation may choose between any of them. OCML allows to define the
chaining of rules when defining them, although default chaining used is the backward
one. LOOM performs both kinds of chaining, and FLogic’s one is in between.
5 Future Works
Future works in this area will try to identify factors to choose among a set of
languages when building a domain ontology for an application. Different needs in KR
and reasoning exist, and some languages are more suitable than others. We
recommend:
œ Web based languages for the interchange of ontologies on the web.
œ Traditional languages for the representation – modeling – of ontologies with high
expressiveness needs. However, if ontologies are considered just as taxonomies,
the use of web-based languages is not a problem.
œ For performing reasoning inside agents, XML-based languages do not provide
inference engines. However, some of the traditional ontology languages not only
provide them but also translators to other computable languages.
Besides, an analysis of the existing tools for editing, managing, integrating and
translating ontologies (which would extend the one described in [5]) will be useful for
determining the most suitable language for our needs, and studies on the treatment of
namespaces in different languages will be also interesting to analyse the easiness of
integrating and scaling up ontologies.
Finally, the analysis on how components are codified in each language will also
help to face up to the translation problem.
Acknowledgements. This paper would not be possible without comments and
feedback of developers and users of the mentioned languages who verified our tables:
V. K. Chaudhri (XOL), Stefan Decker (FLogic), Belén Díaz (LOOM), Yolanda Gil
(LOOM), Jeff Heflin (SHOE), Ian Horrocks (OIL), Enrico Motta (OCML), James
Rice (Ontolingua and OKBC) and Tom Russ (LOOM).
Page 30
hidden
96 O. Corcho and A. Gómez-Pérez
References
1. Amann, B., Fundulaki, I. Integrating Ontologies and Thesauri to Build RDF Schemas. 1999.
2. Bray, T., Paoli, J., Sperberg, C. Extensible Markup Language (XML) 1.0. W3C
Recommendation. Feb 1998. http://www.w3.org/TR/REC-xml.
3. Brickley, D., Guha, R.V. Resource Description Framework (RDF) Schema Specification.
W3C Proposed Recommendation. March, 1999. http://www.w3.org/TR/PR-rdf-schema.
4. Chaudhri, V., Farquhar, A, Fikes, R., Karp, P., Rice, J. The Generic Frame Protocol 2.0.
July, 1997.
5. Duineveld, A., Studer, R., Weiden, M, Kenepa, B., Benjamis, R. WonderTools? A
comparative study of ontological engineering tools. Proceedings of KAW99. Banff. 1999.
6. Farquhar, A., Fikes, R., Rice, J. The Ontolingua Server: A Tool for Collaborative Ontology
Construction. Proceedings of KAW96. Banff, Canada, 1996.
7. Genesereth, M., Fikes, R. Knowledge Interchange Format. Technical Report. Computer
Science Department. Stanford University. Logic-92-1. 1992.
8. Gruber, R. A translation approach to portable ontology specification. Knowledge
Acquisition. #5: 199-220. 1993.
9. van Harmelen, F., Fensel, D. Surveying notations for machine-processable semantics of Web
sources. Proceedings of the IJCAI’99 Workshop on Ontologies & PSMs. 1999.
10.Horrocks, I., Fensel, D., Harmelen, F., Decker, S., Erdmann, M, Klein, M. OIL in a
Nutshell. Proceedings of the ECAI’00 Workshop on Application of Ontologies and PSMs.
Berlin. Germany. August, 2000.
11.Karp, R., Chaudhri, V., Thomere, J. XOL: An XML-Based Ontology Exchange Language.
July, 1999.
12.Kifer, M., Lausen, G., Wu, J. Logical Foundations of Object-Oriented and Frame-Based
Languages. Journal of the ACM. 1995.
13.Lassila, O., Swick, R. Resource Description Framework (RDF) Model and Syntax
Specification. W3C Recommendation. January, 99. http://www.w3.org/TR/PR-rdf-syntax.
14.Lenat, D.B., Guha, R.V. Building Large Knowledge-based systems. Representation and
Inference in the Cyc Project. Addison-Wesley. Reading. Massachusetts. 1990.
15.Luke S., Heflin J. SHOE 1.01. Proposed Specification. SHOE Project. February, 2000.
http://www.cs.umd.edu/projects/plus/SHOE/spec1.01.htm
16.MacGregor, R. Inside the LOOM clasifier. SIGART bulletin. #2(3):70-76. June, 1991.
17.Motta, E. Reusable Components for Knowledge Modelling. IOS Press. Amsterdam. 1999.
18.Schreiber, G., Akkermans, H., Anjewierden, A. Knowledge engineering and management.
The CommonKADS Methodology. MIT press, Massachussets. 1999.
19.Studer, R., Benjamins, R., Fensel, D. Knowledge Engineering: Principles and Methods.
DKE 25(1-2).pp:161-197. 1998
20.Using Protégé-2000 to Edit RDF. Technical Report. Knowledge Modelling Group. Stanford
University. February, 2000. http://www.smi.Stanford.edu/projects/protege/protege-
rdf/protege-rdf.html

Sign up today - FREE

Mendeley saves you time finding and organizing research. Learn more

  • All your research in one place
  • Add and import papers easily
  • Access it anywhere, anytime

Start using Mendeley in seconds!

Already have an account? Sign in

Readership Statistics

31 Readers on Mendeley
by Discipline
 
 
 
by Academic Status
 
48% Ph.D. Student
 
19% Student (Master)
 
6% Post Doc
by Country
 
23% Germany
 
23% United States
 
13% Spain