1. Applying Rigidity to Standardizing OBO Foundry Candidate Ontologies A.Patrice Seyed and Stuart C. Shapiro Department of Computer Science Center for Cognitive Science University at Buffalo ICBO

2. Introduction OBO Foundry Ontologies Basic Formal Ontology (BFO) as the upper ontology OBO includes Ratified/Candidate ontologies But no formal (logical) criteria for ratification OntoClean – Approach for detecting when the taxonomic relation is being used improperly Formal integration between OntoClean’s notion of Rigidity and BFO’s theory of types

3. Hypothesis 1.BFO and OntoClean’s notion of Rigidity can be integrated. 2.This integration can serve as a basis for a system that will assist a modeler in alignment with BFO and result in fewer modeler mistakes. Provides a modeler with: – Formal System – Decision Tree

4. BFO Restricted set of highly generalized classes Independent Continuant: Concrete ``Things’’ Dependent Continuant: Qualities, Functions, Roles Occurrent: Processes BFO Classes are types (universals) – Domain level classes are assigned as subclasses Restricted set of relations Disadvantage – Its not always clear how to perform the assignments

5. OntoClean Constraints on taxonomic hierarchies Rigidity, Identity, Unity, Dependence – Requires a modeler to assign certain features to each property of an ontology A property is: Rigid if it is essential to all instances Non-Rigid if non-essential to some instance Anti-Rigid if non-essential to all instances Constraint: An Anti-Rigid property has only Anti-Rigid subproperties.

6. Modeling Example Applying Rigidity Modeling Example Is Compound and Compound Reactant : Rigid, Non-Rigid, or Anti-Rigid? Compound Compound Reactant Compound

7. Step One: Categorical Unit BFO – Type (Universal) What the general terms of science refer to Person, Student Role, Porous Quality OntoClean – Property (attributive) Meaning of general terms (being a) Person, (being a) Student, (being) Porous Unify Property and Type under the unit of Class

8. Formal Theory of Classes subclass_of(A,B) =def  xt(member_of(x,A,t) → member_of(x,B,t)) exists_at(x,t) – Under a certain ontological theory, object x is within its domain and x’s existence spans some time, t. Everything in the domain exists at some time: ∀ x ∃ t(exists_at(x,t)) membership at a time does not presuppose that existence spans that time ¬ ∀ xt( ∃ A member_of(x,A,t)) → exists_at(x,t))

9. Formal Theory of Classes Two Features of classes : Instantiated(A) =def ∃ xt(member_of(x,A,t) ∧ exists_at(x,t)) Members_Exist(A) =def ∀ xt(member_of(x,A,t) → exists_at(x,t))

10. Integrating Rigidity with BFO theory of types ``Essential’’ reformulated w.r.t. to time: – Rigid(A) =def  x(  t(member_of(x,A,t)) →  t(exists at(x,t) → member_of(x,A,t))) – Non-Rigid(A) =def  x(  t(member_of(x,A,t)) ∧  t(exists at(x,t) →  member_of(x,A,t))) Anti-Rigid is incompatible with BFO

11. Integrating Rigidity with BFO theory of types Additional constraints on Rigid, and also on types: – Instantiated – Members_Exist  A(Type(A) → Rigid(A) ∧ Instantiated(A) ∧ Members_Exist(A))

12. Integrating Rigidity with BFO theory of types instance_of(x,A,t) =def member_of(x,A,t) ∧ Type(A) isa(A,B) =def  xt(instance_of(x,A,t) → instance_of(x,B,t))  AB(isa(A,B) → Type(A) ∧ Type(B)) ⊦  A(Non-Rigid(A) →  B(¬isa(A,B) ∧ ¬isa(B,A)))

13. Integration with BFO theory of Types We lose the Anti-Rigid constraint. What have we gained? – Non-Rigid Classes are not Types!? ? Compound isa Compound Reactant

14. Modeling Example molecule-1 molecule-2 molecule-3 molecule-4 molecule-1 molecule-2 molecule-3 molecule-4 compound-1 compound-2 compound-3 ??? compound-1 compound-2 compound-3 compound-4 reactantRole-1 reactantRole-2 reactantRole-3 Compound isa Compound Reactant

15. Modeling Example molecule-1 molecule-2 molecule-3 molecule-4 molecule-1 molecule-2 molecule-3 molecule-4 compound-1 compound-2 compound-3 Compound Reactant-Role compound-1 compound-2 compound-3 compound-4 reactantRole-1 reactantRole-2 reactantRole-3 Compound Role_Of subclass_of Compound Reactant

16. Modeling Example Compound Reactant molecule-1 molecule-2 molecule-3 molecule-4 Compound Reactant-Role compound-1 compound-2 compound-3 compound-4 compound-1 compound-2 compound-3 reactantRole-1 reactantRole-2 reactantRole-3 Compound Role_Of Has_Role subclass_of

17. Compound Reactant molecule-1 molecule-2 molecule-3 molecule-4 Compound Reactant-Role compound-1 compound-2 compound-3 compound-4 compound-1 compound-2 compound-3 reactantRole-1 reactantRole-2 reactantRole-3 Compound Role_Of Has_Role Independent Continuant Dependent Continuant compound-2 compound-4 compound-3 compound-1 reactantRole-1 reactantRole-2 reactantRole-3 subclass_of isa

18. Modeling Example Compound Reactant molecule-1 molecule-2 molecule-3 molecule-4 Role compound-1 compound-2 compound-3 compound-4 compound-1 compound-2 compound-3 ? ? ? Compound subclass_of ???

19. Disjointness Principle Violations follow the pattern: isa(A,B) ∧ isa(A,C) Where it does not hold that: isa(B,C) ∨ isa(C,B) 1. isa(B,C) or isa(C,B) holds. 2. isa(A,B) or isa(A,C) is removed, including the choice that isa is changed to another relation (e.g., Depends_On). 3. A is partitioned into multiple candidates, some of which are subtypes of B and some of C.

20. Decision Tree Proactive Avoidance of Multiple Inheritance and enforces examination of Non-Rigid classes – Introduces a class, one at a time – Asks a modeler to supply an example member of the class – Yes/No Questions Correspond Upper Level Divisions, BFO/Rigidity Integration, Type-Level relations A gentle approach of linking to BFO classes, and a refactoring when Non-Rigid classes are identified

22. Role_Of Compound Compound Reactant-Role Entity Has_Role Independent Continuant Dependent Continuant Compound Reactant isa subclass_of

23. Integration Summary Class covers both OntoClean’s notion of property and BFO’s notion of type. A class might or might not satisfy Instantiated, Members_Exist, Rigid, or Non-Rigid – the latter two capturing the intuitions of Rigidity within our formal theory BFO’s notion of type is captured by a class that satisfies Instantiated, Members_Exist, and Rigid.

24. Future Work Rigidity and Canonical domains Connection of Non-Rigidity and Other Type- Level Relations Expert review of decision tree procedure – Evaluate “accessibility” of questions Integrate other OntoClean Components