<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [
<!ENTITY dc "http://purl.org/dc/elements/1.1#">
<!ENTITY icom_ac "http://docs.oasis-open.org/ns/icom/accesscontrol/201008#">
<!ENTITY icom_cal "http://docs.oasis-open.org/ns/icom/calendar/201008#">
<!ENTITY icom_card "http://docs.oasis-open.org/ns/icom/contact/201008#">
<!ENTITY icom_conf "http://docs.oasis-open.org/ns/icom/conference/201008#">
<!ENTITY icom_content "http://docs.oasis-open.org/ns/icom/content/201008#">
<!ENTITY icom_core "http://docs.oasis-open.org/ns/icom/core/201008#">
<!ENTITY icom_doc "http://docs.oasis-open.org/ns/icom/document/201008#">
<!ENTITY icom_forum "http://docs.oasis-open.org/ns/icom/forum/201008#">
<!ENTITY icom_meta "http://docs.oasis-open.org/ns/icom/metadata/201008#">
<!ENTITY icom_msg "http://docs.oasis-open.org/ns/icom/message/201008#">
<!ENTITY icom_presence "http://docs.oasis-open.org/ns/icom/presence/201008#">
<!ENTITY icom_task "http://docs.oasis-open.org/ns/icom/task/201008#">
<!ENTITY kids "https://ken.baclawski.com/kids.owl#">
<!ENTITY owl "http://www.w3.org/2002/07/owl#">
<!ENTITY prov "http://www.w3.org/ns/prov#">
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
<!ENTITY skos "http://www.w3.org/2004/02/skos/core#">
<!ENTITY xml "http://www.w3.org/XML/1998/namespace">
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
<!ENTITY copy "&#169;">
]>

<rdf:RDF
    xmlns="&kids;"
    xml:base="&kids;"
    xmlns:dc="&dc;"
    xmlns:icom_ac="&icom_ac;"
    xmlns:icom_cal="&icom_cal;"
    xmlns:icom_card="&icom_card;"
    xmlns:icom_conf="&icom_conf;"
    xmlns:icom_content="&icom_content;"
    xmlns:icom_core="&icom_core;"
    xmlns:icom_doc="&icom_doc;"
    xmlns:icom_forum="&icom_forum;"
    xmlns:icom_meta="&icom_meta;"
    xmlns:icom_msg="&icom_msg;"
    xmlns:icom_presence="&icom_presence;"
    xmlns:icom_task="&icom_task;"
    xmlns:kids="&kids;"
    xmlns:owl="&owl;"
    xmlns:prov="&prov;"
    xmlns:rdf="&rdf;"
    xmlns:rdfs="&rdfs;"
    xmlns:skos="&skos;"
    xmlns:xml="&xml;"
    xmlns:xsd="&xsd;">

  <owl:Ontology rdf:about="">
    <rdfs:label rdf:datatype="&xsd;string">KIDS</rdfs:label>
    <owl:versionIRI rdf:resource="https://ken.baclawski.com/kids.owl/2.0"/>
    <dc:title xml:lang="en" rdf:datatype="&xsd;string">Knowledge Intensive Database System (KIDS)</dc:title>
    <rdfs:comment xml:lang="en" rdf:datatype="&xsd;string">Knowledge Intensive Database System (KIDS) is a formal framework for decision making based on the OODA loop that provides for (1) Categorization of data and reasoning processes; (2) State management of data, reasoning and process; (3) Process model for situation awareness and decision making</rdfs:comment>
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">Knowledge Intensive Database System (KIDS) is a formal framework for decision making based on the OODA loop that provides for (1) Categorization of data and reasoning processes; (2) State management of data, reasoning and process; (3) Process model for situation awareness and decision making</dc:description>
    <dc:publisher xml:lang="en" rdf:datatype="&xsd;string">International Association for Ontology and Application</dc:publisher>
    <dc:date xml:lang="en" rdf:datatype="&xsd;string">21 July 2016</dc:date>
    <dc:source rdf:datatype="&xsd;anyURI">https://ken.baclawski.com/kids.owl</dc:source>
    <owl:versionInfo rdf:datatype="&xsd;string">Version 1.0</owl:versionInfo>
    <dc:creator rdf:datatype="&xsd;string">Kenneth Baclawski (ken@baclawski.com), Northeastern University</dc:creator>
    <dc:contributor rdf:datatype="&xsd;string">Kenneth Baclawski (ken@baclawski.com), Northeastern University</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Eric S. Chan (eric.s.chan@oracle.com), Oracle</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Dieter Gawlick (dieter.gawlick@oracle.com), Oracle</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Adel Ghoneimy (adel.ghoneimy@oracle.com), Oracle</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Kenny Gross (kenny.gross@oracle.com), Oracle</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Zhen Hua Li (zhen.liu@oracle.com), Oracle</dc:contributor>
    <dc:contributor rdf:datatype="&xsd;string">Xing Zhan (zhang.xing1@husky.neu.edu), Northeastern University</dc:contributor>
    <dc:rights xml:lang="en" rdf:datatype="&xsd;string">Copyright &copy; Kenneth Baclawski 2016. All Rights Reserved.</dc:rights>

    <owl:imports rdf:resource="http://www.w3.org/ns/prov-o#"/>
    <!-- 
	 The following were not imported because none of the axioms are being used:

         <owl:imports rdf:resource="https://ken.baclawski.com/icom.owl"/>
         <owl:imports rdf:resource="http://purl.org/dc/elements/1.1"/>
         <owl:imports rdf:resource="http://www.w3.org/2004/02/skos/core"/>

         The following was not imported because it is not compatible with OWL DL:

         <owl:imports rdf:resource="https://ken.baclawski.com/STO.owl"/>
    -->
  </owl:Ontology>


  <!-- Class Declarations -->

  <owl:Class rdf:about="&kids;CARE-Loop">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A collection of activities for decision making. Normally, the collection of activities consists of a sequence of loop iterations where each iteration is in the order classify, assess, resolve and enact, but it is possible to combine the assess and resolve activities in a single step. It is also possible for the activities to branch and merge, forming a directed graph of activities.</dc:description>
  </owl:Class>

  <owl:Class rdf:about="&kids;Reasoning">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A process that uses the information in a situation to produce another situation. Logical reasoning is expressed in terms of rules. Many techniques are available for probabilistic reasoning.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Relevance">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that extracts data relevant to a goal or purpose. Modern sensor technology produces very large amounts of data, only a small part of which will be relevant to a particular goal. The activity is called filtering. Relevance reasoning includes both extraction from raw data as the initial step in a decision making process and detection of relevant new or modified information later in the process.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Classification">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that uses data acquired externally by observations, such as by using sensors, or internally from previous decision cycles. The situation produced by a classification process is a perception. Classification is usually implemented by deductive reasoning, but inductive reasoning is also common. The wide variety of classification techniques includes Support Vector Machines, Naïve Bayesian Networks, Neural Networks, Clustering, Association Rules, Decision Trees, Multivariate State Estimation Technique, Cognitive computing, etc.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Assessment">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that uses perceptions and produces hypotheses relevant to the decision making goal.  The hypotheses are also called diagnoses.  Assessment is typically implemented by abductive reasoning. Examples of techniques include Bayesian Belief Networks, Expectation Maximization, Least-Squares Optimization and Regression of solutions for inverse problems.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Resolution">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that uses hypotheses and produces directives that represent the decision that was made to address the goal. Resolution involves making decisions under the uncertainty of outcomes by considering the relative merit of the different outcomes and the associated payoffs/costs. Resolution techniques include Bayesian Belief Network extended with decision and payoff/cost nodes, known as Influence Diagrams, Dempster-Shafer theory, Decision Trees, and Prognosis of Remaining Useful Life. A directive typically includes a plan of action in the form of a workflow or process. The plan may achieve the goal. If the plan does not fully achieve the goal, then the plan will either involve additional observations or give a reason why the goal should not be achieved.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;AssessmentResolution">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that combines the assessment and resolution steps. It differs from performing assessment and resolution separately in not generating hypotheses. For example, in the healthcare domain, a practitioner will often treat a patient without determining the actual disease.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Enactment">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A reasoning process that performs the directives, thereby affecting the world in some way. Enactment involves control structures of various kinds, usually encoded in scripts, plans, schedules, BPEL workflows, and business processes in BPMN. Enactment often includes a request for additional observations.</dc:description>
  </owl:Class>

  <owl:Class rdf:about="&kids;Data">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">Information relevant to achieving a goal. The kinds of data are classified by when they are used in the decision loop.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Fact">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The information relevant to a goal, acquired externally by observations, such as by using sensors, or internally from previous decision cycles.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Perception">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">Compact representations of facts. Perceptions are generally at a higher level, than raw facts. For example, a fact might be an MRI scan of a patient, while a perception based on the MRI scan would identify objects in the MRI scan that are physiologically relevant to the goal of diagnosing the patient.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Hypothesis">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The potential causes that explain perceptions. Hypotheses are also called diagnoses.</dc:description>
  </owl:Class>
  <owl:Class rdf:about="&kids;Directive">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A plan for achieving the goal either fully or partially, or a reason why the goal is not desirable. A plan is usually encoded in scripts, plans, schedules, BPEL workflows, and business processes in BPMN. Enactment often includes a request for additional observations.</dc:description>
  </owl:Class>

  <owl:Class rdf:about="&kids;TimeInterval">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A period of time. The period will always have a starting time. The ending time can be an actual time or it will indicate some reason why the ending time is not specified, such as that the period of time proceeds indefinitely into the future, or that the period of time is instantaneous so the ending time is not applicable.</dc:description>
  </owl:Class>

  <owl:Class rdf:about="&kids;Guard">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A specification of the requirements for data used by an activity or the characteristics of data produced by an activity.</dc:description>
  </owl:Class>

  <owl:Class rdf:about="&kids;Relation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A flexible relation notion from situation theory that includes, flexible schema data, categorical features, as well as other data and object properties. It is not limited to tables from the relational model.</dc:description>
  </owl:Class>

  <!-- Imported classes -->
  
  <owl:Class rdf:about="&prov;Entity"/>
  <owl:Class rdf:about="&prov;Activity"/>

  <owl:Class rdf:about="&icom_core;Space"/>

  <!-- Derived Classes -->

  <owl:Class rdf:about="&kids;Filter">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of a relevance reasoning process. This class is defined as the activities that use relevance reasoning processs.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Relevance"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <owl:Class rdf:about="&kids;Classify">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of a classification process. This class is defined as the activities that use classification processs.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Classification"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <owl:Class rdf:about="&kids;Assess">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of an assessment process. This class is defined as the activities that use assessment processs.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Assessment"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;Resolve">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of a resolution process. This class is defined as the activities that use resolution processs.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Resolution"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;AssessResolve">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of a process that combines assessment and resolution. This class is defined as the activities that use processs that combine assessment and resolution.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;AssessmentResolution"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;Enact">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The execution context of an enactment process. This class is defined as the activities that use enactment processs.</dc:description>
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Enactment"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <owl:Class rdf:about="&kids;RelevanceSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports relevance reasoning activities.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;RelevanceInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;RelevanceInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Filter"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <owl:Class rdf:about="&kids;ClassificationSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports classification activities.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;ClassificationInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;ClassificationInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Classify"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;AssessmentSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports assessment activities.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;AssessmentInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;AssessmentInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Assess"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;AssessmentResolutionSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports activities that combine assessment and resolution.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;AssessmentResolutionInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;AssessmentResolutionInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;AssessResolve"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;ResolutionSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports resolution activities.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;ResolutionInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;ResolutionInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Resolve"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;EnactmentSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports enactment activities.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;UtteranceSituation"/>
      <owl:Class rdf:about="&kids;EnactmentInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;EnactmentInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Enact"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;FactSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports facts.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;FocalSituation"/>
      <owl:Class rdf:about="&kids;FactInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;FactInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Fact"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;PerceptionSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports perceptions.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;FocalSituation"/>
      <owl:Class rdf:about="&kids;PerceptionInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;PerceptionInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Perception"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  
  <owl:Class rdf:about="&kids;HypothesisSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports hypotheses.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;FocalSituation"/>
      <owl:Class rdf:about="&kids;HypothesisInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;HypothesisInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Hypothesis"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <owl:Class rdf:about="&kids;DirectiveSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">A situation that supports directives.</dc:description>
    <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="&kids;FocalSituation"/>
      <owl:Class rdf:about="&kids;DirectiveInfons"/>
    </owl:intersectionOf>
  </owl:Class>
  <owl:Class rdf:about="&kids;DirectiveInfons">
    <owl:equivalentClass>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;supportsInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Directive"/>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>

  <!-- CARE Loop and Other Axioms -->

  <rdf:Description rdf:about="&kids;RelevanceSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;ResourceSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;RelevanceSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;FactSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;ClassificationSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;FactSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;ClassificationSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;PerceptionSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;AssessmentSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;PerceptionSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;AssessmentSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;HypothesisSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;AssessmentResolutionSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;PerceptionSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;AssessmentResolutionSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;DirectiveSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;ResolutionSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;HypothesisSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;ResolutionSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;DirectiveSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;EnactmentSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;DirectiveSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;EnactmentSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;FactSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:nodeID="supportProduce">
    <owl:propertyChainAxiom rdf:parseType="Collection">
      <owl:ObjectProperty rdf:about="&kids;supportsInfon"/>
      <owl:ObjectProperty rdf:about="&kids;producesInfon"/>
    </owl:propertyChainAxiom>
  </rdf:Description>

  <rdf:Description rdf:nodeID="produceSupport">
    <owl:propertyChainAxiom rdf:parseType="Collection">
      <owl:ObjectProperty rdf:about="&kids;producesSituation"/>
      <owl:ObjectProperty rdf:about="&kids;supportsInfon"/>
    </owl:propertyChainAxiom>
  </rdf:Description>

  <owl:ObjectProperty rdf:about="supportProduce">
    <owl:subPropertyOf rdf:resource="produceSupport"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="produceSupport">
    <owl:subPropertyOf rdf:resource="supportProduce"/>
  </owl:ObjectProperty>

  <!-- Subclass Hierarchy -->

  <rdf:Description rdf:about="&prov;Activity">
    <rdfs:subClassOf rdf:resource="&kids;Infon"/>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;Data">
    <rdfs:subClassOf rdf:resource="&kids;Infon"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Data">
    <rdfs:subClassOf rdf:resource="&prov;Entity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Reasoning">
    <rdfs:subClassOf rdf:resource="&prov;Entity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;CARE-Loop">
    <rdfs:subClassOf rdf:resource="&prov;Entity"/>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;Relevance">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Classification">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Assessment">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Resolution">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;AssessmentResolution">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Enactment">
    <rdfs:subClassOf rdf:resource="&kids;Reasoning"/>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;Fact">
    <rdfs:subClassOf rdf:resource="&kids;Data"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Perception">
    <rdfs:subClassOf rdf:resource="&kids;Data"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Hypothesis">
    <rdfs:subClassOf rdf:resource="&kids;Data"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Directive">
    <rdfs:subClassOf rdf:resource="&kids;Data"/>
  </rdf:Description>

  <!--
    The following should all follow from their definitions, 
    but neither Fact++ nor HermiT were capable of making 
    this inference.
  -->
  <rdf:Description rdf:about="&kids;Filter">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Classify">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Assess">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Resolve">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;AssessResolve">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Enact">
    <rdfs:subClassOf rdf:resource="&prov;Activity"/>
  </rdf:Description>

  <!-- Object Properties -->

  <owl:ObjectProperty rdf:about="&kids;usesSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The situation used by an activity to produce another situation.</dc:description>
    <rdfs:domain rdf:resource="&prov;Activity"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="&kids;isUsedByActivity">
    <owl:inverseOf rdf:resource="&kids;usesSituation"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;producesSituation">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The situation produced by an activity using another situation.</dc:description>
    <rdfs:domain rdf:resource="&prov;Activity"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="&kids;isProducedByActivity">
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
    <owl:inverseOf rdf:resource="&kids;producesSituation"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;usesInfon">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The infons that an activity is using.</dc:description>
    <rdfs:domain rdf:resource="&prov;Activity"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;producesInfon">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The infons that an activity is producing.</dc:description>
    <rdfs:domain rdf:resource="&prov;Activity"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;invokes">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The reasoning process used by an activity.</dc:description>
    <rdfs:domain rdf:resource="&prov;Activity"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;partOfLoop">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The CARE-Loop containing a directed graph of situations.</dc:description>
    <rdfs:domain rdf:resource="&kids;Situation"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
    <owl:inverseOf rdf:resource="&kids;containsSituation"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="&kids;containsSituation"/>

  <owl:ObjectProperty rdf:about="&kids;hasWorkspace">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The collaborative workspace for a CARE-Loop.</dc:description>
    <rdfs:domain rdf:resource="&kids;CARE-Loop"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;hasValidTime">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The time interval during which data are valid.</dc:description>
    <rdfs:domain rdf:resource="&prov;Entity"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;followsInValidTime">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The next focal situation in a valid time series.</dc:description>
    <rdfs:domain rdf:resource="&kids;FocalSituation"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="&kids;followsInTransactionTime">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The next focal situation in a transaction time series.</dc:description>
    <rdfs:domain rdf:resource="&kids;FocalSituation"/>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:about="&kids;inputSpecification">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The guard that specifies the input requirements of an activity.</dc:description>
    <rdfs:domain rdf:resource="&kids;Reasoning"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>
  <owl:ObjectProperty rdf:about="&kids;outputSpecification">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The guard that specifies the characteristics of the output of an activity.</dc:description>
    <rdfs:domain rdf:resource="&kids;Reasoning"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:ObjectProperty>

  <!-- Data Properties -->

  <owl:DatatypeProperty rdf:about="&kids;startTime">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The starting time of a time interval.</dc:description>
    <rdfs:domain rdf:resource="&kids;TimeInterval"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:DatatypeProperty>
  <rdf:Description rdf:about="&kids;TimeInterval">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;startTime"/>
	<owl:allValuesFrom rdf:resource="&xsd;dateTime"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <owl:DatatypeProperty rdf:about="&kids;endTime">
    <dc:description xml:lang="en" rdf:datatype="&xsd;string">The ending time of a time interval. It can be an actual time or it will indicate some reason why the ending time is not specified, such as that the period of time proceeds indefinitely into the future, or that the period of time is instantaneous so the ending time is not applicable.</dc:description>
    <rdfs:domain rdf:resource="&kids;TimeInterval"/>
    <rdf:type rdf:resource="&owl;FunctionalProperty"/>
  </owl:DatatypeProperty>

  <!-- The ending time can be an arbitrary explanation as well as a time. -->
  <rdf:Description rdf:about="&kids;TimeInterval">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;endTime"/>
	<owl:allValuesFrom rdf:resource="&xsd;string"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;endTime"/>
	<owl:someValuesFrom rdf:resource="&xsd;string"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <!-- Range Constraints -->

  <rdf:Description rdf:about="&prov;Activity">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:allValuesFrom rdf:resource="&kids;Reasoning"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;invokes"/>
	<owl:someValuesFrom rdf:resource="&kids;Reasoning"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;UtteranceSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;FocalSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;UtteranceSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;producesSituation"/>
	<owl:allValuesFrom rdf:resource="&kids;FocalSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&prov;Activity">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Infon"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&prov;Activity">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;usesInfon"/>
	<owl:allValuesFrom rdf:resource="&kids;Infon"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;Situation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;partOfLoop"/>
	<owl:allValuesFrom rdf:resource="&kids;CARE-Loop"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&prov;Entity">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;hasValidTime"/>
	<owl:allValuesFrom rdf:resource="&kids;TimeInterval"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Reasoning">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;inputSpecification"/>
	<owl:allValuesFrom rdf:resource="&kids;Guard"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  <rdf:Description rdf:about="&kids;Reasoning">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;outputSpecification"/>
	<owl:allValuesFrom rdf:resource="&kids;Guard"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;FocalSituation">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;followsInValidTime"/>
	<owl:allValuesFrom rdf:resource="&kids;FocalSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;followsInTransactionTime"/>
	<owl:allValuesFrom rdf:resource="&kids;FocalSituation"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>

  <rdf:Description rdf:about="&kids;CARE-Loop">
    <rdfs:subClassOf>
      <owl:Restriction>
	<owl:onProperty rdf:resource="&kids;hasWorkspace"/>
	<owl:allValuesFrom rdf:resource="&icom_core;Space"/>
      </owl:Restriction>
    </rdfs:subClassOf>
  </rdf:Description>
  
  <!-- Disjointness Constraints -->

  <rdf:Description>
    <rdf:type rdf:resource="&owl;AllDisjointClasses"/>
    <owl:members rdf:parseType="Collection">
      <rdf:Description rdf:about="&kids;Filter"/>
      <rdf:Description rdf:about="&kids;Classify"/>
      <rdf:Description rdf:about="&kids;Assess"/>
      <rdf:Description rdf:about="&kids;Resolve"/>
      <rdf:Description rdf:about="&kids;Enact"/>
    </owl:members>
  </rdf:Description>
  <rdf:Description>
    <rdf:type rdf:resource="&owl;AllDisjointClasses"/>
    <owl:members rdf:parseType="Collection">
      <rdf:Description rdf:about="&kids;Relevance"/>
      <rdf:Description rdf:about="&kids;Classification"/>
      <rdf:Description rdf:about="&kids;Assessment"/>
      <rdf:Description rdf:about="&kids;Resolution"/>
      <rdf:Description rdf:about="&kids;Enactment"/>
    </owl:members>
  </rdf:Description>
  <rdf:Description>
    <rdf:type rdf:resource="&owl;AllDisjointClasses"/>
    <owl:members rdf:parseType="Collection">
      <rdf:Description rdf:about="&kids;Fact"/>
      <rdf:Description rdf:about="&kids;Perception"/>
      <rdf:Description rdf:about="&kids;Hypothesis"/>
      <rdf:Description rdf:about="&kids;Directive"/>
    </owl:members>
  </rdf:Description>

  <!-- Annotations -->

</rdf:RDF>
