ontology languages for the semantic web

54 1094-7167/02/$17.00 © 2002 IEEE IEEE INTELLIGENT SYSTEMS

T h e S e m a n t i c W e b

Ontology Languagesfor the Semantic WebAsunción Gómez-Pérez and Oscar Corcho, Universidad Politécnica de Madrid

Ontologies have proven to be an essential element in many applications. They are

used in agent systems, knowledge management systems, and e-commerce plat-

forms. They can also generate natural language, integrate intelligent information, provide

semantic-based access to the Internet, and extract information from texts in addition to

being used in many other applications to explicitlydeclare the knowledge embedded in them.

However, not only are ontologies useful for appli-cations in which knowledge plays a key role, but theycan also trigger a major change in current Web con-tents. This change is leading to the third generation ofthe Web—known as the Semantic Web—which hasbeen defined as “the conceptual structuring of the Webin an explicit machine-readable way.”1 This definitiondoes not differ too much from the one used for defin-ing an ontology: “An ontology is an explicit, machine-readable specification of a shared conceptualization.”2

In fact, new ontology-based applications andknowledge architectures are developing for this newWeb. A common claim for all of these approaches isthe need for languages to represent the semanticinformation that this Web requires—solving the het-erogeneous data exchange in this heterogeneousenvironment. Here, we don’t decide which languageis best of the Semantic Web. Rather, our goal is tohelp developers find the most suitable language fortheir representation needs.

Ontology languagesSeveral ontology languages have been developed

during the last few years, and they will surelybecome ontology languages in the context of theSemantic Web. Some of them are based on XMLsyntax, such as Ontology Exchange Language(XOL),3 SHOE4 (which was previously based onHTML), and Ontology Markup Language (OML),5

whereas Resource Description Framework (RDF)6

and RDF Schema7 are languages created by World

Wide Web Consortium (W3C) working groups.Finally, two additional languages are being built ontop of RDF(S)—the union of RDF and RDFSchema—to improve its features: Ontology Infer-ence Layer (OIL)8 and DAML+OIL9 (see Figure 1).Other languages have also been used, traditionally,for building ontologies, but that analysis is out of thescope of this article.

XML-based Ontology ExchangeLanguage

The US bioinformatics community designed XOLfor the exchange of ontology definitions among aheterogeneous set of software systems in theirdomain. Researchers created it after studying the rep-resentational needs of experts in bioinformatics.They selected Ontolingua and OML as the basis forcreating XOL, merging the high expressiveness ofOKBC-Lite, a subset of the Open Knowledge BasedConnectivity protocol, and the syntax of OML, basedon XML. There are no tools that allow the develop-ment of ontologies using XOL. However, since XOLfiles use XML syntax, we can use an XML editor toauthor XOL files.

Simple HTML Ontology ExtensionSHOE, developed at the University of Maryland

and used to develop OML, was created as an exten-sion of HTML, incorporating machine-readablesemantic knowledge in HTML documents or otherWeb documents. Recently, the University of Mary-land has adapted the SHOE syntax to XML. SHOEmakes it possible for agents to gather meaningful infor-

The authors analyze

the most representative

ontology languages

created for the Web

and compare them

using a common

framework.

mation about Web pages and documents,improving search mechanisms, and knowledgegathering. This process consists of three-phases: Define an ontology, annote HTMLpages with ontological information todescribe themselves and other pages, andhave an agent semantically retrieve informa-tion by searching all the existing pages andkeeping information updated.

The Knowledge Annotator annotates onto-logical information in HTML pages. 4

Ontology Markup LanguageOML, developed at the University of

Washington, is partially based on SHOE. Infact, it was first considered an XML serial-ization of SHOE. Hence, OML and SHOEshare many features.

Four different levels of OML exist: OMLCore is related to logical aspects of the lan-guage and is included by the rest of the lay-ers; Simple OML maps directly to RDF(S);Abbreviated OML includes conceptual graphsfeatures; and Standard OML is the mostexpressive version of OML. We selected Sim-ple OML, because the higher layers don’t pro-vide more components than the ones identi-fied in our framework. These higher layersare tightly related to the representation of con-ceptual graphs.

There are no other tools for authoringOML ontologies other than existing general-purpose XML edition tools.

Resource Description Frameworkand RDF Schema

RDF, developed by the W3C for describingWeb resources, allows the specification of thesemantics of data based on XML in a stan-dardized, interoperable manner. It also providesmechanisms to explicitly represent services,processes, and business models, while allow-ing recognition of nonexplicit information.

The RDF data model is equivalent to thesemantic networks formalism. It consists ofthree object types: resources are describedby RDF expressions and are always namedby URIs plus optional anchor IDs; proper-ties define specific aspects, characteristics,attributes, or relations used to describe aresource; and statements assign a value for aproperty in a specific resource (this valuemight be another RDF statement).

The RDF data model does not providemechanisms for defining the relationshipsbetween properties (attributes) andresources—this is the role of RDFS. RDFSoffers primitives for defining knowledge

models that are closer to frame-basedapproaches. RDF(S) is widely used as a rep-resentation format in many tools and pro-jects, such as Amaya, Protégé, Mozilla,SilRI, and so on.

Ontology Interchange LanguageOIL, developed in the OntoKnowledge

project (www.ontoknowledge.org/OIL), per-mits semantic interoperability between Webresources. Its syntax and semantics are basedon existing proposals (OKBC, XOL, andRDF(S)), providing modeling primitivescommonly used in frame-based approachesto ontological engineering (concepts, tax-onomies of concepts, relations, and so on),and formal semantics and reasoning supportfound in description logic approaches (a sub-set of first order logic that maintains a highexpressive power, together with decidabilityand an efficient inference mechanism).

OIL, built on top of RDF(S) (see Figure1), has the following layers: Core OIL groupsthe OIL primitives that have a direct map-ping to RDF(S) primitives; Standard OIL isthe complete OIL model, using more primi-tives than the ones defined in RDF(S);Instance OIL adds instances of concepts androles to the previous model; and Heavy OILis the layer for future extensions of OIL.

OILEd, Protégé2000, and WebODE canbe used to author OIL ontologies. OIL’s syn-tax is not only expressed in XML but can alsobe presented in ASCII. We use ASCII for ourexamples.

DARPA Agent MarkupLanguage+OIL

DAML+OIL has been developed by ajoint committee from the US and the Euro-pean Union (IST) in the context of DAML, aDARPA project for allowing semantic inter-operability in XML. Hence, DAML+OILshares the same objective as OIL.

DAML+OIL is built on RDF(S). Its nameimplicitly suggests that there is a tight rela-tionship with OIL. It replaces the initial spec-ification, which was called DAML-ONT, andwas also based on the OIL language. OILEd,OntoEdit, Protégé2000, and WebODE aretools that can author DAML+OIL ontologies.

Comparison criteriaWe focus on the identifying components

that can be represented in each language andtheir meaning and which components can bespecified, because inference depends notonly on the language but also on the toolsthat are being currently developed around thelanguage (which is out of the scope of thispaper).10 We will use the same set of criteriato compare different ontology languages,based on different representation formalisms.

Ontology knowledge can be specifiedusing five components: concepts (which areusually organized by taxonomies), relations,functions, axioms, and instances.

ConceptsConcepts can be abstract or concrete, ele-

mentary or composite, real or fictitious; inshort, a concept can be anything about whichsomething is said, and, therefore, could alsobe the description of a task, function, action,strategy, reasoning process, and so on. Con-cepts are also known as classes (XOL,RDF(S), OIL, DAML+OIL), objects (OML)or categories (SHOE). When we evaluateconcepts, we consider several questions.

Is it possible to define partitions (sets ofdisjoint concepts)? This is an important fea-ture, especially for agents that reason withthe information in the ontology. They won’tallow an instance to be an instance of twoconcepts that belongs to a partition. Forexample, concepts Table and Chair candefine a partition in a furniture ontology.

Is it possible to define the documentation ofthe concept? This includes a natural languagedefinition for it. This is a desirable feature formaintenance and readability purposes.

Does the language provide mechanisms todefine concept attributes? Attributes are alsoknown as slots (XOL), functions (OML), orproperties (RDF(S) and DAML+OIL).Binary relations and roles (in SHOE andOIL) can be used to specify attributes. Thefollowing attributes have been identified:

• Instance attributes:Attributes whose valuemight be different for each instance of theconcept.

• Class attributes: Attributes whose value isattached to the concept, that is, its value willbe the same for all instances of the concept.

• Local attributes: Same-name attributesattached to different concepts. For exam-ple, concepts Chair and Table might havean attribute with name color withoutclashes.

JANUARY/FEBRUARY 2002 computer.org/intelligent 55

XOL SHOE OML

OIL DAML + OIL

RDF(S)

XML

Figure 1. The languages stack in theSemantic Web.

• Global attributes: Ones in which thedomain is not specified. They can beapplied to any concept in the ontology. Forexample, if we decide to create attributecolor as a global attribute, it will beapplied to all concepts in the ontology.

Instance and class attributes are commonlyused in concept descriptions. The need forlocal and global attributes will depend on theapplication’s representation needs.

Does the language provide the followingpredefined facets for attributes at a class?

• Default slot value (used to assign a valueto the attribute in case there is no explicitvalue defined for it)

• Type (used to constrain the type—alsocalled range—of the attribute)

• Cardinality constraints (used to constrainthe minimum and maximum number ofvalues)

• Slot documentation (includes a natural lan-guage definition for the attribute)

Constraints on the type of attributes and theircardinality are used to determine what typeof values an attribute might have and howmany values it can have when applied to aclass. For example, a Product has just oneprice (which is an integer value) and fromone to five colors represented by strings. Thedefault values are used in case we do not haveexplicit information about the value of a slot.For example, we can assume that the dis-count of a Product is 0 if it is not specified.

Taxonomies Taxonomies are used to organize ontolog-

ical knowledge using generalization and spe-cialization relationships through which sim-ple and multiple inheritance could beapplied. We analyze whether the followingprimitives are predefined in the languages:

• Subclass of (also called subsumption rela-tionship) specializes general concepts inmore specific concepts.

• Disjoint decomposition (a partition whereall its concepts are subclasses of a commonconcept) does not necessarily have to becomplete—that is, there might be instancesof this concept that are not included in anyof its subclasses. For example, the parti-tion composed of concepts Table and Chairis a disjoint decomposition of concept Fur-niture, and instances of concept Furniture

can exist that are not instances of conceptsTable or Chair (wardrobes are also piecesof furniture).

• Exhaustive subclass decomposition is acomplete disjoint decomposition—that is,any instance of the superclass conceptmust be an instance of any of the conceptsin the partition. For example, the partitioncomposed of concepts RISCMicroproces-sor and CISCMicroprocessor is an exhaus-tive subclass decomposition of the conceptMicroprocessor, as there is no instance ofconcept Microprocessor that is not aninstance of concept RISCMicroprocessoror concept CISCMicroprocessor.

• Not subclass of might be used to state thata concept is not a specialization of anotherconcept. This kind of knowledge is usu-ally represented using the denial of thesubclass of primitive.

Relations and functionsRelations are an interaction between con-

cepts of the domain and attributes. In fact,attributes can be used to define binary rela-tions in XOL, RDF(S) and DAML+OIL.Relations are called relations in SHOE andOML, and roles in OIL.

Functions are a special kind of relationwhere the value of the last argument is uniquefor a list of values of the n–1 preceding argu-ments. We ask the following questions:

• Is it possible to define arbitrary n-ary rela-tions or functions? If this is not possible,which is the maximum number of argu-ments? Examples of n-ary relations andfunctions can be, respectively, purchase (a

buyer purchases a product from a seller foran amount of money) and getTele-phoneNumber (given a name, surname, andaddress, the function will return the person’stelephone number).

• Might the type of arguments be con-strained? In the purchase relation justdescribed, the types of arguments are, Per-son, Product, and Number.

• Is it possible to define any kind of integrityconstraints to check the correctness of thearguments’ value? For example, definethat the price of a product for the purchaserelation must be positive, or that the prod-uct that is sold must have an attributecalled soldOut with value False.

• Is it possible to define operational defini-tions to infer values of arguments withprocedures, formulas, or rules, or to defineits semantic using axioms or rules? Forexample, let’s think of a function calledisUnderMinimumStock, applicable to aProduct and a Store, which returns True ifthe amount of the product’s pieces is undera minimum number, which is the value ofthe product’s attribute minimumStockPer-Store. There is a need for an operationaldefinition (a formula or rule) to obtain thefunction’s output value.

AxiomsAxioms model sentences that are always

true and can be used for several purposes,such as constraining information, verifyingcorrectness, or deducting new information.Axioms are also known as assertions (OML).Axioms are not widely used currently in thecontext of Semantic Web applications.

56 computer.org/intelligent IEEE INTELLIGENT SYSTEMS


Table 1. Definition of concepts (+ indicates a supported feature in the language; - indicates unsupported features, and +/- indicates features that need further

explanation).

Concepts XOL SHOE OML RDF(S) OIL DAML+OIL

General IssuesPartitions - - + - + +Documentation + + + + + +

AttributesInstance attributes + + + + + +Class attributes + - + - + +Local scope + + + + + +Global scope + - + + + +

FacetsDefault value + - - - - -Type constraints + + + + + +Cardinality constraints + - - - + +Documentation + + + + + +

The need for axioms is application-dependent. Although they are not currentlywidely used, they will become an importantfactor in Semantic Web applications, becausenew knowledge will be deducted when look-ing for information, inconsistencies will bedetected when processing millions of Webpages, and so on.

We focus on the following characteristics:

• Is it possible to build axioms in first-orderlogic? The order of a logic specifies whatentities ForAll and Exists might quantifyover. First-order logic can only quantifyover sets of atomic propositions (for exam-ple, ForAll p . p => p), while second-orderlogic can quantify over functions onpropositions (for example, ForAll f(p) .g(p) => h(p)).11

• Is it possible to build second-order logicaxioms?

• Can we define axioms as independent ele-ments in the ontology (independent axioms)?

• Can we embed axioms inside the defini-tion of other elements, such as relations,concepts, and so on?

InstancesInstances represent elements in the

domain attached to a specific concept. Factsrepresent a relation that holds between ele-ments, and claims represent assertions of afact made by an instance. All these terms areused to represent elements in the domain. Weasked the following questions:

• Is it possible to define instances of con-cepts? For example, Peter is an instanceof class Buyer.

• Is it possible to define instances of rela-tions (facts)? For example, “Peter buysComputer2.”

• Does the language provide special mech-anisms to define claims? For example,“John says that Peter has bought Com-puter2.”

We will describe information in distributedresources in the Semantic Web usinginstances of concepts and relations. Claimsare also important, because in the distributedenvironment of the Semantic Web, resourceswill be able to make whatever claims theywant. Agents shouldn’t interpret them asfacts of knowledge, but as claims being madeby a particular instance about itself or aboutother instances or data, which might proveto be inconsistent with others.4

Results for concepts Table 1 shows that partitions are only

definable in OML, OIL, and DAML+OIL.XOL does not allow defining partitions,because it uses a restricted knowledge modeltaken from OKBC (which does not supportpartitions). SHOE and RDF(S) do notinclude it as well.

Documentation is included as a feature inall languages. In SHOE, OML, RDF(S), andDAML+OIL we can find more types of doc-umentation that might be provided for a con-cept, such as short labels in all the languages(which are used to present the informationabout the concept’s name to an agent) orcomment, in RDF(S) and DAML+OIL.

Most languages distinguish betweeninstance and class attributes and specify localor global scopes for classes. XOL uses labelsown and template (the default is own) forexpressing class and instance attributes. Nei-ther SHOE nor RDF(S) distinguish instanceand class attributes, and it is not possible toestablish a fixed value for class attributes. InOML, there is no syntactic difference betweenboth kinds of attributes, but assertions can beadded to add a value to the class attributes andavoid instances filling them with different val-ues. The same applies to OIL, although thevalue is fixed using the has-filler primitive. Itis also necessary to fix the cardinality of theattribute to avoid instances adding more val-ues to the attribute. Finally, DAML+OILallows defining restrictions on attributes in asimilar way to OIL, although it is not neces-sary to fix its cardinality.

Local scope is achieved by restricting thedomain of the attributes to the specific con-cept where they can be applied (in OML, thisis implicit, as attributes are defined inside thedefinition of the class). An attribute withglobal scope might be represented in all lan-guages, except for SHOE, as an attribute orbinary relation where the domain is not spec-ified. In SHOE, you cannot define an attributeor relation without a domain. Hence, you mustdefine it for each concept in the top of all thetaxonomies of concepts, so that it is specifiedfor all concepts through inheritance.

Only XOL supports default values. InOIL, fillers could be used for representingdefault values, but you must be careful whenusing them, as their behavior is different fromthat of default values. If you create aninstance of a concept and assign a value toan attribute that had a default value, thedefault value disappears, whereas a valueincluded as a filler will not disappear as avalue for the attribute in the instance.

The type and documentation of attributescan be declared explicitly in all the lan-guages. Cardinality constraints cannot beestablished in SHOE, OML, or RDF(S).

Results for taxonomiesThere is just one primitive predefined in

all languages and correctly handled by them,subclass of. Related to the rest of the primi-tives for taxonomies, Table 2 shows that thefirst languages that were created did not takeinto account the suitability of partitions forrepresenting taxonomies. Hence, they didn’tinclude primitives to model them.

Table 2 shows the exhaustive subclassdecomposition (in OML, OIL, and DAML+OIL) of concept Book into its subclassesManual and GenericBook (see the “Experi-ment” sidebar also). OIL and DAML+OILprovide built-in primitives that allow defin-ing these kinds of decomposition. In OML,it is represented as a disjoint decomposition,and an additional assertion is needed to estab-lish its exhaustiveness. In the rest of the lan-guages (XOL, SHOE, and RDF(S)), we canonly represent the subclass-of relationshipbetween the concepts Manual and Book, andGenericBook and Book. There is a loss ofinformation that should be handled with carein case we choose any of them to representour ontologies.

OIL and DAML+OIL are the only lan-guages that allow representing not-subclass-of relationships.

Results for relations and functionsRelations and functions’ arity is the first

feature that we studied. Table 3 shows thatonly SHOE and OML include n-ary relations


Table 2. Definition of taxonomies (+ indicates a supported feature in the language; - for unsupported features, and +/- for features that need further explanation).

Taxonomies XOL SHOE OML RDF(S) OIL DAML+OIL

Subclass of + + + + + +Exhaustive decompositions - - +/- - + +Disjoint decompositions - - + - + +Not subclass of - - - - + +

and functions as built-in primitives in the lan-guage. The rest of the languages do not pro-vide primitives for declaring them: they justprovide built-in primitives for binary rela-tions, which correspond to the attributes forthe concepts in the ontology. Hence, n-aryrelations must be specified by means of con-cepts whose attributes correspond to thearguments of the relation.

Type constraints can be defined for argu-ments in all the languages. More general con-straints (integrity constraints) cannot bedefined, except for OML, which lets usdefine general axioms that can be applied tothese arguments. OIL and DAML+OIL alsoprovide some rich methods for establishingconstraints on arguments, such as qualifiedconstraints (for example, cardinality con-straints that are only applied when the rangeof the relation belongs to a specific class).

Finally, operational definitions cannot bedefined for relations and functions in any lan-guage. Other means of representing themshould be used that are out of the scope ofthese ontology specification languages.

Results for axiomsTable 4 shows that we were just able to

represent all the axioms of the ontology in

OML. We could also represent the deductiveaxiom in SHOE, using a SHOE inferencerule, as these rules allow the deduction of val-ues for attributes.

Although they are not considered in ourframework, we must comment that OIL andDAML+OIL allow defining axioms aboutalgebraic properties of relations (symmetry,transitivity, and so on). Studies on semanticpatterns are also available that present a wayto include these types of axioms for RDF(S).

Results for instancesTable 5 shows that instances and facts are

easily represented in all the languages. Thisis not the case of claims, which are just pro-vided as built-in primitives in SHOE, byincluding definitions inside an instance def-inition (this means that the definitions areclaims of the instance in which they areembedded). Claims are not predefined inRDF(S), OIL, or DAML+OIL, but theirspecifications show how claims could bedefined using the language constructs.Additionally, any agent collecting infor-mation from a resource on the Web couldconsider this information as a claim madeby the resource in which the information ispresented.

We have considered representationand information exchange needs

and the current advantages and limitations ofeach existing language. Representationalneeds vary depending on the use of ontolo-gies in applications. The terms lightweightand heavyweight refer to two different kindsof ontologies: those ontologies where con-cepts (described by their attributes and areorganized in taxonomies using only the sub-class-of relationship), relations and func-tions, and possibly instances are the onlycomponents that are represented, and thoseontologies that also contain axioms.

If we could measure the expressiveness oflanguages from languages that allow defininglightweight ontologies to languages thatallow heavyweight ontologies, the orderwould be: XOL, RDF(S), SHOE, OML,OIL, and DAML+OIL.

If you need to define a lightweight ontol-ogy for your application (you are just wor-ried about describing concepts and organiz-ing them in taxonomies), you can use any ofthe languages we presented in this article.You can decide which language to use byconsidering existing tools for editing ontolo-gies in it, available software that handles thelanguage (APIs, inference engines, and soon), familiarity with the representation for-malism (XOL and SHOE use frames, whichmight be easier to use than semantic net-works (RDF(S)), conceptual graphs (OML),or description logic (OIL and DAML+OIL)),and so on.

In defining heavyweight ontologies, youmust carefully select the language—a wrongselection could prevent the success of yourapplication. We recommend starting with ourframework to determine your representationneeds. Once the tables have been filled withthis information, you can compare them withthe ones provided in this article, so you candrop languages without enough expressive-ness capabilities for your application.

The second step should be based on the rea-soning support needed for the application.XOL and OML have no reasoning supportavailable, while inference engines for RDF(S),SHOE, OIL, and DAML+OIL exist. In thiscase, you should consider what kind of rea-soning you need. Query services have beencreated for RDF(S), SHOE, and DAML+OIL.OIL and DAML+OIL also provide automaticclassifications for detecting inconsistencies inthe ontology and organizing concepts in thetaxonomy.

If you still have several candidate lan-



Table 5. Definition of instances (+ indicates a supported feature in the language; - indicates unsupported features, and +/- indicates features that need further

explanation).

Instances XOL SHOE OML RDF(S) OIL DAML+OIL

Instances of concepts + + + + + +Facts + + + + + +Claims - + - +/- +/- +/-

Table 4. Definition of axioms (+ indicates a supported feature in the language; - indicates unsupported features, and +/- indicates features that need further

explanation).

Axioms XOL SHOE OML RDF(S) OIL DAML+OIL

First-order logic - +/- + - +/- +/-Second-order logic - - - - - -Independent axioms - - - - - -Embedded axioms - - + - - -

Table 3. Definition of relations and functions (+ indicates a supported feature in thelanguage; - indicates unsupported features, and +/- indicates features that need

further explanation).

Relations and functions XOL SHOE OML RDF(S) OIL DAML+OIL

n-ary relations/functions +/- + + +/- +/- +/-Type constraints + + + + + +Integrity constraints - - + - - -Operational definitions - - - - - -

guages, your decision should be based onexisting tools for creating ontologies andannotating resources (creating instances andfacts). OIL and DAML+OIL are supportedby a wide range of ontology developmenttools (such as OILEd, OntoEdit (onlyDAML+OIL), Protégé and WebODE).RDF(S) is not supported by any of theseontology tools, but by more general tools formetadata generation. There are also annota-tors for RDF(S), which can be also used for

OIL and DAML+OIL, as instances arestored as RDF instances. The SHOE knowl-edge annotator allows annotating Web pageswith SHOE, but no ontology editor is avail-able for building ontologies. Finally, the restof the languages are not supported by anyspecific tool.

This roadmap has been successfully used inthe selection of a language for the specificationof ontologies in the IST project MKBEEM (seethe “Experiment” sidebar).

AcknowledgmentsThis work is supported by the CICYT project

“Metodología para la Gestión de Conocimiento,” ref-erence TIC-980741, by the IST project MKBEEM(1999-10589) and by a FPI grant, funded by UPM.

This article would not be possible without com-ments and feedback from developers and users ofa wide range of ontology specification languages,who verified our tables: V.K. Chaudhri (XOL), JeffHefflin (SHOE), Ian Horrocks (OIL), StefanDecker (FLogic), Belén Díaz (LOOM), YolandaGil (LOOM), Enrico Motta (OCML), James Rice(Ontolingua and OKBC), and Tom Russ (LOOM).


We used a set of ontologies as a test set to choose the mostsuitable language during the first phase of the European Infor-mation Society Technologies project Multilingual Knowledge-Based European Electronic Marketplace. The tests implementedthe ontologies in all the languages, analyzed the informationthat could be represented, and obtained guidelines on how toimplement different kinds of information in all of them. Theimplemented codes of this ontology can be downloaded athttp://delicias.dia.fi.upm.es/RoadMap/ontologies.html.

The taxonomy of concepts, their attributes (Instance attri-butes are preceded by * and class attributes are not precededby any sign), and the ad-hoc relations are presented graphically(in a frame-based fashion) in Figure A.

Our aim was to build a general ontology about office mater-ial—desks, computers, and books were included, among otherproducts. Computers and books are more specialized, so thereis a disjoint decomposition of computers into Unix servers andPCs, and an exhaustive decomposition of books into manualsand generic books (although representing generic concepts isnot a good practice in ontology modeling). We have createdthis concept for the sake of having an exhaustive partition, sothere are only manuals or generic books. Several attributes

have been defined for concepts in the ontology: price inOfficeMaterial can have at most one value (and by default 0);platform in UnixServer and PC has value UNIX and PC; type inManual, and theme in GenericBook. All concepts in the ontol-ogy have an attribute called name considered as an attributewith global scope.

There are three ad-hoc relationships: hasManual from Com-puter to Manual; purchases, between Buyer, Seller and Office-Furniture, and isRecommended, from Book to Buyer.

We have also defined instances for some concepts. John andPeter, as instances of Buyer and Seller, UnixV5 as an instance ofManual, UnixForDummies as an instance of GenericBook, andfacts between instances, such as John purchases the manualUnixV5 from Peter.

Finally, we have included several axioms expressing constraintsin our e-commerce platform. For example, “a computer that isa Unix Server has a manual that is of type Unix”, and “when aperson purchases a Unix Server, he/she must also purchase amanual of type Unix.” There is also one axiom included fordeductive purposes: “if a person buys a manual of type Unix,he or she must be recommended other generic books withtheme computers.”

Experiment: An Ontology for an E-Commerce Platform

sc sc sc

Is Recommended

sc sc

Has Manual

sc sc

purchases

Disjoint Exhaustive

OfficeMaterial Seller

(*)price:[0]

Desk Computer

Computer

Book

Unix Server

platform: Unix platform: PC

GenericBookManual

(*)type (*)theme

Buyer

Figure A. Part of one of the sample ontologies that have been implemented in all the languages.

References

1. T. Berners-Lee and M. Fischetti, Weaving theWeb: The Original Design and Ultimate Des-tiny of the World Wide Web by its Inventor,Harper, San Francisco, 1999.

2. R. Studer, R. Benjamins, and D. Fensel,“Knowledge Engineering: Principles and Meth-ods,” IEEE Trans. on Data and KnowledgeEng., vol. 25, nos. 1–2, 1998, pp. 161–197.

3. R. Karp, V. Chaudhri, and J. Thomere, “XOL:An XML-Based Ontology Exchange Language(version 0.4),” Aug. 1999, www.ai.sri.com/~pkarp/xol (current Jan. 2002).

4. S. Luke and J. Heflin, SHOE 1.01 ProposedSpecification, SHOE Project, Feb. 2000.www.cs.umd.edu/projects/plus/SHOE/spec1.01.htm (current Jan. 2002).

5. R. Kent, Conceptual Knowledge Markup Lan-guage (version 0.2). 1998. www.ontologos.org/CKML/CKML%200.2.html (current Jan.2002).

6. O. Lassila and R. Webick, “Resource Descrip-tion Framework (RDF) Model and SyntaxSpecification.” W3C Recommendation, Jan.

1999, www.w3.org/TR/PR-rdf-syntax (currentJan. 2002).

7. D. Brickley and R.V. Guha, “ResourceDescription Framework (RDF) Schema Spec-ification,” W3C Proposed Recommendation,Mar. 1999, www.w3.org/TR/PR-rdf-schema(current Jan. 2002).

8. I. Horrocks et al., “OIL in a Nutshell,” Proc.ECAI ’00 Workshop on Application of Ontolo-gies and PSMs, Berlin, Germany, 2000, pp.4.1–4.12.

9. I. Horrocks and F. van Harmelen, ReferenceDescription of the DAML+OIL OntologyMarkup Language, draft report, 2001,www.daml.org/2000/12/reference.html (cur-rent Jan. 2002).

10. O. Corcho and A. Gómez-Pérez, “A Roadmapto Ontology Specification Languages,” 12thInt’l Conf. Knowledge Eng. and KnowledgeManagement, Lecture Notes in ArtificialIntelligence, Springer-Verlag, Berlin, Oct.2000, pp. 80–96.

11. J. Barwise, “An Introduction to First-OrderLogic,” Handbook of Mathematical Logic, J.Barwise, Amsterdam, 1977, pp. 5–46.


I n t e l l i g e n t W e b S e r v i c e s

T h e A u t h o r sAsunción Gómez-Pérez is an associate professor in the Computer ScienceSchool at Universidad Politécnica de Madrid, Spain. Her research interestsinclude theoretical ontological foundations, methodologies for building andmerging ontologies, ontological reengineering, uses of ontologies in appli-cations related with e-commerce and knowledge management, and theSemantic Web. She received a BA in computer science, an MSc in knowledgeengineering, and a PhD in computer sciences from the Universidad Politéc-nica de Madrid, Spain. She also received an MSc in business administrationfrom the Universidad Pontificia de Comillas, Spain. Asunción is author ofOntological Engineering and is chairing the EKAW-2002 conference. Con-tact her at Facultad de Informática, Universidad Politécnica de Madrid, Cam-pus de Montegancedo s/n, Boadilla del Monte, 28660, Madrid, Spain;[email protected].

Oscar Corcho is an invited professor at the Universidad Pontificia de Sala-manca. His research interests include ontology languages, the ontology trans-lation problem, and the Semantic Web. He received his BA in computer sci-ence and his MSc in Software Engineering from the Polytechnic Universityof Madrid, and is a PhD student in Artificial Intelligence there. He belongsto the Ontology Group of the Artificial Intelligence Laboratory at the Com-puter Science School. Contact him at Facultad de Informática, UniversidadPolitécnica de Madrid, Campus de Montegancedo s/n, Boadilla del Monte,28660, Madrid, Spain; [email protected].

RELAUNCHED IN

JANUARY 2002!

Distributed Systems Onlinewill supplement the coverage

in IEEE Internet Computingand IEEE Pervasive Computing.

Each monthly issue will includelinks to magazine content andissue addenda such as source

code, tutorial examples,and virtual tours.

To keep up with all that’s happeningin distributed systems, check out

To get regular updates, [email protected]

IEEE Distributed Systems Onlinebrings you peer-reviewed

features, tutorials,and expert-moderated pagescovering a growing spectrumof important topics, including

❐ Dependable Systems

❐ Mobile and Wireless

❐ Distributed Agents

❐ Security

❐ Middleware❐ and more!

DS Online will feature a newdesign, and it will continue toprovide news, research from thetrenches, book reviews, and more.

dsonline.computer.org

ontology languages for the semantic web

Documents