<?xml version="1.0"?>
<!--  COSMO version 0.46
   Purpose: COSMO is intended to be an internally logically consistent
     foundation ontology that includes representations of all concepts
     used in the 'base defining vocabulary' of English words (approximately
     2000 base words, up to 10,000 with morphological variants).
     The goal is to provide an inventory of basic concepts that can
     be used in combination to create representations of any concept in
     any specialized domain.  This goal is likely to be approached incrementally,
     and the foundation ontology is always open to inclusion of new
     primitives whose meaning cannot be specified by existing elements in
     the COSMO.  Such an ontology can serve as the basis for semantic interoperability,
     allowing separated groups to define their own domains in terms of the 
     foundation ontology, and communicate when desired by sharing definitions not already in 
     the COSMO.
     
   iteration 585
   Version 577 loaded to CIM3 site 20080208

    ran version 583 through OWL validator, using Pellet called from
       Protege 3.3.1.  No inconsistencies reported, though
       a number of superfluous parent types were detected,
       and some implied instances were absent.
    ca. 3600 OWL Classes, > 181 of which are synonyms
    ca. 376 relations including datatype
 last edit 20080211 by Patrick Cassidy
 version number change to 0.46 at iteration 585 -  multiple small changes; 
    3627 classes, 357 object properties (Protege)
 
  NOTE: most concept representations were taken from the OpenCyc version 0.78,
  and many from the SUMO + MILO versions made available to the IEEE..
  The MILO components were made available under the GNU GPL.
  The comments provided by Cyc (used as a short form of OpenCyc) will usually
  mention constants (terms) that are prefixed by a pound-dollar sign,
  like '#$Quantity', and can be  recognized by that formalism, but
  may not be otherwise labeled as coming from the OpenCyc ontology.  Also,
  any Type that has a <guid> </guid> element will also have come from Cyc.
  SUMO comments are usually prefixed by a 'SUMO:' header.
  Other comments may be prefixed by a 'COSMO note' or without any distinctive 
  source markings, and these may be assumed to be added specifically for 
  the COSMO ontology.
  
  Within the comments, reference to Types or Relations defined in this 
  ontology will often be marked by the use of single quotes, as in 'guid'.
  However, this is not always followed, particularly in cases where the
  Types mentioned have names evocative of ordinary words, like 'Object'
  or 'Person'.  In such cases the quotes may be left off, and the intended
  sense will be that the discussion applies to the real-world entities 
  as well as the formal representation of those entities.
  
  History: Started with the initial COSMO ontology.
     Preliminary merge of basic elements of Cyc and SUMO completed
     20070321.  Started adding in Types from BFO 20070322. Most BFO
     elements added (with modifications) 20070329.
     At each point, some Types and relations that were not in any of the starting
     ontologies, or were present in a different form, were also added.
  -->
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:snap="http://www.ifomis.org/bfo/1.0/snap#"
    xmlns:span="http://www.ifomis.org/bfo/1.0/span#"
    xmlns="http://colab.cim3.net/file/work/SICoP/ontac/COSMO/COSMO.owl#"
    xml:base="http://colab.cim3.net/file/work/SICoP/ontac/COSMO/COSMO.owl">

   <owl:Ontology rdf:about="http://colab.cim3.net/file/work/SICoP/ontac/COSMO/COSMO.owl">
      <rdfs:comment>COSMO ontology, version 0.45, iteration 559.
         Last edit 20080128 by Patrick Cassidy
         Uses elements of the OpenCyc, SUMO, BFO and DOLCE ontologies,
         as well as elements created specifically for COSMO.</rdfs:comment>
   </owl:Ontology>

  <owl:AnnotationProperty rdf:ID="guid">
    <rdfs:comment>Globally unique identifier, fromOpenCyc 0.78.
    NOTE that this is a formatted string having 32 alphanumberic characters
    with embedded hyphesns, though it is represented (temporarily) as a simple string
    here.  
    
    Another form of 'unique identifier' has 16 characters, and is
    represented in COSMO as an AbstractString which is a subtype
    of Identifier.   See 'UniqueIdentifier16'</rdfs:comment>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Globally Unique ID</rdfs:label>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
  </owl:AnnotationProperty>  

  <owl:DatatypeProperty rdf:ID="appearsInAxioms">
    <rdfs:comment>Points to a string with axioms that
       include reference to the domain entity.</rdfs:comment>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
  </owl:DatatypeProperty>  

  <owl:ObjectProperty rdf:ID="disjoint">
    <appearsInAxioms rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >(UAX: SUMAX-25)
(&lt;=>
   (disjoint ?CLASS1 ?CLASS2)
   (and
      (instance ?CLASS1 NonNullSet)
      (instance ?CLASS2 NonNullSet)
      (forall (?INST)
         (not
             (and
                 (instance ?INST ?CLASS1)
                 (instance ?INST ?CLASS2))))))</appearsInAxioms>
    <owl:inverseOf rdf:resource="#disjoint"/>
    <rdfs:comment>Classes are disjoint only if they share no instances, i.e. just
      in case the result of applying IntersectionFn to them is empty.</rdfs:comment>
  </owl:ObjectProperty>

  <owl:ObjectProperty rdf:ID="relatedInternalConcept">
    <rdfs:comment>SUMO - 155</rdfs:comment>
  </owl:ObjectProperty>

  <owl:Class rdf:ID="Synonym">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The class of Synonyms has two uses:
    (1) When a synonymous term is included as a subtype of Synonym, 
      it allows searching for a Type by more than one term, in the case where
      the alternative term(s) are also unique in the ontology.  For
      example, where Cyc class names (but not meanings) have been changed,
      the Cyc term may also be included as a Synonym.  We use
      the isaSynonymOf relation to relate Synonym
      classes to the class with the base name.
     (2) when used with the 'hasSynonym' relation, instances
       of Synonym can specify the context (such as namespace)
       in which the second term is a synonym of the first, and
       can indicate the overall frequency with which the term in that
       context actually has the same meaning as the base term.
       Since there can be multiple instances of the same synonymous
       term, it is represented as a datatype String entity.
       
       NOTE that instances of Synonym need to have unique id's as
       their identifiers in the ontology, so it is recommended 
       that the unique ID's be generated by prefixing a namespace
       to the synonymous term that is pointed to by the 
       'hasSynonymousTerm' property of the Synonym instance.
       
       Thus if some term has the synonym 'process' in the PSL context,
        the instance of Synonym that specifies that relation can be named,
        e.g. 'PSL$process'.
        
        The general English contexts, where words may be ambiguous,
        is indicated by the namespace prefix 'engen'.</rdfs:comment>
  </owl:Class>

  <owl:DatatypeProperty rdf:ID="hasSynonymousTerm">
    <rdfs:comment>points from an instance of Synonym to a string
       that is the term which is synonymous to the base concept.
       The term should represent the synonym in its natural form,
       whether capitalized, with spaces, apostrophes, etc.</rdfs:comment>
    <rdfs:domain rdf:resource="#Synonym"/>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
  </owl:DatatypeProperty>  

  <owl:ObjectProperty rdf:ID="isaSynonymOf">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#SymmetricProperty"/>
    <rdfs:domain  rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
    <rdfs:range  rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
    <owl:inverseOf rdf:resource="#isaSynonymOf"/>
    <rdfs:comment>A pointer from a concept  to another  concept of
    which it is a synonym.  This is a crude method to permit search in
    Protege for synonyms of terms in the class search window.
    
    In v0.3 these synonyms were confined to classes.
    For other synoyms, use 'hasSynonym'.</rdfs:comment>
  </owl:ObjectProperty>

  <owl:AnnotationProperty rdf:ID="hasSynonym">
    <rdfs:comment>hasSynonym is used to point to AbstractStrings that
      can serve as a synonym for the base entity (type or instance),
      in some context.  This relation points to an instance of Synonym,
      and that instance can specify the context in which it
      is a synonym for that word.
      
      Because a single word can be a synonym of multiple terms,
      the structure of the 'Synonym' entity includes not
      only the String expression of the synonymous term, but
      also the context in which it is a synonym.  Among the
      contexts, databases and other knowledge models are included.</rdfs:comment>
    <rdfs:range rdf:resource="#Synonym"/>
  </owl:AnnotationProperty>

  <owl:ObjectProperty rdf:ID="isaSynonymTermOf">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#SymmetricProperty"/>
    <rdfs:domain rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
    <rdfs:range>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/>
          <rdf:Description rdf:about="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
          <rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Thing"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:range>
    <rdfs:comment>A superfluous relation for testing.</rdfs:comment>
  </owl:ObjectProperty>

  <owl:Class rdf:ID="Object">
    <rdfs:comment>Objects can be Physical or Abstract or Mental.  All Objects have at 
    least one AttributeType and associated AttributeValue.
    'Object' is a very primitive concept that cannot be defined, but can be 
    comprehended only by the way this concept interacts with other concepts, 
    and by its subclasses and instances.  This Type is useful as an
    umbrella Type for relatoins on Events.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Sign">
    <rdfs:subClassOf rdf:resource="#Object"/>
    <rdfs:comment>A Sign is something that refers to something other than itself; it
      may be a single entity or a group of entities.
      A Sign may be Physical or Abstract or Mental.  'Sign' is a very general
      concept, and is used primarily through its specialized subtypes.
      A physical phenomenon (smoke) can be a sign (of a smoke-producing process),
      and an AbstractSymbolicObject such as the abstract string 'cat' can be a sign
      that refers to some animals in the real world.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Trace">
    <rdfs:subClassOf rdf:resource="#Sign"/>
    <rdfs:comment>A Trace is one or more Signs that relate to ordered states of 
    some Event or FunctionalProcess.  A sequence of footprints in the mud
    can be a Trace of the event of some animal walking on that ground;
    a sequence of abstract symbols, stored in one of more
    computers, can provide a Trace of some computational or reasoning process
    such as one carried out in the computer.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Record">
    <rdfs:subClassOf rdf:resource="#Trace"/>
    <rdfs:subClassOf rdf:resource="#AbstractSymbolicObject"/>
    <rdfs:comment>A Record is an abstract sequence of symbols (usually linguistic) 
    representing a sequence of events that occurred.  For example,
    a sequence of abstract symbols, stored in one of more
    computers, can provide a Trace of some computational or reasoning process
    such as one carried out in the computer.  As an Artifact, it has to have an IntelligentAgent as
    creator - for traces generated by a computer, that Agent will be the programmer
    or, if sufficiently autonomous, the computer itself - or both.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="ReasoningRecord">
    <rdfs:subClassOf rdf:resource="#Record"/>
    <rdfs:comment>A ReasoningRecord is a Record of some process of Reasoning.
    It will usually be a process of Reasoning used in a Computer, but
    could be a record of a person's reasoning..</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="AbstractEntity">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The most general Type for Objects whose subtypes are abstract - intangible -
    things that do not have mass.   Note that AbstractEntity is not a subtype 
    of AbstractObject - the name 
    'Abstract' is retained for alignment with other ontologies.  NOTE in 
    particular that AbstractEntity is not disjoint from
    MentalObject, which may be created by people in space and time, and
    hae a location in space and time.  The kind of abstract things that do not
    have a locaiton in space and time are under 'AbstrctObject' in COSMO.

     COSMO Note:  the notion of 'Abstract' has historically been somewhat vague.
     It is often defined by saying that it represents things 'not located in
     space or time' - but then subclasses are defined which are clearly 
     mental constructs with a defined creation time (e.g. musical compositions) -
     which means that they must indeed be located in time and space. 
     In this ontology we distinguish 'Abstract' things from 'MentalObjects' -
     the latter are things created by IntelligentAgents (people) that have
     no mass, and therefore would traditionally be categorized as 'Abstract'.
     'AbstractObject' here is used mostly to categorize mathematical things 
     such as numbers, which arguably do not depend on intelligent entities for 
     their existence. But 'AbstractEntities" and 'MentalObjects' are not considered 
     disjoint here, so there is room for people to argue whether mathematical
     concepts are created or merely discovered by mathematicians - we take no 
     position on that issue.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="AbstractObject">
    <rdfs:subClassOf rdf:resource="#Object"/>
    <rdfs:subClassOf rdf:resource="#AbstractEntity"/>
    <owl:disjointWith>
       <owl:Class rdf:about="#PhysicalObject"/>
    </owl:disjointWith>
    <rdfs:comment>An AbstractObject is an entity which does not exist in space or time.
     This is more stringnent than merely not having mass, the criterion for
     belinging to 'AbstractEntity.  This category is mostly for mathematical
     concepts.  Under 'AbstractEntity' we also have 'MentalObjects', which do 
     exist in space and time.
     
     COSMO Note:  the notion of 'Abstract' has historically been somewhat vague.
     It is often defined by saying that it represents things 'not located in
     space or time' - but then subclasses are defined which are clearly 
     mental constructs with a defined creation time (e.g. musical compositions) -
     which means that they must indeed be located in time and space. 
     In this ontology we distinguish generically 'Abstract' things from 'MentalObjects' -
     the latter are things created by IntelligentAgents (people) that have
     no mass, and therefore would traditionally be categorized as 'Abstract'.
     'AbstractObject' here is used mostly to categorize mathematical things 
     such as numbers, which arguably do not depend on intelligent entities for 
     their existence. But 'AbstractEntities" and 'MentalObjects' are not considered 
     disjoint here, so there is room for people to argue whether mathematical
     concepts are created or merely discovered by mathematicians - we take no 
     position on that issue.    See the note under 'AbstractEntity' to see how 'Abstract' is used in this ontology. 
    The current (20061027) arrangement here is provisional, keeping some of the
    terminology from Cyc and SUMO for alignment - but it may be changed slightly 
    in the future in a way that will not affect inferencing.

    Intangible_Cyc__Abstract_SUMO__abstract_object_ISO15926

   ISO15926 An Abstract-object is a thing that does not exist in space-time.
   (COSMO note - this is not the interpretation in COSMO - MentalObjects
   are abstract, but they do 'exist' in our ordinary space and time.)

   SUMO: Abstract : Properties or qualities as distinguished from any particular embodiment
   of the properties/qualities in a physical medium. Instances of Abstract can be said
   to exist in the same sense as mathematical objects such as sets and relations, 
   but they cannot exist at a particular place and time without some
   physical encoding or embodiment.

   #$Intangible:  OPENCYC 1: MAY 23, 2002
   The collection of things that are not physical - are not made of, or encoded in, matter. 
   Every #$Collection is an #$Intangible (even if its instances are tangible), and so 
   are some #$Individuals. Caution: do not confuse 'tangibility' with 'perceivability'
   - humans can perceive light even though it's intangible--at least in a sense. 
   For more on this issue, see the relevant #$cyclistNotes.</rdfs:comment>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
     >Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]</rdfs:label>
  </owl:Class>

   <owl:Class rdf:ID="Context">
    <rdfs:comment>COSMO: Context is a very general class of entities that
      can affect the truth of a logical sentence; within any
      given Context, the factual assertions should all be
      logically consistent.  A Context may be relevant to the internal
      states and processes of a computational system, or may more generally
      describe the broad situation in which an Agent finds itself when 
      processing information for the purpose of making a decision.  For the
      latter agent context, the subtype 'SituationalContextComponent' is 
      relevant.  A Context can be a time interval, location, belief system,
      fictional world, theory, hypothetical world, counterfactual situation, 
      segment of text, DatabaseGroup, or the state of our own real world, among other things.
      Contexts can be nested, combined, or intersected.  For example, 
      a Context consisting of a TimeInterval can be intersected with a Context
      consisting of a GeographicalArea to make a Context within with assertions
      are explicitly true only in that time and place.  That does not
      mean, of course that the assertion cannot be true elsewhere; 
      it just doesn't guranteee truth elsewhere.  Every assertion in
      the COSMO ontology is implicitly true only in the 
      context of the COSMO ontology, which is itself a theory.  But that 
      implicit qualification does not appear directly in any asertion - 
      it can be explicitly mentioned if and when COSMO assertions are 
      referenced in other ontologies.
      
      The nesting of Contexts provides a mechanism to create a 
      'lattice' of theories.  In a subcontext for any given
      Context, all the assertions of the parent Context will be
      true in the subcontext, and additional assertions may also be true.
      In this respect, a Context is similar to the 'Microtheories' of
      the Cyc ontology system; it also has some resemblance to
      the 'Environments' discussed by Ballim and Wilks ('Artifical Believers',
      Lawrence Erlbaum, 1991).
      
      One specialized example of Context is a 'DatabaseGroup'.  In a
      particular Organization, its set of Databases, if intended to 
      represent some consistent group of facts, can be viewed and 
      represented as a Context within which reasoning may be performed.</rdfs:comment>
  </owl:Class>

  <owl:ObjectProperty rdf:ID="holdsInContext">
     <rdfs:domain rdf:resource="#Proposition"/>
    <rdfs:range rdf:resource="#Context"/>
    <rdfs:comment>holdsInContext relates a reified Proposition to a Context in which
     it is asserted to be true.  The Context may be as simple as a
     TimeInteral or a Database, or it may be a complex context which
     is a conjunction of a time interval, a location, a belief system, and
     any other thing tha might affect the truth of an assertion.  Context
     in COSMO is used solely as a syntactic device to provide
     an umbrella category that can serve as the argument restriction
     on the 'holdsInContext' statement.  There is no general 'theory'
     of context implied in this usage.  Other than its syntactical
     usage, the only thing that can be asserted about 'contexts' generally
     is that the principle of non-contradiction holds only in a single
     context, and for assertions defined in different contexts, it cannot
     be expected that they will be necessarily true in any other context.
     
     Any set of assertions (including this ontology) will have an
     implied enveloping context.  If the assertions are to be reused,
     it is necessary to be sure that the context of reuse is the same as that
     of the original set of assertions.</rdfs:comment>
  </owl:ObjectProperty>

  <owl:Class rdf:ID="SituationalContextComponent">
    <rdfs:subClassOf rdf:resource="#Context"/>
    <rdfs:comment>Each SituationalContextComponent is one of the components of 
      the situation in which an IntelligentEntity finds itself, of which
      it must be aware in order to act or respond appropriately so
      as to fulfill its goals.  Each SituationalContextComponent is
      defined relative to a particular CognitiveAgent whose actions
      are being represented in the ontology.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="PhysicalContext">
    <rdfs:subClassOf rdf:resource="#SituationalContextComponent"/>
    <rdfs:comment>The PhysicalContext in a Situational is the set of 
      physical objects and attributes that exist at a particular time
      an in a particular place that affect the way an Agent will make
      a decision, and may affect the outcome of that decision.  A simple
      PhysicalContext is, for example, who is present and interacting with 
      the Agent.  What is the location, time, temperature?  Is the agent indoors
      or outdoors?  On land or sea, or underwater?  Is anything happening
      that can physcally affect the Agent?</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="SocialContext">
    <rdfs:subClassOf rdf:resource="#SituationalContextComponent"/>
    <rdfs:comment>The SocialContext in a Situational is the set of 
      people that an Agent is in contact with, or is acting on
      behalf of, directly or indirectly, at a particular time. It also 
      includes prior interactions and goals that affector are affected by 
      agents other than the one .</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="SystemContext">
    <rdfs:subClassOf rdf:resource="#SituationalContextComponent"/>
    <rdfs:comment>A SystemContext is a SituationalContextComponent
    that is specific for computational agents, whether physical
    (a computer system including hardware) or merely software.
    A computational system can be viewed as one agent, though it may include
    within it multiple software agents.  The SystemContext will include
    anything affecting the ability of the agent to act, including,
    among other things, the hardware resources available for use -
    power sources (line or batteries) CPU, disks, RAM, terminals, 
    network connections, anything else connected to a system port, etc.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="NetworkContext">
    <rdfs:subClassOf rdf:resource="#SystemContext"/>
    <rdfs:comment>The NetworkContext of a computational system 
    consists of the number, type, and status of network connections
    connected to system ports, as well as any the type and status
    of software components that have the capbility of interacting
    with networks.  A 'netowrk' includes only those communications
    links that are connected to other computers; links to
    other devices such as measuring devices or non-network
    output devices, are not condered as part of the 'network'.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="GenericLocation">
    <rdfs:subClassOf rdf:resource="#SituationalContextComponent"/>
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
    <rdfs:comment>GenericLocation is the Type representing the most
      general notion of location, which can be abstract or concrete,
      a region of space (including an abstract space, such as the 
      Internet considered as a set of nodes and links, where the nodes
      can represent computers whose physical location may vary),
      a point in space, or a physical object (e.g. building, ship, room).

     NOTE that an Address is not a location, but a label for a location.
        See 'Address'.

     NOTE: although *almost* all GenericLocations are exclusively spatial
      in some way, there is one 'TimeAndPlace' that is spatiotemporal,
      being a region of space-time that specifies some region of space
      over some interval of time.  Use of an instance of 'TimeAndPlace'
      as an argument of a location relation allows one to include the
      important time interval qualifier in location relations, even though
      one is using only binary relations.  this would not be necessary
      in a representation with higher-arity relations.
       
     This is somewhat similar to the Cyc 'Location-Underspecified'
     Cyc comment:   The collection of locations, tangible or
         otherwise, which are typically conceptualized by human
         beings for purposes of common-sense reasoning as 'locations'.
         This collection thus includes tangible Places such as
         #$Ireland-TheIsland, as well as metaphoric locations. For
         instance, many states-of-being are conceptualized as
         abstract locations, such as Trouble ('he saw trouble
         ahead'), Depression ('she fell into a ...'),
         #$Happiness ('they found bliss together').</rdfs:comment>
      <guid>be14f511-9c29-11b1-9dad-c379636f7270</guid>
   </owl:Class>

  <owl:Class rdf:ID="Location-Underspecified">
    <rdfs:comment>Synonym of GenericLocation, included here as a
    pointer to the Cyc element.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#Synonym"/>
    <isaSynonymOf rdf:resource="#GenericLocation"/>
  </owl:Class>

  <owl:Class rdf:ID="RelativeLocation">
    <rdfs:comment>A RelativeLocation is a location that is explicitly relative to
      something else, which may be a region or an object.  All locations
      are ultimately 'relative' in the sense that they can only be understood
      by reference to a distance and/or oritentation with respect to some object.
      However, this Type 'RelativeLocation' is intended to represent those
      locations that are explicitly relative to something else, in particular
      objects or regions that are part of some other object or region.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#GenericLocation"/>
  </owl:Class>

  <owl:ObjectProperty rdf:ID="isLocatedAtOrOn">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#TransitiveProperty"/>
    <rdfs:domain rdf:resource="#GenericLocation"/>
    <rdfs:range rdf:resource="#GenericLocation"/>
    <rdfs:comment>This is the most generic generic 'location' relation, 
      and differs from its subProperty 'isLocatedAt' only in that 
      to be 'located at or on' includes the possibility that
      some pile of objects may be located in some open container and 
      extend beyond the top of the container, but will move when that
      container moves because it is held to the container by the
      force of gravity or by some topological constraint.  The 
      subproperty 'isLocatedAt' means that the thing located is
      wholly locaed within the spatial region coextensie with the
      convex hull of the thing or place where it is located.
      Thus a pile of coal in an open railway coal car can be said to be
      'contained' in the coal car even though it may extend above the
      top of the coal car; it will go wherever the coal car goes,
      as long as it satisfies this relation.  Likewise, flowers in a 
      vase are located 'at or on' the vase, though they typically extend 
      beyond the top of the vase, and the top of the flowers may
      even be above the vase by more than the height of the vase.

      The 'isContainedIn'  relation is a subproperty of this relation; therefore
      if {?x isContainedIn ?Obj} then {?x isLocatedAtOrOn ?Obj}.
      
      NOTE, however that 'isSupportedBy' is not a subtype of 'isLocatedAtOrOn'
      because the supporting object may be flat and extensive, and the supported
      object may extend well above the surface of the supporting object..</rdfs:comment>
  </owl:ObjectProperty>
  
  <owl:TransitiveProperty rdf:ID="isLocatedAt">
    <rdfs:domain rdf:resource="#GenericLocation"/>
    <rdfs:range rdf:resource="#GenericLocation"/>
    <rdfs:subPropertyOf rdf:resource="#isLocatedAtOrOn"/>
    <rdfs:comment>A general 'location' relation for objects and
      regions (but not for Events - use 'occurredAt').
      The location can be a region of space (connected or disconnected)
      or an object (physical or abstract).  Being 'located' at an
      Object means being located within the convex hull of the Object,
      But recall that a GeographicalRegion includes some space above
      the surface of that region, so it is possible that ?obj isLocateAt
      a GeographicalRegion even if it is in the air not far above the 
      surface of that region.
      If a pile of objects or a large object is 'contained' in an
      open-top container, and extends above the top of that container,
      it cannot be said to be 'located at' thet container, in this sense.
      For that case, use 'isContainedIn' or its parent 'isLocatedAtOrOn'.
      The value (object) of this relation answers the question 
      'where is it?' (for the subject) in some sense.  Somewhat 
      non-intuitively, this relation can be used to specify that some set of 
      beliefs (a BeliefSystem) is held by on or more people,
      since the BeliefSystem is considered an InformationStore that
      can have a physical location; that is, beliefs are located in the
      heads of people, or of Groups of people. However, NOTE that 
      specific diseases cannot be located in people by this
      relation, because a Disease is considered as an Event.  Use
      'occurredAt' for relating specific instances of Disease to
      particular people or groups of people.
      
      NOTE that this is an instance-level relation and describes
      where an object is actually located at some particular time.
      For describing where objects typically are located (e.g.
      parts of the body), use 'isNormallyLocatedAt', a relation
      that can take a individual Object or an ObjectType as the
      subject
      
      NOTE: 'isLocatedAt' may be used with an instance
       of 'TimeAndPlace' (a four-dimensional portion of aspace-time)
       in the object position of the relation, to specify the
       location of some thing (but not Events) over some
       interval of time, using a binary relation.  Although this relation
       is transitive, there are permitted range instances that cannot
       bw located at some permitted domain instances: for example, a
       'TimeAndPlace' will never be locatedAt an Object or region that
       is not itself Four-dimensional, unless the domain instance is nominally
       a TimeAndPlace, but with the Time dimension of zero length, in which case
       the domain instance is effectively three-dimensional.  But in general, 
       if the subject is a TimeAndPlace, the Object should also be a TimeAndPlace,
       not a Region or Object.  To avoid unintended errors, this restriction
       should be encoded as a constraint.
       
      NOTE: this relation is close in meaning to that of the OBO_REL relation
      'located_in' (http://www.obofoundry.org/ro/#OBO_REL:located_in).  In OBO
      some relations may also be used on Types to create an implicit restriction,
      but such usage is not part of COSMO, and that usage would need to be 
      represented as a rule.
    OBO_REL: located_in (see http://www.obofoundry.org/ro/)
    OBO comments for located_in: Location as a relation between instances: 
       The primitive instance-level relation c located_in r at t reflects the fact
       that each continuant is at any given time associated with exactly one spatial 
       region, namely its exact location. Following we can use this relation to define 
       a further instance-level location relation - not between a continuant and the 
       region which it exactly occupies, but rather between one continuant and 
       another. c is located in c1, in this sense, whenever the spatial region 
       occupied by c is part_of the spatial region occupied by c1. Note that 
       this relation comprehends both the relation of exact location between one 
       continuant and another which obtains when r and r1 are identical 
       (for example, when a portion of fluid exactly fills a cavity), as well as 
       those sorts of inexact location relations which obtain, for example, 
       between brain and head or between ovum and uterus
    
      </rdfs:comment>
  </owl:TransitiveProperty>
  
  <owl:ObjectProperty rdf:ID="occurredAt">
     <rdfs:domain>
       <owl:Class>
          <owl:unionOf rdf:parseType="Collection">
            <owl:Class rdf:about="#Event"/>
            <rdfs:Class rdf:about="#EventType"/>
          </owl:unionOf>
        </owl:Class>
     </rdfs:domain>
    <rdfs:range rdf:resource="#GenericLocation"/>
    <rdfs:comment>A 'location' relation for Events.  For object
          or region locations, see 'isLocatedAt'.
      The location is a GenericLocation: region of space 
        (connected or disconnected) or an object
        (physical or abstract)
   .  The value of this relation answers the question
        'where did it happen?'.  
      NOTE that the use of the past tense in this relation does not necessarily
      mean that the Event argument occurred in the past before the assertion time;
      if the relation relates a possible future Event, this relation can also 
      be used.  The past tense merely emphasizes that we are discussing Events
      that, in the given context, are viewed as completed and not ongoing.
        
        This can also be used for types of Events, to specify
        a particular location where they always occur.  But
        to specify types of locations where types
        of Events usually occur, use 'typicallyOccursAt'.</rdfs:comment>
  </owl:ObjectProperty>
  
  <owl:ObjectProperty rdf:ID="typicallyOccursAt">
    <rdfs:domain rdf:resource="#EventType"/>
    <rdfs:range rdf:resource="#LocationType"/>
    <rdfs:comment>A Type-level 'location' relation for Events,
    to specify that a certain type of Event usually occurs
    at a certain type of location.
    
      For the instance-level location relation for Events,
        use 'occurredAt'.
      For object  or region locations, see 'isLocatedAt'.
      The location specified is a GenericLocation: region of space 
        (connected or disconnected) or an object
        (physical or abstract)
   .  The value of this relation answers the question
        'where does it usually happen?'.
   .</rdfs:comment>
  </owl:ObjectProperty>
  
<!--
  added below, after 'Occurrent'
  <rdfs:subClassOf rdf:resource="#Occurrent"/>
-->
  <owl:Class rdf:ID="SpatiotemporalRegion">
    <rdfs:subClassOf rdf:resource="#Region"/>
    <rdfs:comment>BFO Definition: An occurrent at or in which processual entities
        can be located.
        
        COSMO note:  this concept in COSMO is very generic,a nd can be used to 
         specify a spatiotemporal region of any shape.  To specify 
         a spatiotemporal region of a more defined shape, use 'TimeAndPlace',
         for which the spatial shape of the region will depend on the 'location'
         component of the instance defined.
        
        BFO Examples: the spatiotemporal region occupied by a human life,
        the spatiotemporal region occupied by the development of a cancer tumor,
        the spatiotemporal context occupied by a process of cellular meiosis</rdfs:comment>
    <owl:equivalentClass>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#ConnectedSpatiotemporalRegion"/>
          <owl:Class rdf:about="#ScatteredSpatiotemporalRegion"/>
        </owl:unionOf>
      </owl:Class>
    </owl:equivalentClass>
    <owl:disjointWith>
      <owl:Class rdf:about="#TemporalRegion"/>
    </owl:disjointWith>
    <owl:disjointWith>
      <owl:Class rdf:about="#SituationProcessEventOrState"/>
    </owl:disjointWith>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >spatiotemporal_region</rdfs:label>
  </owl:Class>

<!-- *db587 added TimeSlice at 585 -->
  <owl:Class rdf:ID="TimeAndPlace">
    <rdfs:subClassOf rdf:resource="#GenericLocation"/>
    <rdfs:subClassOf rdf:resource="#TimeSlice"/>
    <rdfs:subClassOf rdf:resource="#SpatiotemporalRegion"/>
    <rdfs:subClassOf rdf:resource="#CompositeConcept"/>
    <rdfs:comment>A TimeAndPlace is a GenericLocation during some interval
    of time.  It is a four-dimensional spatial region in the way
    that a time-slice of a PhysicalObject is a four-dimensional
    Object.  These concepts are related inheriting the character of
    the TimeSlice Type.
    
      this is a SpatiotemporalRegion that has an explicit location and an explicit 
      time interval specified.  The location is generic, therefore it can
      be defined relative to some object; i.e. one can specify the 
      location of the heart of an individual person over some period
      of time as an instance of this Type.
      
     NOTE: That 'TimeAndPlace' is a subtype of GenericLocation,
      as well as of SpatiotemporalRegion.  Although *almost* all
      GenericLocations are exclusively spatial,
      'TimeAndPlace' is spatiotemporal, being a region of space-time 
      that specifies some region of space over some interval of time.
      Use of an instance of 'TimeAndPlace' as an argument
      of a location relation allows one to include the
      important time interval qualifier in location relations, even though
      one is using only binary relations.  this would not be necessary
      in a representation with higher-arity relations.</rdfs:comment>
  </owl:Class>

  <owl:ObjectProperty rdf:ID="hasSpatialRegion">
    <rdfs:comment>hasSpatialRegion specifies the spatial component
      (of zero to three dimensions) which is extended in time to
      generate a TimeAndPlace.</rdfs:comment>
    <rdfs:domain rdf:resource="#TimeAndPlace"/>
    <rdfs:range rdf:resource="#GenericLocation"/>
  </owl:ObjectProperty>  

  <owl:ObjectProperty rdf:ID="hasTimeInterval">
    <rdfs:comment>hasTimeInterval specifies the time component
       which extends the spatial component of a TimeAndPlace into
       the time dimension, to generate the TimeAndPlace which is the
       subject of this relation.  The intent of this relation can
       be alternatively specified by filling in the values for 
       the beginning and starting times inherited from 'TimeSlice'.</rdfs:comment>
    <rdfs:domain rdf:resource="#TimeAndPlace"/>
    <rdfs:range rdf:resource="#TemporalLocation"/>
  </owl:ObjectProperty>  

<!--  from SUMO: day
    <relatedInternalConcept rdf:resource ="#DayFn"/>
-->
  <owl:Class rdf:ID="TimeDuration">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Any measure of length of time, with or without respect to the universal timeline.</rdfs:comment>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#TimeMeasure"/>
    </rdfs:subClassOf>
  </owl:Class>

  <owl:Class rdf:ID="DayDuration">
    <relatedInternalConcept>
      <owl:Class rdf:about="#Day"/>
    </relatedInternalConcept>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#TimeDuration"/>
    </rdfs:subClassOf>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Time unit. 1 day = 24 hours.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Day">
    <relatedInternalConcept rdf:resource="#DayDuration"/>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#TimeInterval"/>
    </rdfs:subClassOf>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The Class of all calendar Days.</rdfs:comment>
  </owl:Class>
 
     <owl:Class rdf:ID="Street-Generic">
         <rdfs:comment>#$Street-Generic is a specialization of both
             #$Roadway and #$UrbanArea.  Each instance of
             #$Street-Generic is a #$Roadway located inside a city or town.
             
             NOTE: a modern street is typically paved, but that is not
              a necessary attribute of a Street.</rdfs:comment>
         <guid>bd58f514-9c29-11b1-9dad-c379636f7270</guid>
         <rdf:type rdf:resource="#PhysicalObjectType"/>
         <rdfs:subClassOf rdf:resource="#Roadway"/>
     </owl:Class>
 
     <owl:Class rdf:ID="Street-Urban">
         <rdfs:comment>A typical busy street in an urban area.
           This is the physical object that is the street, not a
           region of space.  It would extend down to the underlying soil,
           and include all materials added (such as crushed gravel) to 
           prepare the roadbed.
         
           COSMO note:  This 'street; Type is interpreted as the full
           public right-of-way, including the sidewalks, up to the
           private property line of the property bordering on the
           street.  A RealEstate bounded by a street will therefore be
           related to the street by 'isAdjacentTo'.</rdfs:comment>
         <guid>bd58b4f8-9c29-11b1-9dad-c379636f7270</guid>
         <rdf:type rdf:resource="#PhysicalObjectType"/>
         <rdfs:subClassOf rdf:resource="#Street-Generic"/>
     </owl:Class>
 
    <owl:Class rdf:ID="PopulatedPlace">
        <rdfs:comment>A #$Place or area with clustered or scattered
            buildings and a permanent human population, including
            cities, settlements, towns, and villages.  It does not
            include #$Locales.</rdfs:comment>
        <guid>acf243a4-24df-41d7-92f0-8a8fd5ad2507</guid>
        <rdfs:subClassOf rdf:resource="#GeographicalRegion"/>
    </owl:Class>

  <owl:Class rdf:ID="Outdoors">
    <rdfs:comment>Any region on the surface of the Earth, within the
    Earth's atmosphere, or on some object itself located on
    the surface of the Earth (including on ships at sea), which is not inside of 
    an enclosed structure.  See 'OutdoorsObject' for further elaboration.
    
    The Cyc 'OutdoorLocation' is very similar - not yet (V0.2) clear
    if it is different.</rdfs:comment>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#GeographicalArea"/>
    </rdfs:subClassOf>
  </owl:Class>

  <owl:Class rdf:ID="OutdoorLocation">
        <rdfs:comment>A specialization of #$GeographicalRegion.  Each
            instance of #$OutdoorLocation is a region of outdoor space;
            i.e. a region that is directly subject to atmospheric
            weather.  Thus, the collection #$OutdoorLocation does _not_
            include as instances any instances of #$UnderwaterLocation
            (q.v.) or any places that are underground (see
            #$Underground).  Specializations of #$OutdoorLocation
            include #$MountainRange, #$Stream, and #$Highway.</rdfs:comment>
        <guid>bd58b186-9c29-11b1-9dad-c379636f7270</guid>
        <rdfs:subClassOf rdf:resource="#Outdoors"/>
    </owl:Class>

    <owl:Class rdf:ID="HumanResidenceArea">
        <rdfs:comment>A specialization of #$GeographicalRegion.  Each
            instance of #$HumanResidenceArea is a region in which a
            number of people live semi-permanently (that is, for a
            duration of at least a year or more).  Examples include
            #$SanFranciscoBayArea, #$ResearchTrianglePark, research
            stations at the #$SouthPole, and radar posts in the Aleutians.</rdfs:comment>
        <guid>bd58caab-9c29-11b1-9dad-c379636f7270</guid>
        <rdfs:subClassOf rdf:resource="#PopulatedPlace"/>
        <rdfs:subClassOf rdf:resource="#OutdoorLocation"/>
    </owl:Class>

    <owl:Class rdf:ID="UrbanArea">
        <rdfs:comment>A subcollection of #$HumanResidenceArea.  Each
            instance of #$UrbanArea is a geographical region the whole
            of which (more or less) is characterized by typically  urban
            features (such as streets, buildings, businesses, houses,
            schools, sidewalks, sewer systems, power lines, automobiles,
            pedestrians, and so on).  An urban area might be as small as
            an inner-city street corner or as large as the New York City
            Metropolitan Area.  By default, urbanness is a  stuff-like
            property of human residence areas: (nearly) every subregion
            of an #$UrbanArea is itself an #$UrbanArea.  Examples
            include #$UTAustinCampus, #$ResearchTrianglePark, and the
            territorial extent of various cities (#$CityOfAustinTX,
            #$CityOfToulouseFrance, etc.).</rdfs:comment>
        <guid>bd58caec-9c29-11b1-9dad-c379636f7270</guid>
        <rdfs:subClassOf rdf:resource="#HumanResidenceArea"/>
    </owl:Class>

  <owl:Class rdf:ID="CityBlock">
         <rdfs:comment>A collection of urban regions.  Instances of
             #$CityBlock are usually roughly rectangular regions within
             cities or towns that are bounded by four streets running
             approximately at right angles to each other, and such that
             they do not spatially subsume any other such regions.  City
             blocks are often divided into one or more instances of
             #$LotOfLand, on which typically stand houses or other  buildings.
             
             NOTE: a Region, not a PhysicalObject.  A block can be empty of 
             structures, so there is no necessary connection.  A CityBlock may
             have some thoroughfares in it - access roads, driveways,
             so it is not necessarily devoid of roadways.  The usage
             will be conventional, that is, anything usually thought of or referred
             to in the same sense as a well-demarcated city block can be
             represented as an instance of CityBlock, even if it is not
             neatly adjoined by urban streets on every side.
             
             SUMO: A square-shaped area surrounded by Roadways 
              which is part of a City and typically contains Buildings.</rdfs:comment>
         <guid>bdf4b730-9c29-11b1-9dad-c379636f7270</guid>
         <rdfs:subClassOf rdf:resource="#UrbanArea"/>
         <rdfs:subClassOf>
           <owl:Restriction>
             <owl:onProperty>
               <owl:ObjectProperty rdf:about="#isAdjacentTo"/>
             </owl:onProperty>
             <owl:someValuesFrom>
               <owl:Class rdf:about="#Street-Urban"/>
             </owl:someValuesFrom>
           </owl:Restriction>
         </rdfs:subClassOf>
     </owl:Class>
 
  <owl:Class rdf:ID="GeopoliticalArea">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >COSMO Note: a GeopoliticalArea is the spatial region containing the 
     physical portion of earth controlled by a Geopolitical agent 
     (the government of a country or subdivision).  It is not a physical object, 
     but contains all objects on or near the earth's surface, so that an object
     'locatedAt' any region will also be 'locatedAt' any larger region containing]
     the first region.

     SUMO: Any GeographicArea which is associated with some sort of political structure.  
     This class includes Lands, Cities, districts of cities, counties, etc.
     Note that the identity of a GeopoliticalArea may remain constant after a change in borders.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#GeographicalArea"/>
  </owl:Class>

  <owl:Class rdf:ID="CountryArea">
    <rdfs:subClassOf rdf:resource="#GeopoliticalArea"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >COSMO Note: in SUMO named 'Nation'.  Here we make it unambigous that it is the
    spatial region containing the physical part of the Earth that is represented, not
    the objects in that region nor the governmental organization controlling that
    region.  A CountryArea is controlled by a Country (a GeopoliticalEntity)

   SUMO: Nation: The physical area, not the organization
   The broadest GeopoliticalArea, i.e. Nations are GeopoliticalAreas that are not part of any other overarching and comprehensive governance structure (excepting commonwealths and other sorts of loose international organizations).</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="CityArea">
    <rdfs:subClassOf rdf:resource="#GeopoliticalArea"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >The spatial region of the Earth's surface encompassed by the borderlines
    of a City.
    
    COSMO Note: in SUMO named 'City'.  Here we make it unambigous that it is the
    spatial region containing the physical part of the Earth that is represented,
    not the physical objects in the region, nor the governmental organization
    that controls the region..
    The physical objects in that region are represented separately, and are
    located at the geopolitical area

   SUMO:  A LandArea of relatively small size, inhabited by a community of people,
   and having some sort of political structure. Note that this class includes both large cities and small settlements like towns, villages, hamlets, etc.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="CityDistrict">
    <rdfs:subClassOf rdf:resource="#UrbanArea"/>
    <rdfs:comment>An area that is part of a City, not necessarily
    corresponding to official political district lines.</rdfs:comment>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#isaSpatialPartOf"/>
           </owl:onProperty>
             <owl:someValuesFrom>
               <owl:Class rdf:about="#City"/>
             </owl:someValuesFrom>
         </owl:Restriction>
       </rdfs:subClassOf>
  </owl:Class>

  <CityArea rdf:ID="LondonArea">
    <rdfs:comment>The physical area of The city of London, the capital of the United Kingdom.
     This object includes the space containing everything in the city (at any given time), including
     the people.</rdfs:comment>
    <isaSpatialPartOf>
      <CountryArea rdf:ID="UnitedKingdomArea">
        <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >The physical area of the United Kingdom, including everything in it.</rdfs:comment>
      </CountryArea>
    </isaSpatialPartOf>
    <isSpatiallyDisjointWith>
         <CityArea rdf:ID="DublinIreland"/>
    </isSpatiallyDisjointWith>
  </CityArea>

  <CityArea rdf:ID="NewYorkCityArea">
    <rdfs:comment>The physical area of The city of New York.
     This object includes the space containing everything in the city (at any given time), including
     the people.</rdfs:comment>
    <isaSpatialPartOf>
      <CountryArea rdf:ID="TheUnitedStatesArea">
        <rdfs:comment>The physical area of the United States of America,
         including the regions containing everything in it.</rdfs:comment>
        <isSpatiallyDisjointWith rdf:resource="#UnitedKingdomArea"/>
      </CountryArea>
    </isaSpatialPartOf>
    <isSpatiallyDisjointWith rdf:resource="#DublinIreland"/>
    <isSpatiallyDisjointWith rdf:resource="#LondonArea"/>
  </CityArea>

    <CityBlock rdf:ID="WorldTradeCenterBlockNY">
         <rdfs:comment>The squarish region in New York City on which 
           the two World Trade center towers were located on Sept. 10, 2001.</rdfs:comment>
         <isLocatedAt rdf:resource="#NewYorkCityArea"/>
         <isAdjacentTo>
            <Street-Urban rdf:ID="ChurchStreetManhattan"/>
         </isAdjacentTo>
    </CityBlock>
 
 <TimeAndPlace rdf:ID="WorldTradeCenter20010911">
    <rdfs:comment>The city block on which the two World Trade Center towers were
      located, during the calendar day Sept. 11, 2001, EST (Z-5).</rdfs:comment>
    <hasSpatialRegion rdf:resource="#WorldTradeCenterBlockNY"/>
    <hasTimeInterval>
       <Day rdf:ID="DTEG20010911Z-5">
          <rdfs:comment>The calendar day from 12:00 AM to the instant before 12
              midnight on Sept. 11, 2001, EST (Z-5) New York City time.</rdfs:comment>
          <hasStringRepresentation rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >9-11.</hasStringRepresentation>
       </Day>
    </hasTimeInterval>
 </TimeAndPlace>

  <owl:ObjectProperty rdf:ID="isSomethingOtherThan">
    <rdfs:comment>isSomethingElseThan is a relation that specifies
     that the subject entity of the relation is **not** the
     object entity of the relation.  This is a crude way of
     saying that one knows what something **is not**, even when
     one cannot be more specific about what something **is**.
     The subject and object should have a common Type, but that
     Type can be any Type.</rdfs:comment>
  </owl:ObjectProperty>  

<!-- *db587 -->
   <owl:Class rdf:ID="Alibi">
     <rdfs:comment>An unspecified location that is somewhere other than
       some reference location, for some interval of time.  This 'location'
       category serves as the base element for the pointer to the location where 
       something (person, vehicle) is known **not to be** (at some
       particular time).  Being able to assert absence in a particular location
       does not necessarily mean that the true location of the individual thing
       is actually known - one may simply look around a room and say 'he's
       not here'.
       
       Usage: {?X isLocatedAt ?ALIBI} means that ?X was someplace other
       than the TimeAndPlace pointed to by the isSomethingOtherThan
       relation on the instance of TimeAndPlace that is the ?ALIBI.
       
       This Type allows one to express notions such as 'NN wasn't at the 
        (meeting/party/scene of the crime/etc)'
      
      Every Alibi must specify exactly where and when an entity was absent,
       using the relation 'isSomethingOtherThan' and pointing to a
       TimeAndPlace.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#TimeAndPlace"/>
     <rdfs:subClassOf>
         <owl:Restriction>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#isSomethingOtherThan"/>
            </owl:onProperty>
            <owl:someValuesFrom rdf:resource="#TimeAndPlace"/>
         </owl:Restriction>
     </rdfs:subClassOf>
  </owl:Class>

   <owl:Class rdf:ID="Elsewhere">
      <rdfs:comment>A synonym for 'Alibi'..</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Synonym"/>
      <isaSynonymOf rdf:resource="#Alibi"/>
   </owl:Class>

   <owl:Class rdf:ID="SomeplaceElse">
      <rdfs:comment>A synonym for 'Alibi'..</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Synonym"/>
      <isaSynonymOf rdf:resource="#Alibi"/>
   </owl:Class>

   <owl:Class rdf:ID="Abroad">
      <rdfs:comment>A TimeAndPlace that is disjoint from a
       particular country at a particular time.  This is one
       sense of the English word 'abroad'.</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Alibi"/>
   </owl:Class>

   <owl:Class rdf:ID="Absent">
      <rdfs:comment>A TimeAndPlace that an object is not at,
         and is disjoint from some other TimeAndPlace.
         Very similar to 'Alibi', but can be used for
         convenience with the linguistic 'absent'.  Can be
         used for inanimate objects, not just people. See also 'Absence' for the Event.
         
       Usage: {?X isLocatedAt ?ABSENT} means that ?X was someplace other
       than the TimeAndPlace pointed to by the isSomethingOtherThan
       relation on the instance of TimeAndPlace that is the ?ABSENT.</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Alibi"/>
   </owl:Class>

   <owl:Class rdf:ID="Absence">
      <rdfs:comment>Absence is an Event that consists of 
        some object being absent, and takes place in an
        Absent (a TimeAndPlace where something is not present.).
        For each instance, the Object absent and place of absence must
        be specified.
        
        Linguistically the phrase 'J wasn't at work on Monday'
        can be expressed as an Absence Event.</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#NonEvent"/>
     <rdfs:subClassOf>
         <owl:Restriction>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#hadParticipant"/>
            </owl:onProperty>
            <owl:someValuesFrom rdf:resource="#Object"/>
         </owl:Restriction>
     </rdfs:subClassOf>
     <rdfs:subClassOf>
         <owl:Restriction>
            <owl:onProperty>
              <owl:ObjectProperty rdf:about="#occurredAt"/>
            </owl:onProperty>
            <owl:someValuesFrom rdf:resource="#Absent"/>
         </owl:Restriction>
     </rdfs:subClassOf>
   </owl:Class>

   <owl:Class rdf:ID="NonEvent">
      <rdfs:comment>An Event when some specified thing didn't happen.
        Similar to a PersistentState, but used differently.</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Event"/>
   </owl:Class>

   <Abroad rdf:ID="NotInUSA20070715">
      <rdfs:comment>Someplace other than the US territory during the
         24 hours of 7/15/2007, New York Time.</rdfs:comment>
      <isSomethingOtherThan>
         <TimeAndPlace rdf:ID="InUSA20070715">
            <hasSpatialRegion rdf:resource="#UnitedStatesOfAmerica"/>
            <hasStartingTimePoint> 
               <TimePoint rdf:ID="BeginPointOf20070715Z-5"/>
            </hasStartingTimePoint> 
            <hasEndingTimePoint> 
               <TimePoint rdf:ID="EndPointOf20070715Z-5"/>
            </hasEndingTimePoint> 
         </TimeAndPlace>
      </isSomethingOtherThan>
   </Abroad>

<!-- end *db587 -->

  <owl:ObjectProperty rdf:ID="correspondsToEntityInContext">
    <rdfs:comment>points from one entity in the COSMO ontology
    to another entity in some named Context within which 
    the entity in the Context has a direct equivalance to the ontology entity
    is the subject of the triple.  This permits the ad hoc
    definition of a Context within which reasoning can occur.
    
    This relation is inherently ternary, and should be elaborated
    when Ternary relations are represented.  See also the
    relations on Databases - such as 'correspondsToTable'
    
    Together with the relation 'isDefinedInContext' it is
    possible to create ad hoc (or map) a set of terms that are synonymous
    with entities in the COSMO (or an extension) and perform
    reasoning only on terms within that Context.  This contemplates
    at least two scenarios:
    (1) some previous conceptual classification is imported, and
       because of name clashes, is given its own namespace, which
       is defined as a Context.  For those names that clash, 
       the entity in the imported Context is given a namespace
       prefix to keep it unique within the overall ontology.
       The reasoning engine should then reason only within
       a given Context.
    (2) To make a subset of the overall ontology for efficiency
        purposes, a Context can be defined and each entity in the
        overall ontology that is needed in the new dcontext will be
        related to that Context by this relation 
        ('correspondsToEntityInContext').  The reasoning engine will then
        be able to recognize a Context within which reasoning and inference
        can be confined.</rdfs:comment>
  </owl:ObjectProperty> 

  <owl:SymmetricProperty rdf:ID="isNearTo">
    <rdfs:comment>isNearTo specifies that some GenericLocation (an
      Object or a Region) is 'near' to another, but (usually) not touching the
      other.  'near' is relative to the size of the things being related.  
      To be 'near' another region or object, the distance from one Object or
      Region to the other must be within two diameters of the larger object or region.
      NOTE that 'isSupportedBy' is a subproperty of 'isNearTo'.
    
      If two objects are touching, that can be represented as a 'TouchingState'.
    
      In SUMO treated as an attribute:
      SUMO: (Near) The relation of common sense adjacency.  Note that, if 
       an object is Near another object, then the objects are not connected..</rdfs:comment>
    <rdfs:domain rdf:resource="#GenericLocation"/>
    <rdfs:range rdf:resource="#GenericLocation"/>
  </owl:SymmetricProperty>  

  <owl:ObjectProperty rdf:ID="isAdjacentTo">
    <rdfs:comment>isAdjacentTo specifies that some GenericLocation (an
      Object or a Region) is 'adjacent' to another.  This means that it might
      be touching, with nothing in between, or might be separated by
      some thin space, which might have a name, as in a 'crack' or a
      sulcus in the brain. If there is a solid object separating them, two
      GenericLocations can be 'near' but not 'adjacent'.
      NOTE that this relation makes intuitive sense only when the 
      adjacent objects are of comparable size.  We do not usually 
      say that a bacterium on the skin is 'adjacent to' the skin.
      A different (perhaps more general) relation should be defined for
      such cases, because the gap that exists in non-touching cases
      can be large relative to one object and small relative to the other.
      
      NOTE: this is similar to the instance-level OBO_REL relation 'adjacent_to',
      except that this COSMO relation is solely an instance relation and
      is not used at the Type level.  For specifying the typical
      relations of Types (as in the OBO definition below), a 
      separate class-level relation and inference axioms will be required.
      
      OBO_REL: relation adjacent_to: (only the instance-level relation
         is similar to COSMO 'isAdjacentTo'.
      Definition: C adjacent to C' if and only if: given any
      instance c that instantiates C at a time t, there is some c' 
      such that: c' instantiates C' at time t and c and c' are in 
      spatial proximity.
      OBO Comments: Note that adjacent_to as thus defined is not 
      a symmetric relation, in contrast to its instance-level counterpart.
      For it can be the case that Cs are in general such as to be adjacent
      to instances of C1 while no analogous statement holds for C1s in general
      in relation to instances of C. Examples are: 
      nuclear membrane adjacent_to cytoplasm; 
      seminal vesicle adjacent_to urinary bladder; 
      ovary adjacent_to parietal pelvic peritoneum</rdfs:comment>
    <rdfs:domain rdf:resource="#GenericLocation"/>
    <rdfs:range rdf:resource="#GenericLocation"/>
  </owl:ObjectProperty>  

  <owl:ObjectProperty rdf:ID="isDefinedInContext">
    <rdfs:comment>Specifies the context in which the synonymous term
    is synonymous with the base domain argument term.</rdfs:comment>
    <rdfs:domain rdf:resource="#Synonym"/>
    <rdfs:range rdf:resource="#Context"/>
  </owl:ObjectProperty>  

  <owl:DatatypeProperty rdf:ID="hasFrequencyOfUse">
    <rdfs:comment>Specifies the frequency with which the synonymous
    term, when encountered in the specified context, actually 
    labels the meaning represented by the base entity which
    is synonymous.</rdfs:comment>
    <rdfs:domain rdf:resource="#Synonym"/>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#float"/>
  </owl:DatatypeProperty>  

<!-- removed in v 0.45
-->
<owl:Class rdf:ID="AttributeValue">
    <owl:disjointWith rdf:resource="#Role"/>
    <owl:disjointWith rdf:resource="#Object"/>
    <owl:disjointWith rdf:resource="#SituationProcessEventOrState"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >An AttributeValue is the actual value of some AttributeType possessed by some object,
    such as six feet for a length, or red for a color.  Individual AttributeValues are
    represented as Types (classes) in COSMO, not as instances.
    
      IMPORTANT NOTE:  the values represented by each of these AttributeValue Types are
      here viewed as a region ('Quality Space') in which the actual particular value 
      (see Type 'Quality') is located.  Thus one may say an object has a 'Red' color,
      but later refine the description to say it has a 'Fire Red' color.  The 'Fire Red' 
      is also a color region, contained within the 'Red' color region.

     For quantitative measures, representing attributes as classes allows approximate
     measures to be built in to the ontology itself.  One may specify a range
     for a measure, and any other measure within or overlapping that range can
     be considered as 'indistinguishable from' (not 'equal to') the other measure.</rdfs:comment>
  </owl:Class>
  
 <owl:Class rdf:ID="QualitativeAttributeValue">
    <rdfs:comment>A QualitativeAttributeValue is the value of 
      some AttributeType which is not expressed in quantitative measures.
      
      It can be an attribute of an abstract thing or of a
      concrete physical object.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#AttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="QuantitativeAttributeValue">
    <rdfs:comment>A QuantitativeAttributeValue is a value for
      some AttributeType which is expressed in quantitative measures.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#AttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="EvaluativeAttribute">
    <rdfs:comment>An EvaluativeAttribute is a  QualitativeAttributeValue
      for some entity, cocnrete or abstgract, that reflects the judgment 
      of an IntelligentAgent regarding that entity.  the judgment may be
      objective or subjective, but will be relative to some purpose.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#QualitativeAttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="PercentageAttributeValue">
    <rdfs:comment>A QuantitativeAttributeValue consisting of
       having percentage of some attribute.  Each
       PercentageAttributeValue points to a Percentage, and
       may have other characteristics, such as specifying
       how the Percentage was measured.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#QuantitativeAttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="Percentage">
    <rdfs:comment>A Prevalence that represents an Attribute having some 
      percent intensity, such as percent unemployed (same
      as UnemploymentRate).  It is a type of 'Prevalence'
      in which the quantitative element is a PercentNumber.
      
      The percentage may be dimensionless (in which case it would have to
      be interpreted in a context), or may be associated with the
      measure that specifies what the whole is.  Thus a percentage 
      unemployed (measured by some statisitcal technique) might
      be represented by a measure function such as:
         {5.9 percentUnemployed}.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#Prevalence"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasSecondElement"/>
           </owl:onProperty>
           <owl:someValuesFrom rdf:resource="#PercentNumber"/>
         </owl:Restriction>
       </rdfs:subClassOf>
  </owl:Class>

  <owl:ObjectProperty rdf:ID="hasDefaultVariance">
    <rdfs:comment>hasDefaultVariance can be set differently by each 
        application, but for most precise interoperability, it should be
        the same for all applications.  The default variance
        for a measure can be absolute or relative.  One might specify that
        all temperature measures are accurate to plus or minus one degree
        Fahrenheit - which might make sense in some applications.  A relative
        value can be of several types: one might say that any measure
        is accurate only to within 1% of the nominal value, or might say
        that every measure is accurate to within plus or minus one digit in the last 
        significant digit of the measure.  The 'plus or minus' range by default is
        the conventional variance, within which any measure has a 67% likelihood
        of being found.  The default variance will be used only if an
        explicit variance is not specified.
        
        The default variance can be set for each type of quantitative
        measure, or may be set for any tree of quantitative measures by 
        a restriction on the value for the root of that tree.</rdfs:comment>
      <rdfs:domain rdf:resource="#QuantitativeAttributeValue"/>
      <rdfs:range rdf:resource="#ConfidenceInterval"/>
  </owl:ObjectProperty>

 <owl:Class rdf:ID="SalientCharacteristic">
    <rdfs:comment>A salient and distinguishing AttributeValue.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#AttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="Prevalence">
    <rdfs:subClassOf rdf:resource="#Measurement"/>
    <rdfs:comment>A Prevalence is a Measurement expressing the 
    intensity of some one AttributeValue out of set of attribute
    values that are related in some way.  This is a general
    type of Measurement that might be inluded in a Distribution.</rdfs:comment>
  </owl:Class>

 <owl:Class rdf:ID="Distribution">
    <rdfs:comment>A Distribution is a Group of quantitative 
      measures of the prevalence (often a percentage) of some
      AttributeValue.  It may be relevant to an Individual, but is usually
      of relevance to a Group of entities.  For distributions
      of characteristics among a GroupOfPeople, use
      'PopulationCharacteristicDistribution'.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#AttributeValue"/>
     <rdfs:subClassOf rdf:resource="#Group"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasComponentElement"/>
           </owl:onProperty>
           <owl:allValuesFrom rdf:resource="#Prevalence"/>
         </owl:Restriction>
       </rdfs:subClassOf>
  </owl:Class>

 <owl:Class rdf:ID="PopulationCharacteristicDistribution">
    <rdfs:comment>A group of numbers expressing the fraction of 
      some population that has a particular value for some category
      of population attribute.  This is not a simple number,
      but a group of numbers.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#PopulationCharacteristic"/>
     <rdfs:subClassOf rdf:resource="#Group"/>
     <rdfs:subClassOf rdf:resource="#Distribution"/>
  </owl:Class>

  <owl:Class rdf:ID="AttributeType">
    <rdfs:comment>An AttributeType is a general category of attribute, i.e.
    some property that adheres in an object, such as length or mass or 
    color or shape for physical objects.  More abstract objects such as 
    sets or groups may have more abstract attributes such as cardinality.
    The distinction between attributes and relations between entities is not 
    absolute.
    
    COSMO note:  The use of two distinct trees of attribute-related types
    (AttributeType and AttributeValue) is intended to enable assertions with
    a linguistic form such as:
          {Jack has Height {6 feet})
     where the second argument 'Height' specifies the general type of attribute,
     and the value '{6 feet}' specifies the specific attribute value, where
     'feet' is a function returning a distance measure.  This generic attribute
     assertion can then be used with other types of attributes, such as:
          {Jack has Weight {60 kilograms}) and
          {Car037 has Color RedColor).</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="PopulationAttribute">
    <rdfs:subClassOf rdf:resource="#AttributeType"/>
    <rdfs:comment>A PopulationAttribute is any type of attribute
    that can be asserted about a group of people. It also is used
    to characterize geographical regions, in which case it 
    in fact characterizes the group of people who live in that region. 
    It will be time-sensitive, potentially varying rapidly.
    
    NOTE that this is a subclass of AttributeType, which categorizes
    general types of population attributes, and each PopulationAttribute
    The values for each PopulationAttribute will be a subtype of 
    PopulationCharacteristic.
    
     This AttributeType is mostly of interest for aggregate characteristics,
      such as 'RacialComposition'.
      The individual elements making up that composition would
      be instances of 'PopulationCharacteristic' such as 
      'PercentageAsianAncestry'.</rdfs:comment>
  </owl:Class>

 <owl:Class rdf:ID="PopulationCharacteristic">
    <rdfs:comment>An attribute of a 'Population' that is of interest to
      some group for some purpose.  Examples are: unemployment rate,
      dostribution of religious affiliations, racial distribution.
      The Population is usually human, but may be animal.  Plant
      groups are not included.  It may be quantitative or
      qualitative.  Quantitative characteristics will be instances of
      subtypes of 'PopulationAttributeValue'.
      
      A PopulationCharacteristic may also be used
          to characterize geographical regions, in which case it is interpreted
          as characterizing the group of people who live in that region. 
      It will be time-sensitive, potentially varying rapidly.
      
      The characteristic is often some percentage of the given
      population having a particular attribute, or some distribution of
      attribute values for one type of attribute.  Thus an 
      unemployment rate is a simple percentage under 100; a racial distribution is a
      group of fractions that add up to no more than 100% (if incomplete,
      it may add up to less than 100%).
      
      For qualitative attributes, one might characterize a population
      without reference to the fractions that actually have that attribute,
      for example 'an Asian group'.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#AttributeValue"/>
  </owl:Class>

  <owl:Class rdf:ID="PopulationAttributeValue">
    <rdfs:subClassOf rdf:resource="#PopulationCharacteristic"/>
    <rdfs:subClassOf rdf:resource="#QuantitativeAttributeValue"/>
    <rdfs:comment>A PopulationAttributeValue is a quantitative measure
     describing some characteristic of some population, which is a type of attribute
     that can be asserted about a group of people. 
    
     Examples of PopulationAttributeValues are: infant mortality rate,
     AverageIncome, UnemploymentRate, high school graduation rate, etc..</rdfs:comment>
  </owl:Class>

<!--  needs pointer?
     <rdfs:subClassOf rdf:resource="#PopulationAttributeValue"/>
-->
   <owl:Class rdf:ID="UnemploymentRate">
    <rdfs:comment>The percentage of members of a population capable
       of working who are not employed.  The method for calculating this
       number varies by country.  Each differently calculated rate 
       can be represented as a subtype of this Type.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#Percentage"/>
  </owl:Class>

 <owl:Class rdf:ID="ActivityCharacteristic">
    <rdfs:comment>An attribute of a 'Population' that consists of
      the performance of certain characteristic behaviors.
      The characteristic behaviors may be routine (going to Mass 
      on Sunday for observant Catholics) or sporadic,
      possible triggered by eents (characreistic reactions to Events).
      To fit into this category the eeidence of such characeristic
      behaior should be more than anecdotal.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#PopulationCharacteristic"/>
  </owl:Class>

 <owl:Class rdf:ID="RoutineActivityCharacteristic">
    <rdfs:comment>An attribute of a 'Population' that consists of
      the performance of certain characteristic routine behaviors.
      The RoutineBehavior itself should be represented as 
      an instance of 'RoutineAction'.  Intances of 'RoutineActivityCharacteistic'
      should specify the type of routine activity and the typical frequency.
      
      ###ToDo: relations have not yet been defined to relate this 
      Type to 'RoutineAction'.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#ActivityCharacteristic"/>
  </owl:Class>

 <owl:Class rdf:ID="EconomicAttribute">
    <rdfs:comment>A type of PopulationAttribute that describes
    some attribute of a population related to a traditional measure
    of economic activity: unemployment rate, GNP per capita, exports,
    imports, average work week, etc.  Each of those specific
    measures will be a subclass of 'PopulationCharacteristic'..</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#PopulationAttributeValue"/>
  </owl:Class>

 <owl:Class rdf:ID="PersonalityTraitValue">
    <rdfs:comment>Each subtype of 'PersonalityTraitValue' is a
      PersonalityTrait that may be assigned to some individual
      animal, usually used for people.  Examples are kindness, 
      thriftiness, gregariousness.  The Types are categorized
      by nouns, but the equivalent assignments of such
      traits to people in linguistic statements will typically
      use adjectives such as 'a kind person'.</rdfs:comment>
     <rdfs:subClassOf rdf:resource="#QualitativeAttributeValue"/>
  </owl:Class>

  <owl:Class rdf:ID="Nature">
    <rdfs:subClassOf rdf:resource="#AttributeType"/>
    <rdfs:comment>Nature is the sum of all essential attribute values
     of an individual, forming a recognizable pattern.  This can be
     used generally for any kind of entity, though linguistically
     it often refers to behavioral patterns.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Personality">
    <rdfs:subClassOf rdf:resource="#Nature"/>
    <rdfs:comment>Personality is the sum of all PersonalityTraits of an 
    individual.   This AttributeType can be used for animals as well as
    people, for example a particular animal may be characterized as 
    'aggressive'.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="Trait">
    <rdfs:subClassOf rdf:resource="#AttributeType"/>
    <rdfs:comment>Trait is some characteristic, usually of an animal's personality
      that is considered as a part of its total character or nature.  Examples are
      kindness, ambitiousness, aggressiveness, friendliness.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="PersonalityTrait">
    <rdfs:subClassOf rdf:resource="#Trait"/>
    <rdfs:comment>PersonalityTrait is some trait of personality that is 
      considered as a part of a total personality.  Examples are
      kindness, ambitiousness, aggressiveness.  These triats will be classified
      under 'PersonalAttribute'</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="PersonalAttribute">
    <rdfs:subClassOf rdf:resource="#AttributeValue"/>
    <rdfs:comment>A PersonalAttribute is any of a broad range of values for
      the general attribute type of 'PersonalityTrait'.  the PersonalAttribute
      may be inherent (such as kindness, ambitiousness, aggressiveness), 
      or may be a result of the attitudes of others, such as being 'untouchable' 
      or having a particular social status.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="SocialStatus">
    <rdfs:subClassOf rdf:resource="#PersonalAttribute"/>
    <rdfs:comment>SocialStatus is an Attribute that a person has as a result of
      other people having an opinion of that person.  It is not an inherent
      trait, though it may be strongly influenced by a person's inherent traits.
      Instances may also apply to groups of people, such as women
      or young people in a particular culture.
      
      There are aspects of status, such as within-group and out-of-group
      attitudes that are not represented by a simple attribute.  This
      needs to be elaborated considerably.</rdfs:comment>
  </owl:Class>

  <SocialStatus rdf:ID="Respected"/>
  <SocialStatus rdf:ID="HighlyRespected"/>
  <SocialStatus rdf:ID="HeldInContempt"/>
  <SocialStatus rdf:ID="Despised"/>
  <SocialStatus rdf:ID="TreatedAsProperty"/>
  <SocialStatus rdf:ID="TreatedAsDependent"/>
  <SocialStatus rdf:ID="ConsideredDangerous"/>
  <SocialStatus rdf:ID="ConsideredCrazy"/>
  <SocialStatus rdf:ID="ConsideredInferior"/>

<!--
        <rdf:type rdf:resource="#PrimitiveOrderedQuantityType"/>
        <rdf:type rdf:resource="#AtemporalNecessarilyEssentialCollectionType"/>
-->
   <owl:Class rdf:ID="SocialPower">
        <rdfs:comment>The collection of attributes that describe a
            person's social power, `clout,&apos; the ability to
            influence people and achieve one&apos;s social goals through
            some combination of privilege, position, personal contacts,
            skill, hard work, and intelligence.  Money (income, wealth)
            and esteem/prestige may both contribute to attaining social
            power and may be necessary to hold on to it, but they cannot
            be equated with it.  This is basically Max Weber's schema.</rdfs:comment>
        <guid>bd58a99f-9c29-11b1-9dad-c379636f7270</guid>
        <rdfs:subClassOf rdf:resource="#Quantity"/>
        <rdfs:subClassOf rdf:resource="#AttributeValue"/>
    </owl:Class>

  <owl:Class rdf:ID="Stability">
     <rdfs:subClassOf rdf:resource="#AttributeType"/>
    <rdfs:comment>Each AttributeValue of the Stability Type is a 
      Tendency (which see) to participate in some Event or FunctionalProcess,
      under certain conditions.  The Stability of some Objects, such
      as organic tissues from organisms, can depend in a sensitive manner
      on temperature (frozen? boiled?), on the presence of potentially degrading
      microorganisms (irradiated? pasteurized?) and on the method of
      preparation (germ-free to start with?).  Other things, like mountains,
      may be assumed to be stable in the sense of staying put for very long periods of time,
      regardless of the activities of animals, wind, and weather.
      Large building are of intermediate stability, tending to be in the
      same place from year to year but occasionally being torn down by
      people, tornadoes, or earthquakes.
      
      This AttributeType will be important for resolving issues related
      to the Frame Problem, i.e. if a condition exists now, is it
      likely to exist ten minutes, one day, or one month from now?
      In practical reasoning this issue is critically important, but becasue
      of its complexity has been often ignored in small reasoning systems.
      This generic AttributeType and its associated AttribugteValues
      can be used to address the problem of 
      predicting the relations of situations across time interval.
    .</rdfs:comment>
  </owl:Class>

  <owl:ObjectProperty rdf:ID="wasRealizedByAction">
    <rdfs:comment>wasRealizedByAction relates a CapabilityType,
       who instances are attributes of Objects that can
       enable or perform funcitons, to the ActionType(s)
       that they can anable or perform.  This relation answers the
       questions 'what was it designed for?'. The 'dsign'
       can be either artificial, as the design of an artifact,
       or natural, as the design of an evolved System or System
       component.
    
      *Note* that the CapabilityType that is the subject of 
       this relation in turn can be pointed to by the  relation
       'hasDesignFunction'.  This creates a triangle of
       Object-Capability-Action.</rdfs:comment>
      <rdfs:domain rdf:resource="#CapabilityType"/>
      <rdfs:range>
         <owl:Class>
           <owl:unionOf rdf:parseType="Collection">
             <rdfs:Class rdf:about="#ActionType"/>
             <rdfs:Class rdf:about="#EventType"/>
           </owl:unionOf>
         </owl:Class>
      </rdfs:range>
  </owl:ObjectProperty>


    <owl:Class rdf:ID="Individual">
      <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
      >'Individual' is a  Cyc concept used to distinguish abstract sets
      and collections (classes) from things that are individuals.  Interestingly,
      groups of things can be individuals - if they are defined as distinct
      from sets (see 'Group').   This class may be superfluous, but in COSMO 
      is a convenient catch-all for some aggregate Types that would merely
      serve to clutter the top level and obscure the structure of the ontology 
      if exposed at the top level directly under 'Thing'.
      Conversely, Some of the subtypes of the Cyc 'individual' have also been
      subclassed  directly to 'owl:Thing' to expose those common concepts at the highest level,
      to make the structure of the ontology easier to see.
  
      NOTE that some of the concepts mentioned in the Cyc documnentation differ
      significantly in COSMO from related concepts in Cyc.  But the Cyc documentation is
      given here to describe how the similar Cyc notion of Group is described in
      that ontology.
               From OpenCyc:  OPENCYC 1: MAY 23, 2002
     #$Individual is the collection of all individuals: things that are _not_ sets
     or collections. Individuals might be concrete or abstract, and include 
     (among other things) physical objects, events, numbers, relations, and groups. 
     An instance of #$Individual might have parts or structure (including discontinuous parts); 
     but _no_ individual has elements or subsets (see #$elementOf and #$subsetOf).
     Thus, an individual that has parts (e.g. #$physicalParts or #$groupMembers) 
     is _not_ the same thing as either the set or the collection containing those
     same parts. For example, your car is an individual, but the collection of all 
     the parts of your car is not an individual but an instance of #$Collection. 
     This collection (unlike the car itself) is abstract: it doesn't have a location,
     mass, or a top speed; but it does have instances, subcollections, and supercollections. 
     In partial contrast, the #$Group (q.v.) of parts of your car (while also not
     the same thing as the car itself) _is_ an individual that has location and 
     mass. Another example: A given company, the group consisting of all the 
     company's employees, the collection of those employees, and the set of those 
     employees are four distinct things, and only the first two are individuals.</rdfs:comment>
    </owl:Class>


  <owl:Class rdf:ID="InternalAttribute">
    <rdfs:comment>Any Attribute of an Entity that is an  internal property
     of the Entity, e.g. its shape, its color, its fragility, etc.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#AttributeType"/>
  </owl:Class>


  <owl:Class rdf:ID="BiologicalAttribute">
    <rdfs:subClassOf rdf:resource="#InternalAttribute"/>
    <rdfs:comment>Attributes that apply specifically 
     to instances of Organism.</rdfs:comment>
  </owl:Class>
    
  <owl:Class rdf:ID="SexAttribute">
    <rdfs:subClassOf rdf:resource="#BiologicalAttribute"/>
    <rdfs:comment>Attributes that indicate the sex of an Organism.</rdfs:comment>
  </owl:Class>

    <owl:Class rdf:ID="HeterogeneousCategory">
        <rdfs:comment>HeterogeneousCategory is a catch-all of classes
        that subsume other classes of varied basic types.  Among
        other things, it is a mechanism for assigning qualitative
        adjectives that may apply to more than one basic type (like
        'dangerous'), and to provide a parent aggregate
        Type for some relations.  Thes subtypes may also be defined 
        functionally,and may include entities of different innate
        character.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
    </owl:Class>

<owl:Class rdf:ID="Salient">
        <rdfs:comment>An attribute of things - events, properties, or objects -
        that are worthy of paying attention to because they are
        often (but not always) important to intelligent agents.
        
        This is an attribute that can be used to mark things that
        an agent should keep in mind.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#EvaluativeAttribute"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
    </owl:Class>

<owl:Class rdf:ID="Pleasant">
        <rdfs:comment>An attribute of things - events, processes, or objects -
        that in normal circumstances can be expected to give pleasure
        to people who experience it (Events) or possess it (things).
        
        This provides one method to mark those Assets that are 
        especially worthy of attention.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#EvaluativeAttribute"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
    </owl:Class>

   <owl:Class rdf:ID="Notable">
      <rdfs:comment>A common term for 'Salient'.</rdfs:comment>
      <rdfs:subClassOf rdf:resource="#Synonym"/>
      <isaSynonymOf rdf:resource="#Salient"/>
   </owl:Class>

  <owl:Class rdf:ID="SalientThing">
        <rdfs:comment>An Event or object which is unusual enough
         to warrant attention when it is noticed.
         
         This is very broad: examples are Landmarks.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Salient"/>
         </owl:Restriction>
       </rdfs:subClassOf>
        <owl:disjointWith rdf:resource="#RoutineThing"/>
    </owl:Class>
 
  <owl:Class rdf:ID="RoutineThing">
        <rdfs:comment>An Event or object which is common enough
         that it does not attract special attention when it is noticed.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
        <owl:disjointWith rdf:resource="#SalientThing"/>
    </owl:Class>
 
    <owl:Class rdf:ID="UndesirableThing">
        <rdfs:comment>UndesirableThing is a generic class that can be used
         to label certain types of objects or situations as undesirable,
         and therefore something to avoid, and therefore something
         that is salient.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Salient"/>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>

    <owl:Class rdf:ID="GoodThing">
        <rdfs:comment>A GoodThing is a generic class that can be used
         to label certain types of objects or situations as desirable,
         and therefore something to pay attention to, and perhaps to 
         try to otain or try to do or get done.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Salient"/>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>

    <owl:Class rdf:ID="PleasantThing">
        <rdfs:comment>A PleasantThing is an Event, Process, or Object that
        will typically (or is intended to) give pleasure to a person who
        experences it (an Event) or who has possession of it (an object).
        This is a very broad category, necessarily vague because
        many things can give pleasure in many ways and in many
        degrees, yet it is usefult to be able to predict whether
        a person can be expected to be pleased by something.
        To be more precise insuch prediction will require a great deal of information
        about the circumstances and inclinations of individual people.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#GoodThing"/>
       <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Pleasant"/>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>

  <owl:Class rdf:ID="SpatialThing">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >NOTE that OpenCyc spatialThing does not necessarily have to be in our Space-Time;
    it can be in an abstract space.  So this is not identical to
    DOLCE 'spatio-temporal-particular', which is a subclass.

      OPENCYC 1: MAY 23, 2002
     The collection of all things that have a spatial extent or location relative
     to some other #$SpatialThing or in some embedding space. Note that to say that
     an entity is a member of this collection is to remain 
     agnostic about two issues. First, a #$SpatialThing may be #$PartiallyTangible 
     (e.g. #$Texas-State) or wholly #$Intangible (e.g. #$ArcticCircle or a line mentioned 
     in a geometric theorem). Second, although we do insist on location relative 
     to another spatial thing or in some embedding space, a #$SpatialThing might or might
     not be located in the actual physical universe. It is far from clear that 
     all #$SpatialThings are so located: an ideal platonic circle or a trajectory 
     through the phase space of some physical system (e.g.) might not be. If the 
     intent is to imply location in the empirically observable cosmos, the user should
     employ this collection's specialization, #$SpatialThing-Localized.</rdfs:comment>
    <rdfs:subClassOf rdf:resource="#GenericLocation"/>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#Individual"/>
    </rdfs:subClassOf>
  </owl:Class>
<!--  - added GenericLocation -->

<owl:Class rdf:ID="GeometricallyDescribableThing">
        <rdfs:comment>A subcollection of #$SpatialThing. Each instance
            of #$GeometricallyDescribableThing is a spatially-connected
            spatial thing (of 0, 1, 2, or 3 dimensions) that either (i)
            has or approximates a simple geometric shape (e.g. it is a
            #$Line or a #$Hemisphere) or (ii) consists of a number of
            (connected) parts in a relatively stable geometric
            configuration, where each such part has or approximates a
            simple geometric shape (e.g. a table consisting of a
            3-D-disc-shaped top and four cylindrical legs).  A
            #$GeometricallyDescribableThing might be tangible (see
            #$PhysicalObject) or intangible (see
            #$GeometricallyDescribableThing-Intangible). Note that what
            counts as  approximating  a given simple geometric shape --
            and thus what spatial things count as
            #$GeometricallyDescribableThings - varies with context. In
            a context that was so fine-grained shape-wise that even the
            shapes of the individual molecules on the surface of an
            object were considered relevant to the object's shape,
            perhaps nearly every (connected, solid) tangible object
            would be geometrically-describable.  In more everyday
            contexts, on the other hand, an unopened can of soup would
            be geometrically-describable (as a cylinder), while a
            telephone or an animal's body would probably not.</rdfs:comment>
        <guid>bd58c42e-9c29-11b1-9dad-c379636f7270</guid>
        <rdfs:subClassOf rdf:resource="#SpatialThing"/>
    </owl:Class>
    
  <owl:ObjectProperty rdf:ID="isSpatiallyDisjointWith">
    <rdfs:domain rdf:resource="#SpatialThing"/>
    <rdfs:range rdf:resource="#SpatialThing"/>
    <rdfs:comment>isSpatiallyDisjointWith relates one.SpatialThing
     (a region, object, or event) with another SpatialThing that has
     no regions in common with the first.  This relation can be used to
     express the fact that anything wholly located in one SpatialThing
     cannot have any part located in another SpatialThing that is
     disjoint with the first in this sense.
     
     NOTE that when first-order rules are associated with this
     ontology, it will be possible to infer that any part of a region1
     that isSpatiallyDisjointWith a region2 is also disjoint with
     any part of that region2.</rdfs:comment>
    <owl:inverseOf rdf:resource="#isSpatiallyDisjointWith"/>
  </owl:ObjectProperty>   
  
  <owl:Class rdf:ID="spatio-temporal-particular">
    <rdfs:subClassOf rdf:resource="#SpatialThing"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >COSMO Note: note that Cyc SpatialThing does not have to be in our space-time,
    whereas DOLCE spatio-temporal-particular is.  So the DOLCE class is a subclass
    of the Cyc class.

    OPENCYC 1: MAY 23, 2002
    The collection of all things that have a spatial extent or location relative to some other #$SpatialThing or in some embedding space. Note that to say that an entity is a member of this collection is to remain agnostic about two issues. First, a #$SpatialThing may be #$PartiallyTangible (e.g. #$Texas-State) or wholly #$Intangible (e.g. #$ArcticCircle or a line mentioned in a geometric theorem). Second, although we do insist on location relative to another spatial thing or in some embedding space, a #$SpatialThing might or might not be located in the actual physical universe. It is far from clear that all #$SpatialThings are so located: an ideal platonic circle or a trajectory through the phase space of some physical system (e.g.) might not be. If the intent is to imply location in the empirically observable cosmos, the user should employ this collection's specialization, #$SpatialThing-Localized.
    Note that most of the Cyc 'SpatialThings' are in our universe (though not necessarily) , so most are also under DOLCE 'spatio-temporal-particular'.

    DOLCE: Dummy class for optimizing some property universes. It includes all entities that are not reifications of universals ('abstracts'), i.e. those entities that are in space-time.</rdfs:comment>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >spatio-temporal-particular[DOLCE]%SpatialThing</rdfs:label>
  </owl:Class>

 <owl:Class rdf:ID="SpatiallyContinuousThing">
        <rdfs:comment>COSMO note: all PhysicalObjects are non-trivially continuous
        only with respect to some level of granularity.
        
        Cyc:  A specialization of #$SpatialThing.  For every
            instance REGION of #$SpatiallyContinuousThing, any two
            points it subsumes are connected by some path it also
            subsumes.  Positive exemplars include a drinking glass, a
            haystack, a spiderweb, or a region of space in the shape of
            any of these things.  If the glass is broken and its pieces
            no longer touch each other, it is not a
            #$SpatiallyContinuousThing.  Some borderline exemplars
            depend on granularity.  At a macroscopic level of
            granularity, a dense cloud of smoke is effectively
            continuous.  On the microscopic level, it is composed of
            independent particles that do not touch each other.</rdfs:comment>
        <guid>9ae4ab12-8221-41d7-9022-96b38c86ffc1</guid>
        <rdfs:subClassOf rdf:resource="#SpatialThing"/>
   </owl:Class>
 
  <owl:Class rdf:ID="SpatialThing-Localized">
    <rdfs:subClassOf rdf:resource="#spatio-temporal-particular"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >OPENCYC 1: MAY 23, 2002
     The collection of all spatial things, tangible or intangible,
     that can be meaningfully said to have location or position in the
     empirically observable universe of the context in question. This 
     includes all #$PartiallyTangible things, such as pyramids and ships,
     as well as certain #$Intangible spatial things, like the #$Equator. Also 
     included are all #$Events that can be pinned down to specific places 
     (see #$Event-Localized), and thus all #$PhysicalEvents. But note that many
     events are non-examples, such as the event of a certain law coming into
     effect and (presumably) purely mental events as well, at least in most 
     contexts. Also excluded are #$SpatialThings that are _not_ localized,
     such as purely abstract geometrical figures (e.g. a Platonic sphere).
     All instances of #$SpatialThing-Localized are temporal things, and thus 
     have finite lifespans (the upper bound of which is the lifespan of the 
     universe itself). Finally, note that imaginary entities like Frodo, 
     Captain Queeg, and #$HAL9000-TheComputer may be localized within
     the (imaginary) universes attaching to the fictitious contexts in which 
     they are defined, and so would be instances of #$SpatialThing-Localized
     within those microtheoretic contexts.
     
     NOTE: because Cyc 'SpatialThing-Localized' includes intangible
     spatial things, this is not identical to the purely physical
     objects such as 'Oject' in SUMO.  In COSMO,purely physical objects
     are categorized in the Type 'PhysicalObject', which is a subtype
     of this 'SpatialThing-Localized' category.</rdfs:comment>
  </owl:Class>  


  <!-- *** Artifact ****  -->
  <owl:Class rdf:ID="Artifact-Generic">
    <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#wasCreatedBy"/>
           </owl:onProperty>
           <owl:allValuesFrom rdf:resource="#GenericAgent"/>
         </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:comment>An Artifact-Generic was anything created by an Agent.  More useful
    categories will be the more specific Types.
    
    Original COSMO Indented List name:
    Artifact-Generic_includes_conceptual_works__laws__information_objects_
 
    OPENCYC 1: MAY 23, 2002
       A collection of things created by #$Agents. These creations may be either
       tangible (like a hammer, a bowl, or a bridge) or intangible (like a
       set of laws, a #$KnowledgeBase, or Beethoven's Ninth Symphony). Thus,
       the collection of #$Artifact-Generics is partitioned into #$Artifact
       and #$Artifact-Intangible (q.v.).</rdfs:comment>
   </owl:Class>

  <owl:ObjectProperty rdf:ID="wasCreatedBy">
    <rdfs:domain rdf:resource="#Artifact-Generic"/>
    <rdfs:range>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#GenericAgent"/>
          <owl:Class rdf:about="#AbstractString"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:range>
    <rdfs:comment>wasCreatedBy relates an Artifact (concrete or abstract) to the 
     Agent who created it.  Agents are construed very broadly for this
     relation, and a river could be the Agent that created a
     canyon.
     
     NOTE that the range includes an AbstractString, which is semantically
     nonsense, but is included as a pragmatic tactic to allow
     subrelations of this relation to be used in mapping database
     records to their creators.  The creators will sometimes be 
     represented in the database only as a string, and in such cases
     an implementing system, at its option, can avoid creating
     a new Person object (instead creating an AbstractString object),
     when the system cannot identify the 'creator' of the record.
     This tactic may change as the ontology is further developed,
     and experience with mapping databases increases..</rdfs:comment>
  </owl:ObjectProperty>   

  <owl:ObjectProperty rdf:ID="wasAuthoredBy">
    <rdfs:range rdf:resource="#IntelligentAgent"/>
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#TextualMaterial"/>
          <owl:Class rdf:about="#AbstractText"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
    <rdfs:comment>wasAuthoredBy relates a textual object (concrete or abstract)
     to the IntelligentAgent who is credited with creating it.  The Agent can be 
     a person, organization, group of people or a machine (see 'AuthorOfRecord').
     
     This special relation, together with the companion Type of 'AuthorOfRecord'
     (a subtype of 'IntelligentAgent') serves the purpose of preserving the 
     option to list known people (instances of 'Person') or unknown individuals
     ('Anonymous'), pen names ('MarkTwain'), or pseudonyms whose real identity
     is unknown.  The unknowns and pen names can be instances of 'AuthorOfRecord'.
     When identities of unknown authors are discovered, they can be equated with the
     previous AuthorOfRecord, or that instance can be replaced in the knowledge base,
     if it is unimportant to have a record of the author being initially unknown.</rdfs:comment>
  </owl:ObjectProperty>   

  <owl:Class rdf:ID="Artifact">
      <rdfs:subClassOf rdf:resource="#Synonym"/>
      <isaSynonymOf rdf:resource="#ArtifactObject"/>
      <rdfs:comment>The same as 'ArtifactObject', but the shorter term was
        considered potentially misleading as the main label for this
        concept, as it has been used to refer to abstract artifacts
        as well as physical objects.</rdfs:comment>
    </owl:Class>

  <owl:Class rdf:ID="ArtifactObject">
      <rdfs:subClassOf rdf:resource="#Artifact-Generic"/>
    <rdfs:subClassOf rdf:resource="#PhysicalObject"/>
    <rdfs:subClassOf rdf:resource="#ValuableThing"/>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Artifact*</rdfs:label>
    <rdfs:comment>COSMO note: this class was merged with the Cyc 'Artifact-HumanCreated'
    because little differnce could be discerned.  All instances of Artifact will
    be created by humans - people, groups, organizations, or their automaton
    servants.  Artifactual objecgts created by non-humans (e.g. animals) will
    be instgances of ArtifactObject.

    Artifact( Cyc and SUMO);  material-artifact(DOLCE)
    SUMO: A CorpuscularObject that is the product of a Making.

    Cyc comment for ;Artifact-HumanCreated':
        A collection of individual #$Artifacts. Each
              instance of #$Artifact-HumanCreated is a tangible thing made
              by an instance of #$HomoSapiens, or by a (#$GroupFn
              #$HomoSapiens). Examples include instances of
              #$Clothing-Generic, #$Automobile, #$DrainageCanal, and #$HydroelectricDam.

    OPENCYC 1: MAY 23, 2002
    A specialization of #$InanimateThing. Each instance of #$Artifact is an at least
    partially tangible thing which was intentionally created by an #$Agent (or a group
    of #$Agents working together) to serve some purpose or perform some function. In order
    to create an instance of #$Artifact, it is not necessary that an #$Agent create
    the matter out of which the #$Artifact is composed; rather, an #$Agent can create 
    an instance of #$Artifact by assembling or modifying existing matter. Examples of
    #$Artifacts include a wooden flute that's been whittled from a tree branch, a sawhorse 
    that's been put together out of boards and nails, and a coin that's been minted by
    embossing or by melting liquid silver into a mold. In addition to the obvious human 
    artifacts (buildings, tools, textiles, power lines), the collection #$Artifact also 
    includes certain sorts of things made by #$Animals, such as bird nests, termite mounds,
    and beaver dams. Artifacts without any tangible parts are excluded from the collection
    #$Artifact; they are included in the collection #$Artifact-Intangible.

    DOLCE: material-artifact: No easy definition of artifactual properties is possible,
    hence it is better to rely on alternative descriptions and roles: a physical object
    that shows or is known to have an artifactual origin that counts in the tasks an ontology 
    is supposed to support, will be a material artifact. On the other hand, physical objects
    that do not show that origin, or that origin is unimportant for the task of the ontology, 
    will be physical bodies. Formally, a restriction is provided here that requires that 
    the collection whose members are (at least some of the) proper parts of a material artifact
    is *unified* by a plan or project.</rdfs:comment>
  </owl:Class>

 <owl:ObjectProperty rdf:ID="wasCreatedAtTheRequestOf">
    <rdfs:comment>wasCreatedAtTheRequestOf relates an ArtifactObject
    to the IntelligentAgent (usually a Person) who ordered it
    to be created.  This should be used for objects of special
    interest whose creators will also be of interest.  This differs
    from 'wasCreatedBy' in that most of the work of creation must be done by someone
    other than the agent (person, organization, group) who ordered it to be created.  
    It is therefore mostly used for large objects like buildings and special-order
    objects of any kind.</rdfs:comment>
    <rdfs:domain rdf:resource="#ArtifactObject"/>
    <rdfs:range rdf:resource="#IntelligentAgent"/>
  </owl:ObjectProperty>

    <owl:Class rdf:ID="Artifact-NonAgentive">
        <rdfs:comment>An instance of #$ObjectType, and a specialization
            of #$Artifact-Generic.  #$Artifact-NonAgentive is the
            collection of all artifacts that are _not_ agents (i.e.,
            that are _not_ instances of #$Agent-Generic).
            Specializations of #$Artifact-NonAgentive include #$Bicycle,
            #$Pants, #$Canal, and #$FoodUtensil.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#ArtifactObject"/>
    </owl:Class>

    <owl:Class rdf:ID="ManufacturedGoods">
        <rdfs:comment>COSMO note:
          NOTE that there is a concept of 'scale' of the manufacturing
          process that distinguishes 'manufactured' from handcrafted
          goods.  This is a continuous measure, therefore there will
          be a fuzzy borderline between 'Product' and handcraft.
          Where doubt exists, things manufactured in numbers more than
          a few and offered for public sale and distribution using any form of 
          advertising will be considered as members of this class.
          
         Cyc:  The collection of all #$Artifacts that are made or
            processed in large-scale industrial operations for
            distribution (normally sale) to agents outside the
            manufacturing organization.  This includes manufactured
            stuff, e.g. Finlandia vodka; refined ore, e.g. iron;
            otherwise procesed natural material, e.g. cut diamonds, as
            well as manufactured objects.  This collection excludes
            handicrafts; privately made stuff, e.g. moonshine; and other
            artifacts produced by one or a few people on a small scale.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#ArtifactObject"/>
    </owl:Class>

    <owl:Class rdf:ID="Valuable">
        <rdfs:comment>The property of substances or objects that
          are considered (by their possesor or potential possessor) to 
          have some positive value.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#EvaluativeAttribute"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
        <isTheOppositeOf rdf:resource="#Worthless"/>
    </owl:Class>

<!-- *db587 -->
    <owl:Class rdf:ID="Acceptable">
        <rdfs:comment>The property of being satisfactory to an Agent for
          a purpose, reflecting the Agent's judgment that it will
          serve some purpose.  This is an Evaluative (judgmental) attribute.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#EvaluativeAttribute"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
        <isTheOppositeOf rdf:resource="#Uncceptable"/>
    </owl:Class>

    <owl:Class rdf:ID="Unacceptable">
        <rdfs:comment>The property of not being Acceptable.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#EvaluativeAttribute"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
        <isTheOppositeOf rdf:resource="#Acceptable"/>
    </owl:Class>

    <owl:Class rdf:ID="Worthless">
        <rdfs:comment>The property of substances or objects that
          are considered (by their possesor) to have no positive value.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#QualitativeAttributeValue"/>
        <rdf:type rdf:resource="#QualitativeAttributeType"/>
        <isTheOppositeOf rdf:resource="#Valuable"/>
    </owl:Class>

  <owl:Class rdf:ID="ValuableThing">
        <rdfs:comment>Anything that has value to a cognitive agent.  The 
        value does not have to be monetary, it can be sentimental.  The thing can be
        an object, a right, a substance, or something intangible such
        as friendship or knowledge.  Anything that would cause distress to an
        agent if it were lost is a valuable thing.  Anything that can be
        used to help an agent achieve desired goals (e.g. food)  is also a
        valuable thing - see the subtype 'Resource'.  Anything that an intelligent agent
        would pay money to obtain is a valuable thing; in this case,
        the 'value' is at least approximately quantifiable.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
        <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Valuable"/>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>

  <owl:Class rdf:ID="WorthlessThing">
        <rdfs:comment>Anything that has no net value to the cognitive agent
        that currently possesses it. The thing (object, substance, right)
        may have some value to someone else, but if the possessing agent
        considers it too much of a nuisance to try to gain paymenty for it,
        it is effectively worthless.  This is the quality of
        trash, garbage, refuse, etc..</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#Individual"/>
        <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#hasQualitativeAttribute"/>
           </owl:onProperty>
           <owl:hasValue rdf:resource="#Worthless"/>
         </owl:Restriction>
       </rdfs:subClassOf>
    </owl:Class>

<!-- 'Group' is an important concept in COSMO  -->

  <owl:Class rdf:ID="Group">
    <rdfs:subClassOf rdf:resource="http://www.w3.org/2002/07/owl#Thing"/>
    <rdfs:subClassOf>
      <owl:Class rdf:about="#Individual"/>
    </rdfs:subClassOf>
    <rdfs:comment>Every  Group consists of one or more entities considered as 
    one unit, and is related to the component entities by the relation 'hasComponentElement'.  
    A Group  is not an abstract or mathematical concept - every group derives its
    properties solely from the entities that are its component elements.  Thus
    a group of solid objects would be a solid object, and the mass of that object 
    would be equal to the sum of the masses of the component objects.  It has
    *some* similarity to the 'mereological sum' of mereologists.
    
    However, a Group may have component elements of very diverse kinds - there
    is no restriction on the membership of a Group, though one element can
    only count once in the cardinality of the group.  A Group is somewhat
    similar to a Cyc 'Group', but is not restricted to physical things, and
    has relations to its members named differently than in Cyc.
    
    NOTE: A Group that has one component element is identical to that single element; in this respect
    it is similar to the mereological notion of a 'mereological sum'.  The only group
    that can have itself as a component element is the group of one element.  This 
    latter property is the peculiar characteristic of this concept of 'Group',
    in contrast to other aggregates except, as noted, for 'mereological sum'.
    
    This concept of 'Group' makes certain representations covenient. In some cases,
    we want to deine a finction that may return one or more elements, but if there
    is one element, we also want that single element to be identical to the single element,
    and not encapsulated in an enveloping element.  Returning a Group will allow that behavior.
    
    Cyc Documentation for 'Group' (NOTE some differences from COSMO 'Group')
    OPENCYC 1: MAY 23, 2002
    A collection of temporal objects. Each instance of #$Group is a composite object
    made up of one or more individual objects or events. A group is related to each
    of its members by the predicate #$groupMembers (q.v.) [COSMO: 'hasComponentElement']
    Note that instances of #$Group are _not_ collections. 
    A group has temporal extent [COSMO: a Group may be abstract] and might have spatial
    location, while a collection is timeless and nonspatial. It is of course possible 
    to define a collection parallel to any given group, so that the instances of the 
    collection are exactly the group-members of that group; e.g. each toe on my left 
    foot (and nothing else) is both an instance of the collection of my left toes and 
    a member of the group of toes on my left foot. But that group (of my left toes)
    is a spatiotemporal thing while the correlated collection (of my left toes) is not.
    Similarly, if a certain flock of pigeons is considered as having a location, a spatial 
    extent, and a time of existence, then the flock is being considered a _group_ and not
    a collection. Finally, unlike a collection, a group cannot be empty, but must
    have _at_least_one_ group-member. As a default, a group whose group-members all 
    are instances of #$SomethingExisting is itself an instance of #$SomethingExisting, 
    and a group whose group-members all are #$Events is itself an #$Event. Instances 
    of #$Group include #$QueensGuard, #$ThreeWiseMen, #$SantasReindeer, and
    #$InternationalCommunity.
    </rdfs:comment>
  </owl:Class>

<!-- 
    Cardinality and dimensionality present problems when 
      reified as classes, being both object and attribute, which
      are disjoint
      
   @ToDo - numerical attribute type? 
     !!! number can't be attributevalue: disjoint obj attr
      <rdfs:subClassOf rdf:resource="#AttributeValue"/>

    <owl:Class rdf:ID="Cardinality">
      <rdfs:subClassOf rdf:resource="#NonnegativeInteger"/>
      <rdf:type rdf:resource="#QualitativeAttributeType"/>
      <rdfs:comment>A property of a Group or Set: 
        A negative or nonnegative whole number.</rdfs:comment>
    </owl:Class>

    <owl:Class rdf:ID="Dimensionality">
      <rdfs:subClassOf rdf:resource="#NonnegativeInteger"/>
      <rdfs:subClassOf rdf:resource="#AttributeValue"/>
      <rdf:type rdf:resource="#QualitativeAttributeType"/>
      <rdfs:comment>A property of an Object, Region, or Space.</rdfs:comment>
    </owl:Class>

-->

<owl:DatatypeProperty rdf:ID="hasDimensionality">
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#Object"/>
          <owl:Class rdf:about="#Region"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/>
    <rdfs:comment>hasDimensionality relates an Object or region to the 
       number of dimensions (not necessarily orthogonal) that it occupies.</rdfs:comment>
  </owl:DatatypeProperty>

<owl:DatatypeProperty rdf:ID="hasCardinality">
    <rdfs:domain>
      <owl:Class>
        <owl:unionOf rdf:parseType="Collection">
          <owl:Class rdf:about="#Group"/>
          <owl:Class rdf:about="#Set"/>
          <owl:Class rdf:about="#AbstractString"/>
        </owl:unionOf>
      </owl:Class>
    </rdfs:domain>
    <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#nonNegativeInteger"/>
    <rdfs:comment>hasCardinalty relates a Group to an integer enumerating
       the number of direct component elements of which the group consists.
       Because an element of a Group may itself be a Group, the Cardinality
       does not indicate the number of things that ultimately are not Groups,
       only the number of things that are related by the 'hasComponentElement'
       relation.
       
       NOTE that AbstractString is icluded explicityl, not only as a 
       subtype of Group, because zero-lenght (zero-cardinality, considered
       as though it were an ordered group) strings
       may exist but zero-cardinality Groups are not permitted.</rdfs:comment>
  </owl:DatatypeProperty>

   <owl:Class rdf:ID="Population">
        <rdfs:comment>The collection of all groups of animals of the
            same type living in the same location.  For any instance
            of this Type, it is necessary
            to specify the location to satisfy the restriction.
            
            NOTE that a population is only those animals (or people)
            located in a particualr location at a particular time.
            it is therefore time-sensitive.  The location is 
            generic; therfore, one can use this to describe the 
            people who are on the liner Queen Mary, wherever
            it happens to be at that time.  </rdfs:comment>
        <guid>bde046c0-9c29-11b1-9dad-c379636f7270</guid>
        <rdf:type rdf:resource="#PhysicalObjectType"/>
        <rdfs:subClassOf rdf:resource="#ObjectGroup"/>
      <rdfs:subClassOf>
         <owl:Restriction>
           <owl:onProperty>
             <owl:ObjectProperty rdf:about="#isLocatedAt"/>
           </owl:onProperty>
           <owl:someValuesFrom rdf:resource="#GenericLocation"/>
         </owl:Restriction>
      </rdfs:subClassOf>
   </owl:Class>

   <owl:Class rdf:ID="HumanPopulation">
        <rdfs:comment>The collection of all people living in the
          same location.  This corresponds to the 'population'
          of some geographical area.  Inclusion in the population
          is determined by location, not by citizenship.
          
          A population may be said to have certain characteristics,
          provided that those characteristics are stable for some
          period of time in a given area.</rdfs:comment>
        <rdf:type rdf:resource="#PhysicalObjectType"/>
        <rdf:type rdf:resource="#GroupType"/>
        <rdfs:subClassOf rdf:resource="#Population"/>
        <rdfs:subClassOf rdf:resource="#GroupOfPeople"/>
        <rdf:type rdf:resource="#GroupType"/>
   </owl:Class>

 <owl:ObjectProperty rdf:ID="hasComponentElement">
    <rdfs:comment>hasComponentElement relates a Group to the individual
      elements of which the group consists.
      Any entity can be aggregated with another entity to form
      a conceptual Group.
      
      NOTE: this 'element' is not the chemical 'element'!
      
      See also the specializations of this relation, for
      OrderedGroups, indicating the location in the 
      OrderedGroup of a particular element.
      See 'hasFirstElement' and 'hasSecondElement'.</rdfs:comment>
    <rdfs:domain rdf:resource="#Group"/>
    <owl:inverseOf rdf:resource="#isaComponentElementOf"/>
  </owl:ObjectProperty>

 <owl:ObjectProperty rdf:ID="isaComponentElementOf">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >isaComponentElementOf relates some entity to a Group of which it is a member.
      It is the inverse of 'hasComponentElement'.  Since Groups
      are not defined arbitrarily, and seldom defined automatically, this relation
      will typically be used only when it makes sense to do so.  For example, one
      may define a Group of 'attendees' of some particular meeting.  Then to say
      that a Person is a member of that Group would allow inference that that
      Person was in a particular place at a particular time..</rdfs:comment>
    <rdfs:range rdf:resource="#Group"/>
    <owl:inverseOf rdf:resource="#hasComponentElement"/>
    <rdfs:subPropertyOf rdf:resource="#isaPartOf"/>
  </owl:ObjectProperty>

 <owl:ObjectProperty rdf:ID="hasSubgroup">
    <rdfs:comment>hasSubgroup relates a Group to some
    other definable Group, all of whose component elements are
    also component elements of the larger Group..</rdfs:comment>
    <rdfs:domain rdf:resource="#Group"/>
      <owl:inverseOf>
         <owl:ObjectProperty rdf:ID="isaSubgroupOf"/>
      </owl:inverseOf>
  </owl:ObjectProperty>

  <owl:Class rdf:ID="PluralThing">
        <rdfs:subClassOf rdf:resource="#Group"/>
    <rdfs:comment>Every PluralThing is a Group consisting of at least two or more entities,
    considered as one entity, and is related to the component entities by the
    relation 'hasComponentElement'.
    
    NOTE: in COSMO, Group is restricted to groupings of at least
        one entity, as in OpenCyc.  In this manner PluralThing stays closer to the 
        linguistic intuition of a plural.  A more generic Group that is not a 
        TemporalThing could be defined, but is left out at this point.
        
        NOTE: BFO has the notion of an 'ObjectAggregate' which is similar
        to a 'PluralThing'; but in BFO the requirements are more stringent
        than for COSMO 'Group', since a COSMO 'Group' can be composed of arbitarily
        defined components, whereas in BFO each 'Object' of the aggregate
        must be an object with perceptible boundaries. Since BFO 'Object' 
        is disjoint from 'fiat object part' and from ObjectAggregate,
        we need to make 'ObjectAggregate' a subtype of 'PluralThing',
        and to specify that each component of an 'ObjectAggregate' is a 
        'WholeObject'.</rdfs:comment>
  </owl:Class>

  <owl:Class rdf:ID="OrderedGroup">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >An OrderedGroup is a Group that has some ordering relation between 
      component elements.  It must have more than one component element, 
      Therefore it is a PluralThing and can never be a singleton.
      
      An OrderedGroup may be physical, whereas a List is an AbstractInformationStore.
      Therefore not all OrderedGroups are Lists.  One may define an OrderedGroup
      that is a List, if one is careful that the OrderedGroup is also an
      AbstractInformationStore.
      
      To define a type of OrderedGroup that may have as few as one element,
      define a type that is a subtype of both Group and List.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#PluralThing"/>
  </owl:Class>

  <owl:Class rdf:ID="Queue">
    <rdfs:comment>A Queue is a group of people lined up to do something in 
      sequence - a waiting list.  This is a PhysicalObject - the Group of People,
      not something abstract.</rdfs:comment>
        <rdfs:subClassOf rdf:resource="#OrderedGroup"/>
        <rdfs:subClassOf rdf:resource="#GroupOfPeople"/>
  </owl:Class>

 <owl:ObjectProperty rdf:ID="hasFirstElement">
    <rdfs:comment>hasFirstElement is a specialization of the
     relation 'hasComponentElement' applying to OrderedGroups,
     specifying the first component element of an OrderedGroup.</rdfs:comment>
    <rdfs:domain rdf:resource="#OrderedGroup"/>
    <rdfs:subPropertyOf rdf:resource="#hasComponentElement"/>
  </owl:ObjectProperty>

 <owl:ObjectProperty rdf:ID="hasSecondElement">
    <rdfs:comment>hasSecondElement is a specialization of the
     relation 'hasComponentElement' applying to OrderedGroups,
     specifying the Second component element of an OrderedGroup.</rdfs:comment>
    <rdfs:domain rdf:resource="#OrderedGroup"/>
    <rdfs:subPropertyOf rdf:resource="#hasComponentElement"/>
  </owl:ObjectProperty>

  <owl:Class rdf:ID="OrderedPair">
  