Simple OML Ontology

Reminder: Because MS-Word 2000 is being used to generate these web pages, it is highly recommended that you use Microsoft Internet Explorer version 5.0 when viewing this site.


OML ontologies represent sets (containers) of types. OML collections represents sets (containers) of entities (of all types). So it is natural to define a collection type named Ontology, and to specify ontologies as instances of the Ontology type. The OML ontology defines this type amongst others, allowing for the specification of arbitrary ontologies as instances. In other words, OML has ontology objects! By using nested collections, one can specify collections of ontologies.

Now, OML is a two-tiered framework using both types and instances. Alternate names for type are category and class. Instances are called tokens in the theory of Information Flow. Types and instances in OML can be either binary relations or functions, objects or relations or data values, collections or constants. Since ontologies are used as containers of types and collections are used as containers of instances, ontology instances are syntactically not quite the same as ontologies. However, from a semantical point-of-view they are equivalent. We provide several illustrious examples for comparison.

As for all other types of OML objects, ontologies are specified in terms of a serialization, which can be interchanged in the distributed setting of the internet. The semantics of the OML ontology is specified by the OML basic model.

Simple OML Ontology

The listing below gives the serialization of the Simple OML basic ontology.


  <Ontology id=“OML” version=“0.3”>


      This is the basic (root) ontology for the core part of OML, the

      Ontology Markup Language. This specification contains only the limited

      axiomatization of the sequents of Information Flow. For an example of

      a fuller axiomatization of core OML, see the OML Axiomatics.



    /* object types */


    <Type.Object name=“Thing”/>

    <Type.Object name=“Type”/>

    <Type.Object name=“Type.Entity”/>

    <Type.Object name=“Type.Object”>


        This is the generic concept of a type of objects. When an ontology

        defines a new object type, the object representing that object type

        must be declared as an instance of this meta-object type. Meta-object

        types such as this can also be identified with the least common

        supertype of its meta-extent.

        /* much like a generator a of an order ideal a¯ */



    <Type.Object name=“Type.Data”/>

    <Type.Object name=“Type.BinaryRelation”/>

    <Type.Object name=“Type.Function”/>

    <Type.Object name=“Instance”/>

    <Type.Object name=“Instance.BinaryRelation”/>

    <Type.Object name=“Instance.Function”/>

    <Type.Object name=“Instance.Entity”/>

    <Type.Object name=“Instance.Object”/>

    <Type.Object name=“Instance.Data”>

      <comment>The same as a data value or a literal.</comment>



    /* data types */


    <Type.Data name=“String”/>

    <Type.Data name=“Boolean”>

      <value name=“true”/>

      <value name=“false”/>


    <Type.Data name=“Integer”/>

    <Type.Data name=“Real”/>

    <Type.Data name=“DateTime”/>


    /* binary relation types */


    <Type.BinaryRelation name=“classification.BinaryRelation”



    <Type.BinaryRelation name=“classification.Entity”




        This indicates that an entity is a member of an entity type, and thus

        has all of the properties of that type. It is a binary relation

        between entity instances and entity types that is closed on the     

        right: If entity x is an instance of type A and A is a subtype of  

        type B, then entity x is also an instance of type B.



    <Type.BinaryRelation name=“classification.Object”



    <Type.BinaryRelation name=“subtype.BinaryRelation”



    <Type.BinaryRelation name=“subtype.Entity”




        The subtype binary relation between entity types. It is a reflexive,

        transitive binary relation between categories. It is not necessarily

        antisymmetric because of synonymy.



    <Type.BinaryRelation name=“comment”




        The comment binary relation between things and strings.




    /* function types */


    <Type.Function name=“source.Type”



        <comment>Specifies the source type of a binary relation.</comment>


    <Type.Function name=“target.Type”



      <comment>Specifies the target type of a binary relation.</comment>


    <Type.Function name=“source.Instance”



    <Type.Function name=“target.Instance”



    <Type.Function name=“name”



      <comment>Specifies the ontological name of a type.</comment>


    <Type.Function name=“id”



      <comment>Specifies the ontological name of an instance.</comment>



    /* sequents */


    <subtype.Entity specific=“Type” generic=“Thing”/>

    <subtype.Entity specific=“Type.BinaryRelation” generic=“Type”/>

    <subtype.Entity specific=“Type.Function” generic=“Type.BinaryRelation”/>

    <subtype.Entity specific=“Type.Entity” generic=“Type”/>

    <subtype.Entity specific=“Type.Object” generic=“Type.Entity”/>

    <subtype.Entity specific=“Type.Data” generic=“Type.Entity”/>

    <subtype.Entity specific=“Instance” generic=“Thing”/>

    <subtype.Entity specific=“Instance.BinaryRelation” generic=“Instance”/>


      specific=“Instance.Function” generic=“Instance.BinaryRelation”/>

    <subtype.Entity specific=“Instance.Entity” generic=“Instance”/>

    <subtype.Entity specific=“Instance.Object” generic=“Instance.Entity”/>

    <subtype.Entity specific=“Instance.Data” generic=“Instance.Entity”/>


      specific=“classification.BinaryRelation” generic=“classification”/>


      specific=“classification.Entity” generic=“classification”/>


      specific=“classification.Object” generic=“classification.Entity”/>


      specific=“subtype.BinaryRelation” generic=“subtype”/>


      specific=“subtype.Entity” generic=“subtype”/>






Please send questions, comments and suggestions about this page to: Robert E. Kent

Copyright © 1999 TOC (The Ontology Consortium). All rights reserved.