A simple BFO conformant model for
temporalized relations
Abstract
Ontologies represented in OWL use a different semantics from the one proposed in the original
Relations Ontology paper. So far this has not caused any problems, with the OWL semantics
sufficient to support most bio-ontologies use cases. A recent attempt to reconcile these
proposes the creation of explicit temporalized relations such as attached_to_at_all_times, but
this leads to ontology inflation and has undesirable consequences such as the imposition of a
rigid-classes-only restriction.
Here I provide an explanation of this model and what I see as its main problems. I then describe
a simplified model called the SURF (Structure = Union of Rigid and Flexible) model which can
be adopted by existing ontologies with little or no modification.
Introduction
Logical formalizations of continuant-based ontologies (e.g. BFO) typically use instance-level
relations with three arguments, with the 3rd argument being a time point or interval. For
example, the original on-paper formalization of the RO[Smith2005] used a 3-argument instancelevel instance_of relation, as well as 3-argument relations for part_of between continuants, as
well as other spatial and topological relations (adjacent_to, etc).
Translating n-ary relations into binary relation schemes such as those imposed by OWL has the
potential to introduce a large degree of complexity. In the proposed BFO-in-OWL model[URL?],
we must replace the use of intuitive instance relations such as part_of and adjacent_to1 with
relations such as adjacent_to_at_some_times, adjacent_to_at_all_times and
adjacent_to_during. As well as introducing confusion and requiring modifications to existing
ontologies, the main drawback of this approach is the lack of support for ternary instantiation,
leading to the No Non-Rigid Classes restriction, which carries a high penalty for usability. One
possible extension here is to introduce time-slice occurrents (e.g. “john-at-t1”), requiring
counterpart occurrent relations for continuant relations. This would also have a high usability
penalty, and may have consequences for reasoning.
Here I present a simplified layer conformant with BFO that allows OWL tools to be used without
any modification, and for common intuitive relations (e.g. those currently in
http://purl.obolibrary.org/obo/bfo.owl) to be retained. The simple idea is to introduce a general
1
I use italics for all relations here. All relations are assumed to be instance level, class level
relations are trivially defined from instance relations and are not covered here
grouping class that is a union of continuants and slices of the continuant’s life. I show how this
would be used in building anatomical ontologies, although its utility would extend to most
ontologies. Almost all existing ontologies already naturally fit within this framework, and would
require minimal to no modification.
I will first give background in the form of my interpretation of the current BFO-in-OWL model and
what I perceive to be its limitations. I will then explore some logical next steps for the BFO-inOWL model, such as time slices. Finally I will present the BFO-conformant simplifying layer
“SURF”.
Background: BFO-in-OWL Model
Motivation
According to BFO, instance level relations between continuants should be ternary, with a 3rd
argument for time. These have traditionally been represented using binary object properties in
OWL. In addition, instance_of takes a 3rd temporal argument in BFO documentation and in
RO2005, but this is represented using the binary ClassAssertion predicate in OWL.
Whilst this simplification has thus far not yielded any serious practical problems for ontology
developers, the disconnect between the OWL semantics of existing ontologies and the
surrounding BFO narrative creates confusion. This yielded a new attempt to unify the two, in
what I call here the “BFO in OWL proposed model” [this is the model proposed by Alan at
ICBO2011]. The basic idea is to continue using binary OWL object properties, make the
temporal aspect explicit in the property name (e.g. R_at_all_times), and to handle temporalized
relationships using special “R_during” object properties.
Classes in BFO-in-OWL-proposed
The BFO-in-OWL model can be explained using a subset of BFO plus the proposed new
‘course’ class:
● c (continuant)
● o (occurrent)
○ course
○ process
I originally understood course to be disjoint from process. Perhaps this isn’t the case? In any
case, it’s not strictly relevant for this analysis.
New Relations in BFO-in-OWL-proposed
The model requires the addition of two other object properties for the new ‘course’ class.
● course_of :: course ⇒ c
● has_course :: c ⇒ course
These are functional and inverse functional (domain and range indiciated by the syntax
“ObjectProperty :: Domain ⇒ Range” )
Rather than retaining the simple “part_of” and “has_part” relations, which in RO2005 are ternary
on the instance level (note that as we are working in OWL all relations are object properties, i.e.
binary and instance level), we must bring in a more complex series of relations:
●
has_part_at_some_time* :: c ⇒ c
○ has_part_at_all_times :: c ⇒ c
● part_of_at_some_time* :: c ⇒ c
○ part_of_at_all_times :: c ⇒ c
● has_part_during :: c ⇒ temporal_part_of some c
● part_of_during :: c ⇒ temporal_part_of some c
● part_of_process** :: o ⇒ o
○ temporal_part_of :: o ⇒ o
● process_has_part** :: o ⇒ o
(inverse pairs denoted using * or **)
The general strategy is that when we have a ternary FOL relation R whose domain and range is
a continuant, we introduce the following structure in the OWL representation:
● R_at_some_time
○ R_at_all_times
● R_during :: c ⇒ temporal_part_of some c
Also adding axiom:
R_during o part_of_process → R_during
The R_during relation can be thought of as a reified 3-ary relation. Where in unrestricted FOL
we would say:
R(x,y,t)
Assuming t is a temporal interval.
Here we would say
R_during(x,”y@t”)
temporal_part_of(“y@t”,y-course)
has_temporal_projection(y-course,t)
Although the standard use case is the part_of/has_part relation, a similar treatment applies for
relations such as attached_to, adjacent_to, ventral_to, and so on. In some ways the parthood
case is more complicated, as part_of is currently used for both c-c and o-o. It may be more
instructive to focus on another example.
Example ontology in BFO-in-OWL-proposed
The following shows an example of a developing and developed heart. A ventricle is always part
of a heart, but the heart only acquires the ventricle at some point during development.
A ‘left ventricle’ is always part of a heart:
‘left ventricle’ SubClassOf part_of_at_all_times some heart
A heart has a left ventricle for part of its life:
heart SubClassOf has_part_at_some_times some ‘left ventricle’
If we want to specify that the heart always has a left ventricle after it has finished developing:
heart SubClassOf has_part_during ((course_of some temporal_part_of some ‘left
ventricle) and has_temporal_projection some ‘post-embryonic development’)
Problems with BFO-in-OWL-proposed model
The model has two problems. The first is more of a surface-level problem. Existing ontologies
will have to substitute all uses of “R” with “R_at_all_times”, where the subject of R is a
continuant. This will cause a lot of upheaval and confusion.
A more major problem is the lack of facility for non-rigid classes. A non-rigid class is a class
that a continuant can instantiate for some part of its course. Any class that is one of the
arguments of transformation_of (RO2005) axiom would be non-rigid. Under the existing
proposal, all continuant classes would have to be rigid. This is because of the lack of an intuitive
translation of the ternary instance_of for continuants to binary owl ClassAssertion.
Deciding what classes are rigid and non-rigid is dependent on identity conditions, which is often
not straightforward. One possible social effect of the non-rigidity constraint is a gradual
tightening of identity conditions such that what were previously considered non-rigid becomes
rigid. For example, “larva” may initially be considered non-rigid, since we feel the organism
retains its identity through metamorphoses - we can point at the adult organism and say that it is
the same organism as the organism in its larval form we previously saw. However, the argument
could be made that the transition to and from larva are such that we can consider these to be
different individuals, connected by derives_from, allowing us to keep “larva” in the ontology,
since our strict identity conditions have made it rigid.
Some possible candidate non-rigid classes include:
● phosphorylated EGFR
● cytoplasmic NFkB
● open heart valve
● human patient
● protein that is part of a complex
● developing heart
● stage 3 brain primordium
● oocyte (or any number of cell types)
● human with Parkinson’s disease
● infected lung
● gravid uterus (a uterus that is carrying an embryo)
● fractured bone
● happy person
The lack of time-slice classes like ‘stage 3 brain primordium’ may not be perceived as much of a
loss, or in fact as a benefit. However, for other cases, the lack of a named class for certain nonrigid classes may be a major usability issue for some ontologies. We are talking about
disallowing logically coherent terms that are part of normal scientific discourse, and are vital for
ontology building.
As in the larval example, more rigorous identity conditions can be imposed. We can have a
structural identity condition for molecules, such that we do not say “this EGFR becomes
phosphorylated” but rather “this EGFR fuses with a phosphate, creating a new EGFR-p
molecule”. This may strike some as odd, but it resolves the problem for this particular case. It
becomes even odder if we consider every beating of a heart to create and destroy all the valves
that open and close. We could also say that cells never change type -- they die and are
replaced by new cells (in RO2005 terms, replace all transformation_ofs with derives_froms). But
this seems like a 4D ontology through the back door - If we apply this “4D-ization” strategy for all
of the classes above then we may as well dispense with the notion of continuant altogether, for
nothing really retains identity, thing we previously thought of as the same entity are in fact in a
constant flux of dying and replacement.
One approach to allow non-rigid classes: time slices
We can allow non-rigid classes if we allow them to be instantiated by time-slices of continuants.
This has not yet been explored in the BFO-in-OWL model, but I present one way it might be
handled.
In BFO, a time slice of a continuant would be a slice of the spatiotemporal projection of the
continuant through its life (this may or may not be considered identical to the course). This
means the slice is an occurrent.
We would also have occurrent-counterpart relations. E.g. if we want to say that the brain
primordium has part GMC-X between stage 3 and 6, we would make the assertion about ‘brain
primordium stage 3-6’, an occurrent, and would need an occurrent “shadow” of has_part.
Anatomy ontologies typically have subclass structures such as:
● independent continuant
○ caro:material entity
■heart
● embryonic heart*
● post-embryonic heart*
The classes marked “*” would have to be restructured as:
●
●
independent continuant
○ caro:material entity
■heart
occurrent
○ caro:’part of course of material entity’ (proposed)
■embryonic heart*
■post-embryonic heart*
With axioms such as:
‘embryonic heart’ = occurrent and temporal_part_of some (slice_of some heart)
In effect, all our non-rigid classes from above would be replaced by occurrents (which would be
counterintuitive, to say the least).
A simplified approach
Here I present a simplified layer on top of this BFO model that is completely consistent with
BFO, is backwards compatible with existing practice, and can be easily understood by ontology
editors and consumers.
Proposed Solution: SURF Model
Basic outline
I introduce here a simplifying layer that is consistent with the BFO-in-OWL model. This is called
the SURF model: Structure = Union of Rigid and Flexible classes. I will first present this in a
generalized way without making any strong ontological commitments, then I will show
ontological commitments to BFO.
The idea is that any physical structure has 3 aspects that adhere the following subclass
hierarchy:
●
Structure
○ Rigid Structure
○ Flexible Structure
Here I use ‘flexible’ in place of the awkward ‘non-rigid’. For any structure S, the following axioms
apply:
S = ‘rigid S’ or ‘flexible S’
‘rigid S’ = S and rigid
‘flexible S’ = S and not rigid
Without yet introducing any too strong ontological commitments, we can think of the rigid aspect
as covering the entire life of the structure, and the non-rigid part as covering slices of the life of
the structure.
Example:
● heart
○ heart (rigid)
○ heart (non-rigid)
■heart at stage CS20
Note that it is not the intent that all the classes in italics in the above are named in an ontology.
Neither is there a need to assert rigidity or non-rigidity; the object property we use to provide the
differentia for ‘heart at stage CS20’ would include non-rigidity as its domain constraint. Let us
call this relation ‘at’ for now.
ObjectProperty: at
Characteristics: Functional
Domain: Structure and not rigid
Range: Occurrent ## we may want to tighten this later on
And a GCI:
(not rigid) SubClassOf at some Thing
We can think of ‘at’ as taking a slice through the history of an entity at some time interval.
Thus for any instance of ‘heart’ we cannot assume it is rigid (i.e. the entire life of the heart) or
non-rigid (i.e. a time slice of the heart). However, we can infer that any instance of ‘CS20 heart’
is non-rigid.
SURF relations
Familiar structural and topological relations such as attached_to, adjacent_to as well as domain
specific relations such as synapsed_by can continue to be used. These would have domain and
range constraints of ‘structure’ (i.e. they would not commit to rigid or non-rigid). As far as part_of
is concerned, we can choose to have subrelations for the structure-structure and processprocess case, or we can continue to use a single relation for both and a GCI for ensuring no
cross-over.
Note that if we have an axiom:
heart SubClassOf R some Y
Where the domain and range of R is ‘structure’, then this covers rigid instances (such as my
heart) and non-rigid instances (such as my heart today, or my heart when I was an embryo at
stage CS18). This is consistent with a reading of the axiom as “every heart is R some Y at all
times”.
We can also use the same R for non-rigid subtypes. E.g. the following is fine:
heart SubClassOf part_of some ‘cardiovascular system’
(heart and at some ‘CS20 or after’) SubClassOf has_part some ‘ascending aorta’
We also introduce a relation which for now we call slice_of, to relate a non-rigid class to its rigid
counterpart.
ObjectProperty: slice_of
Inverse: has_slice
Domain: not rigid
Rang: rigid
Translation between common logic and OWL using SURF
In FOL we might want to say:
R(x,y,t)
Assuming t is a temporal interval and R is a structural relation.
Here we would introduce two individuals, x@t and y@t.
R(‘x@t’,’y@t’)
at(‘x@t’,t)
at(‘y@t’,t)
slice_of(x@t,x)
slice_of(y@t,y)
(we can use the same symbol “R” in both - they are distinguished by the number of arguments)
For the FOL ternary instance of
instance_of(i,s,t)
We would translate as:
at(‘i@t’,t)
slice_of(i@t,i)
s(i@t)
We would need additional rules for ‘inheriting’ assertions from rigid wholes to slices and subslcies.
Conformity with BFO
The SURF model can stand in isolation from the ontological commitments of any upper-ontology
- it can even be used with a 4D ontology. Our goal here is to provide a solution that works with
BFO.
There are two options for aligning this to BFO
1. We equate structures with continuants, and introduce two new classes or properties,
rigid and non-rigid
2. We equate rigid classes with continuants, and non-rigid classes with some subclass of
occurrent
Here I assume (2), since (1) involves a very non-standard view of continuants.
For (2), I will reuse course and part_of some course from the BFO-in-OWL model. Note that this
may be over-committing the original intent of this model. If so, it is possible to substitute ‘course’
for some other subclass of spatiotemporal region (perhaps called ‘life’ or ‘history’ or ‘time slice’).
For now we will assume ‘course’ is fine. The same goes for the temporal_part_of object
property. We will equate what in the above is called slice_of with the property chain
temporal_part_of o course_of, and ‘at’ with has_temporal_projection.
First, for convenience, we name another occurrent, ‘course part’, giving the upper level:
●
●
c
o
○
○
○
course
‘course part’ = (temporal_part_of some course) OR course
process
Our template then becomes:
●
c or ‘course part’ (i.e. structure)
○ c (i.e. rigid)
○ ‘course part’ (i.e. non-rigid)
Example:
● heart
○ heart continuant
○ heart course part
■heart and has_temporal_projection some ‘stage CS20’
Note that with the labeling scheme above “heart” is not a continuant, but either a continuant or a
course part. We could equally well reserve the intuitive label “heart” for the continuant. For now
we will reserve the intuitive label for the SURF structure, and return to the naming issue in the
discussion. It is our intent that class in existing ontologies with labels like “heart” would
correspond to the class “heart” in the above.
The italicized classes need not be named. Axioms for named classes may look like:
●
Heart = ‘cavitated organ’ and has_part some ‘cardiac tissue’ and ….
○ ‘CS20 heart’ = heart and at some stage CS20
As a practical measure, all this involves is changing the top-level subclass axiom in an anatomy
ontology from
SubClassOf(‘anatomical entity’, bfo:IndependentContinuant)
to
SubClassOf(‘anatomical entity’, bfo:IndependentContinuant or ‘course part’))
This would come from CARO2 in any case, so individual anatomy ontologies will not need
modified. Other ontologies that make direct commitment to BFO may need to make
modifications of the axioms that connect to BFO.
Discussion
Similarity to SEP triples
It can be argued that the SURF model is similar to SEP triples in terms of a general design
pattern. However, with SEP triples the goal is to (typically) name all 3 classes in the triad in the
ontology (SNOMED). However, with SURF triples, there is in general no benefit to naming all 3
members. Generally we only need name the ‘top’ SURF class, i.e. the structure. We can infer
which classes or individuals are continuants and which are parts of courses based on whether
they are the subject of an at object property.
Compatibility with BFO
The model is entirely compatible with BFO. However, it can be argued it is not compatible with
the spirit of BFO, where the types represented in ontologies represent either continuants or
occurrents. Here we introduce an additional union class, and whilst there is no need to name
this class, the existence of such disjunctions may be perceived as ‘impure’.
Minimal disruption
Many ontologies already have non-rigid classes, and have them as subclasses of their rigid
counterpart. I would argue that the SURF model corresponds to the intuitive model ontology
developers are already following. This means that introducing it formally will require little to no
disruption. The main disruption comes in the form of ontologies that have already committed to
BFO continuants - many (but not all) of these would need to be generalized to commit to
continuants or course parts (the alternative is that bfo continuant is itself generalized).
Temporal reasoning
This proposal does not provide a full set of axioms for temporal reasoning - it merely provides
the framework for such axioms. I do not claim that this will allow us to do everything in OWL there will be some things we would need something stronger (i.e. description graphs, or some
rule extension to OWL). However, the situation here is no different from any other realm,
including simple mereological reasoning over static structures.
Conclusions
The proposed BFO-in-OWL only allows non-rigid classes, which I argue is too high a price to
pay, and will lead to unusable ontologies. The SURF model provides a way to accomodate nonrigid classes and temporalized relations without modifying most existing ontologies.