COSMO.owl
type: Ontology
comment: COSMO ontology, Version 0.52-713. Last edit 20080804 by Patrick Cassidy Has 21 top-level classes under 'Thing' Uses elements of the OpenCyc OWL version 0.78, SUMO, BFO and DOLCE ontologies, as well as elements created specifically for COSMO. Parts of COSMO are adopted or closely aligned with elements of other public ontologies such as OpenCyc, SUMO, and BFO. From the documentation of those ontologies, they are freely usable by the public, though they remain copyrighted by their originators (more detail below). No copyright restrictions are attached to materials added in the COSMO project, therefore the only copyright restrictions for use of this ontology are those placed by the developers of the OpenCyc, SUMO, and BFO on elements derived directly from those works. Relation of COSMO to other ontologies: The COSMO ontology has a structure and basic viewpoint that differs in some significant parts from that of the ontologies from which it has adopted materials, and the main parts of the hierarchical structure and relations are not significantly derived from any of the referenced ontologies. Most basically, the representations were intended to adhere as closely as popssible to linguistic intuitions about the meaning and usage of English terms, while specifying the meanings in a logically precise manner. Every element added to COSMO is individually evaluated for its utility and validity within the conceptual structure of the COSMO ontology, and is not derived or adopted solely or mainly on the basis of the appearance of a similar concept in another ontology. Certain individual subtype relations are similar to those in OpenCyc or SUMO; but because the basic hierarchical structure of COSMO differs from the other ontologies, logical inference using these relations will arrive at conclusions that cannot be aligned directly with either OpenCyc or SUMO. No mapping between COSMO and these other ontologies is likely to enable accurate inference. The documentation derived from Op…

InheritableType
type: Class
subclass of: Class
comment: InheritableType is a specialization of the Protege owl:Class which is used to identify those metatypes which, when specified as the parent Type for some class (Type) in the ontology, will also by implication be the parent Type for all subtypes of any Type explicitly designated as an instance of any subtype of 'InheritableType'. This is a primitive mechanism to permit translation of this ontology among various formats, while permitting the use of reasoning engines which require that arguments to relations, if restricted as to Type, be instances of some specified Type. There are some ontologies, such as SUMO, using first-order logic, which permit one to specify that an argument to a relation must be a *subtype* of some Type in the ontology, rather than an *instance* of some Type. OWL and some other reasoning engines do not permit that kind of restriction. For convenience, to allow this ontology to be used in multiple reasoning engines and to be automatically translated into multiple formats, this metatype is provided and so that one can avoid having to specify the metatype instance of every Type that is to be used as an argument to a relation. When using this ontology in an inference engine that requires explicit types, it will be necessary to add the InheritableType as a Type of each subtype of any Type that is specified to be an instance of such an inheritable type. That addition will have to be one in a preprocessing stage before using that inference engine. An axiom may be added to an ontology using FOL to specify that all subtypes of a Type ?T that is an instance of an InheritableType ?MT will also be instances of that InheritableType: (=> (and (isanInstanceOf ?T ?MT) (isaSubclassOf ?MT InheritableType)) (forall (?ST) (=> (isaSubclassOf ?ST ?T) (isanInstanceOf ?ST ?MT)))) This axiom will permit the ontologist to avoid specifying the metatype for every subtype of the root type of that Type tree, in those ontology implementations that can use FOL.

RoleType
type: Class
comment: RoleType is a metaclass used as the Type restriction on certain relations that take subclasses of Role as their argument.
subclass of: InheritableType

ScopeType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Scope as one of their arguments..
subclass of: InheritableType

ValuableThingType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of ValuableThing as one of their arguments.
subclass of: InheritableType

QuantifierType
type: Class
comment: 'QuantifierType' is a metaclass used as the Type restriction on certain relations that take subclasses of Quantifier as their argument.
subclass of: InheritableType

ProcessType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of FunctionalProcess as one of their arguments..
subclass of: InheritableType

AttributeValueType
type: Class
comment: AttributeValueType is a metaclass used as the Type restriction on certain relations that take subclasses of AttributeValue as their argument.
subclass of: Class
subclass of: InheritableType

VitalityAttributeType
type: Class
comment: VitalityAttributeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for attributes specifyuing vitality (alive, dead) and an argument restriction for some relations on QualitativeAttributes. This is a primitive mechanism to accommodate OWL limitations.
subclass of: QualitativeAttributeType

MeasureType
type: Class
comment: MeasureType is a metatype which is a specialization of rdfs:Class that can serve as type for measures and an argument restriction for relations concerning types of measure (Length, Temperature, Color). An instance of 'MeasureType' may be, in addition to a subtype of QuantitativeAttributeValue, a subtype of 'DimensionlessRatio'. MeasureType instances may be either AttributeTypes or AttributeValues. It may be better to distingish the two, but as of v. 0.46, the same metaclass is used for the two different aspects of quantitative attributes. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: InheritableType
subclass of: AttributeValueType

MeasurableQuantityType
type: Class
comment: MeasurableQuantityType is a metatype which is a specialization of the Protege owl:Class that can serve as type for MeasurableQuantities, whether abstract or physical, and an argument restriction for various relations on MeasurableQuantity types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: AttributeValueType

DifferenceType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Difference as one of their arguments..
subclass of: AttributeValueType

QualitativeAttributeType
type: Class
comment: QualitativeAttributeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for taste attributes and an argument restriction for some relations on QualitativeAttributes. This is a primitive mechanism to accommodate OWL limitations.
subclass of: Class
subclass of: AttributeValueType

IntensiveAttributeValueType
type: Class
comment: IntensiveAttributeValueType is a metaclass used as the Type restriction on certain relations that take subclasses of IntensiveAttributeValue as their argument.
subclass of: Class
subclass of: QualitativeAttributeType

CapabilityType
type: Class
comment: CapabilityType is a metaclass used as the Type restriction on certain relations that take subclasses of Capability as their argument. A 'Capability' is a broad sense, and can be possessed by an Agent, a Device, a ChemicalSubstance, etc.
subclass of: IntensiveAttributeValueType

ContextType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Context as one of their arguments. IT can also be used for types for which namespace prefixes would be convenient to label the instances, such as 'AtomicSymbol'..
subclass of: InheritableType

EventType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Event as one of their arguments..
subclass of: InheritableType

SignType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Sign as one of their arguments..
subclass of: InheritableType

ActionType
type: Class
comment: ActionType is a metaclass used as the Type restriction on certain relations that take subclasses of Action as their argument.
subclass of: EventType
subclass of: TopicType

OccupationType
type: Class
comment: OccupationType is a metaclass used as the Type restriction on certain relations that pertain to Occupations, such as 'isTheOccupationOfa' and 'practicesOccupation'. NOTE that this must not be used as the Type of people who have occupations. For that, use 'OccupationalRoleType'.
subclass of: ActionType
subclass of: RoleType

ServiceType
type: Class
comment: Each instance of 'ServiceType' is a type that represents a service that some perosn performs for another, often for pay. A Service does not have to be performed for pay every time, but must be performed for pay in some cases.
subclass of: ActionType

ConditionType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of SystemCondition as one of their arguments..
subclass of: EventType

LocationType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take an instance of Location as one of their arguments..
subclass of: InheritableType

PhysicalObjectType
type: Class
comment: PhysicalObjectType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical objects and an argument restriction for various relations on Physical Object types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ObjectType
subclass of: LocationType

HabitatType
type: Class
subclass of: LocationType
comment: HabitatType is a metatype which is a specialization of the Protege owl:Class that can serve as type for regions or physical areas with particular characteristics, and can serve as an argument restriction for the relation 'hasTypicalHabitat' OrganismTypes. This is a primitive mechanism to accommodate OWL limitations on relation arguments.

AgentType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Agent as one of their arguments. All Organisms, plant, animal, microorganism, are of AgentType.
subclass of: ObjectType

ArtifactObjectType
type: Class
comment: ArtifactObjectType is a metatype which is a specialization of the Protege owl:Class that can serve as type for ArtifactObjects and an argument restriction for various relations on ArtifactObject types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: PhysicalObjectType

CoveringType
type: Class
comment: CoveringType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical objects that are subtypes of 'Covering-Object', and an argument restriction for various relations on CoveringObject types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: PhysicalObjectType

HolderType
type: Class
comment: ContainerType is a metatype which is a specialization of the Protege owl:Class that can serve as type for 'Holders' and 'Containers' and an argument restriction for various relations on container types. This is a primitive mechanism to accommodate OWL limitations on relation arguments. 'Containers' can be artifacts or natural objects.
subclass of: ArtifactObjectType

ContainerType
type: Class
comment: ContainerType is a metatype which is a specialization of the Protege owl:Class that can serve as type for containers and an argument restriction for various relations on container types. This is a primitive mechanism to accommodate OWL limitations on relation arguments. 'Containers' can be artifacts or natural objects.
subclass of: HolderType

OrganismType
type: Class
comment: OrganismType is a metatype which is a specialization of the Protege owl:Class that can serve as type for LifeForms (including LifeForms that are not true Organisms) and an argument restriction for various relations on specific types of organisms. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: PhysicalObjectType
subclass of: AgentType

OrganizationType
type: Class
comment: OrganizationType is a metaclass used as the Type restriction on certain relations that take subclasses of Organization as their argument. Each Organization is capable of acting as an agent, and this type is therefore a subtype of 'AgentType'.
subclass of: InheritableType
subclass of: AgentType

PersonType
type: Class
comment: PersonType is a metatype which allows specifying relations on ''Person'' as a Class.
subclass of: PhysicalObjectType
subclass of: AgentType

OccupationalRoleType
type: Class
comment: OccupationalRoleType is a metaclass used as the Type restriction on certain relations that pertain to Types describing people in occupational roles, such as 'Nurse', 'Firefighter'..
subclass of: RoleType
subclass of: PersonType

BiologicalOrganType
type: Class
comment: BiologicalOrgan is a metaclass used as the Type restriction on certain relations that pertain to named parts of organisms at particular stages of their life cycle. It is not necessarily an animal body part type - it may be part of a plant.
subclass of: RoleType
subclass of: PhysicalObjectType

AgentRoleType
type: Class
comment: ''AgentRoleType'' is a metaclass that is a subclass of both 'AgentType' and 'RoleType'. It is used as the Type restriction on certain relations that take subclasses of HumanRole as their argument. @mod55
subclass of: AgentType
subclass of: RoleType

HumanRoleType
type: Class
comment: RoleType is a metaclass that is a subclass of both 'PersonType' and 'RoleType'. It is used as the Type restriction on certain relations that take subclasses of HumanRole as their argument. @mod55
subclass of: PersonType
subclass of: AgentRoleType

PhysicalFeatureType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take an instance of Feature as one of their arguments..
subclass of: InheritableType

AnimalBodyPartType
type: Class
comment: A collection of specializations of #$AnimalBodyRegion. Each instance of #$AnimalBodyPartType is a collection of body parts, where the parts in question are differentiated from other body parts according to structure or function. Instances of #$AnimalBodyPartType include #$SpinalColumn, #$Eyelash, #$NervousSystem, #$Urethra, #$Wing-AnimalBodyPart, and #$HeelOfPalm.
subclass of: PhysicalObjectType

ProductType
type: Class
comment: 'ProductType' is a metatype that can be used as an argument restriction for relations that take an instance of Product (i.e. something for sale) as one of their arguments..
subclass of: InheritableType

GroupType
type: Class
comment: GroupType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical objects and an argument restriction for various relations on types of Groups (not just People, but any type of Group). This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ObjectType

SubstanceType
type: Class
comment: SubstanceType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical substances and an argument restriction for the hasComponentSubstance relation. This is a primitive mechanism to accommodate OWL limitations on relation arguments. The restriction on hasGrainDiameter for SubstanceTypes should require subclasses rather than instances of LengthMeasure - instances may have to be created as a workaround.
subclass of: Class
subclass of: InheritableType

SubstanceShapeType
type: Class
comment: SubstanceShapeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical substances in a particular shape 'SubstanceInaSpecificShape' and an argument restriction for the isaFormOfSubstance relation. NOTE: instances are *not* AttributeValues, as are instances of 'ShapeType'. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: SolidSubstanceType

FluidType
type: Class
comment: FluidType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical substances that are in a fluid (liquid or gas) state. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ChemicalSubstanceType

GasType
type: Class
subclass of: FluidType
comment: ''GasType'' is a subtype of ''FluidType'' used to allow references to subtypes of ''Gas'' qua ''Gas''.

EmittableObjectType
type: Class
comment: EmittableObjectType is a metatype which is a specialization of the Protege owl:Class that can serve as type for EmittableObjects and an argument restriction for the canEmit relation. This is a primitive mechanism to accommodate OWL limitations.
subclass of: QualitativeAttributeType
subclass of: InheritableType

OrganismPartType
type: Class
comment: OrganismPartType is a metatype which is a specialization of the Protege owl:Class that can serve as type for parts of organisms - plants,anma,or microorganisms.
subclass of: PhysicalObjectType

FacialHairType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take an instance of FacialHair as one of their arguments..
subclass of: AnimalBodyPartType

LearnedActivityType
type: Class
comment: COSMO note: this metatype has not been used up to v0.54. It includes all actions that need some kind of training beyond mere observation and repetition. Things that need years of training are represented as 'SkilledActivityType'. In Chinese, there is a difference in the words used to say one 'knows' how to do somnething, if that thing is learned or not learned (like knowing a person). This seems to be a fundamental and intuitive difference. An example is knowing how to speak Chinese. Using any complex device is an instance of 'LearnedActivityType', even if the learning is fast, intuitive (for us moderns) and easy. Cyc: This is the collection of activities which must first be learned before they can be performed - i.e., before any role which is a specPred of #$doneBy can be played.
subclass of: ActionType
subclass of: CapabilityType

LimitationType
type: Class
comment: LimitationType is a metaclass used as the Type restriction on certain relations that take subclasses of Limitation as their argument.
subclass of: CapabilityType

CommunicationType
type: Class
comment: CommunicationType is a metaclass used as the Type restriction on certain relations that take subclasses of Communication as their argument.
subclass of: ActionType

MoneyTenderType
type: Class
comment: Each instance of MoneyTenderType denotes a form in which some quantity of Money may be represented. A collection of collections. Each instance of #$MoneyTenderType is a collection of objects of a type commonly offered in payment for goods, services, fees, wage-work, and so on. Notable instances of #$MoneyTenderType include #$Currency, #$CreditCard, and #$Check-TenderObject.
subclass of: InheritableType

MeasuringDeviceType
type: Class
comment: MeasuringDeviceType is a metatype which is a specialization of the Protege owl:Class that can serve as type for MeasuringDevices, and an argument restriction for various relations on MeasuringDevice types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: DeviceType

TransportationDeviceType
type: Class
comment: TransportationDeviceType is a metaclass used as the Type restriction on certain relations involving TransportationDevices.
subclass of: DeviceType

TasteType
type: Class
comment: TasteType is a metatype which is a specialization of the Protege owl:Class that can serve as type for taste attributes and an argument restriction for the hasTaste relation. This is a primitive mechanism to accommodate OWL limitations.
subclass of: QualitativeAttributeType

PhysiologicalConditionType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of PhysiologicalCondition as one of their arguments. NOTE that illness (sickness, disease, ailment) is a subtype of PhysiologicalCondition, and this metatype can be used for relations on types of illness. NOTE that a 'PhysiologicalConditionType' is a subtype of 'ActionType' because it is 'performed' by an Agent, which is an Organism.
subclass of: ActionType
subclass of: ConditionType

AilmentType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of AilmentCondition as one of their arguments..
subclass of: PhysiologicalConditionType

FeelingType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Feeling as one of their arguments..
subclass of: PhysiologicalConditionType

InsuredEventType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Event as one of their arguments. This is used specifically for the restriction on 'InsuranceAgreement'. Each instance of InsuredEventType is a type of Event that commonly is insured against in some InsuranceAgreement. Many kinds of Events *can* in principle be insured against, but this metatype is for those types of Events that *commonly* are insured against, or actually *have been* insured against, in some application that uses this ontology.
subclass of: InheritableType

BiologicalFamily
type: Class
comment: The collection of biological taxonomic subdivisions below #$BiologicalOrder (or #$BiologicalSuborder) and above #$BiologicalGenus. Especially important in Botanical classification.
subclass of: BiologicalTaxonType

BiologicalOrderType
type: Class
comment: A specialization of #$BiologicalTaxon. Each instance of #$BiologicalOrder is an immediate subdivision of some instance of #$BiologicalClass or #$BiologicalSubclass (qq.v.). Instances of #$BiologicalOrder include #$CarnivoreOrder, #$Monotreme, and #$Primate.
subclass of: BiologicalTaxonType

GrammaticalType
type: Class
subclass of: InheritableType
comment: A GrammaticalType is any structure (word, phrase, phoneme, morpheme) in a NaturalLanguage that, in combination with other structures constitues the grammar of the language, as represented in some grammatical theory of the language. Examples would be 'Subject', 'Verb', 'Object', 'VerbPhrase', etc.

LocationMeasureType
type: Class
comment: LocationMeasureType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical substances and an argument restriction for the hasLocation relation. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: InheritableType

PlantPartType
type: Class
comment: PlantPartType is a metatype which is a specialization of the Protege owl:Class that can serve as type for plant parts and an argument restriction for various relations on parts of plants. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: OrganismPartType

ChemicalSubstanceType
type: Class
comment: a metaclass used as the Type restriction on certain relations that take subclasses of ChemicallyDefinedSubstance as their argument. Cyc: A collection of collections and a specialization of #$TangibleStuffCompositionType. Each instance of #$ChemicalSubstanceType is a specialization of #$PartiallyTangible whose instances are defined _only_ by their chemical composition - not by their physical state or any other property. Instances of #$ChemicalSubstanceType can be of two varieties: (1) Collections whose instances are completely uniform with each other in terms of chemical composition; this includes (a) the chemical elements - such as #$Carbon, #$Oxygen, and #$Hydrogen - which are instances of #$ElementStuffTypeByNumberOfProtons (thus, the latter is a specialization of #$ChemicalSubstanceType), and (b) chemical compounds constituted of more than one substance chemically bonded, e.g., #$Water, #$Caffeine, and #$IronOxide, which are instances of #$ChemicalCompoundTypeByChemicalSpecies (2) Substances which have a general chemical specification, that is, whose instances do not have exactly the same chemical composition but fall within certain specifications, e.g., #$DNAStuff. Note that collections that are _not_ instances of #$ChemicalSubstanceType include collections of substances which have some component which is of overriding significance in some context, so that in everyday language such substances are frequently referred to by the name of their important component (e.g., penicillin applied to a tablet containing penicillin), but which have significant admixtures of other substances. Thus, #$Penicillin is an instance of #$ChemicalSubstanceType, but the collection of tablets containing penicillin and including other ingredients is not. Also, specializations of #$Mixture, such as #$Lemonade, are _not_ instances of #$ChemicalSubstanceType, because mixtures are determined by their physical state rather than solely by their chemical composition.
subclass of: InheritableType
subclass of: SubstanceType

ChemicalCompoundByChemicalSpeciesType
type: Class
comment: A collection of collections and a specialization of #$ChemicalSubstanceType. Each instance of #$ChemicalCompoundTypeByChemicalSpecies is a specialization of #$PartiallyTangible whose instances are defined _only_ by their chemical composition - not by their physical state or any other property. Instances of #$ChemicalCompoundTypeByChemicalSpecies are collections whose instances are completely uniform with each other in terms of chemical structure, e.g., #$Water, #$Caffeine, and #$IronOxide. This collection does not include the chemical elements - such as #$Carbon and #$Oxygen, since there can be multiple types that molecules can be formed out of a single element, e.g. O2 and #$Ozone. Use the broader collection, #$ChemicalSubstanceType, for substances which have a general chemical specification, that is, whose instances do not have exactly the same chemical composition but fall within certain specifications, e.g., #$DNAStuff.
subclass of: ChemicalSubstanceType

RepeatedEventType
type: Class
comment: A specialization of #$FirstOrderCollection (q.v.) whose instances are collections of #$Events. Each instance of #$RepeatedEventType is a collection of events whose instances tend to come in series or to occur at more or less regular intervals. These series or recurrences might be the result of natural phenomena (e.g. the spoutings of Old Faithful), human convention (e.g. the occurrence of #$BaseballInnings within a given game), or a combination of both (e.g. the annual celebration of Oktoberfest). An important specialization of this collection is #$RegularlyRepeatedEventType. See also #$IterativeEvent and #$IterativeEventType.
subclass of: EventType

AcidType
type: Class
comment: The collection of all acids. Instances are instances of #$ChemicalCompoundTypeByChemicalSpecies whose instances will react in certain chemically predictable ways with a base (see #$BaseType)
subclass of: ChemicalSubstanceType

DrugSubstanceType
type: Class
comment: ''DrugSubstanceType'' metatype which is a subclass of ''SubstanceType'' that can serve as type for physical substances that are ingested as drugs (legal or illegal), or as vitamins, or as a supplement of any kind for the purpose of having some physiolgical effect. .
subclass of: SubstanceType

AntibioticType
type: Class
comment: An instance of ''AntibioticType'' is a ''PhysicalSubstane'' that is an instance of a ''DrugSubstanceType'' used to treat some ''BacterialInfection'. .
subclass of: DrugSubstanceType

ElementType
type: Class
comment: ElementType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical substances and an argument restriction for the relations on chemical elements. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ChemicalSubstanceType

MetalType
type: Class
comment: MetalType is a metatype which is a specialization of the Protege owl:Class that can serve as type for Metals and an argument restriction for the relations on Metals. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ChemicalSubstanceType

PlasticType
type: Class
comment: ''PlasticType'' can serve as type for subtypes of ''Plastic'' to allow an argument restriction for the relations on ''Plastic''s.
subclass of: SolidSubstanceType
subclass of: ChemicalSubstanceType

StoneType
type: Class
comment: ''StoneType'' can serve as type for subtypes of ''Stone'' to allow an argument restriction for the relations on ''Stone''.
subclass of: SolidSubstanceType

MineralType
type: Class
comment: ''MineralType'' can serve as type for subtypes of ''Mineral'' to allow an argument restriction for the relations on ''Mineral''s.
subclass of: StoneType

ColorAttributeType
type: Class
comment: Each class of a ColorAttribute forms a region with more specific classes of ColorAttribute forming subregions..
subclass of: QualitativeAttributeType
subclass of: AppearanceType

LifeStageType
type: Class
comment: LifeStageType is a metaclass used as the Type restriction on certain relations that pertain to organisms at particular stages of their life cycle. Instances of 'LifeStageType' are types which may represent time periods (the intervals of time during which an organism is in a specific stage), **or** the organism in that stage. NOTE: this is an unusual usage of metatypes; the instances may be a subtype of one of two disjoint types. (Here, a TimeInterval may implicitly play a 'Role'. @ToDo - can this lead to problems?)
subclass of: RoleType

AppearanceType
type: Class
comment: Each instance of ''AppearanceType'' is a QualitativeAttributeValue characterizing the external 'appereance' (light pattern) created by the Object with that QualitativeAttributeValue. This includes subtypes of ''ColorAttribute''
subclass of: QualitativeAttributeType

ShapeType
type: Class
subclass of: AppearanceType
subclass of: PatternType
comment: ShapeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for shape attributes and an argument restriction for the hasShape relation. This is a primitive mechanism to accommodate OWL limitations. NOTE: as of v0.50, both shape attributes and specifically shaped objects can be instances of ShapeType. @ToDo - this should probably be differentiated. CYC note: CYC has 'ThreeDimensionalShapeType', a subtype of 'GeometricShapeType', not used in COSMO: A collection of collections and a specialization of #$GeometricShapeType (q.v.). Each instance of #$ThreeDimensionalShapeType is a specialization of #$ThreeDimensionalGeometricThing (q.v.) all of whose own instances have something in common as regards their shape. Instances include the collections #$Cylinder and #$Cube. As of rev 1111 only 'ShapeType' is used as a Type metaclass, and geometric shapes and other distinctively shaped objects are related to objects having those shapes by the relation 'hasTheShapeOfa'. Instances of SphaeType in COSMO are all AttributeValues.

LexicalType
type: Class
subclass of: InheritableType
comment: A LexicalType is any structure (word, phrase, phoneme, morpheme) in a NaturalLanguage that, has a distinctie pattern of letters in its alphabetical representation. An example would be an Abbreviation.

NaturalResourceType
type: Class
subclass of: InheritableType
comment: The collection of collections of things that are useful in nature.

WireType
type: Class
comment: WireType is a metatype which is a specialization of the Protege owl:Class that can serve as type for different kinds of wire and an argument restriction for the relations on chemical elements. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: SubstanceType
subclass of: SubstanceShapeType

FingerType
type: Class
comment: Each instance of FingerType is a subtype of 'Finger', indicating the specific type of Finger (e.g. 'LeftThumb')
subclass of: AnimalBodyPartType

LigandType
type: Class
comment: A specialization of #$ChemicalCompoundTypeByChemicalSpecies. Instances of #$LigandType are collections whose instances are substances capable of surrounding and bonding to a central metal ion, forming a metal complex (or simply complex). In forming a complex, the ligands are considered to coordinate to the metal.
subclass of: ChemicalCompoundByChemicalSpeciesType

DeviceType
type: Class
comment: DeviceType is a metatype which is a specialization of the Protege owl:Class that can serve as type for Devices and an argument restriction for various relations on specific types of Devices. This is a primitive mechanism to accommodate OWL limitations on relation arguments. NOTE that we allow instances of DeviceType to be considered as a type of agent.
subclass of: ArtifactObjectType
subclass of: AgentType

RegularlyRepeatedEventType
type: Class
comment: A specialization of #$RepeatedEventType (q.v.). Each instance of #$RegularlyRepeatedEventType is a collection of events whose instances typically occur along with other instances of the same event-type at more or less regular intervals. These regular occurrences might be the result of natural phenomena (e.g. the sunrise), human convention (e.g. the execution of a dance step within a given dancing event), or a combination of both (e.g. the annual celebration of Oktoberfest). Other examples of #$RegularlyRepeatedEventType are #$OlympicGames, #$AcademicTerm, and #$TakingABreath. See also #$IterativeEvent and #$IterativeEventType.
subclass of: RepeatedEventType

BiologicalSubclass
type: Class
comment: The collection of biological taxonomic subdivisions more specific than #$BiologicalClass but more general than #$BiologicalOrder.
subclass of: BiologicalTaxonType

InventionType
type: Class
subclass of: Class
comment: A Device or Process in its Role as an Invention. To refer to a device or process as an invention, one can add the type 'InventionType' to the type (OWL class) and then refer to that type. See 'ThomasAlvaEdison' for an examnple of usage. This is approximately sense 2 of 'invention' in WordNet, however, as a metatype it has no direct connection to any other type in WordNet: 2. (6) invention, innovation - (a creation (a new device or process) resulting from study and experimentation)
wordnet: invention
wnsense: invention2n
wordnet: innovation
wnsense: innovation1n

Breed
type: Class
comment: a BiologicalSubspecies that is or maintained by human breeding activities. See 'Breeding'. This corresponds to sense 13 of 'breed' in the random House Webster: 13. Genetics. a relatively homogenous group of animals within a species, developed and maintained by humans. This should be a subtype of 'variety' as used in the biological classification sense, but the owl:class (Types) and rdfs:class (Metatypes) hierarchy needs to be kept apart for clarity. Se 'Type' and 'Sort' for more detail on which COSMO type represents which sort of category. Corresponds to noun sense 2 of 'breed' and sense 5 of 'strain' in WordNet: 2. (1) breed, strain, stock - (a special variety of domesticated animals within a species; 'he experimented on a particular breed of white rats'; 'he created a new strain of sheep')
subclass of: BiologicalTaxonType
subclass of: PhysicalObjectType
ldoce: breed
wordnet: breed
wnsense: breed2n
wordnet: strain
wnsense: strain5n

SkilledActivityType
type: Class
comment: COSMO note: this metatype has not been used up to v0.54. It may be used to help classify actions that require years of training. This differs from the Cyc interpretation. Cyc: This is the collection of collections of activities which require some specialized skill to perform--i.e., to play any role which is a specPred of #$doneBy. So, all skilled activities are learned, but not all learned activities are skilled. For instance, #$WalkingOnTwoLegs is an instance of #$LearnedActivityType but not an instance of #$SkilledActivityType. Since every normal person learns to walk, it requires no special skill. In contrast, #$Juggling is an instance of #$SkilledActivityType, for most people do not know how to juggle.
subclass of: LearnedActivityType

PatternType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take an instance of Pattern as one of their arguments. ***NOTE*** that this is a subtype of 'ObjectType''as well as ''QualitativeAttributeType'' even though 'QualitativeAttributes' and 'Objects' are disjoint. This does not violate the logic of COSMO, though it suggests that more thought is needed to categorize pattterns.
subclass of: QualitativeAttributeType
subclass of: ObjectType

AgreementType
type: Class
comment: ''AwardType'' is a metatype which is a specialization of the Protege owl:Class that can serve as type for subtypes of 'Agreement'
subclass of: ObjectType

TextureType
type: Class
comment: A metaclass to serve as a Type for Surface texture attributes of physical objects.
subclass of: AppearanceType

USAirForceRankType
type: Class
comment: The scale of ranks employed by the United States Air Force. This is a collection of attributes that are used with the predicate #$rank-Military.
subclass of: MilitaryRankType
ldoce: rank
wordnet: rank
wnsense: rank2n

PlantType
type: Class
comment: PlantType is a metatype which is a specialization of OrganismType that can serve as type for a Plant. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: OrganismType

BiologicalTaxonType
type: Class
comment: A collection of collections and a specialization of #$OrganismClassificationType (q.v.). Instances of #$BiologicalTaxon correspond to ranked categories accepted by biologists for the classification of organisms according to their suspected evolutionary relationships. Such categories change as biologists learn more about the organisms involved and determine that existing classifications are more or less useful. They include all levels of taxons. Specializations of #$BiologicalTaxon include #$BiologicalOrder and #$BiologicalSpecies; instances include #$Marsupial and #$Ape. See also #$BiologicalTaxonType.
subclass of: OrganismType

BiologicalGenus
type: Class
comment: The collection of biological taxonomic subdivisions (see #$BiologicalTaxon) created below #$BiologicalFamily and above #$BiologicalSpecies. Sometimes, hybrids are possible between different instances of #$BiologicalSpecies that belong to the same #$BiologicalGenus.
subclass of: BiologicalTaxonType

RegionType
type: Class
comment: RegionType is a metatype which is a specialization of the Protege owl:Class that can serve as type for regions, and an argument restriction for various relations on Region types. CYC also uses a metaclass class called 'RegionType', with broad usage: A collection of collections. Each instance of #$RegionType is a subcollection of #$SpatialThing-Localized each of whose instances is an identifiable subregion of some object, but not itself an independent object. Instances of #$RegionType include #$PalmOfHand, #$Doorway, #$Wall-GenericBarrier, #$WorkSurface, and #$Handle. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: InheritableType

BiologicalSpecies
type: Class
comment: BiologicalSpecies is a metatype that can be used as an argument restriction for relations that take an instance of biological species as one of their arguments. Cyc: An instance of #$BiologicalTaxonType. Each instance of #$BiologicalSpecies is the most general taxon from which two breeding organisms of appropriate sexes can conceivably produce fertile offspring, or, in the case of asexual reproduction, is conventionally defined. Members of different species of animals cannot produce fertile offspring by interbreeding. If there are only two breeds of a given species and one breed becomes extinct, the second breed by virtue of that fact becomes an instance of #$BiologicalSpecies - since the only organisms instances can breed with to produce fertile offspring are, at that point, members of that collection. An instance of #$BiologicalSpecies has members who all have significant traits in common, and members of each biological species have other members as parents. Exceptions occur when a species is conventionally defined to start since parenthood could conceivably be traced back billions of years, yet new species came into existence. In biological taxonomy, related species are grouped into a particular instance of #$BiologicalGenus. Some genera have only a single species, but they remain different taxons. SUMO: The Class of all biological species, i.e. the class of all classes of Organism whose instances can interbreed. Corresponds to noun sense 1 of 'species' in WordNet: 1. (27) species - ((biology) taxonomic group whose members can interbreed)
subclass of: BiologicalTaxonType
wordnet: species
wnsense: species1n

FoodType
type: Class
comment: FoodType is a metatype which is a specialization of the Protege owl:Class that can serve as type for different kinds of Food (a Substance). This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: SubstanceType

FoodObjectType
type: Class
comment: FoodType is a metatype which is a specialization of the Protege owl:Class that can serve as type for different kinds of FoodObject (a PhysicalObject). This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: PhysicalObjectType

ObjectType
type: Class
comment: ObjectType is a metatype which is a specialization of the Protege owl:Class that can serve as type for objects, whether abstract or physical, and an argument restriction for various relations on Object types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: InheritableType

AbstractObjectType
type: Class
comment: AbstractObjectType is a metatype which is a specialization of the Protege owl:Class that can serve as type for physical objects and an argument restriction for various relations on 'AbstractObject' types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: ObjectType
subclass of: LocationType

MentalObjectType
type: Class
comment: ''MentalObjectType'' is a metatype which is a specialization of 'AbstractObjectType' that can serve as type for ''MentalObject''s, i.e. ''AbstractObject''s created by an intelligent agent (usually a Person, but it could be a computer) that contains information in any form (text, graphical, propositions). Rules (laws, theories, documents, graphical images of which there are physical representations) and an argument restriction for various relations on such things. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: AbstractObjectType

PropositionType
type: Class
comment: 'PropositionType' is a metatype which is a specialization of the Protege owl:Class that can serve as type for Propositions and an argument restriction for various relations on Propositions types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: MentalObjectType

SpecificationType
type: Class
comment: SpecificationType is a metatype which is a specialization of the Protege owl:Class that can serve as type for specifications (plays, plans, games) and an argument restriction for the isAnExecutionOf relation. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: AbstractObjectType
subclass of: MentalObjectType

SportType
type: Class
comment: SportType is a metatype which is a specialization of the Protege owl:Class that can serve as type for specifications of sports (games) and an argument restriction for the isAnExecutionOf relation. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: SpecificationType
subclass of: ActionType

GameType
type: Class
comment: GameType is a metatype which is a specialization of the Protege owl:Class that can serve as type for games and an argument restriction for the isAnExecutionOf relation. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: SpecificationType
subclass of: ActionType

PharmacyProductType
type: Class
comment: COSMO note: used for both substances and Objects. @ToDo (v0.50) Probably should be distinguished. Cyc: A collection of collections, and a specialization of #$ManufacturedGoodsType. Instances of this collection are types of pharmaceutical products that may be prescribed by a medical professional. Note that this includes drugs -- specializations of #$DrugSubstance -- as well as pharmaceutical devices such as #$TestStrip or #$HearingAid-Prescription. #$PrescriptionDrugType and #$OverTheCounterDrugType are among the specializations of this collection.
subclass of: InheritableType

AttributeTypeType
type: Class
comment: AttributeTypeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for AttributeTypes (length, mass), and an argument restriction for various relations on AttributeType types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: InheritableType
subclass of: Restriction
  on property: takesValue
  some values from: AttributeValueType

QuantitativeAttributeType
type: Class
comment: QuantitativeAttributeType is a metatype which is a specialization of the Protege owl:Class that can serve as type for QuantitativeAttributes (length, mass), and an argument restriction for various relations on AttributeType types. This is a primitive mechanism to accommodate OWL limitations on relation arguments.
subclass of: AttributeValueType

USArmyRankType
type: Class
comment: The scale of ranks employed by the United States Army. This is a collection of attributes that are used with the predicate #$rank-Military.
subclass of: MilitaryRankType
ldoce: rank
wordnet: rank
wnsense: rank2n

InfectionType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take a subtype of Infection as one of their arguments.
subclass of: AilmentType

TransitiveEventType
type: Class
comment: a metatype that can be used as an argument restriction for relations that take an instance of a transitive Event (an Event that has a 'patient' role, something acted on) as one of their arguments..
subclass of: EventType

EndangeredSpecies
type: Class
subclass of: BiologicalSpecies
comment: COSMO note: in COSMO, 'EndangeredSpecies' is a metatype whose instances are BiologicalSpecies whose survival as a species is at risk. SUMO: EndangeredSpecies is the subclass of Organism that includes plants and animals that are in danger of extinction from destruction of individuals or of habitat. This is a primitive mechanism to accommodate OWL limitations on relation arguments. Corresponds to noun sense 1 of 'endangered species' in Wordnet: 1. endangered species - (a species whose numbers are so small that the species is at risk of extinction)
wordnet: endangered species
wnsense: endangered species1n

PharmaceuticalType
type: Class
comment: PharmaceuticalType is a metaclass used as the Type restriction on certain relations that pertain to more or less well-defined chemical substances that are used officially (in some society) as a medicine..
subclass of: ChemicalSubstanceType

MoneyType
type: Class
comment: 'Money' is treated in COSMO as a GenericSubstance, and specific quantities of money are the objects that consist of Money. MoneyType is a metatype that can be used as an argument restriction for relations that take a subtype of Money as one of their arguments. Instances of MoneyType can be abstract or physical.
subclass of: ValuableThingType
subclass of: SubstanceType

SolidSubstanceType
type: Class
comment: 'SolidSubstanceType' is used to express some relations between some subtypes of 'SolidSubstance' and other entities..
subclass of: SubstanceType

TendencyType
type: Class
comment: TendencyType is a metatype that can be used as an argument restriction for relations that take a subtype of Tendency as one of their arguments. This metaclass is of importance in predicting behaviors over time, and may require probability assignments; therefore it is considered distinct and not a subtype of 'QualitativeAttributeType'..
subclass of: InheritableType

GaseousSubstanceType
type: Class
comment: 'GaseousSubstanceType' is used to express some relations between some subtypes of 'Gas' and other entities..
subclass of: SubstanceType
subclass of: FluidType

TopicType
type: Class
comment: TopicType is a metaclass used as the Type restriction on fields of knowledge, whether formal or informal. This type allows assertions about a whole field, as in the relation 'isKnowledgeableAbout'.
subclass of: ObjectType
subclass of: AgreementType

RankType
type: Class
comment: RankType is a metaclass used as the Type restriction on certain relations that take subclasses of ''Rank'' as their argument. NOTE that this type is a subtype of both ''ActionType'' (as a ''Status'' - state) and ''RoleType'' (as a ''Role'' a Person can play).
subclass of: ActionType
subclass of: RoleType

MilitaryRankType
type: Class
comment: A metatype whose instances are the different ranks (levels) at which military personnel are classified for purpose of pay, duty, or authority. The separate service ranks (USNavyRankType) are subtypes of this type. NOTE that this applies to the person who holds that rank; the abstract more general notion of 'rank' is represented by ''Standing'' or 'Rank''. Corresponds to part of noun sense 2 of 'rank' in WordNet: 2. (6) rank - (relative status; 'his salary was determined by his rank and seniority')
subclass of: RankType
subclass of: PersonType
subclass of: RoleType
ldoce: rank
wordnet: rank
wnsense: rank2n

USNavyRankType
type: Class
comment: The scale of ranks employed by the United States Navy. This is a collection of attributes that are used with the predicate #$rank-Military.
subclass of: MilitaryRankType
ldoce: rank
wordnet: rank
wnsense: rank2n

USMarinesRankType
type: Class
comment: The scale of ranks employed by the United States Marine Corps. This is a collection of attributes that are used with the predicate #$rank-Military.
subclass of: MilitaryRankType
ldoce: rank
wordnet: rank
wnsense: rank2n

Longman vocabulary word
type: AnnotationProperty
comment: A pointer to the word in the LDOCE (Longman Dictionary of Contemporary English) defining vocabulary which the given element represents. Since the LDOCE words can be polysemous, and the nominalized forms of verbs in the COSMO will not be identical to verb meanings, this is not intended as a one-to one mapping, but in many cases the occurrence of a word in a text will be related to the COSMO concept representation by a more or less complex transformation.
range: string

Wordnet vocabulary word
type: AnnotationProperty
comment: A pointer to the synset in WordNet 2.1 which the given element represents. The pointer will in fact be to one of the words in the synset, and the sense number of that word in that synset will be found with the 'wnsense' relation. This pointer does not include the offset number. This can be used with a SPARQL query to find all of the ontology elements that correspond to senses for a given word.
range: string

WordNet sense.
type: AnnotationProperty
comment: A pointer to the sense number (and POS, if needed) in WordNet 2.1 which the given element represents. This is only needed if there is more than one WordNet sense for the word labeled by the 'wordnet' relation. The sense number should include the word whose sense number is referenced, since more than one Wordnet word may be used to label a particular concept. The usage is exemplified by these relations on 'Ordering': wordnet - order - /wordnet wordnet - command - /wordnet wnsense - order1v /wnsense wnsense - command2v - /wnsense
range: string

Globally Unique ID
type: AnnotationProperty
comment: Globally unique identifier, from OpenCyc 0.78. NOTE that this is a formatted string having 32 alphanumeric characters with embedded hyphens, 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'
range: string

en
type: AnnotationProperty
comment: Points to an English language word that is used to refer to the ontology element. This is used when the proper sense of the word does not appear in WordNet.
range: string

enn
type: AnnotationProperty
comment: Points to an English language *noun* that is used to refer to the ontology element. This is used when the proper sense of the word does not appear in WordNet.
range: string

env
type: AnnotationProperty
comment: Points to an English language *verb* that is used to refer to the ontology element. This is used when the proper sense of the word does not appear in WordNet.
range: string

NSM word
type: AnnotationProperty
comment: A pointer to the word in Anna Wierzbicka's 'natural semantic metalanguage' of 60 conceptual primitives that corresponds to the ontology element.
range: string

Object
type: Class
comment: Objects can be Physical or Abstract or Mental only PhysicalObjects have mass, and that is the defining characteristic of a PhysicalObject in COSMO. All Objects have at least one relation other than the type (isa) relation to some other entity that is not an Object. Almost all objects have an Attribute or AttributeValue. But the relation may be some other relation (e.g. to have a location, a composition, or to have proper parts). Thus a point can have Dimensionality (zero-dimensional), and will have a location, though the location may be in a poorly defined abstract space. For example, a character in an alphabet is an abstract object, which has at least one representation as a shaped physical object, and is an element of an Alphabet. This requirement for an Object to have some relation is not presently (v0.48) formalized in COSMO, as it is not needed for performance, only to clarify the meaning for the human users. '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 various purposes,including relations on Events. NOTE that in COSMO an 'Object' is not necessarily 3D (as in an endurantist perspective) nor 4D (as in a perdurantist perspective. It can be use in syntactic constructions that appear to be 3D (such as when they are explicitly time-indexed), but when an object is also an instance of TimeSlice,it can be used in syntactic constructions that are typical of the 4D perspective, in which the time of a relation is not explicitly indexed.

AbstractEntity
type: Class
comment: 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.

hasAttributeType
type: ObjectProperty
comment: hasAttributeType relates an Attribute to the Type of the attribute.
domain: Attribute
range: AttributeTypeType

Group
type: Class
type: GroupType
subclass of: Context
subclass of: Thing
comment: Every Group consists of one or more entities considered as one unit, and is related to the component entities by the relation 'hasComponentElement'. The type ''Group'' is not disjoint with anything, and almost any Object can be viewed as a ''Group'' of other Objects (if one is willing to ignore the relations of the parts). 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. Every 'Group' has some number of elements, specified by the 'hasCardinality' relationship, but it is not necessary to specify the number of elements when instantiating a 'Group'. NOTE that ''Group''is very broad and is placed as a direct subtype of ''Thing'' so as to make the hierarchy easier to navigate,but it is also a subtype of ''Context'' so that assertions about members of a Group that have some distinctive attribute(s) can refer to the Group as the ''Context'' of that distinction when the relation ''existsInContext'' is used on some instance of ''UniqueThingInaContext''. A Group may have component elements of very diverse kinds - there is no restriction on the membership of a Group, though each individual element counts only once in the cardinality of the group, regardless of whether it is of the same type as some other individual elements. 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. For the more specific Group composed only of PhysicalObjects, use 'ObjectGroup'. **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', and emphasizes the point that each 'Group' has no…
ldoce: group
wordnet: group
wnsense: group1n
wordnet: grouping
wnsense: grouping1n
wordnet: collection
wnsense: collection1n
wordnet: aggregation
wnsense: aggregation1n
wordnet: accumulation
wnsense: accumulation2n
wordnet: assemblage
wnsense: assemblage4n

CompositeConcept
type: Class
comment: A CompositeConcept is a Group that consists of component elements of different basic types, such as a System (which see). The notion of a CompositeConcept provides a way to represent things like situations that have essential elements of different type (such as States and FunctionalProcesses).
subclass of: Group

Attribute
type: Class
subclass of: Restriction
  on property: hasAttributeType
  some values from: AttributeTypeType
disjoint with: Role
disjoint with: Object
disjoint with: GenericAgent
disjoint with: GenericLocation
disjoint with: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
disjoint with: SituationProcessEventOrState
comment: Each Attribute is an entity that has an AttributeType and some form of AttributeValue; it can serve as the value of a 'hasAttribute' relation. There are three subtypes of Attribute: QuantitativeAttribute, QualitativeAttribute, and IntensiveAttribute. In COSMO, the representation of 'attributes' (properties in informal terms) includes two or three aspects, depending on whether the Attribute is qualitative or quantitative, respectiely: (1) the AttributeType (Color, Length, Flexibility). The AttributeType specifies the kind of attribute that is being represented. Every instance of Attribute must specify the AttributeType (2) the AttributeValue (Color -Red; Length - 10 feet; Flexibility - high) for quantitative attributes (10 feet, 30 pounds) the AttributeValue is composed of both a number and a UnitOfMeasure. The UnitOfMeasure values include 'Dimensionless', a pure number (e.g. as an attribute of 'Cardinality' for a Group) In the case of quantitative attributes, rather than pointing from an instance of Attribute to a QuantitativeAttributeValue, the relations 'hasUnit' and 'hasQuantifier'can point directly to the UnitOfMeasure and the Quantifier. An instance of QuantitativeAttributeValue can be represented as the UnitOfMeasure and the quantifier, separately, specified by relations 'hasUnit' and 'hasQuantifier'. If the implementation allows use of functions, a QuantitativeAttributeValue can be represented as a function term such as {25.6 feet}. For QualitativeAttributes the AttributeValue may be directly represented. For IntensiveAttributes, the AttributeValue can have interal-type intensity values such as 'Low', 'Medium', 'High'. The type of an Attribute is specified as the value of the 'hasType' relation.

hasEndingTimePoint
type: ObjectProperty
comment: A specialization of the 'finishes' relation which points from a TemporalThing (TimeInterval or Event) to the TimePoint at which that TemporalThing ended.
domain: TemporalThing
range: TimePoint

hasStartingTimePoint
type: ObjectProperty
comment: A specialization of the 'starts' relation which points from a TemporalThing (TimeInterval or Event) to the TimePoint at which that TemporalThing started..
domain: TemporalThing
range: TimePoint

TemporalThing
type: Class
comment: An Entity that has a beginning point in time and an ending point in time. The usage of this term in COSMO differs from the usage in OpenCyc, in that it does **not** include PhysicalObject as a subtype, though the two categories are not disjoint. The purpose of the cyc concept appears to be to permit relating both PhysicalObjects and Events to their time location. In COSMO, that purpose is served by the relation 'hasTemporalLocation' (which see) which has as its domain the union of Events and PhysicalObjects.and 'wasCreatedDuring' and 'wasDestroyedDuring', There is, however, a subtle issue in that the beginning and ending time of a 'TemporalThing' may be the same time, i.e. the instance may be an instantaneous time slice of a time-extended entity. Since in COSMO zero-interval extended entities are indistinguishable from point entities, this means that a '3-D' endurantist object can be an instance of 'TemporalThing' just as a HumanRole, a '4-D' perdurantist object can be an instance of the typically '3-D' Person. In Opencyc a 'TemporalThing' is very generic, it is anything that has a beginning point in time (and presumably an ending point, though it may not be known for existing things). Thus physical objects, which must come into existence at some time (perhaps the beginning of time), as well as events, are 'TemporalThings'. In COSMO, TemporalThing is reserved for TimeIntervals and Events, and PhysicalObjects are not classified as subtypes of TemporalThing. The creation and destruction time of PhysicalObjects will use different relations. OPENCYC 1: MAY 23, 2002 The collection of all things that have temporal extent or location, i.e. things about which one might sensibly ask When? . #$TemporalThing thus contains many kinds of things, including events, physical objects, agreements, and abstract pieces of time. Note that #$TimePoint is a specialization of #$TemporalThing, since time points have temporal location, although they arguably lack temporal extent. Abstract th…
subclass of: Individual
subclass of: Restriction
  on property: hasStartingTimePoint
  all values from: TimePoint
subclass of: Restriction
  on property: hasEndingTimePoint
  all values from: TimePoint

Individual
type: Class
comment: '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.…

Scope
type: Class
subclass of: Individual
type: AttributeValueType
type: ScopeType
comment: A 'Scope' is a very vague concept, without any necessary conditions as of rev 987; it can be a physical area within which something operates or is effective, or a more abstract thing, such as a Context, as in the scope of some law. This is a broad and heterogeneous category use to represent the notions of 'range; or 'scope' or 'compass'. When possible, more specific types should be used. A 'scope' behaves in some ways like a ''QualitativeAttributeValue'' when it specifies an area (of applicability of a law. for example) but making that a formal type would create a contradiction. NOTE: Includes but is broader than noun sense 1 of 'range' and sense 1 of 'scope' in WordNet; note that this includes as a subtype 'Context' which is essentially semantically vacuous; therefore there are no necessary conditions attached to membership in this type - this may change in future versions (after rev987) if a more restricted meaning to 'scope' is adopted: In WordNet: 1. (47) scope, range, reach, orbit, compass, ambit - (an area in which something acts or operates or has power or control: 'the range of a supersonic jet'; 'the ambit of municipal legislation'; 'within the compass of this article'; 'within the scope of an investigation'; 'outside the reach of the law'; 'in the political orbit of a world power')
ldoce: range
wordnet: range
wnsense: range1n
wordnet: scope
wnsense: scope1n
wordnet: compass
wnsense: compass2n
wordnet: ambit
wnsense: ambit1n
wordnet: orbit
wnsense: orbit3n
wordnet: reach
wnsense: reach2n

SituationProcessEventOrState
type: Class
subclass of: CompositeConcept
subclass of: TemporalThing
subclass of: Thing
disjoint with: Object
disjoint with: TimeInterval
disjoint with: spatiotemporal_region
comment: COSMO: SituationProcessEventOrState is a broad category that includes Events, FunctionalProcesses, and PersistentStates,all of which are different aspects of the same fundamental conceptual entity, commonly called an 'Event'. Each instance of 'SituationProcessEventOrState' in COSMO is a Group of TimeIndexedAssertion, in aggregate representing the changes (if any) to the properties (attributes and relations) of one or more objects over some interval of time, An InstantaneousState may have only one TimeIndexedAssertion, but Events and FunctionalProcesses will have at least two. Event is a Group of 'TimeIndexedAssertion's containing the component elements: (1) InstantaneousState at the starting time (2) InstantaneousState at the Ending time (3) The FunctionalProcess that describes the intermediate states between the starting and ending times. **Informally**, a state,process, or event is interpreted as the set of *values* of some 'fluents' (attributes or relations that may change over time), but the actual *formal* representation is a Group in which the group elements are the *LinguisticAssertions* specifying the values of the fluents pertaining to some Group of Objects. Each LinguisticAssertion specifies the value at some time point (or time interval). The differences in State, Process,and Event are: State: The Group of Assertions that hold at one time point (InstantaneousState), or persist without change of value over some contiguous interval of time (PersistentState). No value can chage within a State. FunctionalProcess: The full set of LinguisticAssertions specifying the values of fluents at each time point or smaller TimeInterval within a TimeInterval in which the Process is defined. The set of LinguisticAssertions relate times to values,and in that respect is analogous to a mathematical function. In analogy to a mathematical function, one can derive a 'rate' for a Process (in cases where the values are quantified) by taking the ratio of (difference in value) to (d…

connected_spatiotemporal_region
type: Class
comment: BFO Definition: A space time region that has temporal and spatial dimensions such that all points within the spatiotemporal region are mediately or immediately connected to all other points within the same space time region. Examples: the spatial and temporal location of an individual organism's life, the spatial and temporal location of the development of a fetus. @ToDo: COSMO note: in COSMO, the type TimePoint (instant) is a subtype of TimeInterval, whereas in BFO interval and instant are disjoint. The BFO interval, therefore must be a non-zero length. For simplicity, COSMO does not yet have a non-zero-length instant (no need yet), and when that is added the BFO 'SpatiotemporalInterval' neeeds to be equated with the non-zero-length interval, and the subtype relation of 'SpatiotemporalInstant' and 'SpatiotemporalInterval' must be removed..
equivalent class: Class
  union of: spatiotemporal_instant
  union of: spatiotemporal_interval
disjoint with: scattered_spatiotemporal_region
subclass of: spatiotemporal_region

spatiotemporal_instant
type: Class
subclass of: spatiotemporal_interval
comment: Definition: A connected space time region at a specific moment. Examples: the space time region occupied by a single instantaneous temporal slice (part) of a process. COSMO note: It is unclear why this is not identical to a region of space at some particular moment.

spatiotemporal_interval
type: Class
subclass of: connected_spatiotemporal_region
comment: COSMO note: in COSMO instants are not disjoint from intervals, they are merely the limiting case of intervals of zero lenght. A 'proper interval' is a legitimate concept, but would just be superfluos in COSMO, so this Type will include proper intervals and instants. BFO Definition: A connected space time region that endures for more than a single moment of time. BFO Examples: the space time region occupied by a process or by a fiat processual part

scattered_spatiotemporal_region
type: Class
comment: BFO Definition: A space time region that has spatial and temporal dimensions and every spatial and temporal point of which is not connected with every other spatial and temporal point of which. Examples: the space and time occupied by the individual games of the World Cup, the space and time occupied by the individual liaisons in a romantic affair.
disjoint with: connected_spatiotemporal_region
subclass of: spatiotemporal_region

spatiotemporal_region
type: Class
subclass of: Region
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
equivalent class: Class
  union of: connected_spatiotemporal_region
  union of: scattered_spatiotemporal_region
disjoint with: TemporalLocation
disjoint with: SituationProcessEventOrState

TemporalLocation
type: Class
subclass of: TemporalThing
subclass of: SituationalContextComponent
subclass of: Thing
disjoint with: spatiotemporal_region
disjoint with: SituationProcessEventOrState
disjoint with: PhysicalObject
comment: A TemporalLocation is a location for something - usually an Event - in the universal time line of our real world, or some alternative reality. It may be a time interval or a point in time. Instances of TemporalLocation may be represented by a DateTimeString , without being reified as an actual instance of this Type. This category includes the conceptual 'Datetime' Entity that is pointed to by the common relations like 'CREATION_DATETIME' that occur in databases. This entity is often represented by a built-in dataype of 'DateTime' or something similar. In COSMO, a DateTime is represented by subtpyes of DateTimeString, an AbstractString. A location in time can serve as a Context, which is anything that can affect the truth of a statement. In the real world, virtually every statement about real-world objects is true only in some particular time interval. RELATIVITY: Time is assumed in COSMO to be measured by some clock, which by default is the NIST atomic clock set, but can be specified as some other clock. Thus a time slice of a spatiotemporal region will be unambiguous, and observers moving relative to that clock, or relative to each other, need to adjust their interpretation according to the equations of relativity. In COSMO there is a superfluous subtype link of this entity to the most general 'Thing' so that 'time' will be exposed to viewers of this ontology at the highest level in Protege, for perspicuity. ******** NOTE on BFO 'TemporalRegion' *********************** The BFO 'TemporalRegion' appears to be the closest BFO Type to the COSMO 'TemporalLocation'. BFO Definition ('TemporalRegion'): An occurrent that is part of time. BFO: Examples ('TemporalRegion'): the time it takes to run a marathon, the duration of a surgical procedure, the moment of death COOSMO note: this is not a *quantity* of time, as the BFO example might suggest, but a *location* in time. 'ten minutes' is not an instance of 'TemporalLocation'. ******** NOTE on BFO 'TemporalRegion' ************…

PhysicalObject
type: Class
subclass of: SpatialThing-Localized
subclass of: Object
subclass of: TwoOrHigherDimensionalThing
type: PhysicalObjectType
type: LocationType
comment: A PhysicalObject is an Object that has mass. The mass is relativistic, i..e the Object does not have to have rest mass; so, a photon and other fundamental particles are 'PhysicalObject's, just as are the ordinary objects like rocks, baseballs, and automobiles. In COSMO some quantity of substance (e.g. the water in a glass of water) is also a PhysicalObject (more specifically, an instance of the subtype 'LiquidObject'). Quantities of gas are also PhysicalObjects (more specifically, 'GaseousObject's such as the 'EarthsAtmosphere'). NOTE that a PhysicalSubstance such as Air or Water is not a PhysicalObject, but is the material of which PhysicalObjects consist. See PhysicalSubstance for more detail. Because the determining characteristic of a PhysicalObject is that it has some mass, COSMO has a restirction that all instances of PhysicalObject must specify the mass, using the relation 'hasMassInGrams'. This can be a nuisance when the mass is unknown, and the convention is adopted that a mass of '-1' will be interpreted as an unknown mass. The mass figures can be very approximate - at the OWL phase, the value of the relation 'hasMassInGrams' should be interpreted as only an approximation within an order of magnitude. When more precise mass figures are needed, the relation 'hasMass' can be used (with an instance of MassMeasure as the value), and this relation allows specifying a variance for the mass value. NOTE on '3D' vs '4D' objects: Some ontologists prefer to represent PhysicalObjects as extended in time, thereby forming a '4-dimensional' object ('perdurantism'). Others prefer only 3D objects ('endurantism'), with the time explicitly specified when relations hold on an object. In COSMO this category of 'PhysicalObject' is indeterminate as between a Perdurant and and Endurant - that is, the instances are not necessarily zero-duration time slices, nor are they necessarily time slices of finite duration. An instance of 'PhysicalObject' can be used in relations where the v…
disjoint with: AttributeType
disjoint with: AttributeValue
disjoint with: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]
disjoint with: SituationProcessEventOrState
disjoint with: MentalObject
disjoint with: MathematicalObject
disjoint with: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
disjoint with: Region
disjoint with: GeopoliticalEntity
disjoint with: Organization
subclass of: Restriction
  on property: hasMassInGrams
  some values from: float

GeopoliticalEntity
type: Class
subclass of: GeographicalAgent
subclass of: SocialBeing
subclass of: MentalObject
subclass of: Authority
subclass of: GenericLocation
subclass of: Place
type: RoleType
type: AgentType
type: LocationType
comment: COSMO: A GeopoliticalEntity in COSMO differs from its representation in other ontologies, to stay closer to the linguistic intuitions. Specifically, we say 'government of France', implying that the entity 'France' is not identical to its government. To conform to those intuitions, 'France' and other countries will be GeopoliticalEntities. Therefore a GeopoliticalEntity is something distinct from the organization which forms the government. In COSMO, it is an unusual hybrid, being both a MentalObject and a GenericLocation. Itis neither a PhysicalObject nor an Organization. The Governmen of a GeopoliticalEntity is an Organization. A GeopoliticalEntity in COSMO is a composite Entity which (1) is an agent (2) claims control over some land area of the earth (3) has a government or other ruling organization, which is also an agent (4) is a MentalObject, meaning that it does not have mass and was created by an IntelligentAgent NOTE1: As a GenericLocation, one can say that something isLocatedAt a GeopoliticalEntity even though one means that an object isLocatedAt the region controlled by the GeopoliticalEntity. When an instance of a GeopoliticalEntity is used as an argument that should logically take a region, the implementation should, for consistency, coerce the argument into the corresponding GeopoliticalArea. At present (v0.48) there is no 'disjoint' relation that will cause a logical contradiction, but elaboration of the ontology might cause problems at some point for the use of an Agent as a Location. Alternatives may be worth exploring. NOTE2: if the government performs an action, it is unclear whether it is alway proper to say that a country (or city) performed that action. Therefore the GeopoliticalEntity and its government are treated as distinct agents, though it will probably be true in almost all cases that when one acts, the other can be said to act. NOTE3 that countries have four aspects: (1) the country itself, the GeopoliticalEntity (2) the government of th…

TimeInterval
type: Class
subclass of: TemporalLocation
comment: TimeInterval is not a quantity of time (what is measured by a stopwatch), but a it is a specific region of the time line, what is measured by a calendar (in our real world or in some hypothetical world). Called: TimeInterval(Cyc); TimeInterval(SUMO - but SUMO requires contiguous intervals); time-interval(DOLCE) or period_in_time(ISO15926); the BFO equivalents of TimeInterval ('TemporalInterval') and TimePoint ('TemporalInstant') are disjoint in BFO, but a TimePoint is a subtype of TimeInterval in COSMO. For a quantity of time, use 'TimeDuration'. COSMO NOTE: as a convenience, a calendar time interval can be given a name that conforms to the conventions of one of the DateTime strings defined in COSMO, such as a 'DateTimeExtendedGroup', providing an opportunity for an interpreter to recognize the referenced time interval solely from the name of the instance. See the example used in defining the TimeAndPlace 'WorldTradeCenter20010911'. In Cyc, TimeInterval is not a measure. SUMO: An interval of time. Note that a TimeInterval has both an extent and a location on the universal timeline. Note too that a TimeInterval has no gaps, i.e. this class contains only convex time intervals. OPENCYC 1: MAY 23, 2002 A specialization of #$TemporalThing. Each instance of #$TimeInterval is a temporal thing characterized fully by its temporal attributes. For example, the year A.D. 1967 is an instance of #$TimeInterval; although many interesting things happened during that year, the year itself is completely defined by its temporal extent. On the other hand, the event of Neil Armstrong's walking on the Moon is an #$Event and not a #$TimeInterval, since it is not fully characterized by its temporal extent or other temporal attributes. Specializations of #$TimeInterval include #$CalendarYear, #$CalendarMonth, and #$FiscalQuarter. DOLCE: a region - (Space and Time are special kinds of regions, i.e. AttributeValues or measures) A temporal region, measured according to a calendar. NOTE that a …

GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
type: Class
comment: List name: GenericSubstance_COSMO-added__not_an_object__includes_chemicals_ COSMO: GenericSubstance is an abstract notion of Substance as the stuff of which objects are composed. It is not an object, even though 'Substance' in OpenCyc and SUMO are actually objects of some particular (homogeneous) composition. In COSMO, we make this provision, among other reasons, to allow abstract 'substances' to compose abstract objects. In COSMO 'Subtance' is a concept that is analogous to the derivative of an object with respect to volume, i.e. it acts like an abstract density (of some substance type). For COSMO version 0.01 (COSMOtopOWL03: 2006-01-01) the required axioms for a proper definition have not been added. For more discussion see: http://colab.cim3.net/file/work/SICoP/ontac/reference/DimensionsOfProcessAndEvent.doc
disjoint with: AttributeType
disjoint with: AttributeValue
disjoint with: Object
disjoint with: SituationProcessEventOrState
disjoint with: PhysicalSpaceRegion

SituationalContextComponent
type: Class
subclass of: Context
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.

GenericLocation
type: Class
subclass of: SituationalContextComponent
subclass of: Thing
type: LocationType
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').

GenericAgent
type: Class
type: AgentType
comment: A GenericAgent is an aggregate concept representing things that can be linguistically categorized as agents, that is they are the causative subject of an action. One difficulty comes when including Organizations as Agents; Organizations are not actual physical Objects, therefore cannot literally do things to change the physical world. Rather, people who belong to Organizations, or their 'agents' do the actual moving and lifting that are the causes of actions in the real world. Nevertheless we talk of organizations as though they were somehow objects that did the actions themselves. A second problem arises when inanimate objects take the linguistic form of agents: 'The rock broke the window' or 'The knife cut a deep gash in his arm'. By themseles, those sentences would have the rock or the knife as agents, and the window or arm as patients. If more detail were given: "Tom broke the window with a rock'; 'Tom cut a deep gash in Mike's arm with a knife', the agent now shows up as Tom, and the rock and knife are instruments. For that reason, an instrument (a Role) is categorized in COSMO as a subtype of GenericAgent, to accommodate the linguistic structures where instruments take on the synactic/semantic role of an agent. This category is here to provide a place for the linguistic notion of 'Agent' that can include 'social agents' such as organizations. In this classification we adopt a broad view of agents, allowing inanimate things like hurricanes and tornadoes to be classified as AgentiveObjects.
disjoint with: AttributeValue
disjoint with: SituationProcessEventOrState
disjoint with: PhysicalSpaceRegion

Role
type: Class
subclass of: Thing
subclass of: TemporalThing
comment: Role is a high-level concept that aggregates several primitive notions, and is difficult to describe analytically, but has a necessary property that, as a subtype of TemporalThing, every instance has a beginning time and an ending time. For Roles that are created by an Event and last forever, (The Father of PrinceWilliam), the ending time can be TheEndOfTime. @ToDo: Certain type of Roles (such as Part) may relate abstract entities that are not located in time, and should not be subtypes of TemporalThing. A differentiation of time-dependent and time-independent Roles should be added. The notion of Role is related to the more general notion of a semantic relation, and in some knowledge representations the relations are called 'roles'. In COSMO there is s difference, as a Role is a type, though every Role may in fact imply the existence of some semantic relation that relates the role to another entity with respect to which it plays a role. The details of how to relate these notions is left to a later stage of development of the ontology. For case roles in a specific Event, the Role lasts no longer than the duration of the Event (but may last for less than that time, for participants who participate only for part of an Event). The most common use of 'Role' is for concepts that exist in dependence on other concepts, such as 'Mother', which implies a child, or 'President' which implies some organization. But grammatical roles such as the cases of verb case frames will also fit under this broad category. When a phrase such as 'The ?X of ?Y' is encountered, almost invariably the ?X is a Role of some kind, which also includes parts. In COSMO 'Role' is broad enough to include Events; for example, 'Choice' is a Role, and some Events may fill the Role of 'Choice' - those thing a Person chooses to do. NOTE importantly: that HumanRole is a subtype of this category, and also a subtype of Person, so Person and Role are not disjoint. This allows HumanRoles (janitor, President) to se…

AttributeValue
type: Class
disjoint with: Object
disjoint with: SituationProcessEventOrState
comment: 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. NOTE: under consideration - the possibility of expressing the possession of an attribute for some interval of time by creating instances of AttributeValue or of Attribute that are also TimeSlices, with the time interval of the TimeSlice representing the time interval during which the Attribute was had. This has an advantage over using TimeSlice to create 4D TimeSlices of an object, and then attributing an Attribute to it - in that one need not create new instances of an Object, which may not be easily associated with the 3D object.

VolumeOfSpace
type: Class
comment: COSMO: a three-dimensional region of some space (not necessarily our real world space). This is the space itself, and does not include or immply that ther are any objects in it. However, each instance of this kind fo space will usually be interpreted relative to some defined cooridinate system, which, in the ral world, usually means that it is relative to some physical object (which could be the collecion of all object in the universe as a whole, to provide a universal frame of revernce). In Cyc called 'ChunkOfSpace'. Cyc: A specialization of both #$ExtendedSpaceRegion and #$TwoOrHigherDimensionalThing (qq.v.). Instances of #$ChunkOfSpace are three-dimensional portions of a three-dimensional space. This is the kind of place that solid (i.e. three-dimensional) objects occupy. It makes sense to speak of, or compute, the volume of such objects. An important specialization of this collection is #$ChunkOfSpace-Empirical, whose instances are pieces of space in the empirical universe - the kind of space that physical objects occupy.
subclass of: TwoOrHigherDimensionalThing

Region
type: Class
subclass of: GenericLocation
type: LocationType
comment: A connected part of any space, physical or abstract. A Region does not have to be empty, but can be occupied by solid objects. For an empty region of space see 'FreeSpaceRegion'. NOTE that Region is disjoint with PhysicalObject, but not disjoint with Object (which can be abstract). A Feature is classified as an Object though it may also be a Region. BFO (SpatialRegion): Definition: A continuant at or in which other continuants can be located. COSMO note: in BFO, a SpatialRegion is the union of: Line, Point, Surface, and Volume. This is close to the present concept of 'Region', but those terms in COSMO are more abstract.
disjoint with: AttributeValue
disjoint with: PhysicalObject
disjoint with: SituationProcessEventOrState

SpatialThing-Localized
type: Class
subclass of: spatio-temporal-particular[DOLCE]%SpatialThing
comment: 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.

SpatialRegion
type: Class
subclass of: Region
comment: A SpatialRegion can be of any dimension, though the ones of most interest are three-dimensional in our real world. All Regions must have their location referenced to some definable object, whether abstract or physical. In theory, it may be possible to consider the whole universe as an Object and define 'absolute' regions based on locations in the whole universe, but that may not be useful for any practical purpose. The regions of greatest interest to people are regions defined relative to the Earth's surface, which forms a moving rotating frame of reference, which we treat as stationary for most purposes. NOTE: The BFO 'SpatialRegion' is closest to the COSMO 'PhysicalSpaceRegion' which is a subtype of this Type.

PhysicalSpaceRegion
type: Class
subclass of: Place
subclass of: SpatialRegion
subclass of: VolumeOfSpace
subclass of: SpatialThing-Localized
comment: PhysicalSPaceRegion is a portion of the there-dimensional space of our real world space-time universe. This is considered equialent to\the BFO 'Volume' COSMO Note: SpaceRegion in OpenCyc is not an Object, but pure space. Objects may be located in space. This region is part our our Space-Time This concepts is roughly equivalent to the OpenCyc 'ChunkOfSpace-Empirical', but we allow space regions to be defined by their relation to physical objects - therefore they may not be 'immobile' as the Cyc documentation suggests for 'ChunkOfSpace-Empirical'. For simplicity, the Cyc concept 'SpaceRegion-Empirical' has been merged with this concept, as the distinctions did not seem to have sufficient importance to justify the complexity. BFO: the BFO Type 'SpatialRegion' appears to have the same intent as this Type. The BFo subtypes of Line and Surface appear to be isentical to the subtypes of this Type: SpaceLine-Empirical, SpaceSurface-Empirical, BFO Definition ('SpatialRegion'): A continuant at or in which other continuants can be located. BFO Examples ('SpatialRegion'): the space occupied by an appendix, the space that was occupied by an appendix prior to its removal Cyc comment for 'ChunkOfSpace-Empirical': A specialization of #$SpaceRegion-Empirical, #$ChunkOfSpace, and #$SpatialThing-Localized (qq.v.). Instances of #$ChunkOfSpace-Empirical are three-dimensional portions of the intangible space of the empirically-observable universe. This is the kind of space that physical objects occupy. Cyc comment for 'SpaceRegion-Empirical': A specialization of #$SpaceRegion, #$SpatialThing-Localized, and #$IntangibleExistingThing (qq.v.). Instances of #$SpaceRegion-Empirical are intangible regions of space located in the empirically observable universe. A space region might or might not be connected (see #$SpatiallyContinuousThing). It might be partially or completely filled with (occupied by) #$PartiallyTangibles, or it might be completely empty (but cf. #$EmptySpaceRegion). In any cas…

takesValue
type: ObjectProperty
comment: takesValue relates an AttributeType to the AttributeValues that instantiate the AttributeType. For example, the AttributeType Length will be instantiated by an instance of the type 'LengthMeasure'; thus {Length takesValue LengthMeasure} But because QualitativeAttributeValues are types in COSMO, instances of AttributeValueType may also instantiate an AttributeType. This relation is in some respects reminiscent of the 'instance' relation, but is specific to the relationship between AttributeTypes and AttributeValues (qualitative and quantitative), used to implement the specific method of representing attributes that is adopted for COSMO..
domain: AttributeTypeType
range: AttributeValueType
inverse of: isaValueOf

isaValueOf
type: ObjectProperty
comment: The inverse of 'takesValue'.
range: AttributeTypeType
domain: AttributeValueType
inverse of: takesValue

AttributeType
type: Class
type: AttributeTypeType
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).
subclass of: Restriction
  on property: takesValue
  some values from: AttributeValueType

TimePoint
type: Class
subclass of: TimeInterval
comment: A TimePoint is a closed interval of time having zero length. The beginning TimePoint and Ending TimePoint are identical for any given TimePoint. The representation of a TimePoint as a zero-length time interval is only an alternate view of a TimePoint. (=> (isanInstanceOf ?TP TimePoint) (and (hasStartingTimePoint ?TP ?TP) (hasEndingTimePoint ?TP ?TP))) A TimePoint is classified here as a subclass of TimeInterval because we adopt the interpretation that a time interval of zero length duration is indistinguishable from a time point. We know from special relativity that time may proceed at different rates in objects that are moving relative to each other, so all time values must be relative to some clock. In the absence of any explicit clock designation, the NIST atomic clock signals transmitted from Boulder Colorado are considered as the clock of reference. A TimePoint may be represented by a limit expression, e.g. 'before Jan 1 2008', or by a range ('some time point between Jan 1 200 and Jan 1 2008'). This allows incomplete time information to be entered when not known exactly. This may be implemented by a functional expression, but is not yet formalized in COSMO version 0.44. ******* COSMO NOTE on BFO 'TimeInstant' ************ COSMO note: in COSMO, time points are subtypes of TimeInterval, so the 'disjoint' relation in BFO between TimePoint and TimeInterval was removed. BFO: owl:disjointWith rdf:resource='#TemporalInterval' BFO rdfs:subClassOf rdf:resource="#ConnectedTemporalRegion" BFO Definition: A connected temporal region comprising a single moment of time. BFO Examples: right now, the moment at which a finger is detached in an industrial accident, the moment at which a child is born, the moment of death ******* COSMO NOTE on BFO 'TimeInstant' ************

Place
type: Class
comment: COSMO note: Place can be a PhysicalObject or a Region. This category is very generic. Cyc: A specialization of #$EnduringThing-Localized. Each instance of #$Place is a spatial thing which has a relatively permanent location. Thus, in a given microtheory, each #$Place is stationary with respect to the frame of reference of that microtheory.
subclass of: GenericLocation
type: LocationType

Context
type: Class
subclass of: Scope
type: ScopeType
type: ContextType
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 consis…

OneOrHigherDimensionalThing
type: Class
comment: A #$SpatialThingTypeByDimensionality and a specialization of #$SpatialThing, each instance of which is either a one- or two- or three- (or higher-) dimensional spatial object. Examples include tangible or intangible spatially-localized dimensional objects, such as the edge of a tabletop, the surface of the tabletop, and the table itself, as well as abstract geometrical objects that are at least one-dimensional, such as a Platonic circle or cube. Specializations of this collection include #$ExtendedSpaceRegion, #$ShapedThing, and #$TwoOrHigherDimensionalThing.
subclass of: SpatialThing

TwoOrHigherDimensionalThing
type: Class
comment: A #$SpatialThingTypeByDimensionality and a specialization of #$SpatialThing, each instance of which is either a two- or three- (or higher-) dimensional spatial object. Examples include tangible or intangible spatially-localized polydimensional objects, such as the flat surface of a tabletop and the table itself, as well as abstract geometrical objects that are at least two-dimensional, such as a Platonic cube. Specializations of this collection include #$PartiallyTangible, #$BilateralObject, and #$TwoDimensionalGeometricThing.
subclass of: OneOrHigherDimensionalThing

MentalObject
type: Class
subclass of: Object
subclass of: Artifact-Generic
subclass of: IntangibleIndividual*
comment: A MentalObject is an Object that does not have mass and was created by an IntelligentAgent (usually a Person.or Organization). This is a very broad and primitive category comprehensible mostly by inspection of a list of subtypes. Since this is not physical, instances of this Type are not observable, but physical representations of instances of this Type (such as a specific copy of 'Gone With the Wind') can be weighed and felt. Abstract texts, musical compositions, propositions, theories, plays, poems, speeches, rights - all are MentalObjects. They will invariably have a physical representation in some PhysicalObject (including brains, light waves and sound waves). But the MentalObject itself has no physical (material) component. This corresponds closely to what in some systems (e.g. the Ontology Works top ontology) is called an 'AbstractArtifact' - something created by a Person that is not a PhysicalObject. We adopt the convention that an individual MentalObject exists only so long as there is some PhysicalObject that represents it. That PhysicalObject could be the brain of a Person, some sound or electromagnetic waves encoding that MentalObject, or some piece of paper with markings on it. When the last physical object representing that MentalObject ceases to exist, that MentalObject also ceases to exist. A new MentalObject indistinguishable from a previously existing one can always be created (even by the original creator), but it would be a different individual with a different identity. NOTE that a MentalObject is a subtype of 'AbstractEntity', but we adopt the convention that it can hava a location in space-time, being the collection of locations where its physical representations are located. Thus a Belief or a Proposition may be located in the brain of one or more IntelligentAgents, or in physical documents describing the belief symbolically. This 'location' differs from the location of any individual physical object, because the location is the collection of …
disjoint with: PhysicalObject

Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]
type: Class
subclass of: Object
subclass of: AbstractEntity
disjoint with: PhysicalObject
type: ObjectType
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 A…

spatio-temporal-particular[DOLCE]%SpatialThing
type: Class
subclass of: SpatialThing
comment: 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.

hasMassInGrams
type: DatatypeProperty
comment: hasMassInGrams relates an Object to its mass measured in grams. This is a shortcut to using more general functional mass measures, and is used here only for illustration, to permit some specifics in instances. The values given should be taken as crude estimates (order of magnitude estimates, possible error over 100%), particularly since no time interval is given by this relation. Relations expressing more exact values of mass have not yet (v0.45) been written in COSMO. This is mostly a placeholder for more meaningful relations. NOTE: for objects whose mass is unknown, a value of '-1' will serve as the code for 'unknown mass'. Since, as of v0.49, a mass value is required in COSMO for PhysicalObjects (mass is the characteristic property of PhysicalObjects), an explicit value must be provided even if it is unknown. If an approximate value can be guessed within +- 100% (as with human weights),a value should be entered so that the reasoner will have some information with which to make inferences. For example, a car mass of 1,000,000 grams (one ton) will allow the reasoner to infer 'too heavy for a person to lift'.
domain: PhysicalObject
range: float

GeographicalThing
type: Class
subclass of: SpatialThing-Localized
comment: OPENCYC 1: MAY 23, 2002 This collection may be thought of as consisting of all the entities which are localizable within the context of a geography, in the sense that they might plausibly be represented on a map. This includes both #$PartiallyTangible entities like #$GeographicalRegions, and also entities that may be wholly #$Intangible, like territorial borders and boundaries, #$LatitudeLines and #$LongitudeLines, trajectories of missiles and courses of ships, and the #$Equator.

GeographicalAgent
type: Class
comment: A specialization of both #$MultiIndividualAgent and #$GeographicalThing. Each instance of #$GeographicalAgent is a group of people and/or organizations cohesive enough to be treated as an agent (see the collection #$Agent, of which #$GeographicalAgent is a specialization), and which occupies a particular instance of #$GeographicalRegion. Important specializations of #$GeographicalAgent include #$GeopoliticalEntity, #$University, and #$Neighborhood. Note that instances of #$GeographicalAgent are viewed in two significantly different ways with respect to two different types of geography-related microtheories. In a 'physical' geography microtheory (i.e. #$PhysicalGeographyMt and its submicrotheories), geographical agents are clearly distinguished from the regions they occupy. (#$TerritoryFn GEO-AGENT) is used in these contexts to denote the land mass (an instance of #$GeographicalRegion) occupied by a given geographical agent GEO-AGENT. In a 'dualist' geography microtheory (i.e. #$DualistGeopoliticalMt and its submicrotheories), on the other hand, geographical agents are viewed as being _both_ agents _and_ land masses (instances of #$GeographicalRegion). Thus, there is little need for #$TerritoryFn in the latter sort of context. (Despite their somewhat paradoxical flavor, dualist microtheories arguably allow Cyc to mimic commonsense reasoning about geographical agents and regions more closely than do the stricter physical microtheories.) There are also some 'generic' geography microtheories (e.g. #$WorldGeographyMt and #$UnitedStatesGeographyMt) which are neutral with respect to the physical and dualist views. Also see the shared-note for this constant.
subclass of: CollectiveAgent
subclass of: GeographicalThing

SocialBeing
type: Class
comment: A specialization of #$IntelligentAgent. Each instance of #$SocialBeing is an intelligent agent whose status as an agent is acknowledged within some social system, and who is capable of playing certain social roles within that system. Note that in many (but not all) cases, a #$SocialBeing will have certain rights and responsibilities associated with his/her/its status within the relevant social system. For agents who are granted rights and responsibilities under some legal system, see the specialization #$LegalAgent. Other notable specializations of #$SocialBeing are #$Person and #$Organization.
subclass of: IntelligentAgent
type: AgentType

Authority
type: Class
subclass of: IntelligentAgent
subclass of: Role
type: AgentType
comment: An Authority is an IntelligentAgent who has created a Rule. Usually, the Rule will be communicated to other Agents to follow (for some purpose), but in a special case an Authority (e.g. an individual person) may create a rule intended only for the Authority itself to follow e.g. a personal code of behavior). The Authority may have authority over a small domain - a parent over his/her children, for example, or the leader of a small group whos emembers consent to follow the rules of the leader. The owner of a property is an Authority for what can be done on that property, and can create a Rule prohibiting actions on that property. 'Authority' is a Role, and an individual Agent does not have to be classified as an Authority, unless the Agent participates in some action or relation that requires an Authority.

Organization
type: Class
subclass of: CollectiveAgent
subclass of: MentalObject
subclass of: Authority
type: AgentType
comment: COSMO note: In COSMO, an Organization differs from its representation in some other ontologies. In COSMO, an Organization is not a group of people, it is a MentalObject, an artifact created by people. the essence of an Organization is that it is organized. It therefore must have an explicit set of organizing principles (a charter or constitution) whether that is written or, as in some small informal organizations, merely retained in the minds of its members. In addition to its charter, an Organization will have one or more lists of associated agents (people or other organizations). There may be more than one list, and the 'members' may not be called members. A complex organization like a corporation may have several lists, e.g. board members, stockholders, corporate officers, employees, even long-term contractors. The relationships of the agents on those lists to the organization and to each other is specified in the charter. Any or all of the lists of associated agents ('members' in simple organizations) may be empty. An Organization can exist without members, and this differs from the specification in SUMO (below). There are some bordeline cases where groups of people have some degree of organizing principle, but no charter (consitution) developed specifically for that group. In those cases, such groups wll be instances of 'GroupOfPeople'. An example is a jury, which is called together by the judicial system, not organized by its members for their own purposes. A pick-up team of basketball or baseball players playing one day and not remaining as a team is also a GroupOfPeople. But stable suborganizations of larger organizations, such as a company or platoon of soldiers, is an Organization and not just a GroupOfPeople. Because an Organization in COSMO is not a physical object, the parts of Cyc or other ontologies that consider Organization as a subtype of group of people (a physical object) will be inconsistent. Some effort will be needed to convert Organizations i…

MathematicalOrComputationalThing
type: Class
comment: The collection of #$Intangible things that are intrinsically mathematical (see #$MathematicalThing) or computational (see #$ComputationalObject). Instances of #$MathematicalOrComputationalThing are abstract in the very strong sense of being nonspatial, atemporal, and massless. Examples include numbers, sets, collections, relations, algorithms, and abstract character strings.
subclass of: AbstractEntity

MathematicalThing
type: Class
comment: A specialization of #$MathematicalOrComputationalThing. Each instance of #$MathematicalThing is an atemporal, nonspatial, purely mathematical thing. #$MathematicalThing is partitioned into two main specializations, #$MathematicalObject and #$SetOrCollection (qq.v).
subclass of: MathematicalOrComputationalThing

MathematicalObject
type: Class
comment: A specialization of both #$MathematicalThing and #$IntangibleIndividual. Each instance of #$MathematicalObject is a purely abstract mathematical thing which is also an individual (see #$Individual). Specializations of #$MathematicalObject include #$Quantifier, #$RealNumber, #$Triangle, and #$TruthValue. Note that instances of #$SetOrCollection are not instances of #$MathematicalObject, since they are not instances of #$Individual.
type: ObjectType
subclass of: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]
subclass of: MathematicalThing

PhysicalSubstance
type: Class
subclass of: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
comment: Each PhysicalSubstance is an abstraction representing the properties of aggregates composed of multiple small objects of a common type; the notion of a PhysicalSubstance includes any of the common 'substances' we encounter every day: water, air, sugar, salt, coffee (ground or as a drink), beer, meat, steel, plastic, etc., as well as less common substanes such as ion plasma and groups of elementary particles. Every PhysicalSubstance has some basic unit which is the smallest object that can be considered as composed of that substance. For chemical elements the basic unit is an atom; for chemical compounds, the molecule; for sand, one grain of sand, etc. For PhysicalSubstances that are composed of mixtures (e.g. concrete), the formal notion of a 'grain' is used, the 'grain' being the size of the smallest object composed of a substance, that can be subdivided so that the pieces are still objects composed of the same substance. The 'grain' will in general be eight times the size of the 'unit' (allowing division in any of three planes) , but for mixtures the 'unit' may be difficult to identify, and the 'grain' will be the only object identifed as characterizing the PhysicalSubstance. For mixtures, the size of the grain will depend on the sizes and proportions of the constituent objects. Thus in concrete, the grain will have to be at least several times as large as the largest pebble of gravel used in the mixture. The commonly understood properties of substances such as water are characteristic only of aggregates of the basic units (atoms, molecules, grains). To approximate the commonly measured properties (boiling point, melting point, density, etc.) the number of basic units may need to be fairly large; this will also vary with the substance. As of v0.52 this issue is not addressed. This concept must not be construed as a physical object made of some substance (which is the way substances are represented in Cyc - see CycNote below).. PhysicalObjects which are relatively …
ldoce: matter
wordnet: substance
wnsense: substance2n
wordnet: stuff
wnsense: stuff1n
wordnet: material
wnsense: material1n
wordnet: matter
wnsense: matter1n

Situation-Localized
type: Class
comment: A specialization of #$Situation. Each instance of #$Situation-Localized is a situation whose temporal extent occurs at a specific location in space. Notable specializations of #$Situation-Localized include #$PhysiologicalCondition and #$Event-Localized.
subclass of: SpatialThing-Localized
subclass of: SituationProcessEventOrState

process_boundary
type: Class
subclass of: SituationProcessEventOrState
comment: BFO Definition: A processual entity that is the fiat or bona fide process boundary. BFO Examples: birth, death, the forming of a synapse, the onset of REM sleep, the detaching of a finger in an industrial accident, the final separation of two cells at the end of cell-division, the incision at the beginning of a surgery
disjoint with: fiat_process_part

fiat_process_part
type: Class
subclass of: SituationProcessEventOrState
comment: COSMO: this BFO Type is interpreted as an Event, but one that is specifically represented as not a complete Event (i.e. not a 'Process' in BFO). It is unclear under what circumstances designating an Event as 'Fiat' will be useful, but this is included for compatibility. BFO Definition: A processual entity that is part of a process but that does not have bona fide beginnings and endings corresponding to real discontinuities. Examples: chewing during a meal, the middle part of a rainstorm, the worst part of a heart-attack, the most interesting part of Van Gogh's life. COSMO note: In real physical Events, the precise boundaries can be fuzzy, but most Events of interest will have conceptually fairly well-defined beginnings and ends (periods duting which the fluents (attributes) of interest are static), even if those beginnings and ends stretch out over some period of time. We anticipate that most Events will be classified under 'Event' as subtypes of the BFO 'Pocess' which is intended to *not* be a Fiat Process (event). Thus this category may rarely if ever be used for classification.
disjoint with: process_boundary

FunctionalProcess
type: Class
subclass of: SituationProcessEventOrState
disjoint with: Event
comment: A FunctionalProcess corresponds to the linguistic intuition of something happening at some point in time, rather than something that has happened in some interval of time, which is an Event. Intuitively, it may be considered as the time derivative of an Event: a Process occurring over some interval of time gives rise to an Event, which is a change (or series of changes) in the properties of some Objects during some interval of Time. Every FunctionalProcess is intimately associated with some Event as one of the components of that Event (see 'Event'). NOTE that this differs from the notion of 'process' used in Cyc, where a Process is a kind of Event that can be subdivided and still result in an Event of the same kind. In COSMO taking some temporal part of a FunctionalProcess does not necessarily result in a FunctionalProcess of the same kind. **NOTE** A FunctionalProcess may also be defined, not by specifying the individual values of the fluents at points in time, but by specifying the manner in which a fluent can change over time. One specific example of this is a **differential equation** which can be used to take the value of a fluent at some starting point in time, and calculate the values at subsequent points in time. Thus a FunctionalProcess can have, as its TimeIndexedAssertion, a differential equation. This is an important difference between Event and FunctionalProcess. @ToDo: the specifics of how a differential equation are to be represented have not been elaborated as of v0.50. Formally, a FunctionalProcess is a Group consisting of one or more TimeIndexedAssertions, where each TimeIndexedAssertion is an InstantaneousState or PersistentState. Each State contains a Group of assertions specifying the values of the fluents that hold at that TimePoint; if only one Object is a participant in the FunctionalProcess, thre may be only one TimeIndexedAssertion in each State. A TimeIndexedAssertion can be a differential equation relating a fluent to time. Thus if, at so…

Event
type: Class
subclass of: Situation-Localized
type: EventType
disjoint with: FunctionalProcess
disjoint with: fiat_process_part
comment: Each Event in COSMO is a Group of 'TimeIndexedAssertion's, in aggregate representing the changes to the properties (attributes and relations) of one or more objects over some interval of time, and containing the component elements: (1) InstantaneousState at the starting time (2) InstantaneousState at the Ending time (3) The FunctionalProcess that describes the intermediate states between the starting and ending times. **Informally**, a state,process, or event in COSMO is interpreted as the set of *values* of some 'fluents' (attributes or relations that may change over time), but the actual *formal* representation is a Group in which the group elements are the *TimeIndexedAssertions* specifying the values of the fluents pertaining to some Group of Objects, at some TimePoint or TimerInterval. he differences between State, Process,and Event are: State: The Group of Assertions that hold at one time point (InstantaneousState), or persist without change of value over some contiguous interval of time (PersistentState). No value can chage within a State. NOTE that one can represent the state of an individual relation or attribute for some Object, without specifying how other attributes may or may not change. Therfore one can, for example, represent a Feeling as a PersistentState that continues without change in value over somme interval of time, while other attributes or relatikons on the same Person change dramatically. Each attribute of each Object represented in a State can be represented as a State separately from the states of other Objects. FunctionalProcess: The full set of LinguisticAssertions specifying the values of fluents at each time point or smaller TimeInterval within a TimeInterval in which the Process is defined. The set of LinguisticAssertions relate times to values,and in that respect is analogous to a mathematical function. In analogy to a mathematical function, one can derive a 'rate' for a Process (in cases where the values are quantified) by taking th…

ConceptualWork[Cyc]
type: Class
comment: In COSMO a 'ConceptualWork' (a MentalObject) is classified as an AbstractSymbolicObject, since such works are always created in symbols, though the symbols may have information content - the 'meaning'. COSMO differs somewhat from the Cyc description in that we consider Codes to be included, but have a different usage of the term 'Code'. Cyc: OPENCYC 1: MAY 23, 2002 The collection of abstract works which are the deliberate creations of one or more individuals working in concert, have instantiations [#$instantiationOfCW] which are #$InformationBearingThings, and associated #$AbstractInformationStructures. This is a specialization of #$DevisedPracticeOrWork [q.v.]. For works with propositional content see the more specific collection, #$PropositionalConceptualWork (PCW). Positive examples include: #$MobyDickNovel (as opposed to any instances of #$BookCopy such that (#$instantiationOfCW #$MobyDickNovel BOOK_COPY)), Beethoven's 9th Symphony (as opposed to any performance of this symphony or any copy of its score). Negative examples include: games (performances are not IBTs), awards (they do not have associated #$AbstractInformationStructures), paintings (not abstract), customs (not deliberate creations), natural languages (not a deliberate creation), and codes (their uses, not instantiations, are IBTs).
subclass of: AbstractSymbolicObject

Description
type: Class
comment: description (from DOLCE-D_S) From DOLCE (Descriptions and Specifications): A description is a social object which represents a conceptualization (e.g. a mental object or state), hence it is generically dependent on some agent and communicable. Descriptions define or use concepts or figures, are expressed by an information object and can be satisfied by situations. The typology of descriptions is still preliminary. In COSMO, a Description is somewhat more specific: it is two or more assertions that all include the same entity as one of the arguments, and it is a MentalObject created to enable an Intelli"gentAgent to understand the nature of that entity.
subclass of: MentalObject
type: ObjectType

Specification[COSMO-suggested]
type: Class
type: SpecificationType
comment: COSMO: A Specification is a broad category of intentionally created abstract informational artifacts whose purpose is to describe the structure of a thing or a series of steps that may be taken to construct a thing or to accomplish a goal. It is a mental object having ordered components,the order of which is designed to accomplish a purpose. The steps may be abstract things like computational events or game rules, or physical things such as in industrial processes. The format of a formatted document is a specification,i.e. it specifies how a document of that type is to be constructed. Likewise a grammar or computer program is a specification. A specification does not necessarily require that the steps be in sequence. If they must be in sequence, it is a procedure. This differs somewhat from the Cyc 'Specification': Cyc comment: A specialization of #$ConceptualWork. Each instance of #$Specification is an abstract work that constitutes a description of the properties of a #$Situation or a #$SomethingExisting, and sometimes even entire collections of such things. Things are made, bought, and searched for according to specifications, which can be instantiated as printed instructions or as diagrams. This collection is modally neutral with regard to the descriptive character of its instances. Thus, it includes descriptions of how things are, were, should be, must be, etc.
subclass of: Description
subclass of: ConceptualWork[Cyc]
subclass of: Restriction
  on property: wasCreatedBy
  some values from: IntelligentAgent

Pattern
type: Class
comment: This is the most general Type in which to collect patterns of different kinds - visual, sound patterns, numerical patterns, behavioral patterns, etc. In COSMO, a Pattern is a Specification, which means that it is a kind of MentalObject. That means that Patterns do not have existence unless created by IntelligentAgents. This will probably seem odd to some people, who would prefer to think that patterns have an independent existence - especially when geometric figures are subtypes of 'Pattern'. At this point, there is no reason to classify Patterns in any way other than as specifications that people create to classify some types of relations that obejcts within groups of things may have to each other. If some reason is presented to consider patterns as independent of the way people use them, that may be a different concept, or may warrant reclassification.
subclass of: Specification[COSMO-suggested]
type: SpecificationType

VisualPattern
type: Class
comment: This is the most general Type in which to collect visual patterns - geometric designs, fingerprint patterns, artifact structural patterns, appearances, shapes, outlines, etc.. NOTE that an abstract image itself (e.g. an image of a fingerprint) can be a pattern.
subclass of: Pattern

GeometricallyDescribableThing
type: Class
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.
subclass of: SpatialThing

GeometricallyDescribableThing-Intangible
type: Class
comment: A specialization of both #$GeometricallyDescribableThing and #$IntangibleIndividual (qq.v.). This is the collection of all intangible, geometrically-describable things, whether spatially localized or not. #$GeometricallyDescribableThing-Intangible is the intersection (see #$collectionIntersection) of #$GeometricallyDescribableThing and #$Intangible. Examples include any spatially-connected, intangible thing that has or approximates (or which consists entirely of parts that all have or approximate) a simple geometric shape, such as the intangible space determined by a particular Egyptian pyramid, an abstract Platonic sphere, or the center of mass of the solar system (a point) at the first instant of the Twentieth Century in Greenwich, England. Important specializations of this collection are #$GeometricThing-Localized (which includes all spatially localized instances) and #$GeometricThing-Abstract (which includes all instances not spatially located in the empirically-observable universe).
subclass of: IntangibleIndividual*
subclass of: GeometricallyDescribableThing
subclass of: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]

GeometricFigure
type: Class
comment: An instance of #$GeometricShapeType and a specialization of #$GeometricallyDescribableThing-Intangible and #$HomogeneousExtendedSpaceRegion (qq.v.). This is the collection of geometrical figures, conceived of as bounded (one- or higher-dimensional) regions of space. Neither a single point (see #$GeometricalPoint), nor a sum of scattered points, is an instance of #$Figure-Geometrical. Note that this collection includes line segments, but not unbounded lines. An important specialization of this collection is #$PlaneFigure-Geometrical. The class of all geometric figures, i.e. the class of all abstract, spatial representations. Instance of GeometricFigure are abstract mathematical objects which can be considered as independent of anything in our material universe. They are therefore not MentalObjects, which must be created by people. The instances of this class are GeometricPoints, TwoDimensionalFigures or ThreeDimensionalFigures or any other Object that can be represented as being a distribution of points, lines, planes, volumes, or hypervolumes in some abstract space.
type: ShapeType
subclass of: GeometricallyDescribableThing-Intangible
subclass of: VisualPattern

hasAttributeValue
type: ObjectProperty
comment: hasAttributeValue relates an Object or Substance or Event to some AttributeValue which the Object may have. Each AttributeValue will be a value for at least one AttributeType, but this relation does not specify the AttributeType. For cases where an AttributeValue may measure more than one AttributeType (such as LengthMeasure, which can specify length, width, height, altitude, distance, etc.), using this relation may leave ambiguity as to its precise meaning. NOTE that the term 'heterogeneity' is included as a synonym. Although the '-ness' forms of attributes can be used to refer to 'states' of things, in the type of usage in COSMO where attributes are asserted with the relation 'hasAttribute' to say that something 'has heterogenity' is indistingishable from saying 'it has the quality heterogeneous'. If the usage were to be to say 'X *is* heterogeneous', then to say 'X *is* heterogeneity' would be an odd usage, So generally the difference between a base QualitativeAttributeValue and the '-ness' form depends on the way it is used, indicating that the '-ness' form can have alternative meanings. Here the '-ness' form is considered a synonym of the base attribute form, unless the '-ness' form designates a range of potential attributes of different intensity. COSMO Note: AttributeValues may be either classes (instances of AttributeValueType), or instances of AttributeValue. This allows one to express an attribute as a region (e.g. colors will bw classes, not instances, to permit subclassing), or for quantitative measures as instances (e.g. '25 feet'). Also, where one has attribute values that are ranges of values and other attribute values as subtype with included ranges, 'MeasureType' will allow one to use classes to represent the ranges so that they can also be subtyped. For quantitative measures, the representation of measurements as classes would be conceptually permissible (the class representing the set of possible values, determined by the measured value and possib…
domain: Class
  union of: GenericAgent
  union of: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
  union of: Object
  union of: GeometricFigure
  union of: Event
  union of: Group
  union of: ObjectType
  union of: EventType
  union of: AgentType
  union of: SubstanceType
  union of: GroupType
  union of: PhysicalObjectType
range: Class
  union of: AttributeValueType
  union of: AttributeTypeType
  union of: AttributeValue
  union of: MeasureType
inverse of: isAnAttributeValueOf
en: is

isAnAttributeValueOf
type: ObjectProperty
comment: isAnAttributeValueOf is the inverse of 'hasAttributeValue'. This relation will be used explicitly only in special cases where particular AttributeValues are appropriately applied only to specific types of things.
range: Class
  union of: GenericAgent
  union of: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
  union of: Object
  union of: GeometricFigure
  union of: Event
  union of: Group
  union of: ObjectType
  union of: EventType
  union of: AgentType
  union of: SubstanceType
  union of: GroupType
  union of: PhysicalObjectType
domain: Class
  union of: AttributeValueType
  union of: AttributeTypeType
  union of: AttributeValue

hasQualitativeAttribute
type: ObjectProperty
range: QualitativeAttributeType
domain: Class
  union of: Event
  union of: Object
  union of: ObjectType
  union of: PhysicalSubstance
  union of: SubstanceType
sub property of: hasAttributeValue
comment: hasQualitativeAttribute relates individual Objects or substances to some qualitative attribute (a subclass of QualitativeAttributeValue) that the object has. The accurate use of this property for substances is difficult to express in OWL. Since Substances are classes, to describe a qualitative attribute of a substance, in OWL one would need a metatype specifically for each substance, which multiplies reified entities unnecessarily. A FOL rule would be easy to construct to correctly relate the substances to their properties, but for COSMO version 0.2 a work-around for such a rule is not yet on hand. The restrictions on substances should be interpreted as meaning necessary conditions on all subclasses of the substances.

QualitativeAttributeValue
type: Class
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. NOTE that adjectives expressing qualities in English often have a nominalized form: 'Red-Redness' or 'Beautiful-Beauty'. When linguistically to 'have @Att-nom' (@Att-nom is the nominalized form of an attribute) is the same as 'to be @Att' where @Att is the adjectival form, the concept will be represented only once, usually in the adjectival form, and nominalized form needs to be referenced to the adjectival by the linguistic processor.
subclass of: AttributeValue
type: AttributeValueType

EvaluativeAttribute
type: Class
comment: An EvaluativeAttribute is a QualitativeAttributeValue for some entity, concrete or abstract, that reflects the judgment of an IntelligentAgent regarding that entity. the judgment may be objective or subjective, but will be relative to some purpose.
subclass of: QualitativeAttributeValue

isTheOppositeOf
type: ObjectProperty
type: SymmetricProperty
domain: QualitativeAttributeType
range: QualitativeAttributeType
comment: isTheOppositeOf relates one attribute to another attribute that would be commonly considered the opposite of the first attribute. There is a hub-and-spoke structure to certain core attributes and related attribute, and the notion of 'opposite' is in many cases more lexical than conceptual. This relation tries to capture the common cases of opposites.

Worthless
type: Class
comment: The property of substances or objects that are considered (by their possesor) to have no positive value.
subclass of: QualitativeAttributeValue
type: QualitativeAttributeType
is the opposite of: Valuable

Valuable
type: Class
comment: The property of substances or objects that are considered (by their possesor or potential possessor) to have some positive value.
subclass of: EvaluativeAttribute
type: QualitativeAttributeType
is the opposite of: Worthless

ValuableThing
type: Class
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.
subclass of: Individual
subclass of: Restriction
  on property: hasQualitativeAttribute
  has value: Valuable

Artifact*
type: Class
subclass of: Artifact-Generic
subclass of: PhysicalObject
subclass of: ValuableThing
comment: COSMO note: this class was merged with the Cyc 'Artifact-HumanCreated' because little difference could be discerned. Most instances of Artifact will be created by humans - people, groups, organizations, or their automaton servants. Artifactual objects created by non-humans (e.g. animals) will also be instances of ArtifactObject (e.g. 'SpiderWeb').. 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 alt…

Artifact-NonAgentive
type: Class
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. COSMO note: Artifacts are not Agentive in the sense that they are not IntentionalAgents (they can't speak or fporm plans). However, in COSMO an Instrument is an instance of GenericAgent, so the name must not be interpreted as meaning that an Artifact-NonAgentive is not a GenericAgent.
subclass of: Artifact*
disjoint with: IntentionalAgent

IntentionalAgent
type: Class
subclass of: GenericAgent
type: AgentType
disjoint with: Artifact-NonAgentive
comment: An IntentionalAgent is an Agent that (typically) has the capacity to form a plan of action. Therefore an IntentionalAgent is an Agent to whom some purpose may be assigned - even if only the purpose of survival. The level of intentionality required to belong to this category is not as high as that required to belong to the more specific category of 'IntelligentAgent'. Therefore computer programs that do not approach human-level linguistic capacity, but have some level of intentionality (in this ontology 'SoftwareAgents') will fit in this category. But to belong to this category a comouter program must have a high degree of autonomy - it must be able to reason about situations and form plans that were not directly preprogrammed. As of 2008 it is uncertain whether any such programs exist. @ToDo: NOTE that an IntentionalAgent does not necessarily have to be a PhysicalObject (as of v0.52) because the subtype SoftwareAgent is not a PhysicalObject, and sprits that in religion or folklore have agentive powers are also not PhysicalObjects.. IntentionalAgent is disjoint from Artifact-NonAgentive. This category will also include some non-human animals that can be said to be able to form some plans, however primitive. As of COSMO version 0.3, we include only mammals under this class. If it is shown that other animals can form primitive plans, at that time they may also be added as subtypes of this category. OPENCYC 1: MAY 23, 2002 #$Agent-Generic is the collection of all agents, or things (like #$Animals, #$Robots, #$DivineBeings, etc.) that have desires and intentions and the presumed ability to act on them. An instance of this collection may be an instance of #$AgentiveArtifact or #$Agent (but not both). In SUMO, 'CognitiveAgent' appears to be the approximate equivalent. SUMO: An Agent that has rights but may or may not have responsibilities and the ability to reason. If the latter are present, then the Agent is also an instance of CognitiveAgent. Domesticated animals are an …

IntelligentAgent
type: Class
comment: An IntelligentAgent is an agent (Person, Organization, GroupOfPeople, or possibly spirits or an intelligent machine) that can form plans, use knowledge in plans, and can communicate in language. Some activities, such as buying things, can only be performed by an IntelligentAgent. Among the natural animals, only people qualify for this status - in this respect, this category differs from the definition given by Cyc (below). Groups of people, or organizations whose acts are in fact carried out by people (or machines directed by people), can be considered as IntelligentAgents - by the convention that the acts carried out by people who are authorized to act in the name of an organization are acts of the organization. (see Organization). To some degree, existing or future computers may also have such a capacity, and would fit into this category, even if the range of linguistic inputs that would generate an appropriate response may be much more limited than for an adult human;'intelligence' is therefore a quantitative attribute, which has a range of values. NOTE that this category needs to be carefully axiomatized so that the system will recognize blocking conditions that may prevent the understanding of language in specific circumstances: for example, an individual person will only understand one or a small number of languages; a person will understand language only when conscious and awake, and able to perceive the input. A human baby will not understand language at birth, and will develop that capacity gradually; nevertheless a human baby is an instance of this Type. Implementing the use of such blocking conditions will be complex, but including any agent type that can normally understand some human or near-human language appears to be preferable to creating a subtype of human that can qualify absolutely as understanding language, without conditions. NOTE that a Person is an IntelligentAgent, and therefore a DeadPerson is also an IntelligentAgent. In most circumstances…
subclass of: IntentionalAgent
type: AgentType

CognitiveAgent
type: Class
comment: The SUMO approximate equivalent of Cyc 'IntentionalAgent'.
isa synonym of: IntentionalAgent
subclass of: Synonym

agentive-social-object
type: Class
comment: COSMO note: this type appears to be intended to represent humans and human groups, so it is placed as a subtype of 'IntelligentAgent'. DOLCE only: 'agentive-social-object' A social object that is assumed to internally represent a plan. Since social objects are dependent on physical ones, it is not trivial to interpret the local sense in which a social object 'internally represents' a plan. For example, an institution can have the plan to promote or regulate some activities, but this is possible by means of the powers conferred to it by some legal system, through its representatives, and that plan has to be executed by means of the physical agents that 'act for' the institution.
subclass of: IntelligentAgent
type: AgentType

CollectiveAgent
type: Class
comment: A CollectiveAgent is a human group or organization, acting as a unit or having some other agent acting in its behalf. OPENCYC 1: MAY 23, 2002 (termed MultiIndividualAgent in Cyc) The collection of all #$Agent-Generics that each consist of other #$Agent-Generics operating together. Usually the constituent agents form some kind of #$Group that itself acts as an #$Agent-Generic. Examples: a #$LegalCorporation, a #$GeographicalAgent, a #$Neighborhood or an #$Industry-Localized. Although it would be a positive exemplar of (#$GroupFn #$Agent), the 'group of people whose first names all start with the letter 'B'' is a negative exemplar of #$MultiIndividualAgent. In almost all contexts, such a group will not act as an #$Agent in any way. It is less cohesive than some of the least cohesive kinds of #$MultiIndividualAgents such as #$CrowdOfPeople.
subclass of: agentive-social-object

SpatialThing
type: Class
comment: 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.
subclass of: GenericLocation
type: LocationType
subclass of: Individual

InformationObject
type: Class
comment: COSMO: An InformationObject is a MentalObject created by an IntelligentAgent that contains Information in some form. The name 'Information-object' is from DOLCE. Comparable to the OpenCyc '#$AbstractInformationalThing'. This subsumes both the symbolic objects that people may create as well as the yet more abstract informational content ('propositional content') which may be viewed as existing independent of the symbols used to encode it. 'Information' has not been well defined yet, so this category does not have clear defining conditions of its own, but subsumes things like AbstractSymbolicObjects, Propositions, and Languages. Every Communication transfers some InformationObject. DOLCE; Information objects are social objects. They are realized by some entity. They are ordered (expressed according to) by some system for information encoding. Consequently, they are dependent from an encoding as well as from a concrete realization.They can express a description (the ontological equivalent of a meaning/conceptualization), can be about any entity, and can be interpreted by an agent.From a communication perspective, an information object can play the role of 'message'. From a semiotic perspective, it plays the role of 'expression'. OPENCYC 1: MAY 23, 2002\nA heterogeneous collection of abstract objects that pertain to information. Subsumes not only #$Proposition, but also the collections #$Sentence, #$CharacterString, #$AtomicSymbol-Abstract, #$Microtheory, #$PropositionalInformationThing, and #$ConceptualWork. Note that while all #$AbstractInformationalThings are abstract objects (this collection is disjoint with #$SpatialThing-Localized), most instances of this collection can have multiple concrete 'embodiments';. A single instance of #$Sentence can be written on several peices of paper (see #$instantiationOfAIS); a #$PropositionalInformationThing may be the content of several concrete documents, such as instances of #$BookCopy (see #$containsInfoPropositional-IBT); and…
subclass of: MentalObject

InformationBearingThing
type: Class
comment: A collection of spatially-localized individuals, including various actions and events as well as physical objects. Each instance of #$InformationBearingThing (or IBT ) is an item that contains information (for an agent who knows how to interpret it). Examples: a copy of the novel Moby Dick; a signal buoy; a photograph; an elevator sign in Braille; a map; a US dollar bill; a resume; a musical score; copies of the #$CycProgram. For representations of the propositional content of information bearing things, see #$PropositionalInformationThing; but note that not all IBTs have a propositional content (cf. #$ArtObject). An important specialization of #$InformationBearingThing is #$InformationBearingObject, which comprises all of those IBTs that are also physical objects (i.e. #$PartiallyTangibles). Though often a subtle task in particular contexts, it is important to distinguish the various specializations of #$InformationBearingThing from those of #$AspatialInformationStore (whose instances are the chunks of information instantiated in particular IBTs; see #$instantiationOfAIT) and from those of #$ConceptualWork (whose instances are the conceptual or artistic creations that are instantiated in particular IBTs; see #$instantiationOfWork). For instance, #$TextString is a specialization of #$AspatialInformationStore, #$TextualMaterial is a specialization of #$InformationBearingThing, and #$TextualPCW is a specialization of #$ConceptualWork; to conflate any of these with another would be to make a category error . Also note that events in which information is transferred (see #$InformationTransferEvent) are not considered instances of #$InformationBearingThing. Rather, such transfer events have as one of their participants (see #$actors) some instance of #$InformationBearingThing; though in cases where IBTs are themselves events this will require distinguishing very finely between the event that encodes the information and the event that is the information transfer. See also…
subclass of: Artifact-Generic

AbstractSymbolicObject
type: Class
subclass of: InformationObject
subclass of: InformationBearingThing
type: ObjectType
comment: A AbstractSymbolicObject is a mental object which is created to serve as a Symbol, i.e. to represent something other than itself. This is not a physical object, but more abstract, such as the letter 'a', which may have representations in billions of different physical objects, but retains its identity as the unique (Roman alphabet) letter 'a'. Every SymbolicObject is represented in at least one PhysicalObject, even if only the brain of the person who created it. The more interesting SymbolicObjects are texts and documents. This Type is approximately equal to,and merged with, the Cyc 'AbstractInformationStructure' From Cyc: OPENCYC 1: MAY 23, 2002\ A subcollection of #$AbstractInformationalThing whose instances involve symbols standing in certain relations to one another. Important specializations include #$CharacterString and #$Sentence. #$AbstractInformationStructure also includes abstract diagrams, graphs, and bit strings. The collection can be more precisely defined as follows: Each #$AbstractInformationStructure is such that each of its physical instantiations (see #$instantiationOfAIS) consists of instantiations of instances of #$AtomicSymbol-Abstract, arranged in a certain way. For example, the abstract sentence 'The pig flies' is an #$AbstractInformationStructure. Each written instantiation of it consists of an instantiation of the words (symbols) 'The', 'pig' and 'flies', written in that order. (If the #$AbstractInformationStructure 'The pig flies' were spoken, the same words would appear in the same order, i.e. 'The' first, etc., but the sequence would be determined by the arrangement of the words in time, rather than space.) Likewise with abstract diagrams, graphs, etc. Each of these is such that their physical instantiations consist of arrangements of instantiations of instances of #$AtomicSymbol-Abstract. A hard copy of a wiring diagram consists of a group of concrete symbols representing various circuit components, in which these symbols are spatially a…

AbstractSymbol
type: Class
subclass of: AbstractSymbolicObject
type: ObjectType
comment: A AbstractSymbol is a unit mental object which is created to serve as a Symbol, and cannot be broken in parts without destroying much of the meaning of the symbol. Examples are single characters in some language or graphical icons representing ideas or objects. The more interesting Symbols are texts and images.

AbstractCharacter
type: Class
subclass of: AbstractSymbol
type: ObjectType
comment: An AbstractCharacter is an AbstractSymbol that is one of the symbols contained in some linguistic alphabet, or any other symbol used in typography or in the control of format during electronic transmission of information. In information processing systems, any sequence of bits having the proper length for use in strings (e.g., seven bits or eight bits or sixteen bits) can count as an AbstractCharacter, the length depending on the computational context. An AbstractCharacter will have a graphical representation (may have multiple different representations in different fonts), and the graphical representations can be distinguished from each other by their shape, but as an AbstractCharacter per se, it can have properties that are independent of the shape, such as the fact that a certain sequence of characters form a certain word. Therefore it is necessary to maintain the distinciton between an AbstracgtCharacgter and its graphical representation. For example, a pdf document may have page images that consist wholly of representations of text - yet it is stored as an image. The distinction has to be made between such images of text and the AbstractText that is represented by that image, and the distinction must be in the way the image is composed - of lines, pixels, or other graphical elements, whereas the text is a linear arrangement of abstract characters, requiring no specification of graphical form for the characters. Specifying the graphical representation of an AbstractCharacter is not essential to distinguish one AbstractCharacter from another, at the abstract level.

AbstractText
type: Class
comment: An AbstractText is the abstract representation of some linguistic expressions. The text may have formatting, such as columns and rows, beyond simple linear text.
subclass of: AbstractSymbolicObject
type: ObjectType

InformationStore
type: Class
comment: Cyc: A specialization of #$PartiallyIntangibleIndividual. Each instance of #$InformationStore is a tangible or intangible, concrete or abstract repository of information. The information stored in an information store is stored there as a consequence of the actions of one or more agents. Wholly intangible instances of #$InformationStore include instances of #$AspatialInformationStore and #$PropositionalInformationThing. Some instances of #$InformationStore - namely, instances of #$InformationBearingObject, such as copies of a newspaper at a newsstand - are only partially intangible.
subclass of: InformationBearingThing

AbstractInformationStore
type: Class
comment: Cyc term: 'AspatialInformationStore' Cyc: A specialization of #$AspatialThing, #$IntangibleIndividual, and #$InformationStore. #$AspatialInformationStore is the collection of all information stores that have no spatial location. Specializations of #$AspatialInformationStore include #$ConceptualWork, #$Microtheory, #$AbstractInformationStructure, and #$FieldOfStudy. Although no instance of #$AspatialInformationStore has a spatial location, some instances can have multiple spatio-temporal embodiments . For example, an instance of #$PropositionalInformationThing may be the content of several concrete documents, such as several instances of #$BookCopy (see #$containsInfoPropositional-IBT); and several distinct events, such as spoken utterances, may have a certain unique #$Proposition as their content (see #$containsInformation).
subclass of: AbstractSymbolicObject
subclass of: InformationStore
type: ObjectType

StructuredInformationSource
type: Class
comment: COSMO note: in COSMO this type is abstract and does not include physical objects. Cyc: A specialization of both #$InformationStore and #$PartiallyIntangibleIndividual. Each instance of #$StructuredInformationSource is an #$InformationStore in which bits of information are represented as related in a systematic way that is easily characterized by some type of formal structure, including spatial or architectural terms (used metaphorically). Examples include: a database organized in fields and values; a spreadsheet organized in rows and columns with entries; an organizational tree diagram with nodes and branches; a topographical map; a document written in HTML (hyper-text markup language). Negative examples include computer programs, poems, and novels.
subclass of: AbstractInformationStore

Tuple
type: Class
subclass of: StructuredInformationSource
subclass of: MathematicalObject
comment: A specialization of both #$MathematicalObject and #$StructuredInformationSource. Each instance of #$Tuple is a complex consisting of one or more indexed (and possibly ordered) components; it might be a single, a pair, a triple, or so on; and the components might be things of any sort whatsoever (see #$memberOfTuple). For example, a specialization of #$Tuple is #$NTupleOfIntervals (q.v.), whose instances are tuples consisting exclusively of #$ScalarIntervals (q.v.); e.g. complex numbers and physical vectors are n-tuple-intervals. Another specialization of #$Tuple is #$List (q.v.), whose instances are ordered. Each tuple has an associated index set : the set of things that serve (via an associated indexing function ) to index or individually represent the tuple's members (see #$tupleIndexSet and #$tupleMemberIndex). If the index set for a given tuple is the set of positive integers (or an initial segment thereof), then the integers' usual ordering serves to order the tuple's components, and the tuple is in fact an _ordered_n-tuple_, i.e. it is a #$List. But in general any set (e.g. the column names in a relational database) may be used to index the components of a tuple.

List
type: Class
comment: A List is a MentalObject, i.e. an Object without mass created by an IntelligentAgent, with the distinctive character that it is a linearly ordered arrangement of AbstractSymbolicObjects. A List may be empty, and has its own properties in addition to the properties of the constituent elements, therefore it is not a Group. Note that AbstractStrings are subtype of List. A List is ordered, and it can have the same entity in different positions in the llist. It is not a type of Set. A List has a 'first' and 'rest' component. The 'rest' can be another list, or null. Therefore a list may have one element (or none) Cyc comment: A specialization of #$Tuple. Each instance of #$List is a finite sequence of things with a first and last member-position, with each member-position other than the last having a successor member-position. As with tuples generally, lists allow for repetition of their members, so that the same item can appear at multiple member-positions in the same list. A list can be represented formally as a function from a finite index set of counting numbers, beginning with one, into the domain of all #$Things (but note that #$Lists are _not_ explicitly represented as functions in the Cyc ontology). Unlike an instance of #$Series (q.v.), a list is purely abstract (i.e. both aspatial and atemporal), and the only implied relation between an item and its successor in a list is the successor relation of the list itself. Technically, #$List is more specific than #$Tuple only in that the index set (see #$tupleIndexSet) for a given list must be the counting numbers in their usual order (or some initial segment thereof), whereas the index set for a tuple, generally speaking, might be any set whatsoever.
subclass of: AbstractSymbolicObject
subclass of: Tuple

isInList
type: ObjectProperty
comment: isInList relates some symbol to a List that contains that symbol as an element. SUMO (named 'inList' in SUMO): The analog of 'element' and 'instance' for Lists. (inList ?OBJ ?LIST) means that ?OBJ is in the List ?LIST. For example, (inList Tuesday (ListFn Monday Tuesday Wednesday)) would be true.
domain: AbstractSymbolicObject
range: List
inverse of: hasListElement

AbstractString
type: Class
comment: An AbstractString is a linear array (A List) of basic characters in some character set (not necessarily just an alphabet). It is the abstract representation of the characters, and the base string will not have any formatting, either of font or size or capitalization. Formatting can be represented as attributes of a String. Every defined instance of AbstractString should be represented by a datatype String using the relation 'hasStringRepresentation', unless it is a binary string, or has a number of bits that is not evenly divisible by 8 (in which case, a BinaryString should be used). The name of the AbstractString in the ontology can be very much shorter than the actual String represented; e.g. the string representation of AbstractString 'WarAndPeace' might be the full text of a long book..
subclass of: AbstractText
subclass of: List
type: ObjectType
subclass of: Restriction
  on property: hasListElement
  all values from: AbstractCharacter

wasCreatedBy
type: ObjectProperty
domain: Artifact-Generic
range: Class
  union of: GenericAgent
  union of: AbstractString
comment: wasCreatedBy relates an Artifact (concrete or abstract) to the Agent or Agents who created it. Knowing the identity of one creator (e.g. of an artifact) does not guarantee that one knows the identity of all creators. @ToDo: NOTE: as of v0.52, ArtificialSubstance is included in the domain as a subtype of 'Artifact-generic', but this should be restricted to objects, since it is quantities of ArtificialSubstance that are actually created by agents, not the abstract substance. Change the range to some subtype of 'Artifact-generic'?? 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..

Artifact-Generic
type: Class
subclass of: Restriction
  on property: wasCreatedBy
  all values from: GenericAgent
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.).

IntangibleIndividual*
type: Class
comment: OPENCYC 1: MAY 23, 2002 The collection of wholly intangible individuals, a specialization of both #$Intangible and #$Individual. Instances of #$IntangibleIndividual are immaterial, and thus do not have mass, color, or other tangible qualities. Examples include mathematical objects (such as numbers, functions, and relations), attributes, time intervals, space regions, and events. Excluded are sets and collections because, although intangible, they are not individuals.
subclass of: AbstractEntity

Object4D
type: Class
subclass of: Object
comment: An Object4D is an Object extended in time, making it effectively four-dimensiona. This is the object that is used to represent physical objects in a Perdurantist ontology. See 'Object' and 'PhysicalObject' for further discussion. the type Object4D is disjoint from the type Object3D. An Object4D can have a TimeSlice, but an Object3D cannot. The preferred representation of PhysicalObjects uses the type PhysicalObject and its subtypes, which are subtypes of the more general Object, Object4D and Object3D are included only to enable representation of explicitly perdurantist or endurantist ontologies.
disjoint with: Object3D

Object3D
type: Class
subclass of: Object
comment: An Object3D is an Object *not* extended in time, making it only three-dimensional. In COSMO assertions on what are instances of Object3d in a purely endurantist ontology are equivalent to assertions on the dimension-neutral 'Object'. However, an instance of Object3D cannot also be an instance of TimeSlice. See 'Object' and 'PhysicalObject' for further discussion. The type Object4D is disjoint from the type Object3D. An Object4D can have a TimeSlice, but an Object3D cannot. The preferred representation of PhysicalObjects uses the type PhysicalObject and its subtypes, which are subtypes of the more general Object, not of Object3D, Object4D and Object3D are included only to enable representation of explicitly perdurantist or endurantist ontologies.
disjoint with: Object4D

SetOrCollection[Cyc]%SetOrClass[SUMO]
type: Class
subclass of: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]
comment: COSMO: SetOrType is the union of theTypes Set and Type. 'Type' in COSMO is used to refer to those intensionally-defined groupings called: Class in Ontolingua and Protege; Class in RDF and OWL; Class in SUMO; Collection in OpenCyc; Universal in DOLCE; Property in Ontology Works' IODE system * The Class 'Type' in COSMO is intended to be equivalent to the classes by those names in those other ontologies. * (isaSubtypeOf A B) means that Type A is a subtype of Type B and that all instance of Type A are also instances of Type B.

Set
type: Class
comment: COSMO:
subclass of: SetOrCollection[Cyc]%SetOrClass[SUMO]

hasUnitObject
type: ObjectProperty
domain: SubstanceType
range: PhysicalObjectType
comment: hasUnitObject relates a PhysicalSubstance to the PhysicalObjects that are the characteristic objects that constitute the substance. For example, a ChemicalElement hasUnitObject Atom.

consistsOfManyOf
type: ObjectProperty
domain: SubstanceType
range: PhysicalObjectType
sub property of: hasUnitObject
comment: consistsOfMany relates a granular material consisting of multiple individual objects of the same type (e.g. sand), considered as a Substance, to the individual objects. This is similar to and a subproperty of 'hasUnitObject', but is restricted to granular materials, whereas the parent 'hasUnitObject' can be used to treat large quantities of any object as a substance.

PhysicalQuantity
type: Class
subclass of: MeasurableQuantity
subclass of: QuantitativeAttributeValue
type: QuantitativeAttributeType
comment: A PhysicalQuantity is a measurable quantity that has a numerical value qualifying a UnitOfMeasure. In one notation, a mass of 25 grams could be expressed as '{25 grams}' where 'grams' is a function that returns a MassMeasure. PhysicalQuantities are measures of attributes of objects in our real world, and as such are subject to uncertainty, also called 'measurement error'. PhysicalQuantity has an attribute of 'MeasurementUncertainty', which is an optional attribute. When a MeasurementUncertainty is not explicitly provided with an instance of PhysicalQuantity, each implementing system has the option to designate default uncertainties, which may be general or specific to particular categories of measurement. COSMO note: PhysicalQuantities in COSMO are categorized both as quantities, and as AttributeValues. Conceptually, to be viewed as an attribute, some combination of AttributeType and AttributeValue would both be involved (e.g. 'a length of 30 cm'). But at this point (v0.3) it does not appear necessary to represent such quantitative attributes in that explicit manner. This issue remains open for possible future elaboration. SUMO: A PhysicalQuantity is a measure of some quantifiable aspect of the modeled world, such as 'the earth's diameter' (a constant length) and 'the stress in a loaded deformable solid' (a measure of stress, which is a function of three spatial coordinates). All PhysicalQuantities are either ConstantQuantities or FunctionQuantities. Instances of ConstantQuantity are dependent on a UnitOfMeasure, while instances of FunctionQuantity are Functions that map instances of ConstantQuantity to other instances of ConstantQuantity (e.g., TimeDependentQuantities are FunctionQuantities). Although the name and definition of PhysicalQuantity is borrowed from physics, PhysicalQuantities need not be material. Aside from the dimensions of length, time, velocity, etc., nonphysical dimensions such as currency are also possible. Accordingly, amounts of money would be …

QuantitativeAttributeValue
type: Class
comment: A QuantitativeAttributeValue is a value for some AttributeType which is expressed in quantitative measures, comnsisting of a quantifier and a unit of measure.. Examples (using the ESKIF format) are {10 feet} and {32 degreesF}. In formalisms such as OWL that do not have function terms or higher-arity relations, each such QuantitativeAttributeValue must be constructed as an instance that has relations pointing to the quantifier and the UnitOfMeasure. In OWL, where bare numbers are not allowed as labels for elements, the numbers may be represented using a NamespacePrefix in front of the number, such as N_10 (for 10) (for a range) R_29-30. Each instance of QuantitativeAttributeValue is an OrderedPair, the first element of which is a Quantifier (or QuantifierType) and the second element a UnitOfMeasure. A QuantifierType is allowed as a value in order to represent reified ranges of values. See 'GreaterThanHalf' for an example. When an instance of QuantitativeAttributeValue is represented by creating a reified instance, the UnitOfMeasure and the quantifier are specified by using the relations 'hasUnit' and 'hasQuantifier' to specify , respectively. . If an implementation allows use of functions, a QuantitativeAttributeValue can be represented, without reification in the ontology, as a function term such as {25.6 feet} or {N_25.6 feet}, depending on whether the implementation allows bare numbers in expressions. The NamespacePrefix 'N_' can be used for numbers, and 'R_' can be used for NumberRanges.
subclass of: AttributeValue
subclass of: OrderedPair
type: QuantitativeAttributeType
subclass of: Restriction
  on property: hasQuantifier
  some values from: Class
    union of: Quantifier
    union of: QuantifierType

Quantifier
type: Class
comment: A Quantitifier is some numerical or verbal value that specifies or restricts the numerical prefix for a QuantitativeAttributeValue. The simples arre numbers, suc as 3 in the distance measure {3 feet}. A quantifier can also be a range {2 to 4}, such has in{{2 to 4} feet}. A quantifier can also be a number with a variance {3 +- 1}, such has {{3 +- 1} feet}. A quantifier can be verbal, such as 'High', 'Medium' or 'Low' such as {High Intensity}. Quantifiers may have default variances. See: 'hasDefaultVariance' and 'ConfidenceInterval'.
subclass of: Quantity

Quantity
type: Class
comment: Quantities can be numbers (integer, real, imaginary) or number ranges or approximate numbers, or distributions, or restricted ranges (greater than or less than), or PhysicalQuantities, which are measures. Numbers may have different qualitative dimensions (scales), and quantitative comparisons will generally only be meaningful when two numbers are expressed on the same scale.

Ordered
type: Class
subclass of: QualitativeAttributeValue
subclass of: IntensiveAttributeValue
type: AttributeValueType
comment: 'Ordered' is an AttributeValue of Groups that have some kind of ordering. More specific orderings will be subtypes of this AttributeValue, such as 'LinearlyOrdered'

LinearlyOrdered
type: Class
subclass of: Ordered
type: AttributeValueType
comment: 'Ordered' is an AttributeValue of Groups that have some kind of ordering. More specific orderings will be subtypes of this Attributealue, such as 'LinearlyOrdered'

OrderedGroup
type: Class
comment: An OrderedGroup is a Group that has some ordering relation between component elements. It usually has more than one component element, but to allow generalization of certain concepts such as an ActionSeries, an OrderedGroup is allowed to have as few as one component element. The ordering may be of any kind: a simple linear order, or a complex multi-dimensional pattern. The most common kind of OrderedGroup is one that is linearly ordered, and each such Group is an instance of the subtype 'LinearlyOrderedGroup'. 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.
subclass of: Group
type: GroupType
subclass of: Restriction
  on property: hasAttributeValue
  has value: Ordered

hasComponentElement
type: ObjectProperty
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'.
domain: Group
inverse of: isaComponentElementOf
sub property of: hasPart

isaComponentElementOf
type: ObjectProperty
comment: 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..
range: Group
inverse of: hasComponentElement
sub property of: isaPartOf

hasFirstElement
type: ObjectProperty
comment: hasFirstElement is a specialization of the relation 'hasComponentElement' applying to OrderedGroups or Lists, specifying the first component element of the OrderedGroup or List.
domain: Class
  union of: LinearlyOrderedGroup
  union of: List

LinearlyOrderedGroup
type: Class
comment: A LinearlyOrderedGroup is a Group that has a linear ordering, which is a mapping from the natural numbers to elements of the Group. It will usually have more than one element, but may have only one.
subclass of: OrderedGroup
type: GroupType
subclass of: Restriction
  on property: hasAttributeValue
  has value: LinearlyOrdered

hasSecondElement
type: ObjectProperty
comment: hasSecondElement is a specialization of the relation 'hasComponentElement' applying to OrderedGroups, specifying the Second component element of an OrderedGroup.
domain: LinearlyOrderedGroup
sub property of: hasComponentElement

hasThirdElement
type: ObjectProperty
comment: hasThirdElement is a specialization of the relation 'hasComponentElement' applying to OrderedGroups, specifying the Third component element of an OrderedGroup.
domain: LinearlyOrderedGroup
sub property of: hasComponentElement

UnitOfMeasure
type: Class
subclass of: PhysicalQuantity
type: MeasurableQuantityType
comment: A standard of measurement for some dimension. For example, the Meter is a UnitOfMeasure for the dimension of length, as is the Inch. There is no intrinsic property of a UnitOfMeasure that makes it primitive or fundamental; rather, a system of units (e.g. SystemeInternationalUnit) defines a set of orthogonal dimensions and assigns units for each. NOTE that each UnitOfMeasure is represented as a 'QuantitativeAttributeValue' which means that it has a Quantifier and a UnitOfMeasure. This convention means that a unit of measure is just *some* instance of measure that is chosen as the 'unit'. This requires that the Quantifier be the number 1, and the UnitOfmeasure be the unit itself. This may seem a bit peculiar, and might be changed if it seems desirable. Cyc: A specialization of #$ScalarDenotingFunction (q.v.). Each instance of #$UnitOfMeasure is a function that takes one or two numbers or other #$NumericIntervals as arguments, and returns as value a #$MeasurableQuantity (q.v.), such as a #$Distance or a #$Speed or a #$Volume. If a unit of measure is applied to one number (see #$Number-General) the result is a precise quantity that is a #$ScalarPointValue; if applied to two (different) numbers -- or to one (or two) #$ProperIntervalOnNumberLine(s) -- the result is a closed-interval quantity that is a #$ScalarProperInterval. For example, (#$Meter 5) is the distance five meters and (#$Meter 5 10) is the distance five to ten meters (inclusive) . (A partial exception to the above is the unit-of-measure #$Unity (q.v.), which always returns a #$NumericInterval rather than a #$MeasurableQuantity.) Specializations of #$UnitOfMeasure grouped by what they measure include #$UnitOfTime, #$UnitOfSpeed, and #$UnitOfVolume. Other specializations are #$OneDimensionalUnitOfMeasure, #$MultiDimensionalUnitOfMeasure, #$UnitOfMeasureWithPrefix and #$UnitOfMeasureNoPrefix.
subclass of: Restriction
  on property: hasQuantifier
  has value: N 1

dimensionless
type: UnitOfMeasure
comment: The UnitOfMeasure for a number, which may be a limit (e.g. > 3, lessThan 5).

hasValue
type: ObjectProperty
comment: hasValue relates an Attribute to the Value of the attribute. The value may be qualitative (Flexible) or quantitative {10 feet}. NOTE that AttributeValues can take the form of either instances of AttributeValue or *subtypes* of AttributeValue, which are instances of AttributevalueType. The latter are used to allow for subclassing of AttributeValues, to allow inferring that having one value also implies having its parent AttributeValues (up to the least specific value).
domain: Attribute
range: Class
  union of: AttributeValueType
  union of: AttributeValue

hasUnit
type: ObjectProperty
comment: hasUnit relates an Attribute or QuantitativeAttributeValue to the UnitOfMeasure in which the value is expressed. For a length, for example, this might be meters, feet, miles, etc.. This relation may be used to relate quantitativeAttributes directly to their UnitOfMeasure (if they are quantiative attributes), or to relate the QuantitativeAttributeValue to its UnitOfMeasure. The direct relations allows one to specify QuantitativeAttributeValues without reifying the AttributeValue in addition to the Attribute.
domain: Class
  union of: QuantitativeAttributeValue
  union of: Attribute
range: UnitOfMeasure

hasMeasure
type: ObjectProperty
comment: hasMeasure relates a QuantitativeAttributeValue to the AttributeType that the QuantitativeAttributeValue is a measure of. A LengthMeasure, for example, could be a measure of a distance, a diameter, a girth, oany other property or relation expressed in units of distance.
domain: QuantitativeAttributeValue
range: AttributeType

Pair
type: Class
subclass of: Group
type: GroupType
comment: A Pair is a Group containing exactly two elements.
subclass of: Restriction
  on property: hasCardinalityNumber
  has value: 2

Measurement
type: Class
subclass of: OrderedPair
comment: A Measurement is an OrderedPair representing the result of a MeasurementEvent. It is an abstract representation of a MeasurableQuantity. Each instance of Measurement is an OrderedPair in which the first element is a UnitOfMeasure or other Quantifiable AttributeValue, and the second element is a quantity expressing some kind of magnitude associated with that UnitOfMeasure. The magnitude will typically be a number indicating, for example, how many individuals have that attribute, or a percentage indicating what fraction of a group have that Attribute. A Prevalence will typically be one element of a Distribution. NOTE that a Measurement does not have to use actual numbers in the 'Quantifier' field - a Measurement may be approximate, using quantities like 'High', 'Low', etc. qualifying an AttributeValue, but it does have to modify a unit of measure.
subclass of: Restriction
  on property: hasSecondElement
  some values from: Quantifier
subclass of: Restriction
  on property: hasFirstElement
  some values from: UnitOfMeasure

MeasurableQuantity
type: Class
comment: COSMO note: A MeasurableQuantity is some attribute of which a number (or other quantifier) is a part, and also has a unit of measure. This is disjoint from pure numbers. Cyc: A specialization of #$Quantity (q.v.). This is the collection of quantities that have a numeric component and could actually be used to measure something, as opposed to (say) merely ranking it on a scale. Arithmetic operations (such as addition and multiplication) can be performed on measurable quantities, as they can on purely numeric scalars (see #$NumericInterval). Specializations of #$MeasurableQuantity include #$Distance, #$Temperature, #$Mass, and #$Time-Quantity. Other, broader specializations are #$OneDimensionalQuantity, #$TwoDimensionalQuantity, and #$ThreeDimensionalQuantity. Any quantity (that at least in principle could be) returned by a #$UnitOfMeasure (q.v.) function is a measurable quantity. In CycL, particular measurable quantities are usually represented as the result of applying a unit-of-measure function to a real number or pair of reals. For example, (#$Meter 5) is the distance 5 meters.
subclass of: Quantity
subclass of: QuantitativeAttributeValue
type: QuantitativeAttributeType
subclass of: Restriction
  on property: hasAbstractRepresentation
  all values from: Measurement

hasRepresentation
type: ObjectProperty
comment: hasRepresentation is the most general relation that points from some concept or thing - of any type - to another thing (abstract or physical) that represents it in some way. This relation will be used, if at all, less frequently than the more specific 'representation' relations, and may be useful primarily to collect those more specific relations in one location to make the representation relations easier to understand. The related relation 'hasURL' points to a datatype string that is the address of some file relevant to the subject entity. As a datatype relation,

hasAbstractRepresentation
type: ObjectProperty
comment: hasAbstractRepresentation relates some entity - concrete or abstract - to a MentalObject that represents - or contains a part that represents - that entity. The mental object is itself abstract in the sense of having no mass. A common example of an abstract representation is the word (string of characters) 'cat', representing a small furry animal. NOTE that an AbstractRepresentation (such as an AbstractImage) of a person will contain an abstract representation of that person, but may also contain (and thus be, in this sense) an abstract representation of the clothing or accessories that person is wearing, or of the chair s/he is sitting in, or of the cat next in his/her lap, or of anything else in that image. NOTE also that, just as the representation pointed to by this relation may only have a part that actually represents the subject matter (other parts may represent other subject matters), the subject of the inverse relation 'isanAbstractRepresentationOf' may only have a part that is the representation of the object of that relation.
range: AbstractSymbolicObject
sub property of: hasRepresentation
inverse of: isanAbstractRepresentationOf

isanAbstractRepresentationOf
type: ObjectProperty
domain: AbstractSymbolicObject
comment: points from an abstract representation (for example, an AbstractString or AbstractImage) of something to that thing it represents. The abstract string 'the cat' could point to a specific instance of a cat A DateTimeExtendedGroup string would point to a TimeInterval.

hasQuantifier
type: ObjectProperty
comment: hasQuantifier relates a QuantitativeAttributeValue to the quantifier that indicates how many units large the value is.
domain: Class
  union of: QuantitativeAttributeValue
  union of: Attribute
range: Class
  union of: Quantifier
  union of: QuantifierType

OrderedPair
type: Class
subclass of: LinearlyOrderedGroup
subclass of: Pair
type: ObjectType
comment: A OrderedPair is a Tuple containing two elements.

Number
type: Class
comment: A Number is both a Quantity and an Object. This contrasts with PhysicalQuantity, which is a Quantity and an AttributeValue. Pure numbers and physical quantities (numbers plus units of measure) are disjoint entities.
subclass of: Quantifier
subclass of: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]

RealNumber
type: Class
comment: Any Number that can be expressed as a (possibly infinite) decimal, i.e. any Number that has a position on the number line.
subclass of: Number

NumberRange
type: Class
comment: A NumberRange is a Quantifier that is mostly used with units of measure, to express the idea that a measure falls within that range. Instances of NumberRange can be represented in COSMO by using the NamespacePrefix 'R_' in front of the range, which is the lower number and higher number separated by a hyphen. Thus the NumberRange 25 to 30 can be reified by creating an instance of NumberRange labeled 'R_25-30'. Using this formalism, a measure that is within the range of 30 to 32 meters could be represented by the function term (in ESKIF) '{R_25-30 meters)'. In implementations that allow the use of bare numbers in an expression, two numbers separated by a hyphen (e.g. '25-30') might be interpreted as a range, rather than as a number derived by subtraction Programs interpreting such a NumberRange may use it as required for the local application.
subclass of: Quantifier
subclass of: Intangible[Cyc]%Abstract[SUMO]%abstract_object[ISO15926]
subclass of: Restriction
  on property: hasLowerLimit
  some values from: float
subclass of: Restriction
  on property: hasUpperLimit
  some values from: float

ExclusiveNumberRange
type: Class
comment: A NumberRange in which the lower number of the range is not included in the range, but the upper number is.
subclass of: NumberRange

hasLowerLimit
type: DatatypeProperty
comment: 'hasLowerLimit' relates an instance of 'Number' or 'NumberRange' to a datatype number, which is below or equal to the lowest possible value for the RealNumber. Whether the limit is inclusive or exclusive depends on the context in which it is used. This is a way to relate reified instances of number in the ontology to datatype numbers. See, for example,'GreaterThanHalf'.
domain: Class
  union of: Number
  union of: NumberRange
range: float

hasUpperLimit
type: DatatypeProperty
comment: 'hasUpperLimit' relates an instance of 'Number' or 'NumberRange' to a datatype number, which is above or equal to the highest possible value for the RealNumber. Whether the limit is inclusive or exclusive depends on the context in which it is used. This is a way to relate reified instances of number in the ontology to datatype numbers.
domain: Class
  union of: Number
  union of: NumberRange
range: float

GreaterThanNumber
type: Class
comment: Any Number in some range that is greater than the specified value, related by the 'hasLowerLimit' relation. The range of permitted values does not include the limit. The implementation will have to interpret these numbers in whatever manner less-than and greater-than numbers are interpreted.
subclass of: RealNumber

GreaterThanHalf
type: Class
comment: 'GreaterThanHalf' is the type including all RealNumbers that have a numerical value greater than 0.5.
subclass of: GreaterThanNumber
type: QuantifierType
subclass of: Restriction
  on property: hasLowerLimit
  has value: 0.5

LessThanNumber
type: Class
comment: Any Number in some range that is less than the specified value, related by the 'hasUpperLimit' relation. The range of permitted values does not include the limit. The implementation will have to interpret these numbers in whatever manner less-than and greater-than numbers are interpreted.
subclass of: RealNumber

IrrationalNumber
type: Class
comment: Any RealNumber that is not also a RationalNumber.
subclass of: RealNumber

NonnegativeRealNumber
type: Class
comment: A RealNumber that is greater than or equal to zero.
subclass of: RealNumber

NegativeRealNumber
type: Class
subclass of: RealNumber
comment: A RealNumber that is less than zero.

PositiveRealNumber
type: Class
subclass of: NonnegativeRealNumber
comment: A RealNumber that is greater than zero.

RationalNumber
type: Class
subclass of: RealNumber
comment: Any RealNumber that is the product of dividing two Integers. To represent a fraction in the name of a RationalNumber, the prefix 'N_' should be used, and to separate the two integers, an underscore can be used (to stay within the OWL naming conventions). Thus three-halves would be named 'N_3_2',and two-thirds would be 'N_2_3'. However, percents, which are also rational numbers, will have a different naming scheme.

Synonym
type: Class
comment: 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'.

hasSynonym
type: AnnotationProperty
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.
range: Synonym

RatioQuantity
type: Class
comment: COSMO note: this is not a pure ratio, but a MeasurableQuantity that is a ratio of other MeasurableQuantities. It is represented, as are other MeasurableQuantities, as a Quantifier and a unit. In this case the quantifier is a ratio and therefore a RationalNumber, and the unit is expressed as a ratio of other units. Cyc: A specialization of #$MultiDimensionalQuantity (q.v.). Each instance of #$RatioQuantity is a quantity that is derivable (via #$QuotientFn) as a ratio of other quantities. For example, (#$MilesPerHour 65) is a ratio quantity obtainable by dividing (#$Mile 65) by (#$HoursDuration 1); and (#$PoundsPerSquareInch 50) is equal to (#$QuotientFn (#$Pound-UnitOfForce 50) (#$SquaredFn (#$Inch 1))) . Ratio quantities are used for measuring a difference or change in one quantity against a (usually incremental) difference or change in another quantity. When the later quantity is a #$Time-Quantity (as in the first example above), the ratio quantity is an instance of the specialization #$Rate. See also #$PerFn.
subclass of: MeasurableQuantity
subclass of: Restriction
  on property: hasQuantifier
  some values from: Class
    union of: RealNumber
    union of: QuantifierType

DimensionlessRatio
type: Class
comment: A DimensionlessRatio is a ratio of quantities in which the dimension of the numerator is the same as the dimension of the denominator, resulting in a dimensionless number. However, this type is for ratios of measures, and the resulting number is not a pure number, but a measure with the dimension 'dimensionless'. The Quantifier is a RationalNumber. Each DimensionlessRatio can be labeled by using the 'RTO_' namespace prefix, and an underscore between the numerator and denominator; see 'RationalNumber' for more similar treatment of the labels for RationalNumbers. Thus a DimensionlessRatio of one-third could be labeled 'RTO_1_3'.
subclass of: RatioQuantity
subclass of: Restriction
  on property: hasQuantifier
  some values from: Class
    union of: RealNumber
    union of: QuantifierType
subclass of: Restriction
  on property: hasUnit
  has value: dimensionless

PercentNumber
type: Class
subclass of: DimensionlessRatio
comment: A RationalNumber that expresses a ratio of one quantity to another, multiplied by one hundred. This is distinguished from a pure number only in that it has the dimension 'percent'. For its use to express distributions, see 'PercentageAttribute'.

Integer
type: Class
subclass of: RationalNumber
comment: A negative or nonnegative whole number.

NonnegativeInteger
type: Class
subclass of: Integer
subclass of: NonnegativeRealNumber
comment: An Integer that is greater than or equal to zero.
disjoint with: NegativeInteger

isWithinAnOrderOfMagnitudeOf
type: SymmetricProperty
type: ObjectProperty
domain: Quantity
range: Quantity
comment: 'isWithinAnOrderOfMagnitudeOf' relates one numerical quantity (dimensionless number or ConstantQuantity) to another and asserts that the ratio r of the numerical values of the two fall in the range 10 > r > 0.1 Thus: {{3 meters} isWithinAnOrderOfMagnitudeOf {10 meters}}.

isWithinaFactorOfTwoOf
type: SymmetricProperty
type: ObjectProperty
domain: Quantity
range: Quantity
sub property of: isWithinAnOrderOfMagnitudeOf
comment: 'isWithinaFactorOfTwoOf' relates one numerical quantity (dimensionless Number or ConstantQuantity) to another and asserts that the ratio r of the numerical values of the two fall in the range 2 > r > 0.5 Thus: {{3 meters} isWithinaFactorOfTwoOf {2 meters}}.

isApproximatelyEqualTo
type: SymmetricProperty
type: ObjectProperty
domain: Quantity
range: Quantity
sub property of: isWithinaFactorOfTwoOf
comment: 'isApproximatelyEqualTo' relates one numerical quantity (dimensionless Number or ConstantQuantity) to another and asserts that the ratio r of the numerical values of the two fall in the range 1.5 > r > 0.6667. Thus: {{4 meters} isApproximatelyEqualTo {3 meters}}.

isAlmostTheSameAs
type: SymmetricProperty
type: ObjectProperty
domain: Quantity
range: Quantity
sub property of: isApproximatelyEqualTo
comment: 'isAlmostTheSameAs' relates one numerical quantity (dimensionless Number or ConstantQuantity) to another and asserts that the ratio r of the numerical values of the two fall in the range 1.11111 > r > 0.9. Thus: {{10 meters} isApproximatelyEqualTo 11 meters}}.

isLessThan
type: ObjectProperty
domain: Quantity
range: Quantity
type: TransitiveProperty
comment: COSMO note: the quantities related by this relation must be instances of types in the ontology, not datatype quantities. Cyc: A #$NumericComparisonPredicate that is a generalization of the mathematical less-than ( < ) relation to #$ScalarIntervals (q.v.) of all sorts, including quantitative intervals as well as point values (see #$ScalarPointValue). (#$lessThan VALUE1 VALUE2) means that VALUE1 is less than VALUE2 with respect to some scale that they are both on. More precisely, there is some #$TotallyOrderedScalarIntervalType SCALE that both VALUE1 and VALUE2 are instances of and either (i) SCALE is a specialization of #$NumericValue (e.g. #$RealNumber) and the maximum (see #$maxQuantValue) of VALUE1 is less than the minimum (see #$minQuantValue) of VALUE2 or (ii) (#$followingValueOnScale VALUE1 VALUE2 SCALE) holds. Note that #$lessThan is an #$ELRelation (q.v.), and the above sentence would actually canonicalize to (#$greaterThan VALUE2 VALUE1).
inverse of: isGreaterThan

isLessThanOrEqualTo
type: ObjectProperty
type: TransitiveProperty
comment: A #$NumericComparisonPredicate that is a generalization of the mathematical less-than-or-equal-to ( <= ) relation to #$ScalarIntervals (q.v.) of all sorts, including quantitative intervals as well as point values (see #$ScalarPointValue). (#$lessThanOrEqualTo VALUE1 VALUE2) means that VALUE1 is less than or equal to VALUE2 with respect to some scale that they are both on. More precisely, there is some #$TotallyOrderedScalarIntervalType SCALE that both VALUE1 and VALUE2 are instances of and either (i) SCALE is a specialization of #$NumericValue (e.g. #$RealNumber) and the maximum (see #$maxQuantValue) of VALUE1 is less than or equal to the minimum (see #$minQuantValue) of VALUE2, (ii) (#$followingValueOnScale VALUE1 VALUE2 SCALE) holds, or (iii) (#$equals VALUE1 VALUE2) holds. Note that #$lessThanOrEqualTo is an #$ELRelation (q.v.), and the above sentence would actually canonicalize to (#$greaterThanOrEqualTo VALUE2 VALUE1).
domain: Quantity
range: Quantity

isGreaterThanOrEqualTo
type: ObjectProperty
type: TransitiveProperty
comment: A #$NumericComparisonPredicate (q.v.) that is a generalization of the mathematical greater-than-or equal-to (>=;) relation to #$ScalarIntervals (q.v.) of all sorts, including quantitative intervals (see #$NumericInterval and #$Quantity) as well as point values (see #$ScalarPointValue). (#$greaterThanOrEqualTo VALUE1 VALUE2) means that VALUE1 is greater than or equal to VALUE2 with respect to some scale that they are both on. More precisely, there is some #$TotallyOrderedScalarIntervalType SCALE; that both VALUE1; and VALUE2; are instances of and either (i) SCALE; is a specialization of #$NumericInterval (e.g. #$RealNumber) and the minimum (see #$minQuantValue) of VALUE1; is greater than or equal to the maximum (see #$maxQuantValue) of VALUE2;, (ii) (#$followingValueOnScale VALUE2 VALUE1 SCALE); holds, or (iii) (#$equals VALUE1 VALUE2); holds. See also #$greaterThan and #$lessThanOrEqualTo.

isGreaterThan
type: ObjectProperty
type: TransitiveProperty
comment: A #$NumericComparisonPredicate that is a generalization of the mathematical greater-than ( > ) relation to #$ScalarIntervals (q.v.) of all sorts, including quantitative intervals (see #$NumericInterval and #$MeasurableQuantity) as well as point values (see #$ScalarPointValue). (#$greaterThan VALUE1 VALUE2); means that VALUE1; is greater than VALUE2; with respect to some scale that they are both on. More precisely, there is some #$TotallyOrderedScalarIntervalType SCALE that both VALUE1; and VALUE2; are instances of and either (i) SCALE; is a specialization of #$NumericInterval (e.g. #$RealNumber) and the minimum (see #$minQuantValue) of VALUE1; is greater than the maximum (see #$maxQuantValue) of VALUE2; or (ii) (#$followingValueOnScale VALUE2 VALUE1 SCALE); holds.
sub property of: isGreaterThanOrEqualTo
domain: Quantity
range: Quantity
inverse of: isLessThan

PositiveInteger
type: Class
subclass of: NonnegativeInteger
subclass of: PositiveRealNumber
comment: An Integer that is greater than zero.

NegativeInteger
type: Class
comment: An Integer that is less than zero.
subclass of: NegativeRealNumber
subclass of: Integer
disjoint with: NonnegativeInteger

hasCardinalityNumber
type: DatatypeProperty
domain: Class
  union of: Group
  union of: Set
  union of: List
  union of: AbstractString
range: nonNegativeInteger
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 included explicitly, not only as a subtype of Group, because zero-length (zero-cardinality, considered as though it were an ordered group) strings may exist but zero-cardinality Groups are not permitted.

QuantityOfMoney
type: Class
subclass of: MeasurableQuantity
subclass of: QuantitativeAttributeValue
type: QuantitativeAttributeType
comment: A 'QuantityOfMoney' is any amount of money in any currency.

PluralThing
type: Class
subclass of: Group
type: GroupType
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' The name of subtypes of 'PluralThing' in COSMO may take the form of a plural of a count noun. But plurals of count nouns are also used to name 'CommodityProducts', so that usage is not a reliable indicator that a term represents a PluralThing. A 'PluralThing' is an Object, and a 'CommodityProduct' is a substance, so the two are disjoint concepts, in spite of the close relation. The 'CommodityProduct should only be used in the substance sense, and PluralThing for those things who individual members are the focus of representation. 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'.

hasRoleFiller
type: ObjectProperty
domain: Class
  union of: Role
  union of: RoleType
range: Class
  union of: Object
  union of: ObjectType
comment: Points from an instance of Role or a RoleType to the Object or ObjectType that fills that Role. Each instance of Role will always have a start and end point, though they may not be known. NOTE that this relation and its inverse can be used for individuals or types; in the latter case, it means that every Role of a particular type has a role filler of a particualr type - but if this is expressed directly as a relation rather than a restriction, it merely serves as an instruction to the reasoner not to instantiate the filler.
inverse of: fillsTheRoleOf

fillsTheRoleOf
type: ObjectProperty
comment: Inverse of 'hasRoleFiller' - points to a Role filled by some Object or ObjectType.
domain: Class
  union of: Object
  union of: ObjectType
range: Class
  union of: Role
  union of: RoleType

BiologicalAttributeValue
type: Class
subclass of: AttributeValue
type: AttributeValueType
comment: Some AttributeValue specific to Organisms. This is very general.

IntensiveAttributeValue
type: Class
subclass of: AttributeValue
type: IntensiveAttributeValueType
comment: Each 'IntensiveAttributeValue' is an AttributeValue that may be qualitative or quantitative, and expresses an intensity of some AttributeType. This is very general. Certain IntensiveAttributeValues may take both verbal intensive values (high'. 'medium', 'low'. and numerical values 'the drug is only 25% effective at preventing cancer'.

pertainsTo
type: ObjectProperty
comment: 'pertainsTo' relates an AttributeValue to some other type. This relation is used to relate AttributeValues that serve to represent adjectives to other types, so as to indicate that the word modified by the adjective is related to that other type in one of several direct ways. In dictionaries this relation is often expressed, in definitions of adjectives, by the phrase 'of or pertaining to'. In WordNet such adjectives are described as related to other words by the phrase 'pertains to'. For example, 'historical' pertains to 'history'.
domain: Class
  union of: QualitativeAttributeValue
  union of: AttributeValueType
range: Class

EventAttributeValue
type: Class
comment: An EventAttributeValue is an AttributeValue that specifically characterizes Events.
subclass of: QualitativeAttributeValue
type: AttributeValueType

PertainingAttributeValue
type: Class
comment: Each PertainingAttributeValue is an AttributeValue that is related to some other type by the relation 'pertainsTo'. The exact manner in which a 'PertainingAttributeValue' can be related to the object of the 'pertainsTo' relation can vary with the noun (often representing a type) that the adjective (represented by the PertainingAttributeValue) modifies. Thus an 'historical town' would be a town in which something of sufficient interest or significance occurred to justify the mention of the town in some history book; An American president will be some person who served as President of America (not just an American who was a President of some organization). The meanings of the individual 'pertaining' relations will vary with the word modified and the adjective modifying that word. .
subclass of: QualitativeAttributeValue
type: AttributeValueType
subclass of: Restriction
  on property: pertainsTo
  some values from: Class

isMoreIntenseThan
type: ObjectProperty
domain: IntensiveAttributeValueType
range: IntensiveAttributeValueType
comment: A transitive relation that allows the ordering of IntensiveAttributeValues, such as 'good' 'so-do' and 'Poor'.

BiologicalAttribute
type: Class
comment: Any AttributeType specific to Organisms.
type: AttributeTypeType
subclass of: AttributeType
takes value: BiologicalAttributeValue

DegreeOfIntensity
type: Class
subclass of: AttributeType
type: AttributeTypeType
comment: 'DegreeOfIntensity' is an AttributeType whose values express some 'IntensiveAttributeValue'.

Surface-Generic
type: Class
comment: A specialization of #$TwoOrHigherDimensionalThing and #$SpaceRegionLimit. This is the collection of all surfaces, tangible or intangible (see #$Surface-Physical and #$Surface-Intangible), of spatial things. Each instance of #$Surface-Generic is a spatial thing that has extent in at least two dimensions, and either has no thickness (i.e. is a purely two-dimensional object) or has an insignificant thickness compared to its length and width. (If it is a closed surface, e.g. an apple skin, then any significant subregion of it must have insignificant thickness compared to that subregion's length and width.) Thus a surface might be two- or three-dimensional; tangible or intangible; spatially connected or not; it might be flat, curved, folded, or crumpled. Other examples of surfaces are the skin of a basketball, the face-up side of a table top, and a particular face of an abstract cube. Other specializations of #$Surface-Generic are #$FlatSurface, #$Surface-Closed, and #$Surface-Open.
subclass of: TwoOrHigherDimensionalThing
subclass of: GenericLocation
type: LocationType

Surface-Open
type: Class
comment: A specialization of #$Surface-Generic (q.v.).This is the collection of open surfaces of (tangible or intangible) spatial objects. Each instance of #$Surface-Open has some boundary, such as an edge, perimeter, or hole. Examples include the top surface of a tabletop, the surface of a whiffle ball, a slightly cracked eggshell, and the skin of an apple with a bite taken from it. Non-examples are a basketball skin and an intact eggshell; cf. #$Surface-Closed. Note that 'hole' here is intended in its colloquial, human-scale sense, according to which (e.g.) a wiffle ball has holes but a baseball does not (even though at some fine-grained level the latter does have tiny holes).
subclass of: Surface-Generic

GeographicalRegion[Cyc-includes_other_planets]
type: Class
subclass of: GeographicalThing
subclass of: PhysicalSpaceRegion
subclass of: Surface-Open
comment: GeographicalRegion_Cyc-includes_other_planets In COSMO, this type includes any region on or near the surface of a planet, including the region that contains its atmosphere. But the usage here differs from that in Cyc, and this category is not a physical object. For physical objects at the surface of a planet, see 'PlanetarySurfaceObject'. Cyc comment: A specialization of #$GeographicalThing and #$Surface-Physical. Each instance of #$GeographicalRegion is a tangible spatial region that includes some piece of the surface of a planet (usually #$PlanetEarth), and may be represented on a map of the planet. This includes purely topographical regions like mountains and underwater spaces, places defined by demographics (e.g., language areas) and territory otherwise demarcated (e.g. #$TimeZones). In dualist geopolitical contexts [see #$DualistGeopoliticalMt], instances of #$GeopoliticalEntity are also considered to be instances of #$GeographicalRegion. In all cases the region in question must contain some tangible component with which it is possible to make physical contact. The instances of #$GeographicalRegion contrast in this respect with the instances of #$GeographicalThing-Intangible, which are wholly intangible. Examples of #$GeographicalRegion include #$RockyMountainStates-USRegion, the #$ContinentOfAustralia, #$SinaiPeninsula, and - in dualist geopolitical contexts - #$YaleUniversity and #$CityOfPittsburghPA. Some important types of regions are represented by the sub-collections #$LanguageArea, #$TimeZone, #$PostalCodeRegion, #$EcologicalRegion, #$ConstructionSite, and - in dualist geopolitical contexts -- #$GeopoliticalEntity. No instances of #$GeographicalRegion are wholly indoor locations.

GeographicalRegion
type: Class
comment: Each GeographicalRegion is a connected one-,two- or three-dimensional region of space located on or near the surface of some astronomical body, not necessarily the Earth. For 3-dimensonal regions specifically on the Earth, use 'GeographicalArea'. It is understood that the regions defined are stationary with respect to some coordinate system in which the astronomical object itself is considered to be stationary. The astronomical object itself (most commonly the Earth) will of course be rotating and moving through space, and those motions are ignored when the relative locations defined by 'GeographicalRegion' are used. A GeographicalRegion will include some portion of the space above the solid material that defines the region, and below the surface; at this point (v 0.44) we have not precisely specified how much of the space above or below the surface is included. COSMO note: this Cyc category is reinterpreted as representing only spatial regions - points, areas, or volumes, on or near the surface of some planetary body (to clearly specify the Earth, use the subtype 'GeographicalArea'), but this does not represent any of the physical objects that might exist in that region. The discussion of 'tangible' in the Cyc documentation below suggests the inclusion of physical objects, but that is not the intent of this COSMO cateegory. Though this category does not include any physical objects, one may use 'GeographicalObject' to specify all of the objects in any GeographicalRegion, if desired. Cyc: A specialization of #$GeographicalThing and #$Surface-Physical. Each instance of #$GeographicalRegion is a tangible spatial region that includes some piece of the surface of a planet (usually #$PlanetEarth), and may be represented on a map of the planet. This includes purely topographical regions like mountains and underwater spaces, places defined by demographics (e.g., language areas) and territory otherwise demarcated (e.g. #$TimeZones). In dualist geopolitical contexts [see #$D…
subclass of: PhysicalSpaceRegion
subclass of: GeographicalRegion[Cyc-includes_other_planets]

PopulatedPlace
type: Class
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. NOTE that this is a subtype of PhysicalSpaceRegion and is disjoint with Agent. This is a synonym for 'Settlement': 'Settlement' is a very general concept of some area that has people residing in it, the people in it recognizing the area as having an identity distinct from that of other areas. It can be very small or very large. This is similar to the notion of "Populated Place" used in geographical Databases. OCM thesaurus: the topic of 'Settlements' is described: General statements covering several specific aspects of the physical configuration and material facilities of settlements ranging in size and complexity from a temporary camp to a great metropolis. To distinguish early-stage settlements from more established ones, the term 'Settlement' is reserved for this general concept, and 'EarlySettlement' for an early-stage settlement.
subclass of: GeographicalRegion
subclass of: Place

Settlement
type: Class
comment: A synonym for 'PopulatedPlace' used in Geographical Information systems.
subclass of: Synonym
isa synonym of: PopulatedPlace

Feature
type: Class
comment: A Feature is an Object or Region within the ConvexHull of an Object. The Object may be abstract.
type: ObjectType
subclass of: Object
subclass of: Restriction
  on property: overlapsOrTouches
  some values from: Object

existsInContext
type: ObjectProperty
range: Context
comment: existsInContext is most useful to relate fictional, nythical, or hypothetical characters to the contexts in which they appear. It can be used to refer to the 'Real World', but that may be in most cases the default context that needs no explicit reference.

overlapsOrTouches
type: ObjectProperty
type: SymmetricProperty
comment: A general 'overlap' relation for both regions and objects, abstract and physical. In COSMO Objects are distinct from the regions that they occupy, but for the purpose of this relation, the 'overlap' can be viewed as the spatial overlap of the regions occupied by objects, or of that region with some other region. Regions that are in any way adjacent, with no space between other than a point, line, or infinitesimally thick plane, are considered as 'touching' for this relation. This relation is used to express the relation between a Feature of an Object and the Objec tht has that Feature. The Feature can be part of the Object (a protrusion) or a region within the ConvexHull of the Object (e.g. the hole in a doughnut). Such a region overlapsOrTouches the Object it is parasitic upon. In Cyc a similar 'overlaps' relation is labeled 'overlaps-RCC' (for regional Connection Calulus). But that is for regions only, and differs from this COSMO relation. Cyc: (#$overlaps-RCC REG1 REG2) means that REG1 overlaps REG2, i.e., REG1 and REG2 have a common part. The three immediate specialization of #$overlaps-RCC are #$partiallyOverlaps-RCC, #$partOf-RCC and #$partOf-Inverse-RCC. Note that this relation is a #$negationPreds of #$externallyConnectsWith-RCC, compare also with #$discreteFrom-RCC.
domain: Class
  union of: Region
  union of: Object
  union of: ObjectType
range: Class
  union of: Region
  union of: Object
  union of: ObjectType

TwoArgumentValue
type: Class
type: AttributeValueType
subclass of: AttributeValue
comment: Each 'TwoArgumentValue' is an AttributeValue that specifies the two argument values for an instance of a CompactedTernaryRelation. This is a mechanism to reresent ternary relations in the binary relation format of OWL.. Each instance of 'TwoArgumentValue' will have relations pointing to the two arguments that make up the ternary assertion that is represented.

isaSynonymOf
type: ObjectProperty
type: SymmetricProperty
domain: Class
range: Class
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 synonyms, use 'hasSynonym'.

wasCreatedBySoleAgent
type: ObjectProperty
sub property of: wasCreatedBy
domain: Artifact-Generic
range: Class
  union of: GenericAgent
  union of: AbstractString
comment: wasCreatedBySoleAgent relates an Artifact (concrete or abstract) to the individual Agent who created it. The Agent may be a Group, but there will be only one value for this relation, and to fill that value means that one knows the identity of all of the agents who participated enough in the creation to be called creators. This is not necessarily the same as an autor of record for a textual work, where ghost writers may get no credit. This is the real creator.

isaPartOf
type: ObjectProperty
domain: Class
  union of: SpatialThing
  union of: Object
  union of: GenericAgent
  union of: Group
  union of: Event
  union of: SubstanceType
  union of: EventType
  union of: ObjectType
range: Class
  union of: SpatialThing
  union of: Object
  union of: GenericAgent
  union of: Group
  union of: Event
  union of: SubstanceType
  union of: EventType
  union of: ObjectType
inverse of: hasPart
comment: isaPartOf is a very general 'part' relation applicable to spatial regions or objects in some space. This relation has no axioms associated with it because it is only an 'umbrella' relation that gathers together other relations having different meaning, so as to provide an anchor point for the ambiguous linguistic notion of 'part' It cannot be transitive, because it subsumes the relation of a member to the group, which is not transitive. But some of its subrelations are transitive. NOTE that to say that something is a part of something else - or inversely, that something has a part - can present issues of implementation and some nuances of interpretation. Regarding implementation, if one asserts that every object ?O of type ?T has a part of type ?P, then for each individual of the ?T type it follows that some part of type ?P must exist. Then the reasoner must be instructed what to do if there is no individual of type ?P that is specifically asserted to be a part of object ?O. One option is to refuse to accept data asserting exstence of object ?O because no part is instantiated. Another option is to automatically instantiate *every* implied part - this can be done in a FOL reasoner by 'Skolemization' - creating a Skolem function that returns the individual. One may want alternative options - to be able to assert a necessary part relation, but *not* to create a Skolem individual if the part itself is not also asserted. In interpretation, it will be necessary to decide whether, for a type ?T that has necessary parts, whether the parts must be in place for an instane of type ?T to exist. If a musical instrument is borken down into its parts in a carrying case, is there a musical instrument in the case, or doe the instrument only exist when it is assembed and functional? These issues are not decided in COSMO, but the 'part' relations can be asserted at the individual or type level, and the proper interpretation of such relations will need to be determined before an implem…

hasPart
type: ObjectProperty
domain: Class
  union of: SpatialThing
  union of: Object
  union of: GenericAgent
  union of: Group
  union of: Event
  union of: SubstanceType
  union of: EventType
  union of: ObjectType
range: Class
  union of: SpatialThing
  union of: Object
  union of: GenericAgent
  union of: Group
  union of: Event
  union of: SubstanceType
  union of: EventType
  union of: ObjectType
inverse of: isaPartOf
comment: the inverse of 'isaPartOf', a very general relation applicable to spatial regions, events, or objects in some space.

hasApproximateShape
type: ObjectProperty
sub property of: hasAttributeValue
domain: Class
  union of: PhysicalObjectType
  union of: SubstanceType
  union of: PhysicalSubstance
  union of: SubstanceShapeType
  union of: PhysicalObject
  union of: ObjectType
  union of: GeometricFigure
  union of: RegionType
  union of: Region
  union of: phenomenon[DOLCE?no_actor_involved]
range: ShapeType
comment: 'hasApproximateShape' relates abstract figures, substances, substance types, or individual objects to one or more shapes (subtypes of 'ShapeAttribute') that **approximately** describe the spatial form of that entity. The subproperty ''hasShape'' can be used for things that are perceptually close to the reference shape type, even if not geometrically identical. For abstract geometric figures, the shape may be precise, with infinitely precise edges. Using this replation rather than the subproperty ''hasShape'' suggests that the shape is only very roughly similar to the shape type referenced.

phenomenon[DOLCE?no_actor_involved]
type: Class
comment: A phenomenon is basically an Event that does not include any intentional active participation. Therefore it is disjoint with 'Action'. Natural events that are not caused by the action of an animal will be subtypes of this category. DOLCE (phenomenon) Therefore, it cannot be sequenced by a task. It can be seen as an accomplishment when some intentionality puts boundaries on it (although it is not claimed to be inherently intentional). On the other hand, a purely physical phenomenon does not seem to have inherent boundaries either ... and also for biological processes as well as economic processes this seems to be disputable. If the boundary hypothesis is discarded, phenomenon should migrate under process.
subclass of: Event
type: EventType
disjoint with: Action

hasShape
type: ObjectProperty
sub property of: hasApproximateShape
domain: Class
  union of: PhysicalObjectType
  union of: SubstanceType
  union of: PhysicalSubstance
  union of: SubstanceShapeType
  union of: PhysicalObject
  union of: ObjectType
  union of: GeometricFigure
  union of: RegionType
  union of: Region
  union of: phenomenon[DOLCE?no_actor_involved]
range: ShapeType
inverse of: isTheShapeOfa
comment: 'hasShape' relates abstract figures, substances, substance types, or individual objects to one or more shapes (subtypes of 'ShapeAttribute' that describe the spatial form of that entity. When applied to substances, the shape description (e.g. 'lumpy') will be interpreted as a description of objects (quantities of substance) that are composed predominantly of that substance. For abstract geometric figures, the shape may be precise, with infinitely precise edges. For real-world objects, the shape will be only approximate, and in some cases very approximate.

isTheShapeOfa
type: ObjectProperty
comment: Inverse of ''hasShape''.
inverse of: hasShape

Action
type: Class
comment: An Event in which some Agent plays a causative role. NOTE that an Agent may cause an action indirectly and with a time delay, via some device - and that action, controlled largely by the device, is still considered as an Action of that Agent in COSMO. This means that the 'action' set in motion by an Agent may continue even after the death of the Agent. Thus, the fire in an oil burner, being controlled by the Agent that controls the oil burner, is considered as an Action here, even though the burner continues for a long time automatically. The Action in such cases of indirect and delayed effects extends from the time at which the Agent started the action until the end of the time when the predictable immediate consequences occur. At some point it will probably be worthwhile distinguishing the Action of setting a Device from the Events controlled by the device, but as of v0.43 that distinction is not encoded. For Actions directly including only the immediate motion of an animal and its direct, almost simultaneous consequences, use 'AnimalActivity'. NOTE that a MentalEvent such as a feeling or Emotion is also considered an Action,as it is performed by a CognitiveAgent. In different ontologies, the same notion has different names: Action(Cyc) IntentionalProcess (SUMO) action(DOLCE) Activity(ISO15926). NOTE: in COSMO we classify an 'Experience' as a subtype of 'Action' to indicate that the focus of the subject is an Agent, even though no Events external to the Agent may be caused by the Experience. Cyc comment: The collection of #$Events (q.v.) that are carried out by some doer (see #$doneBy). Instances of #$Action include any event in which one or more actors effect some change in the (tangible or intangible) state of the world, typically by an expenditure of effort or energy. Note that it is not required that any tangible object be moved, changed, produced, or destroyed for an action to occur; the effects of an action might be intangible (such as a change in a bank bal…
subclass of: Event
type: ActionType
disjoint with: phenomenon[DOLCE?no_actor_involved]

Activity
type: Class
comment: A common term, also used in ISO15926, for 'Action'.
subclass of: Synonym
isa synonym of: Action

String-EntityRelation
type: Class
subclass of: ObjectProperty
comment: Each instance of String-Entity relation is an ObjectProperty that can be translated into a String type attribute when converting from an OWL ontology to a schema, UML model, or other representation that uses String datatypes to refer to property values that are best represented as first-class entities in an ontology. This OWL Property type is specifically designed to assist translation of ontologies into other formats.

dbMappedRelation
type: Class
subclass of: ObjectProperty
comment: Each instance of 'dbMappedRelation' is a OWL Property that can be mapped to one or more columns in a database when using an OWL ontology to access conceptual information from one or more database tables.

CompactedTernaryRelation
type: Class
subclass of: ObjectProperty
comment: Each instance of 'CompactedTernaryRelation' is a OWL Property that could be represented by a ternary relation in an FOL format, but has been compacted to fit into the binary relation format of OWL. The range of these relations will be instances of a type that specifies the two arguments that are folded into a single argument to fit into an OWL relation.

ExistentialRelation
type: Class
subclass of: ObjectProperty
comment: Each instance of 'ExistentialRelation' is a relation between types of entities, rather than between instances of entities; a relation is specified as being of the type 'ExistentialRelation' when the intended meaning is that every instance of the subject is related to *some* instance of the object. This meaning could also be expressed by an OWL restriction using 'someValuesFrom'; however, the OWL restriction will be interpeted logically as being an inconsistency if no instance satisfying that relation is present in the ontology for every instance of the subject. It may not be necessary or desirable to create instances of the object every time an instance of the subject of a relation is created - and yet, we will want the reasoner to know, when it needs to, that some instance of the object type must exist. This formalism is adopted to allow an explicit assertion within the ontology that certain instances are implied by others, but to allow the reasoner to ignore that information unless it is required. So relations between types that imply the existence of an instance of the object for every instance of the subject will be made instances of 'ExistentialRelation'. Use of such information will require an FOL reasoner, but COSMO is intended to represent all information in the OWL format, in such a way tat it can be converted to an FOL format for more detailed reasoning. Whether and how this represented information will be used will be up to the implementation. The task of the ontology is to represent that information, and this provides a means to do so without overburdening the reasoner. There will also be relations between types (as for example subclasses of PhysicalSubstance or of AttributeValue) for which there is no implication of the existence of instances of the object type. These relations will not be instances of 'ExistentialRelation'.

dbMappedDataRelation
type: Class
subclass of: DatatypeProperty
comment: Each instance of 'dbMappedDataRelation' is a OWL Property that can be mapped to some datatype column in a database when using an OWL ontology to access conceptual information from one or more database tables.

consistsMostlyOfSubstance
type: ObjectProperty
domain: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
range: SubstanceType
sub property of: hasConstituentSubstance
comment: consistsMostlyOfSubstance relates physical objects or physical object types that have a relatively homogeneous spatial distribution of component substances to the substance(s) which form the dominant composition. If the component substance does not form a larger weight fraction than any other substance, the relation 'hasConstituentSubstance' should be used instead. Thus a drinking glass will be composed of glass, a lake of water, a structural I-beam of steel. In Cyc the 'substances' (or stuffs) were represented as objects made of a particular substance. In COSMO we distinguish the object from its composition, and this relation specifies, where it makes sense to do so, what the substance composition of particular objects is.

hasColor
type: ObjectProperty
sub property of: hasAttributeValue
range: ColorAttributeType
domain: Class
  union of: AbstractSymbol
  union of: PhysicalObject
  union of: PhysicalSubstance
  union of: SubstanceType
comment: hasColor relates abstract symbols (abstract representations of things), substances, substance types, or individual objects to one or more colors that characterize the way that light is reflected from or passes through the object. For real-world objects, the color value will be a color region, which could be further restricted to a more specific color, down to a monochromatic color of specific saturation and intensity. The colors are represented as Types.

SolidObject
type: Class
subclass of: PhysicalObject
type: PhysicalObjectType
comment: A SolidObject is a PhysicalObject that retains its shape with less than 30% distortion in any one dimension when placed on a surface in air *or in water* in Earth's gravitational field. This means that reasonably solid but compressible gels qualify as SolidObjects. For objects that are less distortable than gels, use 'RigidObject'. NOTE that a SolidObject does not have to be rigid. All Organisms are SolidObjects, even jellyfish. To be solid, and object may distort, but cannot flow as a liquid or disperse as a gas.

ObjectConsistingOfSubstance
type: Class
subclass of: PhysicalObject
type: PhysicalObjectType
comment: Eacj 'ObjectConsistingOfSubstance' is a PhysicalObject that is characterized, among other things, by the substance of which it consists.
subclass of: Restriction
  on property: consistsMostlyOfSubstance
  some values from: SubstanceType

DynamicObject
type: Class
subclass of: PhysicalObject
type: PhysicalObjectType
comment: A DynamicObject is a PhysicalObject for which the internal movement of the whole or some part is an essential characteristic of its identity. A tornado, a whirlpool, or a dust devil are examples. This does not include microscopic movements such as biological processes, therefore living things are not instances. NOTE that simple linear moving things like currents are represented as FunctionalProcesses, even though they have some of the character of a DynamicObject. A current of water is not an instance of DynamicObject. This distinction is not entirely arbitrary; a linear current has a flow rate as one of its salient characteristics, and that is representd as a time derivative, which is one salient characteristic of a FunctionalProcess. A DynamicObject will exhibit salient characteristics beyond a simple linear flow, as in the case of a tornado which moves up, down, and sideways as well as in a circle.

Dry
type: Class
comment: Dry is an attribute of objects and substances that do not lose enough liquid by vaporization on standing in an open space so as to cause a significant change in their properties. This is an Attribute that can be used to reason about the likely stability of an Object or substance on standing in the open..
type: QualitativeAttributeType
subclass of: QualitativeAttributeValue
is the opposite of: Moist

Moist
type: Class
comment: A quality of substances or objects that have water either interspersed within it or on the surface.
type: QualitativeAttributeType
subclass of: QualitativeAttributeValue
is the opposite of: Dry

DryObject
type: Class
comment: A DryObject is a SolidObject that does not have a significant content of a liquid that may volatilize so as to significantly change the weight (by more than 10%) or rigidity or functionality after standing in an open space for some time. The category is determined by the moisture contnet considered as such at the time it was created. RigidObjects that have some surface mosture are still DryObjects. This type is created to allow a reasoner to infer some commonsense information about the consequences of aging of an object. The disjoint alternative is 'MoistObject', which includes objects such as animals and some foods, which change substantially when left in a place where the water content can evaporate without replacement. NOTE that this type applies to types that were dry when they were created: an Organism is a MoiopstObject, but when it reaches the stage where it is a dry skeleton, it becomes a physically dry object, but is still an instance of MoistObject. This type represents a property that is relevant to stability, not necessarily representing the physical character throughout a lifetime.
type: PhysicalObjectType
subclass of: SolidObject
disjoint with: MoistObject
subclass of: Restriction
  on property: hasQualitativeAttribute
  has value: Dry

MoistObject
type: Class
comment: A MoistObject is a SolidObject that has a significant content of a liquid that may volatilize so as to significantly change the weight (by more than 10%) or rigidity or functionality after standing in an open space for some time. This criterion is applied in reference to the state of the object at the time it was created. A MoistObject that has dried out may still be an instance of the type MoistObject. This type represents a property that is relevant to stability, not necessarily representing the physical character throughout a lifetime. This type is created to allow a reasoner to infer some commonsense information about the consequences of aging of an object. The disjoint alternative is 'DryObject', which includes all RigidObjects and objects such as sheets of metal or cloth, which are more stable to standing in an open space than a MoistObject would be. Examples of moist objects would be an organism, fresh bread or cake, or .
type: PhysicalObjectType
subclass of: SolidObject
disjoint with: DryObject
subclass of: Restriction
  on property: hasQualitativeAttribute
  has value: Moist

AgentiveObject
type: Class
comment: An AgentiveObject is a PhysicalObject that can cause changes to other objects. This class contains subclasses that have the capacity to act as agents, i.e. to cause changes in the real world; but this general class of agents do not have to have intentions or form plans.. People are the Agents that are typically of greatest interest. But Tornadoes, hurricanes, tsunamis, volcanoes, etc. can behave a agents in that they cause external events due to their internal processes. All of these agentic objects are included in this category, but Organizations, which are classified as MentalObjects in this ontology, are in a separate agentive category.
subclass of: GenericAgent
subclass of: PhysicalObject
type: AgentType
type: PhysicalObjectType

LifeForm
type: Class
subclass of: AgentiveObject
subclass of: SolidObject
subclass of: OrganicObject
comment: Life Form is very general catgory of organic objects tht can reproduce themselves in a manner resembling the reproduction of animals and plants, and includes intact organisms, viruses, and prions. A part of an organism is not a life form in itself. NOTE that artificial life forms that are not organic (e.g. robots) are not included in this category. NOTE also that 'LifeForm' is not disjoint with 'InanimateThing' though 'Organism' is. This is because some primitive life forms, like some viruses, can occur in crystalline form (while still being viable), and we have categorized crystals as inanimate. The border between living and non-living at the subcellular level is fuzzy, and in COSMO (rev639) we are still trying to find the proper distinctions.

SpatiallyContinuousThing
type: Class
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.
subclass of: SpatialThing

MineralObject
type: Class
comment: A specialization of #$InanimateThing-Natural. Each instance of #$Mineral is a piece of homogeneous inorganic physical substance that has a crystalline structure. Specializations of #$Mineral include the collections #$Diamond, #$Turquoise-Gem, #$Jade-Gem, and #$Corundum.
subclass of: CrystallineObject
type: PhysicalObjectType
subclass of: Restriction
  has value: Crystalline
  on property: hasQualitativeAttribute
subclass of: Restriction
  on property: consistsMostlyOfSubstance
  has value: Mineral

InorganicMaterial
type: Class
comment: COSMO note: In COSMO, this is a substance, not an object. There are some inorganic materials, such as carbon dioxide and carbon tetrachloride, that contain carbon. So carbon content is not the only criterion to distinguish organic from inorganic substances. Cyc: A specialization of #$InanimateThing. Each instance of #$InorganicMaterial is a tangible thing wholly composed of one or more types of inorganic molecule. Instances of #$InorganicMaterial usually didn't originate as parts or products of living things. Notable specializations of #$InorganicMaterial include #$Mineral, #$Metal, and #$Glass.
subclass of: PhysicalSubstance

Mineral
type: Class
comment: A PhysicalSubstance that is in a solid and usually crystalline form, and inorganic (possibly except for some small amount of included organic material), In COSMO this is a Substance, not an Object, whereas the Cyc term is an Object. This is the solid substance: when molten it is not considered 'Mineral' in COSMO. Cyc: A specialization of #$InanimateThing-Natural. Each instance of #$Mineral is a piece of homogeneous inorganic physical substance that has a crystalline structure. Specializations of #$Mineral include the collections #$Diamond, #$Turquoise-Gem, #$Jade-Gem, and #$Corundum. SUMO: Any of various naturally occurring homogeneous substances (such as stone, coal, salt, sulfur, sand, petroleum), or synthetic substances having the chemical composition and crystalline form and properties of a naturally occurring mineral.
subclass of: InorganicMaterial
subclass of: SolidSubstance
type: SubstanceType
subclass of: Restriction
  has value: Crystalline
  on property: hasQualitativeAttribute

ExanimateThing
type: Class
comment: An important specialization of #$InanimateThing. Each instance of #$ExanimateThing is an individual that is typically regarded as truly inanimate, or non-agentive in the sense that it is utterly incapable of any subjective or mental experience.
subclass of: InanimateThing

MicroscopicScaleObject
type: Class
comment: COSMO note: in COSMO, a SubatomicParticle is not an instance of this type. This type partly overlaps with 'Particle' - the distinction is not resolved as of v0.54. This should be used for objects down to atom-sized. Cyc: A specialization of #$PartiallyTangible. Each instance of #$MicroscopicScaleObject is a partially tangible object which is so small that human beings cannot perceive it, except (perhaps) with the use of special devices such as #$Microscopes or #$ElectronMicroscopes. Specializations of #$MicroscopicScaleObject include #$Molecule, #$Atom, #$SubAtomicParticle, #$Chloroplast, and #$Mitochondrion.
type: PhysicalObjectType
subclass of: PhysicalObject

ChemicalObject
type: Class
comment: A specialization of #$MicroscopicScaleObject. Each instance of #$ChemicalObject is an object whose behavior is typically described in terms of its outer cloud of #$Electrons. Specializations of #$ChemicalObject include the collections #$Atom, #$Molecule, and #$Ion.
subclass of: ExanimateThing
subclass of: MicroscopicScaleObject
type: PhysicalObjectType

Atom
type: Class
comment: A specialization of #$ChemicalObject. Each instance of #$Atom is a microscopic-scale object with exactly one atomic nucleus (see #$AtomicNucleus) and some number of electrons (see #$Electron). A typical instance of #$Atom has no net charge, i.e., it has as many instances of #$Electron as it does of #$Proton. For the collection of atoms that do have non-zero charges, see #$MonoatomicIon.
type: PhysicalObjectType
subclass of: ChemicalObject

ChemicalElement
type: Class
comment: A substance which is a chemical element, for which the unit is an atom; each atom of a ChemicalElement has the same number of protons in its nucleus. In Cyc called 'ElementStuff' Cyc: An instance of #$TangibleStuffCompositionType and a specialization of #$InanimateThing. Each instance of #$ElementStuff is a piece of tangible stuff, composed of a quantity of atoms, all of which are of the same chemical element. That is, every atom in a given piece of #$ElementStuff has the same number of protons in its atomic nucleus. For example, all pieces of carbon (i.e. all instances of #$Carbon) are instances of #$ElementStuff. On the other hand, instances of #$Water, because they are all constituted of both #$Hydrogen and #$Oxygen atoms, do not belong to the collection #$ElementStuff.
subclass of: PhysicalSubstance
type: SubstanceType
has unit object: Atom

DosageFormType
type: Class
comment: COSMO note: In Cyc, where there was no taxonomic distinction between substances and objects, this metatype was used to label both substances (in some particular form) and objects. In COSMO, this is used as a parent class for certain substances having particular forms. These categories can serve as ?X in the phrase 'given as an ?X' in pharmacy descriptions. Cyc comment: Drug products organized according to their form when they are given as doses.
subclass of: ExistingStuffType

ColorAttribute
type: Class
comment: Each class of a ColorAttribute forms a region with more specific classes of ColorAttribute forming subregions..
subclass of: QualitativeAttributeValue
type: QualitativeAttributeType

hasProtonCount
type: DatatypeProperty
comment: hasProtonCount relates a chemical element to the number of protons in each atomic nucleus of that element. This is very specifically a chemistry/physics concept. NOTE that the domain is ElementType because elements are represented as types (classes), not instances. This representation permits element isotopes to be subtypes of each element.
domain: ElementType
range: int

isNearTo
type: SymmetricProperty
type: ObjectProperty
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..
domain: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation
range: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation

isLocatedAtOrOn
type: ObjectProperty
sub property of: isNearTo
domain: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation
range: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation
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 located within the spatial region coextensive with the ConvexHull 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..

isLocatedAt
type: TransitiveProperty
type: ObjectProperty
sub property of: isLocatedAtOrOn
domain: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation
range: Class
  union of: PhysicalObjectType
  union of: PhysicalObject
  union of: GenericLocation
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 ConvexHull of the Object; therefore a Hole in an Object, which contains no part of the Object 'isLocatedAt' that Object. Also, 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' that 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 one 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 instances of a disease 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 space-time) in the object position of the relation, to specify the location of some t…

Capability
type: Class
subclass of: AttributeValue
type: CapabilityType
comment: COSMO: a Capability is an attribute of some physical object or PhysicalSubstance that specifies some role that that object or substance may play in events or processes. This is a very broad concept, including participation in actions and passive processes. In general, it is not necessary or desirable to list all the roles that an object may play, as in many cases those roles may be very numerous. This 'attribute' would be used rather to indicate the more salient roles that an object can play. For example, a Person who has a particular talent or skill could have that skill specified (e.g. 'AbilityToDanceTheTango'); a company that can make a particular product would have that capability specified (e.g. 'AbilityToManufactureWidgets'). For people, Capabilities to do specific actions often come in a wide range of degrees of expertise. Another important 'Capability' is categorized under the subtype 'Tendency', which specifies the way that an object is likely to behave; the tendency of non-living organic material to decompose when not frozen is an example of such a tendency. See 'Tendency' for additional discussion of that subtype. NOTE that to have a Capability does not mean that it is possible for the agent to perform that action at any time, or even that the agent has performed that action. There may be motivational inhibitions or blocking conditions that prevent an agent from exercising a Capability at any given time and place. Each CapabilityType represents the ability to serve in some Role in some type of Action or Event. The RoleType and ActionType are specified by the relations 'isAbilityToServeInRole' and 'isAbilityToServeInActionType', repsectively. For any given Capability Type, the Roles and ActionTypes specified are interpreted to mean that the entity having that capability can serve in any of those Roles, in any of those Actions. **But** is is understood that for any given situation, there may be circumstances that prevent the Agent or Object from serving in …

DesignFunction
type: Class
subclass of: Capability
type: CapabilityType
comment: A DesignFunction is the ability to do something or to enable doing something by acting as an instrument. This notion encompasses two different roles in an Event, and is therefore an aggregate concept that is high-level in COSMO. Its subtypes will be Events which may be Actions (doing something) or merely non-active participations (being an instrument). This is the function that an artifact is designed to perform, when it is designed to perform a function, or the function that an evolved part of an organism is designed to perform, by evolution.

SituationRole
type: Class
subclass of: Role
subclass of: SituationProcessEventOrState
comment: SituationRole is a compound Type representing both a Situation and a Role. This category was created specifically to allow an inherently Ternary relation (the Cyc intendedPrimaryFunction) to be represented as binary. it will include a Situation and a Role which specifies the function of an Object in that Situation. ToDO - to be useful, the structure of this Type needs elaboration.

hasDesignFunction
type: ObjectProperty
comment: See also intendedPrimaryFunction - should be merged?? This relation is not functional - there may be more than one design function, especially for natural organic objects. This specifies the Action part of SituationRole, where the Situation is an Action. An axiom should relate them. hasDesignFunction relates a PhysicalObject or Substance (usually an artifact, but could be an organic object, as part of an organism)) or a System (i.e. something created for a purpose, which may be a natural biological System) to the action(s) that it is intended to perform, or can help perform. This relation answers the questions 'what is it good for?' or 'What does it do?'. A similar relation, ''isUsedToMake'' can point from an Object that is used as a instrument in the preparation or manufacture of some Object or Substance. Individual PhysicalObjects that are not artifacts are **not** included in the domain of this relation. For natural objects that have a function (e.g. biological), only the type of object, not the individual object, can serve as the subject of this relation. Note that this is close to but not identical to the relation 'enablesOrAssists' for resources. The distinction is threefold: (1) resources do not have to be artifacts; (2) each artifact is classified by its design (intended) function, but it may actually not be useful for that purpose; (3) an Artifact may enable or assist actions that it was not designed to be used for. NOTE: For things such as objects, devices, or substances that can enable actions but are not artifacts with that action as a DesignFunction, use ''isUsedAsInstrumentInAction''(includes substances) or ''canServeAsInstrumentInActionType'' (PhysicalObjects only). ***************** CAUTION ********************************* **NOTE** This relation points to an ActionType or EventType. There are instances of ActionType that are subtypes of Action, but also there are Types that are subtypes of 'DesignFunction' which are also instances of ActionType, but…
domain: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: PhysicalSubstance
  union of: SubstanceType
range: Class
  union of: DesignFunction
  union of: SituationRole
  union of: CapabilityType
  union of: EventType
inverse of: isaDesignFunctionOf

ObjectGroup
type: Class
comment: A Group consisting exclusively of PhysicalObjects. One may consider the collection of disjoint parts of a physical object as a Group, but in doing so one must ignore the relations among the objects, so the ObjectGroup consisting of the parts of a connected PhysicalObject is not identical to the whole object itself. In SUMO, this is called a 'Collection'. NO identical Cyc class seems to be defined. SUMO: Collections have members like Classes, but, unlike Classes, they have a position in space-time and members can be added and subtracted without thereby changing the identity of the Collection. Some examples are toolkits, football teams, and flocks of sheep.
subclass of: Group
type: GroupType
subclass of: PhysicalObject
subclass of: Restriction
  on property: hasComponentElement
  all values from: PhysicalObject

containsObjects
type: ObjectProperty
sub property of: contains
range: Class
  union of: ObjectGroup
  union of: System
  union of: GroupType
comment: containsObjects is a specialization of 'contains' that points to an ObjectGroup that is contained in some aggregate entity or region. This relation allows the definition of some Group of PhysicalObjects and relating it to another entity where that group is 'contained' in some sense, without being part of the containing thing. A System can contain other Systems (which contain objects), so the range includes System

System
type: Class
comment: A System consist of a group of two or more physical objects that are designed (by people or evolution) to work together to perform some function, plus the AttributeValues attached to those objects, and the relations among those objects - the attributes and relations are component elements of the Group, thus distinguishing a System from a simple group of Objects. There is therefore some significant relation between any Object in a System and some other Object in the System. The System is an aggregate consisting not only of the Objects, but also of the relations between them. This is the basic Entity that participates in Situations. The Attributes of the System as a whole are not component elements of the Group that comprise the system. A PersistentState of a System may include any subset of the Group of Attributes and Relations that are part of the System, and possibly some relations of the System as a whole to its external environment (e.g. orientation). NOTE: In Cyc something as simple as a shield or TurtleShell can qualify as a 'System' so the requirement for two objects may need to be taken liberally: a shield needs a handle to function, so the handle and plate of the shield can qualify as the two objects. Usually a System has several distinct Objects that interact in some way beyond merely being attached to each other. @@ToDo: Although this generic notion of System is not a PhysicalObject, it can have PhysicalObjects as subypes and instances. Representing a particular PhysicalObject or type of Object as a System is to assert a view of the PhysicalObject as something functional, and to provide a formal mechanism for discussing the structure and states of the System. The restriction that requires specifying an 'ObjectGroup' (or GroupType) will force the ontologist to specify at least some of the components of a System - the ObjectGroup specified should but does not have to include all of the Objects that characterize the System; therefore one may specify that an O…
subclass of: CompositeConcept
type: PhysicalObjectType
subclass of: Restriction
  on property: containsObjects
  some values from: Class
    union of: ObjectGroup
    union of: GroupType
subclass of: Restriction
  on property: hasDesignFunction
  some values from: CapabilityType

isInsideOf
type: ObjectProperty
sub property of: isLocatedAt
domain: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: SubstanceType
  union of: PhysicalSubstance
range: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: System
  union of: Region
  union of: Place
  union of: SubstanceType
comment: 'isInsideOf' is a specialization of 'isLocatedAt' specifying that the subject is located within the Region defined by the outer limits of the containing Object or Region. This includes the notions of being a physical part of something, and being contained inside a container, as well as being within some spatial reagion. Those individual senses are subrelations of this relation. This relation also includes the sense of one substance being contained in another; even though that sense is already represented by 'hasComponentSubstance', the notion of 'inside' can include the notion of being part of a mixture, so it is included here as a way to relate these general notions.
ldoce: inside
wordnet: inside
wnsense: inside2adv

contains
type: ObjectProperty
domain: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: System
  union of: Region
  union of: Place
  union of: SubstanceType
range: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: SubstanceType
  union of: PhysicalSubstance
inverse of: isContainedIn
comment: contains is a very general relation that specifies that some PhysicalObject or PhysicalSubstance.is contained, in some way, in the subject entity. The subject entity does not have to be a Container. For the 'containment' relation between AbstractSymbolicObject's (texts, documents, strings) use 'containsSymbolicObject' or its inverse 'isContainedInSymbolicObject'. @ToDo: needs review for relationship to substance containment (substances may not be needed here). This may be too hetereogeneous. NOTE that a Region of space can also 'contain' something. NOTE that this differs from 'isLocatedAt' in that the containment relation requires that the thing contained is not a part of the containing thing. Thus one PhysicalObject can contain another PhysicalObject only if the containing PhysicalObject has a cavity of some kind. This restriction does not hold for the general 'isLocatedAt' relation. However, 'contains' does not include Events as either subject or object. For Events, use 'occurredAt'. As a generic 'contains' relation, this relation will also include the 'containment' of Substances by PhysicalObjects. The relation on Substances is more properly handled by the specific substance relations 'hasConstituentSubstance' and 'containsSubstance' This 'contains' relation is more generic, to accommodate the ambiguous linguistic 'contains' assertion, to provide a direct conceptual definition of that notion. OBO_REL: 'contains' is similar to this relation, but has some differences OBO documentation for OBO rel 'contained_in': OBO Definition: C contained_in 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 located_in c' at t, and it is not the case that c *overlaps* c' at t. (c' is a conduit or cavity.) OBO Comments: Containment obtains in each case between material and immaterial continuants, for instance: lung contained_in thoracic cavity; bladder contained_in pelvic cavity. Hence containment …

isContainedIn
type: ObjectProperty
sub property of: isInsideOf
domain: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: SubstanceType
  union of: PhysicalSubstance
range: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: System
  union of: Region
  union of: Place
  union of: SubstanceType
comment: 'isContainedIn' is the inverse of 'contains' and expresses a very general notion of some physical entity being 'contained' in some way in something else. This does not apply to abstract entities - see 'isContainedInSymbolicObject'. Although this relation implies that the contained thing 'isLocatedAtOrOn' the containing thing, this cannot be a subproperrty because substances are included in this relation. This generic location relation only specifies that the thing contained is somewhere either (1) within the convex hull of the containing thing, or (2) piled on or resting in an open-top container, being held in place by the force of gravity. Things that are contained in a container must move in synchronization with the container when the container is moved. Thus a flower in a vase, that extends above the top of the vase, 'isContainedIn' the vase. NOTE: the case of something that is partly in an object, extending beyond the limits of the object, but held to the object by some topological constraint is not included in this relation. That relation would be subsumed by 'isConnectedTo'.
ldoce: inside
wordnet: inside
wnsense: inside2adv

hasConstituentSubstance
type: ObjectProperty
sub property of: contains
sub property of: hasPart
domain: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: Region
  union of: Place
range: SubstanceType
inverse of: isaConstituentSubstanceOf
comment: hasConstituentSubstance relates physical objects or regions to the substance(s) which form some part of the composition of the object or region. The component substance pointed to in this relation does not have to be the main component, and the object does not have to have a uniform distribution of substance types. If the component substance does form a larger weight fraction than any other substance, the relation 'consistsMostlyOfSubstance' should be used instead. One could say that a {shovel hasConstituentSubstance Steel}, even if the handle is wooden. We can use a relation which also specifies the actual weight fraction of each substance, but such a relation would be ternary, and cannot be directly supported as an OWL 'property'. NOTE that In Cyc the 'substances' (or stuffs) were represented as objects made of a particular substance. In COSMO we distinguish the object from its composition, and this relation specifies, where it makes sense to do so, what the substance compostion of particular objects is. NOTE that this relation is a subProperty of the generic 'hasPart' relation. The 'hasPart' relation has no implications, and is used only as an umbrella to collect all the 'part' relations that may ber used in language. The notion of a substance being a 'part' of an object may be the least common use of 'part', but it is found, and this subproperty relation allows it to be used in this ontology.

isaConstituentSubstanceOf
type: ObjectProperty
sub property of: isContainedIn
sub property of: isaPartOf
domain: SubstanceType
range: Class
  union of: PhysicalObject
  union of: PhysicalObjectType
  union of: Region
  union of: Place
comment: The inverse of 'hasConstituentSubstance'.
inverse of: hasConstituentSubstance

Carbon
type: Class
comment: The element with six protons in each nucleus.
type: ElementType
subclass of: ChemicalElement
has proton count: 6

Oxygen
type: Class
comment: The element with eight protons in each nucleus.
type: ElementType
subclass of: ChemicalElement
subclass of: Gas
has proton count: 8

LiquidSubstance
type: Class
subclass of: TangibleStuffStateType
comment: Each subclass of LiquidSubstance labels a PhysicalSubstance which is liquid at normal temperatures and pressures. This category has been set as identical to the Cyc 'Liquid-StateOfMatter', though the original Cyc category is a physical object. This redefinition was done as part of the disentanglement of Cyc substances and objects. The Cyc category definition does not apply to this Type,and is closer to the COSMO 'LiquidObject'. The Cyc category was reinterpreted as a substance because it was used in Cyc predominantly as a parent class for what in COSMO are considered as substances. Water, gasoline, and vodka are examples. Although most substances are classified mainly by their composition, and may be solids or liquids (and sometimes gases) depending on temperature, there are some categories of substances that are conceptually in one state; ice is an example - it must be solid. A 'BathOil' must be a liquid. A LiquidSubstance is a PhysicalSubstance that must be liquid, at normal temperature and pressure.

Gas
type: Class
subclass of: TangibleStuffStateType
disjoint with: LiquidSubstance
comment: Any PhysicalSubstance in the Gaseous form, at room temperature and atmospheric pressure. A quantity of gas does not have a defined volume, but will expand to become uniformly distributed throughout its container. NOTE that a substance that happens to be gaseous at some elevated temperature is **not** necessarily a subtype of 'Gas'; likewise, a quantity of cooled or compressed gas that has become liquid due to cooling or compression can still be composed of a subtype of 'Gas' - for example Liquified Natural Gas. To classify a quantity of matter that is in the gaseous form, use 'GaseousObject'. This is equivalent to saying that it has the property of being 'gaseous' - but that property is not yet (v 0.45) defined in COSMO. At low enough temperature, all substances condense to a liquid or solid.

ChemicallyDefinedSubstance
type: Class
comment: A ChemicallyDefinedSubstance is a PhysicalSubstance that is defined by its chemical composition. The specialized types will have a relatively well-defined composition, though the higher level catagories may have significant variation in the exact chemical composition, such as 'Rubber' or 'Alloy'. Substances that are commonly thnought of as relatively defined, even though they are mixtures such as Ivory and gemstone substances, are also subtypes of this Type. In Cyc labeled 'TangibleStuffCompositionType'. Cyc: A collection of collections and a specialization of #$ExistingStuffType. Instances are subcollections of #$PartiallyTangible whose membership is based only on the physical and/or chemical composition of their instances. #$TangibleStuffCompositionType does not have as instances collections whose instances are determined _solely_ by the physical state they are in - for that, see #$TangibleStuffStateType. However, many substances that chemically break down before melting (e.g. #$FattyTissue) _are_ included in this collection, even though they exist solely in one physical state. The collection #$Water is an instance of #$TangibleStuffCompositionType, as instances of #$Water are all pieces of substance with the chemical composition H20. On the other hand , the collection of all pieces of ice (i.e. (#$SolidFn #$Water)) is not a #$TangibleStuffCompositionType, because membership in that collection depends on the substance's composition _and_ on its physical state. #$TalcumPowder is not an instance of this collection because a fused mass of the substance would no longer be powder, but would still be of the same #$TangibleStuffCompositionType. Further instances of #$TangibleStuffCompositionType are #$Nylon, #$GasolineFuel, #$FattyTissue, #$Nitrogen, and #$Glass. An important specialization of this collection is #$ChemicalSubstanceType - those substance types defined solely by their chemical formulae.
subclass of: PhysicalSubstance
type: ChemicalSubstanceType

hasChemicalComposition
type: ObjectProperty
comment: hasChemicalComposition specifies the proportion of elements in a ChemicallyDefinedSubstance. The range is an AbstractString, but the string is restricted in that the alphabetical parts must be ligitimate chemical symbols for elements. This relation includes not only ChemicalFormulas, which specify the number of atoms in each molecule (or balanced ion group for ionic materials), but also proportions of atoms in organic substances such as biopolymers, where the numbers behind each element may be fractional, representing an average over several closely related molecules or an average in a large molecule. However, percent compositions, specified as percentages, cannot be represented using this relation.
domain: ChemicalSubstanceType
range: AbstractString
inverse of: isTheCompositionOf

hasChemicalFormula
type: ObjectProperty
comment: hasChemicalFormula specifies the number of atoms in each unit (molecule or repeating balanced ion group) of each element in a ChemicallyDefinedSubstance that is not considered as a mixture of substances. The range is an AbstractString, but the string is restricted in that the alphabetical parts must be legitimate chemical symbols for elements, and the numbers after each element symbol must be an integer. For macromolecules, only those whose true molecular formula is known can have a formula pointed to by this relation. A simple grouping is permitted to express some structure: a hyphen represents a single bond between atom groups, as in 'NH2-CO-NH2' for Urea, or '-COOH' represents a carboxyl group. To specify a name that is not a ChemicalFormula, use 'hasChemicalname'.
domain: ChemicalSubstanceType
range: ChemicalFormula
inverse of: isTheChemicalFormulaOf
sub property of: hasChemicalComposition

NamespacePrefix
type: Class
comment: The ontology name of each NamespacePrefix can serve as a string designating a Namespace, and each such string must be unique within the ontology so that the ontology can recognize and reason about Contexts such as Namespaces. A NamespacePrefix will concatenate with an underscore and any other names or prefixes to uniquely identify (within any ontology) entities such as codes, databses, databse tables, database columns,etc. No entity name in the ontology that is not intended to relate to the databsse or code symbolized by the rpefix should begin its name with that prefix followed by an underscore. It should be unquestioned that any specified prefix, followed by an underscore and other characters, represents som eentity within the context symbolized by that namespace prefix.
subclass of: AbstractString

hasNamespacePrefix
type: ObjectProperty
comment: hasNamespacePrefix Specifies an entity whose ontology identifier can serve as a string which constitutes a unique namespace prefix to be used to make unique identifiers for entities in the ontology. By making the NamespacePrefixes into first-class entities in the ontology, the internal ontology uniqueness function can serve as a check that each NamespacePrefix is unique..
domain: Class
  union of: Context
  union of: ContextType
range: NamespacePrefix
inverse of: isThePrefixForContext

CHEM
type: NamespacePrefix
comment: The prefix used for the chemical symbols of elements and compounds (i.e. chemical formulas, which are not necessarily unique for each compound). The chemical symbol for Ethyl alcohol, for example, can be represented as 'CHEM_C2H5OH' or 'CHEM_C2H6O', though the former contains more information; and water would be 'CHEM_H2O'. Elements that have symbols similar to other words can be unambiguosly represented this way, such as 'CHEM_At' for Astatine.

ChemicalFormula
type: Class
comment: An AbstractString representing the atomic composition for well-defined substances, in which each atomic symbol in the String is followed by an integer, or another atomic symbol (implying the integer '1'). Chemical formulas should use the 'CHEM_' namespace prefix, so as to minimize ambiguity, even if the bare formula appears unambiguous.
subclass of: AbstractString
type: ContextType
has namespace prefix: CHEM

InorganicChemical
type: Class
comment: .
type: SubstanceType
subclass of: InorganicMaterial
subclass of: ChemicallyDefinedSubstance

hasComponentSubstance
type: TransitiveProperty
range: SubstanceType
domain: SubstanceType
sub property of: hasPart
sub property of: contains
type: ObjectProperty
comment: hasComponentSubstance is used to specify that some particular substance necessarily contains within it a component which is another substance. This is very broad, and can be used to specify multiple heterogeneous types of substance components, such as mixtures, pure chemicals, or elements. Thus we can say that blood contains protein, or that protein contains nitrogen. In addition to substances that are composed of whole molecules, we also permit representation of 'Substances' that are parts of molecules, such as 'phosphateGroup'. The latter type of substance will be represented by the Cyc 'MolecularComponent'. >> This relation is transitive. In order to specify a relation that points only to some primary component(s) (e.g. a polymer contains a unique type of monomer unit), a relation that is not a subrelation of this one must be defined.

hasMainComponentSubstance
type: ObjectProperty
domain: Class
  union of: PhysicalSubstance
  union of: SubstanceType
range: SubstanceType
sub property of: hasComponentSubstance
comment: hasMainComponentSubstance is used to specify that some particular substance necessarily contains within it a dominant component which is another substance. The 'Main Component' substance pointed to will not necessarily be more than 50% of the total, but it will usually be percentage-wise greater than the other Substance components, and in rare cases (such as concentrated solutions of highly soluble solids) when another substance is of greater percentage weight, it should contribute significantly to the properties of the whole Substance; this is the case in some solutions, where the solvent will be pointed to by this relation, even though the solvent will occasionally not be the main constituent by weight. An example of this relation would be to point to Gold as the 'main compnent substance' even for 10-karat gold, where the Gold is less than 50% of the total weight of the Substance, but is the most salient component in terms of properties. For the case when a Substance has some significant properties that characterize a mixture, but may not necessarily be a significant fraction of the weight, the relation 'hasMainActiveIngredient' should be used.

CarbonDioxide
type: Class
comment: The compound with one carbon and two oxygens in each molecule - CO2.
type: ChemicalSubstanceType
subclass of: InorganicChemical
subclass of: Gas
has chemical formula: CO2
has component substance: Carbon
has component substance: Oxygen

OrganicSubstance
type: Class
comment: COSMO note: This is similar to the Cyc concept 'OrganicMaterial' but has been reinterpreted in COSMO as a substance, not an object. Also, in COSMO cellular substances suc as animal and vegetable materials are subtypes of OrganicSubstance, even though they contain up to 80% by weight of water. So it is not necessary that a substance be composed mostly of organic chemicals to qualify as an 'OrganicSubstance', but the organic compoounds should comprise most of the non-solvent portion of the substance.. Other than the object/substance distinction, it is close to 'OrganicMaterial', but whether there is any useful distinction has not been resolved as of COSMO version 0.48. For ***objects*** that are composed predomintly from stuff derived from living things, see 'OrganicObject'. NOTE that an OrganicSubstance can be complex, and can include inorganic substances such as water. For substances composed predominantly of organic chemicals, use 'OrganicCompound' COSMO: An OrganicSubstance is a PhysicalSubstance (not an Object) whose molecules (other than inert solvent such as water) are composed predominantly of carbon atoms bonded directly either to other carbon atoms or to hydrogen atoms. Many other elements may occur in organic substances, especially oxygen and nitrogen, but the dominant molecules should each have at least one of either a carbon-carbon or carbon-hydrogen bond. Cyc: A collection of tangible things. Each instance of #$OrganicMaterial is a tangible thing composed of one or more types of organic #$Molecule. Instances of #$OrganicMaterial usually have their origin in the bodies (or other products) of living things. Since some organic substances can be synthesized, #$OrganicMaterial is not a subcollection of #$NaturalTangibleStuff. Chemically, instances of #$OrganicMaterial have fairly (or very) complex carbon-based structures. Examples include all instances of the collections #$Oil, #$DNAStuff, #$Alcohol-Compound, #$Ivory, and #$AnimalBodyPart.
subclass of: PhysicalSubstance
type: SubstanceType
subclass of: Restriction
  on property: hasComponentSubstance
  has value: Carbon

OrganicMaterialObject
type: Class
comment: In Cyc, named 'OrganicMaterial'. This can be a solid or liquid, and can be an object composed of complex material from a living thing, or an organic chemical of defined composition. Cyc: A collection of tangible things. Each instance of #$OrganicMaterial is a tangible thing composed of one or more types of organic #$Molecule. Instances of #$OrganicMaterial usually have their origin in the bodies (or other products) of living things. Since some organic substances can be synthesized, #$OrganicMaterial is not a subcollection of #$NaturalTangibleStuff. Chemically, instances of #$OrganicMaterial have fairly (or very) complex carbon-based structures. Examples include all instances of the collections #$Oil, #$DNAStuff, #$Alcohol-Compound, #$Ivory, and #$AnimalBodyPart.
type: PhysicalObjectType
subclass of: PhysicalObject
subclass of: ObjectConsistingOfSubstance
subclass of: Restriction
  on property: consistsMostlyOfSubstance
  has value: OrganicSubstance
subclass of: Restriction
  on property: hasConstituentSubstance
  has value: Carbon

OrganicObject
type: Class
comment: An OrganicObject is an object at least as large as a cell of an organism, that consists predominantly of substances which are living or are derived from living things, or are synthetic substances similar to those found in living things. An OrganicObject may be living or dead, or if dead, highly processed, providing that the main active constituent is derived from or similar to those in living things. Thus one muscle or one apple pie would each be an OrganicObject, but one virus particle would be too small to qualify. A macroscopic object consisting of macromolecules such as protein, nucleic acid, or polysaccharide similar to those found naturally would be OrganicObjects, but a quantity of small molecules such as alcohol or amino acid would not be. In the triad 'animal, vegetable or mineral', this would be either of animal or vegetable. NOTE that this Type is disjoint with MineralObject, though an OrganicObject may have some minor portions of Mineral in it. NOTE in particular that a Corpse, skeleton, and FuneraryAshes are classified as 'OrganicObject' although a strong fire may have removed almost all of the carbon in it.
subclass of: OrganicMaterialObject
disjoint with: MineralObject

ExistingStuffType
type: Class
comment: COSMO note: This Cyc category is reinterpreted in COSMO to include certain subtypes of 'PhysicalSubstance', that are not subcategorized solely on the basis of composition, or inherent properties depending on composition, but of other attributes, such as state of matter (e.g. SolidSubstance or Gas). One such category is 'CommodityProduct' which treats commercial products sold in quantities (such as potatoes, onions) as 'substances'. Cyc: A collection of collections, and a specialization of #$TemporalStuffType. Each instance of #$ExistingStuffType is a collection of things (including portions of things) which are both temporally and spatially stufflike. Division in time or space does not destroy the stufflike quality of the object (down to a certain granularity). (#$isa STUFFTYPE #$ExistingStuffType) implies both (i) for most instances STUFF of STUFFTYPE, for any proper physical part (see #$physicalParts) PART of STUFF, PART is also an instance of STUFFTYPE and (ii) for all instances STUFF of STUFFTYPE, for most proper physical parts PART of STUFF, PART is also an instance of STUFFTYPE. For example, every piece of wood is temporally stufflike: if W-168 is a piece of wood during 1996, then it's also a piece of wood for the one-minute time-slice 9:05am 7/7/96. It's also spatially stufflike: if we take that piece of wood W-168 and cut it in half, we have two things which are both pieces of wood. Since every piece of wood is both temporally and spatially stufflike, #$Wood is an instance of #$ExistingStuffType. Other instances of #$ExistingStuffType include the collections #$AppleJuice, #$IceCream, #$Diamond, #$WaxedPaper, and #$StriatedMuscle. See the comment for #$StuffType to learn more about the distinctions between, and the need for, these four collections: #$StuffType, #$ObjectType, #$ExistingStuffType, and #$ExistingObjectType.
subclass of: PhysicalSubstance

InanimateThing
type: Class
comment: A subcollection of #$PartiallyTangible. Each instance of #$InanimateThing is an (at least partly) tangible thing that is not currently a living structure. Things that were never alive, dead organisms, and dead (or completely non-functioning) organism parts are included in this collection. Examples: #$YaleUniversity, a piece of #$Meat, a dead armadillo, the #$StatueOfLiberty, and a pile of #$Sawdust. Two important specializations of this collection are #$InanimateThing-Natural and #$InanimateThing-NonNatural.
type: PhysicalObjectType
subclass of: PhysicalObject

TangibleStuffStateType
type: Class
comment: A #$SecondOrderCollection and a specialization of #$ExistingStuffType (q.v.). Each instance of #$TangibleStuffStateType is a collection of pieces of tangible stuff that are all in the same distinct physical state, where the notion of physical state is a naive (as in #$NaivePhysicsMt) concept of a distinctive physical structure and/or texture. Some instances of #$TangibleStuffStateType have distinctive chemical compositions, such as #$Diamond; but for collections that are distinguished _solely_ on the basis of chemical composition, see #$TangibleStuffCompositionType. #$TangibleStuffStateType includes both (i) collections of substances that can exist only in one distinct physical state (e.g. #$Diamond again) and (ii) collections of pieces of stuff that by definition are in a certain distinct state (e.g. ice). Instances of #$TangibleStuffStateType include #$Foam, #$Rubble, and (#$LiquidFn #$Water). Note that #$Water per se is _not_ an instance of #$TangibleStuffStateType, since some water is in a gaseous state or a solid state. See also (the somewhat orthogonal) #$PhysicalStructuralAttribute.
subclass of: ExistingStuffType

SolidSubstance
type: Class
comment: COSMO note: In Cyc, this was 'SolidTangibleThing', a collection of objects. In COSMO, we rename and repurpose this category to be a solid substance, with subtypes that are substances that are solid at normal temperature and pressure. Cyc comment: An instance of #$ExistingStuffType, and a specialization of #$PartiallyTangible. Each instance of #$SolidTangibleThing is a piece of stuff possessing many of the properties that matter in a solid state (see the constant #$Solid-StateOfMatter) exhibits (although not all instances of #$SolidTangibleThing are formally in a solid state). Instances have a shape independent from their container, and, when deformed with sufficient force (which may be small for weak, brittle materials or high for materials that deform easily), they break. Examples of #$SolidTangibleThings include: pieces of substances in a solid state of matter, such as ice cubes; solid mixtures like a quarter-dollar coin or a paper bag; and complex mixtures of biological origin that behave like solids, e.g., bone. Note that some pieces of matter that are formally in a solid state (for example, pieces of clay) are not instances of #$SolidTangibleThing, since they do not readily break when deformed; for this reason, #$Solid-StateOfMatter is _not_ a specialization of #$SolidTangibleThing. Collections of the solid form of any type of stuff can be created using #$SolidFn (q.v.).
subclass of: Restriction
  has value: NonFluidlike
  on property: hasQualitativeAttribute
subclass of: TangibleStuffStateType
subclass of: DosageFormType

Opaque
type: Class
comment: The attribute of being Opaque, i.e. of not permitting light to pass through. Specifying this can be useful in rendering objects in images, but perhaps it should be the default? NOTE that this is a ColorAttribute, and objects and substances can possess this attribute while also possessing other color attributes. COSMO note: Opacity is an attribute only of objects that have a certain size, or of solid substances; at molecular dimensions, almost nothing will absorb all of the light impinging on it. Cyc comment: #$Opaque is a #$PhysicalAttribute representing a specific degree of #$Transparency. #$Opaque objects do not transmit light. See also #$transparencyOfObject.
type: ColorAttributeType
subclass of: ColorAttribute

OpaqueObject
type: Class
comment: COSMO note: Opacity is an attribute only of objects that have a certain size; at molecular dimensions, almost nothing will absorb all of the light impinging on it. Cyc comment: #$Opaque is a #$PhysicalAttribute representing a specific degree of #$Transparency. #$Opaque objects do not transmit light. See also #$transparencyOfObject.
equivalent class: Class
  intersection of: PhysicalObject
  intersection of: Restriction
    on property: hasColor
    has value: Opaque

BiologicalLivingObject
type: Class
comment: COSMO note: as of version 0.49, this category is not properly represented. COSMO has 'Corpse' as a subtype of 'BiologicalLivingObject' and these need to be distinguished. Cyc: The collection of all structures that are composed of one or more living cells (see #$Cell). Note that this can be solid or liquid, because blood and lymph are composed of cells. Biological living objects (or BLO s) might either be instances of #$Organism-Whole (like dogs or pine trees) or components of such whole living organisms (like noses, tails, and pine needles). The healthy leg of a living person is a BLO (as is the person), but an amputated leg is not a BLO. Almost every instance of #$BiologicalLivingObject is either capable of biological reproduction itself or has components which are capable of biological reproduction (such as the cells in a living arm). Red blood cells are abnormal instances of BLO in that they cannot reproduce.
type: PhysicalObjectType
subclass of: OpaqueObject
subclass of: OrganicObject

NonFluidlike
type: Class
comment: The subcollection of #$PartiallyTangible whose instances are not like fluids. #$NonFluidlike objects do not flow and have an intrinsic shape. #$NonFluidlike is primarily a collection union of #$SolidTangibleThing and #$SemiSolidTangibleThing. It is useful as a genl collection for certain collections whose members can be both #$SolidTangibleThings and #$SemiSolidTangibleThings, like #$Deformable.
subclass of: QualitativeAttributeValue
type: QualitativeAttributeType

Crystalline
type: Class
comment: In OpenCyc this class is a collection of pieces of crystalline material. In COSMO it is reinterpreted as an attribute of some solids. Cyc: The collection of instances of #$PartiallyTangible having a solid crystalline structure. In a crystalline solid the atoms, ions, or molecules are ordered in well-defined arrangements. These solids often have flat faces that make angles with one another. They are frequently translucent and brittle.
type: QualitativeAttributeType
subclass of: NonFluidlike

CrystallineObject
type: Class
comment: In OpenCyc called 'Crystalline'. Cyc: The collection of instances of #$PartiallyTangible having a solid crystalline structure. In a crystalline solid the atoms, ions, or molecules are ordered in well-defined arrangements. These solids often have flat faces that make angles with one another. They are frequently translucent and brittle.
subclass of: SolidObject
subclass of: InanimateThing
subclass of: Restriction
  on property: hasQualitativeAttribute
  has value: Crystalline

Organism
type: Class
subclass of: LifeForm
subclass of: SpatiallyContinuousThing
subclass of: BiologicalLivingObject
subclass of: MoistObject
type: PhysicalObjectType
disjoint with: InanimateThing
disjoint with: GenericSubstance[COSMO-added:_not_an_object,_includes_chemicals]
comment: In Cyc called 'Organism-Whole'. An Organism must be a whole individual, composed of one or more cells, capable of living independently of other living things (though it may have to feed on other living things, even as a parasite). This cannot be just part of an organism, such as a liver removed and fed in a perfusion apparatus. An organism can be single-celled, like a bacterium. An organism must have a cell membrane that separates the internal cytoplasm from the exterior environment while it is living and metabolizing. Therefore a virus is not an organism, but a different form of life. A seed or spore or other reproductive body that is not metabolically active is not considered as a whole Organism, but as a part or a life stage of an Organism. NOTE carefully that in COSMO v0.2 the category 'Organism' by default is intended to represent typical living adults forms of an organism, but abnormal forms are not actually excluded logically. Therefore though we make certain necessary assertions about an 'Organism' without being concerned about exceptions, the results will be true only in the default case and certain logical contradictiona may occur. This is a temporary measure until a better way of handling default reasoning is implemented. Note, for example, that dead organisms are still categorized as Organisms (this is used mostly for People), even though an Organism is disjoint with 'InanimateThing' - this is to allow the reasoner to catch unintended mistakes of classification. . When exceptional circumstances are encountered, one should use the category 'ImmatureOrganism' or 'AbnormalOrganism'. Rather than reify such categories for each organism type, they can be generated by use of functions on the typical organism Type. If functions are not available in some implementation, reification may be necessary. A more accurate solution would be to leave the organisms as generic, and create a 'typical adult' subtype to hold the values for the prototype. This requires a quasi-…