title: How can an individual in a OWL ontology be classified as an instance of A, if A is mutually exclusive to B and the individual is not in B?
body: <p>Here is my ontology created with Protege.</p>
  <pre><code>Prefix(:=&lt;http://www.semanticweb.org/kolam/ontologies/2020/9/exInference#&gt;)
  Prefix(owl:=&lt;http://www.w3.org/2002/07/owl#&gt;)
  Prefix(rdf:=&lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#&gt;)
  Prefix(xml:=&lt;http://www.w3.org/XML/1998/namespace&gt;)
  Prefix(xsd:=&lt;http://www.w3.org/2001/XMLSchema#&gt;)
  Prefix(rdfs:=&lt;http://www.w3.org/2000/01/rdf-schema#&gt;)
  
  
  Ontology(&lt;http://www.semanticweb.org/kolam/ontologies/2020/9/exInference&gt;
  
  Declaration(Class(:Course))
  Declaration(Class(:Professor))
  Declaration(Class(:ProfessorBusy))
  Declaration(Class(:ProfessorLazy))
  Declaration(ObjectProperty(:hasChild))
  Declaration(ObjectProperty(:teaches))
  Declaration(NamedIndividual(:INF1000))
  Declaration(NamedIndividual(:INF2000))
  Declaration(NamedIndividual(:INF3000))
  Declaration(NamedIndividual(:INF4000))
  Declaration(NamedIndividual(:INF5000))
  Declaration(NamedIndividual(:John))
  Declaration(NamedIndividual(:Marc))
  
  ############################
  #   Classes
  ############################
  
  # Class: :Professor (:Professor)
  
  EquivalentClasses(:Professor ObjectSomeValuesFrom(:teaches :Course))
  
  # Class: :ProfessorBusy (:ProfessorBusy)
  
  EquivalentClasses(:ProfessorBusy ObjectIntersectionOf(:Professor ObjectComplementOf(:ProfessorLazy)))
  
  # Class: :ProfessorLazy (:ProfessorLazy)
  
  EquivalentClasses(:ProfessorLazy ObjectIntersectionOf(:Professor ObjectMaxCardinality(2 :teaches :Course)))
  
  
  ############################
  #   Named Individuals
  ############################
  
  # Individual: :INF1000 (:INF1000)
  
  ClassAssertion(:Course :INF1000)
  
  # Individual: :INF2000 (:INF2000)
  
  ClassAssertion(:Course :INF2000)
  
  # Individual: :INF3000 (:INF3000)
  
  ClassAssertion(:Course :INF3000)
  
  # Individual: :INF4000 (:INF4000)
  
  ClassAssertion(:Course :INF4000)
  
  # Individual: :INF5000 (:INF5000)
  
  ClassAssertion(:Course :INF5000)
  
  # Individual: :John (:John)
  
  ObjectPropertyAssertion(:teaches :John :INF1000)
  ObjectPropertyAssertion(:teaches :John :INF2000)
  
  # Individual: :Marc (:Marc)
  
  ObjectPropertyAssertion(:teaches :Marc :INF3000)
  ObjectPropertyAssertion(:teaches :Marc :INF4000)
  ObjectPropertyAssertion(:teaches :Marc :INF5000)
  
  
  DifferentIndividuals(:INF1000 :INF2000 :INF3000 :INF4000 :INF5000)
  )
  </code></pre>
  <p>As expected, the reasoner correctly classifies <code>Marc</code> as an instance of <code>ProfessorBusy</code> since he teaches more than 2 courses. However, <code>John</code> teaches only 2 courses and the reasoner won't classify him as a <code>ProfessorLazy</code>.</p>
  <p>I'm guessing that because of the open world assumption, we are never sure that John actually teaches less than 2 courses.</p>
  <p>Is there another way to make this work ? If something is not a <code>ProfessorBusy</code>, it is a <code>ProfessorLazy</code> ?</p>