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.