It is often recommended that identifiers for ontology terms should be semantics-free or meaningless. In practice, ontology developers tend to use numeric identifiers, starting at 1 and working upwards. Here we describe a number of significant flaws to this scheme, and the alternatives to them which we have implemented in our library, identitas. Software is available from https://github.com/phillord/ identitas.
During the years that ontologies have moved to becoming a standard part of the biomedical chain, a set of standard practices have build up which are used to enable their good management, including the addition of standardised metadata about each ontology term, including labels, definitions, editorial status and so forth.
One key piece of metadata is the identifier. For most ontological
technologies this is in the form of an IRI (Internationalized Resource
Identifer), or something that is convertable into one. Much has been
written about the nature of identifier and how they should be chosen.
The percieved wisdom is that identifiers should be semantics-free or
meaningless. The key aim here is to enable persistence of access to a
term [
As an example, OBO Foundry principles [
While semantics-free identifiers have their advantages there are distinct disadvantages as well, especially for humans. They are poorly mnemonic, hard to differentiate from each other and relatively difficult to read. For this reason, for example, many bioinformatics databases provide both semantic-free accession numbers (which are essentially the same thing as an identifer in ontology terminology), and an identifier (which is rather like a compressed, syntactically predicatable label). It is also interesting to note that, with software development, programmers emphasise the use importance of semantically-meaningful identifiers, and use other techniques to manage change. should addressed:
In this paper, we ask whether it is possible to overcome these and some related issues with monotonic, numeric identifiers while remaining semantics-free. We describe our solutions, along with the identitas library which implements these.
Racing: One unusual aspect of ontological identifiers is that
they are usually monotonically increasing. This causes a significant
race condition if two developers are building a single ontology in
parallel. If both attempt to add a new term, they both must coin a
new identifier, which must be unique. This is impossible to achieve
without some degree of co-ordination. One typical strategy is for
developers have to pre-coordinate to build the ontology by using
pre-allocation schema. For example, one developer allocated with
the IDs from 1 to 1000, another allocated with 1000 to 2000 and
so on. This approach is effective, however it requires developers
to manage the ID space accurately, and also reduces the overall
ID space since preallocated IDs cannot be used elsewhere. Another
approach is to just-in-time co-ordinate; for example, the URIGen [
We propose a much simpler approach which is to simply use random IDs not just as temporary identifiers. While randomness does not a priori completely remove the potential race condition, given a large enough identifier space, the chances of collision can be reduced to provide world (or universe) uniqueness. This approach is commonly used with random UUIDs (Universal Unique Identifiers) being perhaps the most common example.
Pronouncing: The use of randomness raises a secondary issue.
These identifiers are likely to be relatively long, exacerbatting the
problems of memorability and pronounceability. One solution to
this problem is to just not show the identifiers to humans. With
tools like Proteg´e´ this is possible, of course, because it has a view
which may be different from the underlying model. With text
fileformats, including OBO format, the various OWL serialisations
or the Tawny-OWL [
We have considered using a dictionary-based approach, to replace
numeric identifiers with English words. However, this approach
raises the probability of selecting a word which is inappropriate or
unfortunate – consider the Sonic Hedgehog gene mutations which
causes holoprosencephaly in humans. Instead, we are investigating
a solution in the form of the proquint [
Four-bits as a consonant: 0 1 2 3 4 5 6 7 8 9 A B C D E F b d f g h j k l m n p r s t v z
For example a numeric identifier 10 associated with some term in a given ontology would be translated to babab-babap, 11 would be translated to babab-babar by using proquint function which is quite readable, spellable and pronounceable string. In practice, if used to represent random numbers, the proquints would rarely be so close in alphabetic space. Note that proquints map directly to a single number, so can be freely converted in either direction, and that they are alphabetically ordered. Mappings between integer values are shown in Figure 2.
Integer 0 1 2 3 4 5 Integer/MIN VALUE Integer/MAX VALUE
Equivalent string
Fig. 2. Integer to Proint(string).
In a simple extension, to the original algorithm, we have also provided conversions from the Java short and long data types which provides either a larger identifier space, or less typing; conversions are shown in Figure 3.
Short - Long 0 1 2 0 1 Long/MIN VALUE Long/MAX VALUE
Equivalent string ”babab” ”babad” ”babaf” ”babab-babab-babab-babab” ”babab-babab-babab-babad” ”mabab-babab-babab-babab ”luzuz-zuzuz-zuzuz-zuzuz
We note that the short range at 216 numbers is large enough for
most ontologies current in operation. However, it is far too small
when combined with randomness as due to the birthday problem
is very likely to result in collisions even for small ontologies [
Checking: We note that monotonic numeric ideas suffer from a final problem. As well as being unmnenomic, if a numeric ID is misunderstood, it is very likely that the incorrect ID is stil actually a valid one; for instance, OBI:0001440 (“all pairs design”) and OBI:0001404 (“genetic characteristics information”) are IDs which differ in one one number.
A solution to this problem is well-understood with the use of a
checksum. For the identitas library, we use the Damm algorithm [
Of course, the Damm algorithm incorporates a checksum so reduces the total space of valid identifiers, in this case by an order of magnitude, which will have implications if combined with randomness. Under these circumstances, the larger numeric spaces (int or long) are likely to be necessary.
In this paper we present a critique of current ontology
semanticsfree identifiers; monotonically increasing numbers have a number of
significant usability flaws which make them unsuitable as a default
option, and we present a series of alternatives. We have provide an
implementation of these alternatives which can be freely combined.
We are now starting to integrate these into ontology development
environments such as Tawny-OWL [