The first purpose of UMBEL is to provide a general vocabulary (the UMBEL Vocabulary) of classes and predicates for describing domain ontologies, with the specific aim of promoting interoperability with external datasets and domains. This document provides the specifications for this UMBEL Vocabulary.
The UMBEL Vocabulary defines three classes:
Qualifier; and 38 properties:
relatesToXXX (31 variants),
isCharacteristicOf. In addition, UMBEL re-uses certain properties from external vocabularies. These classes and properties are used to instantiate the UMBEL Reference Concept ontology (see the UMBEL Specification), and to link Reference Concepts to external ontology classes. Below we describe each of these classes and properties.
- 1 Namespaces
- 2 Classes
- 3 Properties
- 4 Incorporation of External Properties
- 5 Linking to Instances and Named Entities
- 6 ENDNOTES
Here are the URIs of the namespaces used to describe the UMBEL Vocabulary, the Reference Concepts ontology, the named entities defined in UMBEL and the
SuperTypes for both the Reference Concept classes and named entities.
The folder structure of these classes of URIs has been generalized to meet the design goals of using UMBEL with domain extensions. The portion "/umbel/" in the URIs is a placeholder for the name of these extensions. Each extension, including UMBEL itself, will share the same identification structure. An example for a ‘Foo’ domain ontology at an alternative example.com domain using the "/foo/" folder extension is shown in the table below.
The UMBEL Vocabulary URI uses a "hash URI" for convenience purposes. This facilitates the retrieval of the document of the descriptions of the vocabulary for tools that consume such documents. However considering the size of the reference concepts descriptions files and related named entities files, we choose to use "slash URIs" so that consumer tools do not have to download the description of everything when they only want descriptions of one of these resources.
FOO Ontology (a domain ontology based on UMBEL)
The UMBEL vocabulary contains three classes,
Here are the specifications for the three UMBEL classes in the vocabulary.
|Description|| Reference Concepts are a distinct subset of the more broadly understood concept such as used in the SKOS RDFS controlled vocabulary or formal concept analysis or the very general or abstract concepts common to some upper ontologies.
Reference Concepts are selected for their use as concrete, subject-related or commonly used notions for describing tangible ideas and referents in human experience and language. Reference Concepts are classes, the members of which are nameable instances or named entities, which by definition are held as distinct from these concepts. The UMBEL ontology is a coherently organized structure (or reference "backbone") of these Reference Concepts.
|In-domain-of||umbel:isRelatedTo, skos:prefLabel, skos:altLabel, skos:hiddenLabel, skos:definition|
|Description||SuperTypes are a collection of (mostly) similar Reference Concepts. Most of the SuperType classes have been designed to be (mostly) disjoint from the other SuperType classes. SuperTypes thus provide a higher-level of clustering and organization of Reference Concepts for use in user interfaces and for reasoning purposes.|
|| skos:prefLabel, skos:altLabel, skos:hiddenLabel, skos:definition|
|Description||The Qualifier class is a set of descriptions that indicate the method used in order to establish an isAbout or correspondsTo relationship between an UMBEL reference concept (RC) and an external entity. This description should be complete enough to aid understanding of the nature and reliability of the "aboutness" assertion and to be usable for filtering or user interface information. The descriptions may be literal strings or may refer to literal numeric values resulting from an automated alignment technique.|
The UMBEL predicates, and those used from external vocabularies, provide the mapping basis for the vocabulary. Predicates (properties) are provided for all structural combinations of classes, individuals and properties.
Use of Inverse Properties
Ontologies based on the UMBEL vocabulary have the purpose of being available for context reference by external Web data. In this regard, ontologies based on the UMBEL vocabulary are largely passive. Other external systems generally refer to them, rather than embedding those mappings within the UMBEL-based ontology (though that design is legal, as well).
However, mapping may be done either from the perspective of the local domain ontology based on the UMBEL vocabulary or from the perspective of an external ontology aligning to an UMBEL-based reference ontology. In the latter case, a tagger might be run so as to map to the reference ontology.
Attention has thus been given within the UMBEL vocabulary to provide appropriate inverse properties. These inverse properties of
isCharacteristicOf, in combination with the OWL equivalency predicates of
equivalentClass, provide the mechanisms whereby external references can be traced back from UMBEL to find additional corresponding external data.
These capabilities are readily demonstrated via some of the UMBEL Web services (including taggers) discussed in Annex E: Using UMBEL.
Figure 1 below describes the available object properties within the UMBEL vocabulary (maroon color) and those re-used from external ontologies (blue color) for mapping and structural relations. Also shown is the twin views of UMBEL concepts as both classes (
RefConcept) and individuals, achieved via 'punning' in OWL 2 (c.f., OWL 2 and Metamodeling).
The figure is presented as a quadrant. On the left-hand side (quadrants A and C) is the "class" view of the structure; the right-hand side is the "individual" (or instance) view of the structure (quadrants B and D). These two views represent alternative perspectives for looking at the UMBEL reference concepts based on metamodeling.
The top side of the diagram (quadrants A and B) is an internal view of UMBEL reference concepts (
RefConcept) and their predicates (properties). This internal view applies to the UMBEL Reference Concept ontology or to domain ontologies based on the UMBEL Vocabulary. These relationships show how
RefConcepts are clustered into
SuperTypes or how hierarchical relationships are established between Reference Concepts (via the
skos:broaderTransitive relations). The concept relationships and their structure is a "class" view (quadrant A); treating these concepts as instances in their own right and relating them to SKOS is provided by the right-hand "individual" (instance) view (quadrant B).
The bottom of the diagram (quadrants C and D) shows either classes or individuals in external ontologies. The key mapping predicates cross this boundary (the broad dotted line) between UMBEL-based ontologies and external ontologies:
UMBEL "Class" View
This view is quadrant A in the above diagram.
In this view, the reference concepts and their relationships are treated entirely in a class manner. Given reference concepts may be related to one another in
subClass relationships, or multiples of them may be clustered into
superTypes, the relationships between which may be established as
disjoint (or not).
The class view provides the major reasoning structure for the ontology, and corresponds (mostly) to what is known as the TBox (terminological box) in description logics.
UMBEL "Individual" View
This view is quadrant B in the above diagram.
The individual (or instance) view parallels all of the reference concepts, only portrays the relationships as instances, not classes. An instance view allows mapping to the SKOS conceptual structure, provides a more flexible means for describing relationships, and is the preferred way to relate the subject matter of external content to the reference vocabulary. The individual view also provides good hooks for relating the attributes of external datasets to their governing concepts in the vocabulary.
The "Punning" Relationship
In OWL 2, these dual views as either instances (individuals) (quadrant B) or classes (quadrant A) occur via a metamodeling technique called "punning". When a given concept is used in both an instance and class mode, the object is "punned" as both a class and instance. Both views of the concept share the same URI. Then, based on use context, the object is treated either as an individual or a class.
This "punning" relationship is shown by the maroon dotted lines in Figure 1. Generally, each reference concept is punned in this dual manner.
Though the object shares the URI, for reasoning and consistency purposes the object is actually treated as two different things (class or individual) depending on usage and context. It is this trick that enables
RefConcepts to both model structural relationships and provide instance hooks to external vocabularies in OWL 2 while being decidable via description logics and reasoners.
External "Class" View
The external class view is shown by quadrant C in the above diagram. It represents a "standard" mapping where an exact assertion of the mapped relationship between internal (UMBEL vocabulary) and external classes can be made.
The two possible mapping predicates are
External "Individual" and Properties View
The major uses of the reference vocabularies are reflected in the quadrant D mappings in the above diagram.
In most uses, the most prevalent property to be used is the
umbel:isAbout assertion. This predicate is useful when tagging external content with metadata for alignment with an UMBEL-based reference ontology. The reciprocal assertion,
umbel:isRelatedTo is when an assertion within an UMBEL vocabulary is desired to an external ontology. Its application is where the reference vocabulary itself needs to refer to an external topic or concept.
For the approximate mapping relations there is also the optional
umbel:hasMapping property to describe the "degree" of the assertion. (This degree could be quantified, such as from some analytical technique, or use textual qualifiers.)
umbel:hasMapping may be reified for the
umbel:isLike properties (#1 in the diagram) assertion, or the
umbel:relatesToXXX predicates (#2 in the diagram, and the LINKING AND MAPPING PREDICATES section below).
Two annotation properties are used to describe the attribute characteristics of a
umbel:hasCharacteristic and its reciprocal,
umbel:isCharacteristicOf. These properties are the means by which the external properties to describe things are able to be brought in and used as lookup references (that is, metadata) to external data attributes. As annotation properties, they have weak semantics and are used for accounting as opposed to reasoning purposes.
Metadata or descriptive characteristics of external concepts could also be related using the
umbel:isAbout relationship, which is legal given the domain and range definitions of the
However, where you want to clearly relate to datasets and data attributes, the
umbel:hasCharacteristic property provides a means for such refined distinctions, which can be quite helpful when feeding widgets or data displays with metadata not explicit modeled in the domain ontology.
In all cases, the linkage from either external classes or instances occur via the "punned" individual in UMBEL. If the external object is a class, it is therefore punned within the system (shown as the dual color bubble).
More discussion and use guidance (#2 in the Figure 1 diagram, including for the
umbel:relatesToXXX predicates) are provided under the LINKING AND MAPPING PREDICATES section below.
Here are the specifications for the UMBEL properties in the vocabulary. Most properties have a status of 'Testing'.
|Description|| The property umbel:correspondsTo is used to assert a close correspondence between an external class, named entity, individual or instance with a Reference Concept class. umbel:correspondsTo relates the external class, named entity, individual or instance to the class through the basis of both its subject matter and intended scope. This predicate should be used where the correspondence between the two entities is felt to be nearly equivalent to a sameAs assertion, and is reflexive, but without the full entailments of intensional class memberships. In these cases, both entities are understood to have the same type and intended scope, but without asserting a full class-level or sameAs individual relationship.
This predicate is designed for the circumstance of aligning two different ontologies or knowledge bases based on node-level correspondences, but without entailing the actual ontological relationships and structure of the object source. For example, the umbel:correspondsTo predicate is used to assert close correspondence between UMBEL Reference Concepts and Wikipedia categories or pages, yet without entailing the actual Wikipedia category structure.
This property asserts a different and stronger relationship than umbel:isAbout. One practical use is to guide specific instance member determinations when, say, the native structure of the external ontology or knowledge base is to be analyzed and replaced with an UMBEL-based structure.
This property is therefore used to create a nearly equivalent assertion (however, with the degree of that equivalence being unknown or unknowable) between an external instance or class and a Reference Concept class.
|Description|| The property umbel:isAbout is used to assert the relation between an external named entity, individual or instance with a Reference Concept class. umbel:isAbout relates the external named entity, individual or instance to the class through the basis of its subject matter. The relation acknowledges that the scope of the class can not be determined solely by the aggregation or extent of its associated individual entity members, and that the nature of the Reference Concept class may not alone bound or define the individual entity.
This property is therefore used to create a topical assertion between an individual and a Reference Concept.
|Description||Check the definition of umbel:isAbout for the definition of this property; isRelatedTo is the inverse property of isAbout.|
|Description|| The various properties designated by umbel:relatesToXXX are used to assert a relationship between an external instance (object) and a particular (XXX) umbel:SuperType. There may be as many umbel:relatesToXXX properties as there are numbers of SuperTypes (see next table for the listing of all specific umbel:relatesToXXX predicates).
The assertion of this property does not entail class membership with the asserted SuperType. Rather, the assertion may be based on particular attributes or characteristics of the object at hand. For example, a British person might have an umbel:relatesToXXX asserted relation to the SuperType of the geopolitical entity of Britain, though the actual thing at hand (person) is a member of the Person class SuperType.
This predicate is used for filtering or clustering, often within user interfaces. Multiple umbel:relatesToXXX assertions may be made for the same instance.
Some deprecations and new STs were added in UMBEL version 1.50. Each of the 31 mostly disjoint UMBEL SuperTypes has a matching predicate for external topic assignments (
umbel:relatesToOtherOrganism shares two SuperTypes, leading to 30 different predicates):
|Activities||relatesToActivity||This predicate relates an external entity to the SuperType (ST) shown. It indicates there is a relationship to the ST of a verifiable nature, but which is undetermined as to strength or a full rdf:type relationship|
|Animals||relatesToAnimal||same as above|
|AreaRegion||relatesToArea||new as of version 1.50|
|AtomsElements||relatesToElement||new as of version 1.50|
|AudioInfo||relatesToAudioMusic||This predicate relates an external entity to the SuperType (ST) shown. It indicates there is a relationship to the ST of a verifiable nature, but which is undetermined as to strength or a full rdf:type relationship|
|BiologicalProcesses||relatesToBioProcess||new as of version 1.50|
|Chemistry||relatesToChemistry||This predicate relates an external entity to the SuperType (ST) shown. It indicates there is a relationship to the ST of a verifiable nature, but which is undetermined as to strength or a full rdf:type relationship|
|Diseases||relatesToDisease||same as above|
|Drugs||relatesToDrug||same as above|
|Events||relatesToEvent||same as above|
|Facilities||relatesToFacility||same as above|
|FinanceEconomy||relatesToFinanceEconomy||same as above|
|FoodorDrink||relatesToFoodDrink||same as above|
|Forms||relatesToForm||new as of version 1.50|
|LocationPlace||relatesToLocation||new as of version 1.50|
|NaturalSubstances||relatesToSubstance||same as above|
|OrganicChemistry||relatesToOrgChemistry||new as of version 1.50|
|Persons||relatesToPersonType||same as above; name changed in version 1.50 from PersonTypes to Persons|
|Products||relatesToProductType||same as above|
|Prokaryotes||relatesToOtherOrganism||same as above|
|Situations||relatesToSituation||new as of version 1.50|
|StructuredInfo||relatesToStructuredInfo||same as above|
|Times||relatesToTime||same as above; name changed in version 1.50 from Time to Times|
|VisualInfo||relatesToVisualInfo||same as above|
|WrittenInfo||relatesToWrittenInfo||same as above|
|Attributes||relatesToAttribute||may still be used, but not designed as disjoint|
|Entities||relatesToEntity||may still be used, but not designed as disjoint|
|Abstraction||relatesToAbstraction||may still be used, but not designed as disjoint; name changed in version 1.50 from Abstract to Abstraction|
|TopicsCategories||relatesToTopic||may still be used, but not designed as disjoint|
|MarketsIndustries||relatesToMarketIndustry||deprecated as of version 1.20|
|Workplaces||relatesToWorkplaces||deprecated as of version 1.20|
|Earthscape||relatesToEarth||deprecated as of version 1.50|
|Extraterrestrial||relatesToHeavens||deprecated as of version 1.50|
|NotationsReferences||relatesToNotation||deprecated as of version 1.50|
|Numbers||relatesToNumbers||deprecated as of version 1.50|
|Description|| The property umbel:isLike is used to assert an associative link between similar individuals who may or may not be identical, but are believed to be so. This property is not intended as a general expression of similarity, but rather the likely but uncertain same identity of the two resources being related.
This property may be considered as an alternative to sameAs where there is not a certainty of sameness, and/or when it is desirable to assert a degree of overlap of sameness via the umbel:hasMapping reification predicate. This property can and should be changed if the certainty of the sameness of identity is subsequently determined.
umbel:isLike has the semantics of likely identity, but where there is some uncertainty that the two resources indeed refer to the exact same individual with the same identity. Such uncertainty can arise when, for example, common names may be used for different individuals (e.g., John Smith).
It is appropriate to use this property when there is strong belief the two resources refer to the same individual with the same identity, but that association can not be asserted at the present time with full certitude.
|Description|| This property is used to reify a umbel:isAbout, umbel:isRelatedTo or an umbel:isLike property assertion with a statement as to its degree of mapping or relationship between subject and object.
The hasMapping property may be expressed as a mapping percentage value, some quantitative metric value, or a qualitative descriptor characterizing the linkage degree or overlap between the two classes, predicates, individuals or datatypes. This value might be calculated from some external utility, may be free form, or may be based on some defined listing of mapping values expressed as literals.
|Description||The property umbel:hasCharacteristic is used to assert the relation between a Reference Concept, or any other classes, and external properties that may be used in external ontologies to characterize, describe, or provide attributes for data records associated with that concept or that class. It is via this property or its inverse, umbel:isCharacteristicOf, that external data characterizations may be incorporated and modeled within a domain ontology based on the UMBEL vocabulary.|
|Description||The property umbel:isCharacteristicOf is used to assert the relation between a property and a Reference Concept (or its punned individual), or any other classes, to which it applies. Such properties may be used in external ontologies to characterize, describe, or provide attributes for data records associated with that concept or that class. It is via this property or its inverse, umbel:hasCharacteristic, that external data characterizations may be incorporated and modeled within a domain ontology based on the UMBEL vocabulary.|
Incorporation of External Properties
The UMBEL vocabulary re-uses several properties from external vocabularies. Here is the list of such properties that are recommended for or used by the UMBEL Reference Concept ontology (see Part II).
Listing of Properties
Language Annotations of Classes
The idea of Reference Concepts is that they are referents to real-world concepts with exact definitions and instance members, the combination of which (through both intension and extension) defines what the concept means. The label for the concept is merely a useful handle to the class membership and meaning of that concept, and has no further meaning in and of itself.
What this means is that the various labels for a given concept may be readily switched out to reflect that concept in different languages. To enable multiple language use, then, all annotations and labels should be labeled with their source language.
Earlier versions of UMBEL used the lingvoj ontology for this purpose. However, that ontology has been deprecated by its editor.
Now, each label and definition related properties should be defined by a language identifier, as defined by IETF RFC 4646 or successor. Different methodologies should be used depending on the serialization language used to serialize the UMBEL reference concepts structure.
Linking to Instances and Named Entities
UMBEL thus provides a class structure of Reference Concepts to which the actual instance data of the world, what we term named entities, can interact. Named entities are the real things or instances in the world that are themselves natural and notable class members of Reference Concepts. 
Named entities that are instances of external ontologies can be related to UMBEL via their class relationships. In addition, UMBEL provides the predicate
umbel:isLike (to supplement the
owl:sameAs) for relating named entities from disparate sources to one another.
- A general design approach is to make explicit a split between the “ABox” (for instance data) and “TBox” (for ontology schema) in accordance with our working definition for description logics:Description logics and their semantics traditionally split concepts and their relationships from the different treatment of instances and their attributes and roles, expressed as fact assertions. The concept split is known as the TBox (for terminological knowledge, the basis for T in TBox) and represents the schema or taxonomy of the domain at hand. The TBox is the structural and intensional component of conceptual relationships. The second split of instances is known as the ABox (for assertions, the basis for A in ABox) and describes the attributes of instances (and individuals), the roles between instances, and other assertions about instances regarding their class membership with the TBox concepts.
- See http://www.w3.org/2003/06/sw-vocab-status/note.
- The intension of a concept is provided by its definition as the described scope and coverage; the extension of a concept is the set of its members, which collectively imply its scope and coverage. Use of both approaches is encouraged and allowed in the idea of a "reference concept".
- Op cit., Distilling Subject Concepts from OpenCyc Volume 1. Also, see M. Bergman, Subject Concepts and Named Entities: Part 3 of 4 on Foundations to UMBEL, April 1, 2008, http://www.mkbergman.com/?p=432.