OIL is fundamentally frame based, partly for reasons of upward compatibility with XOL (as discussed before), and partly because frame-based modeling is very intuitive for many users. Moreover, DL approaches can be seen as an extension and generalization of the frame idea, with frames being closely related to DL concepts and slots being very closely related to DL roles. The main differences stem from the fact that frames generally provide quite a rich set of primitives, but impose very restrictive syntactic constraints on how primitives can be combined and on how they can be used to define a class. DLs on the other hand generally have a more restricted set of primitives (they are constrained by requirements for clear semantics, decidability and the provision of practical reasoning procedures), but allow primitives to be combined in arbitrary boolean expression and used to define different kinds of class (in particular primitive classes, where the definition is taken to be a necessary condition for membership of the class, and non-primitive classes, where the definition is taken to be both a necessary and sufficient condition for membership of the class).

A central difference between frame-based approaches and approaches based on Description Logics are that the former rely solely on explicit statements of class-subsumption, whereas the latter are able to efficiently compute the subsumption relationship between classes on the basis of the intensional definition of these classes. Other relations between classes such as disjointness, consistency etc., can all be expressed in terms of the same subsumption relationship. The ability to automatically compute these relations is important for verification of ontologies. This may be less important with small local ontologies that are probably designed by one expert person. However, our intention is to exchange, share, reuse and merge ontologies. In such a case, reasoning support can be very valuable tool. This has been demonstrated even for database schema integration, which should be much easier than integrating ontologies.

It is the frame structure itself that restricts the way language primitives can be combined to define a class. In XOL, class definitions consist of the specification of zero or more parent classes (from which characteristics are inherited) and zero or more slots--binary relations whose characteristics can be additionally restricted using slot facets (e.g., the range of the relation can be restricted using the value-type facet). Viewed from a logical perspective, each slot (with its associated facets) defines a class (e.g., a slot eats with the value-type junk-food defines the class of individuals who eat nothing but junk food), and the frame is implicitly 1 the class formed from the conjunction of all the slots and all the parent classes. Consequently, each class must be defined by a conjunction of slots (which themselves have a very restricted form) and other named classes. In contrast, DLs usually allow language primitives to be combined in arbitrary boolean expressions (i.e., using conjunction, disjunction and negation), as well as allowing class definitions to be used recursively wherever a class name might appear. Moreover, XOL only provides one form of class definition statement. It is not clear whether the resulting class is meant to be primitive or non-primitive: we will assume that it is primitive. 2

In our opinion, this very restricted form of class definition makes XOL (and indeed OKBC) unsuitable as a standard ontology language: it makes it impossible to capture even quite basic DL ontologies and precludes some very simple and intuitive kinds of class definition. For example, it is impossible to define the class of vegetarian as the subclass of person such that everything they eat is neither meat nor fish. On the one hand, the value of the value-type facet of the slot eats cannot be an expression such as "not (meat or fish)". On the other hand, because vegetarian must be primitive, there could be individuals of type person who eat neither meat nor fish but who are not classified as vegetarians. 3 Another serious weakness of XOL class definitions (and those of OKBC) is that there is no mechanism for specifying disjointness of classes, a basic modeling primitive that can be captured even by many conceptual modeling formalisms used for database schema design. 4 This makes it impossible to capture the fact that the class male is disjoint from the class female. This is easy for a DL, where the class female can simply be made a subclass of "not male".

Another weakness of XOL (and OKBC) is that slots (relations) are very much second class citizens when compared to classes. In particular, there is no support for a slot hierarchy and only restricted kinds of properties that can be specified for relations. For example, it is not possible to define the slot has-parent as a subslot of the has-ancestor, nor is it possible to specify that has-ancestor is a transitive relation. The specification of this kind of slot hierarchy including transitive and non-transitive relations is essential in ontologies dealing with complex physically composed domains such as human anatomy [Rector et al., 1997] and engineering [Sattler, 1995] .

Finally, the semantics of OKBC (on which XOL relies) are relatively informally specified, and have idiosyncrasies that are difficult to either formalize or justify.

In OIL we propose to solve these problems by providing the language with a well defined semantics and by extending XOL in the following ways.

As mentioned above, OIL also restricts XOL in some respects.

XML can be used as a serial syntax for OIL. Such a syntax is very useful because it puts OIL in the mainstream of tools that are currently being developed for supporting XML-based documents. Validation and rendering techniques developed for XML can directly be used for ontologies specified in OIL. Therefore, the appendix of this paper provides the definition of a DTD that defines constraints on valid documents in OIL.

Meanwhile a successor of DTDs called XML schemas have been published as a proposal by the W3C (cf. [Biron & Malhotra, 1999] , [Thompson et al., 1999] , [Walsh, 1999] ). The main improvements of XML schemas compared to DTDs are:

Therefore, it was natural to also define the XML syntax of OIL by using the XML schema mechanism (see the appendix). 5 However, a more significant question is whether XML schemas also allow the capturing of some of the semantics of ontologies specified in OIL. Central to an ontology is the is-a relationship, and XML schemas incorporate the notion of inheritance. In addition to the direct XML schema syntax of OIL we provide in the appendix, we discuss in [Klein et al., 2000] a more complex translation procedure that leads to XML documents capturing more aspects of the semantics of an ontology in OIL. This includes the use of type refinement as present in XML schemas to model the subsumption relationship between concepts in OIL.

The Resource Description Framework (RDF) [Lassila & Swick,1999] is a recommendation of the World Wide Web Consortium (W3C) for representing meta-data in the web. RDF data represents resources and attached attribute/value pairs. A resource represents anything representable through a URI. Attributes are named properties of the resources, and their values are either atomic entities (text strings, numbers, etc.) or other resources represented by a URI. The resources, properties, and values build up the RDF data model that can be seen as a labeled directed graphs.

Besides defining the data model, RDF needs a serialization syntax to make actual data available in the web. XML was chosen for this purpose. RDF and XML are complementary as RDF represents the abstract model and XML provides the concrete textual representation of the model. There are several ways to represent the same RDF data model in XML.

A third component in the RDF-context has to be introduced: since RDF does not define any particular vocabularies for authoring data, a schema language with appropriate primitives is needed. The RDF-schema specification was created for this purpose. RDF-schema is a simple ontology language able to define basic vocabularies. This language covers the simplest parts of a knowledge model like OKBC (classes, properties, domain and range restrictions, instance-of, subclass-of and subproperty-of relationships). RDF-Schema is itself defined in RDF, and an RDF-schema defining the RDF-schema language itself is also available [Brickley & Guha, 2000] .

The relationship between OIL and RDF/RDFS is much closer than that between OIL and XML Schemas. This is not surprising, since XML-schema was meant to generalize the way of defining the structure of valid XML-documents and RDF/RDFS was meant to capture meaning in the manner of semantic nets. In the same way as RDF-Schema is used to define itself it can also be used to define other ontology languages. We have therefore defined a syntax for OIL by giving an RDF-schema for the core of OIL, and proposing related RDF-schemas that could complement this core by covering further aspects. To ensure maximal compatibility with existing RDF/RDFS-applications and vocabularies, the integration of OIL with the resources defined in RDF-schema has been a main focus in designing the RDF-model for OIL.

The "Appendix B: OIL Syntax in RDF" provides the RDF-Schema specification of OIL. In [Broekstra et al., to appear] the relation between OIL and RDF is examined in more detail.