sumo++.kif

;; Access to and use of this file is governed by the GNU General
;; Public License <http://www.gnu.org/copyleft/gpl.html>.

;; This file contains modified versions of SUMO and three domain
;; ontologies.  The effective date of modification is 2003-01-22.
;; Please refer to the accompanying documentation (sumo2loom_doc
;; rev. 2003-01-22 or similar) for a detailed explanation of the
;; modifications.

;; This file is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  NIST does not
;; assume legal liability or responsibility for anything done with
;; this file.

;; Please refer to sumo2loom_doc for details of the copyright and
;; licensing terms.


;; ================================================
;;      SUMO (Suggested Upper Merged Ontology)
;; ================================================

;; This is the source file for the SUMO (Suggested Upper Merged Ontology),
;; an ontology that was developed within the SUO Working Group by merging
;; the SUO "candidate content" sources and refining and extending this content on
;; the basis of various knowledge engineering projects and input from the SUO
;; Working Group.

;; The SUMO incorporates elements of John Sowa's upper ontology (as described at
;; http://www.bestweb.net/~sowa/ontology/toplevel.htm and in Chapter 2 of his
;; book _Knowledge Representation_, Brooks/Cole, 2000), Russell and Norvig's
;; ontology, PSL (Process Specification Language), Casati and Varzi's theory of
;; holes, Allen's temporal axioms, the relatively noncontroversial elements of
;; Smith's and Guarino's respective mereotopologies, the KIF formalization of the
;; CPR (Core Plan Representation), the ontologies available on the Ontolingua
;; server maintained by Stanford University's Knowledge Systems Laboratory, the
;; ontologies developed by ITBM-CNR, some of the spatial relations from an
;; unpublished paper by Iris Tommelein and Anil Gupta entitled "Conceptual
;; Structures for Spatial Reasoning", and a "Structural Ontology" proposed by
;; David Whitten and substantially revised and extended by Chris Menzel.
;; Note that some of the subclasses of 'Process' in the SUMO were originally
;; inspired by some of the verb classes from the second part of Beth Levin's book
;; "English Verb Classes and Alternations:  A Preliminary Investigation."

;; The knowledge representation language in which the SUMO is expressed is SUO-KIF,
;; which stands for "Standard Upper Ontology - Knowledge Interchange Format".  SUO-KIF
;; is a simplified form of the popular KIF knowledge representation language.  A
;; specification of SUO-KIF can be found at:  http://suo.ieee.org/suo-kif.html.  It
;; should be noted that some of the axioms in the SUMO make use of row variables
;; (indicated with a "@" prefix).  Such variables are not currently part of the SUO-
;; KIF specification, but they simplify matters significantly in some cases.  Details
;; about row variables can be found in the following paper:
;; http://reliant.teknowledge.com/IJCAI01/HayesMenzel-SKIF-IJCAI2001.pdf.

;; The SUMO is a modular ontology.  That is, the ontology is divided into
;; self-contained subontologies.  Each subontology is indicated by a section
;; header, and the dependencies between the subontologies are specified with
;; statements of the form ";; INCLUDES '<SUBONTOLOGY>'".  These statements are
;; found at the beginning of each section.  The dependencies between the
;; various subontologies can also be graphed informally as follows:
;;
;;                             STRUCTURAL ONTOLOGY
;;                                      +
;;                                      |
;;                                      |
;;                                      +
;;                                 BASE ONTOLOGY
;;                                 /   |   |   \
;;                                /    |   |    \
;;                               /     |   |     \
;;                              /      |   |      \
;;                             /       |   |       \
;;                            +        +   +        +
;;             SET/CLASS THEORY   NUMERIC  TEMPORAL  MEREOTOPOLOGY
;;                               /     |        |           |
;;                              /      |        |           |
;;                             /       |        |           |
;;                            +        +        +           +
;;                        GRAPH   MEASURE   PROCESSES +--+ OBJECTS
;;                                              +           +
;;                                               \         /
;;                                                \       /
;;                                                 \     /
;;                                                  +   +
;;                                                 QUALITIES
;;
;;
;; Note that the "+" sign at the end of an arc indicates the direction of
;; dependency - the node near the sign includes the subontology at the other
;; end of the arc.  Note too that in some cases the dependency is
;; bidirectional.  Separating ontologies in cases like these is useful when
;; their respective topics can be cleanly differentiated.


;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;   STRUCTURAL ONTOLOGY   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'BASE ONTOLOGY'

;; The Structural Ontology consists of definitions of certain syntactic
;; abbreviations that can be both heuristically useful and computationally
;; advantageous.

(instance instance BinaryPredicate)
(domain instance 1 Entity)
(domain instance 2 SetOrClass)
(documentation instance "An object is an &%instance of a &%SetOrClass if
it is included in that &%SetOrClass.  An individual may be an instance of many
classes, some of which may be subclasses of others.  Thus, there is no
assumption in the meaning of &%instance about specificity or uniqueness.")

(subrelation immediateInstance instance)
(instance immediateInstance AsymmetricRelation)
(instance immediateInstance IntransitiveRelation)
(documentation immediateInstance "An object is an &%immediateInstance of
a &%SetOrClass if it is an instance of the &%SetOrClass and there does not exist a
subclass of &%SetOrClass such that it is an instance of the subclass.")

(=>
   (immediateInstance ?ENTITY ?CLASS)
   (not (exists (?SUBCLASS)
      (and
         (subclass ?SUBCLASS ?CLASS)
         (instance ?ENTITY ?SUBCLASS)))))

(instance inverse BinaryPredicate)
(domain inverse 1 BinaryRelation)
(domain inverse 2 BinaryRelation)
(documentation inverse "The inverse of a &%BinaryRelation is a relation
in which all the tuples of the original relation are reversed.  In
other words, one &%BinaryRelation is the inverse of another if they are
equivalent when their arguments are swapped.")

(=>
   (inverse ?REL1 ?REL2)
   (forall (?INST1 ?INST2)
      (<=>
         (holds ?REL1 ?INST1 ?INST2)
         (holds ?REL2 ?INST2 ?INST1))))

(instance subclass BinaryPredicate)
(instance subclass PartialOrderingRelation)
(domain subclass 1 SetOrClass)
(domain subclass 2 SetOrClass)
(documentation subclass "(&%subclass ?CLASS1 ?CLASS2) means that ?CLASS1 is
a subclass of ?CLASS2, i.e. every instance of ?CLASS1 is also an instance of
?CLASS2.  A class may have multiple superclasses and subclasses.")

(=>
   (subclass ?SUBCLASS ?CLASS)
   (forall (?INST)
      (=>
         (instance ?INST ?SUBCLASS)
         (instance ?INST ?CLASS))))

(subrelation immediateSubclass subclass)
(instance immediateSubclass AsymmetricRelation)
(instance immediateSubclass IntransitiveRelation)
(documentation immediateSubclass "A &%SetOrClass ?CLASS1 is an &%immediateSubclass
of another &%SetOrClass ?CLASS2 just in case ?CLASS1 is a subclass of ?CLASS2 and
there is no other subclass of ?CLASS2 such that ?CLASS1 is also a subclass of it.")

(=>
   (immediateSubclass ?CLASS1 ?CLASS2)
   (not (exists (?CLASS3)
      (and
         (subclass ?CLASS3 ?CLASS2)
         (subclass ?CLASS1 ?CLASS3)
         (not (equal ?CLASS2 ?CLASS3))
         (not (equal ?CLASS1 ?CLASS3))))))

(instance subrelation BinaryPredicate)
(instance subrelation PartialOrderingRelation)
(domain subrelation 1 Relation)
(domain subrelation 2 Relation)
(documentation subrelation "A &%Relation R is a &%subrelation
&%Relation R' if R is a &%subclass R'.  This implies that every
tuple of R is also a tuple of R'.  Again, if R holds for some arguments
arg_1, arg_2, ... arg_n, then R' holds for the same arguments.  Thus, a
&%Relation and its subrelation must have the same valence. In CycL,
&%subrelation is called #$genlPreds.")

(=>
   (and
      (subrelation ?PRED1 ?PRED2)
      (valence ?PRED1 ?NUMBER))
   (valence ?PRED2 ?NUMBER))

(=>
   (and
      (subrelation ?PRED1 ?PRED2)
      (domain ?PRED2 ?NUMBER ?CLASS1))
   (domain ?PRED1 ?NUMBER ?CLASS1))

(=>
   (and
      (subrelation ?REL1 ?REL2)
      (holds ?REL1 @ROW))
   (holds ?REL2 @ROW))

(=>
   (and
      (subrelation ?PRED1 ?PRED2)
      (instance ?PRED2 ?CLASS)
      (instance ?CLASS InheritableRelation))
   (instance ?PRED1 ?CLASS))

(instance domain TernaryPredicate)
(domain domain 1 Relation)
(domain domain 2 PositiveInteger)
(domain domain 3 SetOrClass)
(documentation domain "Provides a computationally and heuristically
convenient mechanism for declaring the argument types of a given relation.
The formula (&%domain ?REL ?INT ?CLASS) means that the ?INT'th element of each
tuple in the relation ?REL must be an instance of ?CLASS.  Specifying argument
types is very helpful in maintaining ontologies.  Representation systems can
use these specifications to classify terms and check integrity constraints.
If the restriction on the argument type of a &%Relation is not captured by a
&%SetOrClass already defined in the ontology, one can specify a &%SetOrClass
compositionally with the functions &%UnionFn, &%IntersectionFn, etc.")

(=>
   (and
      (domain ?REL ?NUMBER ?CLASS1)
      (domain ?REL ?NUMBER ?CLASS2))
   (or
      (subclass ?CLASS1 ?CLASS2)
      (subclass ?CLASS2 ?CLASS1)))

(instance domainSubclass TernaryPredicate)
(domain domainSubclass 1 Relation)
(domain domainSubclass 2 PositiveInteger)
(domain domainSubclass 3 SetOrClass)
(documentation domainSubclass "&%Predicate used to specify argument
type restrictions of &%Predicates.  The formula (&%domainSubclass
?REL ?INT ?CLASS) means that the ?INT'th element of each tuple in the
relation ?REL must be a subclass of ?CLASS.")

(=>
   (and
      (subrelation ?REL1 ?REL2)
      (domainSubclass ?REL1 ?NUMBER ?CLASS2))
   (domainSubclass ?REL2 ?NUMBER ?CLASS2))

(=>
   (and
      (domainSubclass ?REL ?NUMBER ?CLASS1)
      (domainSubclass ?REL ?NUMBER ?CLASS2))
   (or
      (subclass ?CLASS1 ?CLASS2)
      (subclass ?CLASS2 ?CLASS1)))

(instance equal BinaryPredicate)
(instance equal EquivalenceRelation)
(instance equal RelationExtendedToQuantities)
(domain equal 1 Entity)
(domain equal 2 Entity)
(documentation equal "(equal ?ENTITY1 ?ENTITY2) is true just in case
?ENTITY1 is identical with ?ENTITY2.")

(=>
   (equal ?THING1 ?THING2)
   (forall (?ATTR)
      (<=>
         (property ?THING1 ?ATTR)
         (property ?THING2 ?ATTR))))

(=>
   (equal ?THING1 ?THING2)
   (forall (?CLASS)
      (<=>
         (instance ?THING1 ?CLASS)
         (instance ?THING2 ?CLASS))))

(instance range BinaryPredicate)
(instance range AsymmetricRelation)
(domain range 1 Function)
(domain range 2 SetOrClass)
(documentation range "Gives the range of a function.  In other words,
(&%range ?FUNCTION ?CLASS) means that all of the values assigned by
?FUNCTION are &%instances of ?CLASS.")

(=>
   (and
      (range ?FUNCTION ?CLASS)
      (equal (AssignmentFn ?FUNCTION @ROW) ?VALUE))
   (instance ?VALUE ?CLASS))

(=>
   (and
      (subrelation ?REL1 ?REL2)
      (range ?REL1 ?CLASS1))
   (range ?REL2 ?CLASS1))

(=>
   (and
      (range ?REL ?CLASS1)
      (range ?REL ?CLASS2))
   (or
      (subclass ?CLASS1 ?CLASS2)
      (subclass ?CLASS2 ?CLASS1)))

(instance rangeSubclass BinaryPredicate)
(instance rangeSubclass AsymmetricRelation)
(domain rangeSubclass 1 Function)
(domainSubclass rangeSubclass 2 SetOrClass)
(documentation rangeSubclass "(&%rangeSubclass ?FUNCTION ?CLASS) means that
all of the values assigned by ?FUNCTION are &%subclasses of ?CLASS.")

(=>
   (and
      (rangeSubclass ?FUNCTION ?CLASS)
      (equal (AssignmentFn ?FUNCTION @ROW) ?VALUE))
   (subclass ?VALUE ?CLASS))

(=>
   (and
      (subrelation ?REL1 ?REL2)
      (rangeSubclass ?REL1 ?CLASS1))
   (rangeSubclass ?REL2 ?CLASS1))

(=>
   (and
      (rangeSubclass ?REL ?CLASS1)
      (rangeSubclass ?REL ?CLASS2))
   (or
      (subclass ?CLASS1 ?CLASS2)
      (subclass ?CLASS2 ?CLASS1)))

(instance DomainFn UnaryFunction)
(domain DomainFn 1 BinaryRelation)
(range DomainFn SetOrClass)
(documentation DomainFn "The domain of a &%BinaryRelation ?REL is
the &%SetOrClass of all things that bear ?REL to something.")

(<=>
   (instance ?INST1 (DomainFn ?REL))
   (exists (?INST2)
      (holds ?REL ?INST1 ?INST2)))

(=>
   (instance ?REL BinaryRelation)
   (domain ?REL 2 (DomainFn ?REL)))

(instance RangeFn UnaryFunction)
(domain RangeFn 1 BinaryRelation)
(range RangeFn SetOrClass)
(documentation RangeFn "The range of a &%BinaryRelation ?REL is the
&%SetOrClass of all things such that something bears ?REL to them.")

(<=>
   (instance ?INST1 (RangeFn ?REL))
   (exists (?INST2)
      (holds ?REL ?INST2 ?INST1)))

(=>
   (instance ?REL UnaryFunction)
   (range ?REL (RangeFn ?REL)))

(=>
   (instance ?REL BinaryPredicate)
   (domain ?REL 2 (RangeFn ?REL)))

(instance valence BinaryPredicate)
(instance valence AsymmetricRelation)
(instance valence SingleValuedRelation)
(domain valence 1 Relation)
(domain valence 2 PositiveInteger)
(documentation valence "Specifies the number of arguments that a
relation can take.  If a relation does not have a fixed number of
arguments, it does not have a valence and it is an instance of
&%VariableArityRelation.  For example, &%holds is a
&%VariableArityRelation.")

(instance documentation BinaryPredicate)
(instance documentation AsymmetricRelation)
(domain documentation 1 Entity)
(domain documentation 2 SymbolicString)
(documentation documentation "A relation between objects in the domain
of discourse and strings of natural language text.  The domain of
&%documentation is not constants (names), but the objects themselves.
This means that one does not quote the names when associating them with
their documentation.")

(instance disjoint BinaryPredicate)
(instance disjoint SymmetricRelation)
(instance disjoint IrreflexiveRelation)
(domain disjoint 1 SetOrClass)
(domain disjoint 2 SetOrClass)
(documentation disjoint "&%Classes are &%disjoint only if they share no
instances, i.e. just in case the result of applying &%IntersectionFn to
them is empty.")

(=>
   (disjoint ?CLASS1 ?CLASS2)
   (forall (?INST)
      (not
         (and
	    (instance ?INST ?CLASS1)
          (instance ?INST ?CLASS2)))))

(instance disjointRelation Predicate)
(instance disjointRelation VariableArityRelation)
(relatedInternalConcept disjointRelation disjoint)
(documentation disjointRelation "This predicate relates any number of &%Relations.
(&%disjointRelation @ROW) means that any two relations in @ROW have no tuples in
common.  As a consequence, the intersection of all of the relations in @ROW is the
null set.")

(=>
   (and
      (disjointRelation @ROW)
      (inList ?REL (ListFn @ROW)))
   (instance ?REL Relation))

(=>
   (and
      (disjointRelation @ROW)
      (inList ?REL1 (ListFn @ROW))
      (inList ?REL2 (ListFn @ROW))
      (valence ?REL1 ?NUMBER))
   (valence ?REL2 ?NUMBER))

(=>
   (and
      (domain ?REL1 ?NUMBER ?CLASS1)
      (domain ?REL2 ?NUMBER ?CLASS2)
      (disjoint ?CLASS1 ?CLASS2))
   (disjointRelation ?REL1 ?REL2))

(=>
   (and
      (domainSubclass ?REL1 ?NUMBER ?CLASS1)
      (domainSubclass ?REL2 ?NUMBER ?CLASS2)
      (disjoint ?CLASS1 ?CLASS2))
   (disjointRelation ?REL1 ?REL2))

(=>
   (and
      (range ?REL1 ?CLASS1)
      (range ?REL2 ?CLASS2)
      (disjoint ?CLASS1 ?CLASS2))
   (disjointRelation ?REL1 ?REL2))

(=>
   (and
      (rangeSubclass ?REL1 ?CLASS1)
      (rangeSubclass ?REL2 ?CLASS2)
      (disjoint ?CLASS1 ?CLASS2))
   (disjointRelation ?REL1 ?REL2))

(=>
   (and
      (disjointRelation @ROW1)
      (inList ?REL1 (ListFn @ROW1))
      (inList ?REL2 (ListFn @ROW1))
      (holds ?REL1 @ROW2))
   (not (holds ?REL2 @ROW2)))

(instance contraryAttribute Predicate)
(instance contraryAttribute VariableArityRelation)
(documentation contraryAttribute "A &%contraryAttribute is a set of &%Attributes
such that something can not simultaneously have more than one of these &%Attributes.
For example, (&%contraryAttribute &%Pliable &%Rigid) means that nothing can be both
&%Pliable and &%Rigid.")

(=>
   (contraryAttribute @ROW)
   (=>
      (inList ?ELEMENT (ListFn @ROW))
      (instance ?ELEMENT Attribute)))

(=>
   (contraryAttribute @ROW)
   (forall (?ATTR1 ?ATTR2)
      (=>
         (and
            (inList ?ATTR1 (ListFn @ROW))
            (inList ?ATTR2 (ListFn @ROW))
            (not (equal ?ATTR1 ?ATTR2)))
         (=>
            (property ?OBJ ?ATTR1)
            (not (property ?OBJ ?ATTR2))))))

(instance exhaustiveAttribute Predicate)
(instance exhaustiveAttribute VariableArityRelation)
(domainSubclass exhaustiveAttribute 1 Attribute)
(documentation exhaustiveAttribute "This predicate relates a &%Class to a
set of &%Attributes, and it means that the elements of this set exhaust the
instances of the &%Class.  For example, (&%exhaustiveAttribute &%PhysicalState
&%Solid &%Liquid &%Gas) means that there are only three instances of the class
&%PhysicalState, viz. &%Solid, &%Liquid, and &%Gas.")

(=>
   (exhaustiveAttribute ?CLASS @ROW)
   (=>
      (inList ?ATTR (ListFn @ROW))
      (instance ?ATTR Attribute)))

(=>
   (exhaustiveAttribute ?CLASS @ROW)
   (forall (?OBJ)
      (=>
         (instance ?ATTR1 ?CLASS)
         (exists (?ATTR2)
            (and
               (inList ?ATTR2 (ListFn @ROW))
               (equal ?ATTR1 ?ATTR2))))))

(instance exhaustiveDecomposition Predicate)
(instance exhaustiveDecomposition VariableArityRelation)
(domain exhaustiveDecomposition 1 Class)
(relatedInternalConcept exhaustiveDecomposition partition)
(documentation exhaustiveDecomposition "An &%exhaustiveDecomposition of a
&%Class C is a set of subclasses of C such that every subclass of C either
is an element of the set or is a subclass of an element of the set.  Note:
this does not necessarily mean that the elements of the set are disjoint
(see &%partition - a &%partition is a disjoint exhaustive decomposition.)")

(=>
   (exhaustiveDecomposition @ROW)
   (=>
      (inList ?ELEMENT (ListFn @ROW))
      (instance ?ELEMENT Class)))

(instance disjointDecomposition Predicate)
(instance disjointDecomposition VariableArityRelation)
(domain disjointDecomposition 1 Class)
(relatedInternalConcept disjointDecomposition exhaustiveDecomposition)
(relatedInternalConcept disjointDecomposition disjoint)
(documentation disjointDecomposition "A &%disjointDecomposition of a &%Class
C is a set of subclasses of C that are mutually &%disjoint.")

(=>
   (disjointDecomposition @ROW)
   (=>
      (inList ?ELEMENT (ListFn @ROW))
      (instance ?ELEMENT Class)))

(instance partition Predicate)
(instance partition VariableArityRelation)
(domain partition 1 Class)
(documentation partition "A &%partition of a class C is a set of
mutually &%disjoint classes (a subclass partition) which covers C.
Every instance of C is an instance of exactly one of the subclasses
in the partition.")

(<=>
   (partition @ROW)
   (and
      (exhaustiveDecomposition @ROW)
      (disjointDecomposition @ROW)))

(instance relatedInternalConcept BinaryPredicate)
(instance relatedInternalConcept EquivalenceRelation)
(domain relatedInternalConcept 1 Entity)
(domain relatedInternalConcept 2 Entity)
(documentation relatedInternalConcept "Means that the two arguments are
related concepts within the SUMO, i.e. there is a significant similarity
of meaning between them.  To indicate a meaning relation between a SUMO
concept and a concept from another source, use the Predicate
&%relatedExternalConcept.")

(instance relatedExternalConcept TernaryPredicate)
(domain relatedExternalConcept 1 SymbolicString)
(domain relatedExternalConcept 2 Entity)
(domain relatedExternalConcept 3 Language)
(relatedInternalConcept relatedExternalConcept relatedInternalConcept)
(documentation relatedExternalConcept "Used to signify a three-place
relation between a concept in an external knowledge source, a concept
in the SUMO, and the name of the other knowledge source.")

(subrelation synonymousExternalConcept relatedExternalConcept)
(disjointRelation synonymousExternalConcept subsumedExternalConcept subsumingExternalConcept)
(documentation synonymousExternalConcept "(&%synonymousExternalConcept
?STRING ?THING ?LANGUAGE) means that the SUMO concept ?THING has the
same meaning as ?STRING in ?LANGUAGE.")

(subrelation subsumingExternalConcept relatedExternalConcept)
(documentation subsumingExternalConcept "(&%subsumingExternalConcept
?STRING ?THING ?LANGUAGE) means that the SUMO concept ?THING subsumes
the meaning of ?STRING in ?LANGUAGE, i.e. the concept ?THING is broader
in meaning than ?STRING.")

(subrelation subsumedExternalConcept relatedExternalConcept)
(documentation subsumedExternalConcept "(&%subsumedExternalConcept
?STRING ?THING ?LANGUAGE) means that the SUMO concept ?THING is subsumed
by the meaning of ?STRING in ?LANGUAGE, i.e. the concept ?THING is narrower
in meaning than ?STRING.")

(instance subAttribute BinaryPredicate)
(instance subAttribute PartialOrderingRelation)
(domain subAttribute 1 Attribute)
(domain subAttribute 2 Attribute)
(disjointRelation subAttribute successorAttribute)
(documentation subAttribute "Means that the second argument can be
ascribed to everything which has the first argument ascribed to it.")

(<=>
   (subAttribute ?ATTR1 ?ATTR2)
   (forall (?OBJ)
      (=>
         (property ?OBJ ?ATTR1)
         (property ?OBJ ?ATTR2))))

(=>
   (and
      (subAttribute ?ATTR1 ?ATTR2)
      (instance ?ATTR2 ?CLASS))
   (instance ?ATTR1 ?CLASS))

(instance successorAttribute BinaryPredicate)
(instance successorAttribute AsymmetricRelation)
(domain successorAttribute 1 Attribute)
(domain successorAttribute 2 Attribute)
(documentation successorAttribute "(&%successorAttribute ?ATTR1 ?ATTR2)
means that ?ATTR2 is the &%Attribute that comes immediately after ?ATTR1
on the scale that they share.")

(=>
   (and
      (successorAttribute ?ATTR1 ?ATTR2)
      (holdsDuring ?TIME1 (property ?ENTITY ?ATTR2)))
   (exists (?TIME2)
      (and
         (temporalPart ?TIME2 (PastFn ?TIME1))
         (holdsDuring ?TIME2 (property ?ENTITY ?ATTR1)))))

(instance successorAttributeClosure BinaryPredicate)
(instance successorAttributeClosure TransitiveRelation)
(instance successorAttributeClosure IrreflexiveRelation)
(domain successorAttributeClosure 1 Attribute)
(domain successorAttributeClosure 2 Attribute)
(relatedInternalConcept successorAttributeClosure successorAttribute)
(documentation successorAttributeClosure "The transitive closure of
&%successorAttribute.  (&%successorAttributeClosure ?ATTR1 ?ATTR2) means
that there is a chain of &%successorAttribute assertions connecting
?ATTR1 and ?ATTR2.")

(=>
   (successorAttribute ?ATTR1 ?ATTR2)
   (successorAttributeClosure ?ATTR1 ?ATTR2))

(instance and LogicalOperator)
(domain and 1 Formula)
(domain and 2 Formula)
(documentation and "The truth-functional connective of conjunction.")

(instance or LogicalOperator)
(domain or 1 Formula)
(domain or 2 Formula)
(documentation or "The truth-functional connective of disjunction.")

(instance => LogicalOperator)
(domain => 1 Formula)
(domain => 2 Formula)
(documentation => "The truth-functional connective of implication.")

(instance <=> LogicalOperator)
(domain <=> 1 Formula)
(domain <=> 2 Formula)
(documentation <=> "The truth-functional connective of bi-implication.")

(instance not LogicalOperator)
(domain not 1 Formula)
(documentation not "The truth-functional connective of negation.")

(instance forall LogicalOperator)
(domain forall 1 List)
(domain forall 2 Formula)
(documentation forall "The universal quantifier of predicate logic.")

(instance exists LogicalOperator)
(domain exists 1 List)
(domain exists 2 Formula)
(documentation exists "The existential quantifier of predicate logic.")

(instance entails LogicalOperator)
(domain entails 1 Formula)
(domain entails 2 Formula)
(documentation entails "The operator of logical entailment.  (&%entails
?FORMULA1 ?FORMULA2) means that ?FORMULA2 can be derived from ?FORMULA1
by means of the proof theory of SUO-KIF.")

(=>
   (entails ?FORMULA1 ?FORMULA2)
   (=> ?FORMULA1 ?FORMULA2))

(instance AssignmentFn Function)
(instance AssignmentFn VariableArityRelation)
(domain AssignmentFn 1 Function)
(range AssignmentFn Entity)
(documentation AssignmentFn "If F is a function with a value for the
objects denoted by N1,..., NK, then the term (AssignmentFn F N1 ... NK)
denotes the value of applying F to the objects denoted by N1,..., NK.
Otherwise, the value is undefined.")

(instance holds Predicate)
(instance holds VariableArityRelation)
(domain holds 1 Relation)
(documentation holds "(holds P N1 ... NK) is true just in case
the tuple of objects denoted by N1,..., NK is an element of
the &%Relation P.")

(<=>
   (and
      (holds ?REL @ROW ?INST)
      (instance ?REL Function))
   (equal (AssignmentFn ?REL @ROW) ?INST))

(=>
   (instance ?REL Predicate)
   (<=>
        (holds ?REL @ROW)
        (?REL @ROW)))

(instance PowerSetFn UnaryFunction)
(domain PowerSetFn 1 SetOrClass)
(rangeSubclass PowerSetFn SetOrClass)
(documentation PowerSetFn "(&%PowerSetFn ?CLASS) maps the &%SetOrClass
?CLASS to the &%SetOrClass of all &%subclasses of ?CLASS.")

(<=>
   (instance ?SUBCLASS (PowerSetFn ?CLASS))
   (subclass ?SUBCLASS ?CLASS))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;
;;   BASE ONTOLOGY   ;;
;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'STRUCTURAL ONTOLOGY'

;; The following hierarchy incorporates content from Sowa, Russell & Norvig,
;; and the top-level ontology from ITBM-CNR.

(documentation Entity "The universal class of individuals.  This is the root
node of the ontology.")

(instance ?THING Entity)

(exists (?THING) (instance ?THING Entity))

(=>
	(instance ?CLASS Class)
      (subclass ?CLASS Entity))

(subclass Physical Entity)
(partition Physical Object Process)
(documentation Physical "An entity that has a location in space-time.
Note that locations are themselves understood to have a location in
space-time.")

(<=>
	(instance ?PHYS Physical)
	(exists (?LOC ?TIME)
     		(and
			(located ?PHYS ?LOC)
                  (time ?PHYS ?TIME))))

(subclass Object Physical)
(documentation Object "Corresponds roughly to the class of ordinary
objects.  Examples include normal physical objects, geographical regions,
and locations of &%Processes, the complement of &%Objects in the &%Physical
class.  In a 4D ontology, an &%Object is something whose spatiotemporal
extent is thought of as dividing into spatial parts roughly parallel to the
time-axis.")

(subclass SelfConnectedObject Object)
(documentation SelfConnectedObject "A &%SelfConnectedObject is any
&%Object that does not consist of two or more disconnected parts.")

(instance FrontFn SpatialRelation)
(instance FrontFn UnaryFunction)
(instance FrontFn AsymmetricRelation)
(instance FrontFn IrreflexiveRelation)
(domain FrontFn 1 SelfConnectedObject)
(range FrontFn SelfConnectedObject)
(documentation FrontFn "A &%Function that maps an &%Object to the side
that generally receives the most attention or that typically faces the
direction in which the &%Object moves.  Note that this is a partial
function, since some &%Objects do not have sides, e.g. apples and
spheres.  Note too that the &%range of this &%Function is indefinite in
much the way that &%ImmediateFutureFn and &%ImmediatePastFn are indefinite.
Although this indefiniteness is undesirable from a theoretical standpoint,
it does not have significant practical implications, since there is
widespread intersubjective agreement about the most common cases.")

(=>
   (instance ?OBJ SelfConnectedObject)
   (part (FrontFn ?OBJ) ?OBJ))

(instance BackFn SpatialRelation)
(instance BackFn UnaryFunction)
(instance BackFn AsymmetricRelation)
(instance BackFn IrreflexiveRelation)
(domain BackFn 1 SelfConnectedObject)
(range BackFn SelfConnectedObject)
(documentation BackFn "A &%Function that maps an &%Object to the side
that is opposite the &%FrontFn of the &%Object.  Note that this is a
partial function, since some &%Objects do not have sides, e.g. apples
and spheres.  Note too that the &%range of this &%Function is indefinite in
much the way that &%ImmediateFutureFn and &%ImmediatePastFn are indefinite.
Although this indefiniteness is undesirable from a theoretical standpoint,
it does not have significant practical implications, since there is
widespread intersubjective agreement about the most common cases.")

(=>
   (instance ?OBJ SelfConnectedObject)
   (part (BackFn ?OBJ) ?OBJ))

(subrelation part located)
(instance part SpatialRelation)
(instance part PartialOrderingRelation)
(domain part 1 Object)
(domain part 2 Object)
(documentation part "The basic mereological relation.  All other
mereological relations are defined in terms of this one.
(&%part ?PART ?WHOLE) simply means that the &%Object ?PART is part
of the &%Object ?WHOLE.  Note that, since &%part is a
&%ReflexiveRelation, every &%Object is a part of itself.")

(instance properPart AsymmetricRelation)
(instance properPart TransitiveRelation)
(subrelation properPart part)
(documentation properPart "(&%properPart ?OBJ1 ?OBJ2) means that
?OBJ1 is a part of ?OBJ2 other than ?OBJ2 itself. This is a
&%TransitiveRelation and &%AsymmetricRelation (hence an
&%IrreflexiveRelation).")

(<=>
   (properPart ?OBJ1 ?OBJ2)
      (and
	   (part ?OBJ1 ?OBJ2)
	   (not
	      (part ?OBJ2 ?OBJ1))))

(subrelation piece part)
(domain piece 1 Substance)
(domain piece 2 Substance)
(documentation piece "A specialized common sense notion of part for
arbitrary parts of &%Substances.  Quasi-synonyms are: chunk, hunk, bit,
etc.  Compare &%component, the other subrelation of &%part.")

(=>
   (piece ?SUBSTANCE1 ?SUBSTANCE2)
   (forall (?CLASS)
      (=>
         (instance ?SUBSTANCE1 ?CLASS)
         (instance ?SUBSTANCE2 ?CLASS))))

(subrelation component part)
(domain component 1 CorpuscularObject)
(domain component 2 CorpuscularObject)
(documentation component "A specialized common sense notion of part
for heterogeneous parts of complexes. (&%component ?COMPONENT ?WHOLE)
means that ?COMPONENT is a component of ?WHOLE. Examples of component
include the doors and walls of a house, the states or provinces of a
country, or the limbs and organs of an animal.  Compare &%piece, which
is also a subrelation of &%part.")

(instance material BinaryPredicate)
(domainSubclass material 1 Substance)
(domain material 2 CorpuscularObject)
(documentation material "(&%material ?SUBSTANCE ?OBJECT) means that
?OBJECT is structurally made up in part of ?SUBSTANCE. This relation
encompasses the concepts of 'composed of', 'made of', and 'formed of'.
For example, plastic is a &%material of my computer monitor.  Compare
&%part and its subrelations, viz &%component and &%piece.")

(subclass Substance SelfConnectedObject)
(documentation Substance "An &%Object in which every part is similar to
every other in every relevant respect.  More precisely, something is a
&%Substance when it has only arbitrary pieces as parts - any parts have
properties which are similar to those of the whole.  Note that a &%Substance
may nonetheless have physical properties that vary.  For example, the
temperature, chemical constitution, density, etc. may change from one part
to another.  An example would be a body of water.")

(=>
   (and
      (subclass ?OBJECTTYPE Substance)
      (instance ?OBJECT ?OBJECTTYPE)
      (part ?PART ?OBJECT))
   (instance ?PART ?OBJECTTYPE))

(=>
   (and
      (instance ?OBJ Substance)
      (attribute ?OBJ ?ATTR)
      (part ?PART ?OBJ))
   (attribute ?PART ?ATTR))

(subclass PureSubstance Substance)
(partition PureSubstance CompoundSubstance ElementalSubstance)
(documentation PureSubstance "The &%Class of &%Substances with constant
composition.  A &%PureSubstance can be either an element (&%ElementalSubstance)
or a compound of elements (&%CompoundSubstance).  Examples: Table salt
(sodium chloride, NaCl), sugar (sucrose, C_{12}H_{22}O_{11}), water (H_2O),
iron (Fe), copper (Cu), and oxygen (O_2).")

(subclass ElementalSubstance PureSubstance)
(documentation ElementalSubstance "The &%Class of &%PureSubstances that
cannot be separated into two or more &%Substances by ordinary chemical
(or physical) means. This excludes nuclear reactions. &%ElementalSubstances
are composed of only one kind of atom. Examples: Iron (Fe), copper (Cu),
and oxygen (O_2).  &%ElementalSubstances are the simplest
&%PureSubstances.")

(subclass Metal ElementalSubstance)
(documentation Metal "A &%Metal is an &%ElementalSubstance that conducts heat
and electricity, is shiny and reflects many colors of light, and can be hammered
into sheets or drawn into wire.  About 80% of the known chemical elements
(&%ElementalSubstances) are metals.")

(subclass Atom ElementalSubstance)
(documentation Atom "An extremely small unit of matter that retains its
identity in Chemical reactions.  It consists of an &%AtomicNucleus and
&%Electrons surrounding the &%AtomicNucleus.")

(=>
   (instance ?ATOM Atom)
   (exists (?PROTON ?ELECTRON)
      (and
         (component ?PROTON ?ATOM)
	   (component ?ELECTRON ?ATOM)
         (instance ?PROTON Proton)
         (instance ?ELECTRON Electron))))

(=>
   (instance ?ATOM Atom)
   (forall (?NUCLEUS1 ?NUCLEUS2)
      (=>
         (and
            (component ?NUCLEUS1 ?ATOM)
	      (component ?NUCLEUS2 ?ATOM)
            (instance ?NUCLEUS1 AtomicNucleus)
            (instance ?NUCLEUS2 AtomicNucleus))
	   (equal ?NUCLEUS1 ?NUCLEUS2))))

(subclass SubatomicParticle ElementalSubstance)
(documentation SubatomicParticle "The class of &%ElementalSubstances that
are smaller than &%Atoms and compose &%Atoms.")

(=>
   (instance ?PARTICLE SubatomicParticle)
   (exists (?ATOM)
      (and
         (instance ?ATOM Atom)
         (part ?PARTICLE ?ATOM))))

(subclass AtomicNucleus SubatomicParticle)
(documentation AtomicNucleus "The core of the &%Atom.  It is composed of
&%Protons and &%Neutrons.")

(=>
   (instance ?NUCLEUS AtomicNucleus)
   (exists (?NEUTRON ?PROTON)
      (and
         (component ?NEUTRON ?NUCLEUS)
	   (component ?PROTON ?NUCLEUS)
         (instance ?NEUTRON Neutron)
         (instance ?PROTON Proton))))

(subclass Electron SubatomicParticle)
(documentation Electron "&%SubatomicParticles that surround the
&%AtomicNucleus.  They have a negative charge.")

(subclass Proton SubatomicParticle)
(documentation Proton "Components of the &%AtomicNucleus.  They have a
positive charge.")

(subclass Neutron SubatomicParticle)
(documentation Neutron "Components of the &%AtomicNucleus.  They have no
charge.")

(subclass CompoundSubstance PureSubstance)
(documentation CompoundSubstance "The &%Class of &%Substances that contain
two or more elements (&%ElementalSubstances), in definite proportion by weight.
The composition of a pure compound will be invariant, regardless of the method
of preparation. Compounds are composed of more than one kind of atom (element).
The term molecule is often used for the smallest unit of a compound that still
retains all of the properties of the compound.  Examples: Table salt (sodium
chloride, NaCl), sugar (sucrose, C_{12}H_{22}O_{11}), and water (H_2O). ")

(subclass Mixture Substance)
(documentation Mixture "A &%Mixture is two or more &%PureSubstances,
combined in varying proportions - each retaining its own specific properties.
The components of a &%Mixture can be separated by physical means, i.e. without
the making and breaking of chemical bonds. Examples: Air, table salt thoroughly
dissolved in water, milk, wood, and concrete. ")

(=>
   (instance ?MIXTURE Mixture)
   (exists (?PURE1 ?PURE2)
      (and
         (subclass ?PURE1 PureSubstance)
         (subclass ?PURE2 PureSubstance)
         (not (equal ?PURE1 ?PURE2))
         (piece ?PURE1 ?MIXTURE)
         (piece ?PURE2 ?MIXTURE))))

(subclass Solution Mixture)
(documentation Solution "A liquid mixture. The most abundant component in
a solution is called the solvent. Other components are called solutes.
A solution, though homogeneous, may nonetheless have variable composition.
Any amount of salt, up to a maximum limit, can be dissolved in a given
amount of water.")

(subclass CorpuscularObject SelfConnectedObject)
(disjoint CorpuscularObject Substance)
(documentation CorpuscularObject "A &%SelfConnectedObject whose parts have
properties that are not shared by the whole.")

(=>
   (instance ?OBJ CorpuscularObject)
   (exists (?SUBSTANCE1 ?SUBSTANCE2)
      (and
         (subclass ?SUBSTANCE1 Substance)
         (subclass ?SUBSTANCE2 Substance)
         (material ?SUBSTANCE1 ?OBJ)
         (material ?SUBSTANCE2 ?OBJ)
         (not (equal ?SUBSTANCE1 ?SUBSTANCE2)))))

(subclass Region Object)
(documentation Region "A topographic location.  &%Regions encompass
surfaces of &%Objects, imaginary places, and &%GeographicAreas.  Note
that a &%Region is the only kind of &%Object which can be located at
itself.  Note too that &%Region is not a subclass of &%SelfConnectedObject,
because some &%Regions, e.g. archipelagos, have &%parts which are not
&%connected with one another.")

(=>
   (instance ?REGION Region)
   (exists (?PHYS)
      (located ?PHYS ?REGION)))

(subclass Collection Object)
(disjoint Collection SelfConnectedObject)
(documentation Collection "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.")

(=>
   (instance ?COLL Collection)
   (exists (?OBJ)
	(member ?OBJ ?COLL)))

(subrelation member part)
(instance member AsymmetricRelation)
(instance member IntransitiveRelation)
(domain member 1 SelfConnectedObject)
(domain member 2 Collection)
(relatedInternalConcept member instance)
(relatedInternalConcept member element)
(documentation member "A specialized common sense notion of part for
uniform parts of &%Collections.  For example, each sheep in a flock of
sheep would have the relationship of member to the flock.")

(instance subCollection BinaryPredicate)
(instance subCollection TransitiveRelation)
(instance subCollection IrreflexiveRelation)
(domain subCollection 1 Collection)
(domain subCollection 2 Collection)
(documentation subCollection "(&%subCollection ?COLL1 ?COLL2) means that
the &%Collection ?COLL1 is a proper part of the &%Collection ?COLL2.")

(subclass ContentBearingObject SelfConnectedObject)
(relatedInternalConcept ContentBearingObject containsInformation)
(documentation ContentBearingObject "Any &%SelfConnectedObject that expresses
information.")

(subclass SymbolicString ContentBearingObject)
(documentation SymbolicString "The &%Class of alphanumeric sequences.")

(subclass Character SymbolicString)
(documentation Character "An element of an alphabet, a set of numerals, etc.
Note that a &%Character may or may not be part of a &%Language.  &%Character
is a subclass of &%SymbolicString, because every instance of &%Character is
an alphanumeric sequence consisting of a single element.")

(=>
    (instance ?STRING SymbolicString)
    (exists (?PART)
        (and
            (part ?PART ?STRING)
            (instance ?PART Character))))

(instance containsInformation BinaryPredicate)
(instance containsInformation AsymmetricRelation)
(subrelation containsInformation represents)
(domain containsInformation 1 ContentBearingObject)
(domain containsInformation 2 Proposition)
(documentation containsInformation "A subrelation of &%represents.  This
predicate relates a &%ContentBearingObject to the &%Proposition that is
expressed by the &%ContentBearingObject. Examples include the relationships
between a physical novel and its story and between a printed score and its
musical content.")

(subclass Icon ContentBearingObject)
(documentation Icon "This is the subclass of &%ContentBearingObjects
which are not part of a &%Language and which have some sort of similarity
with the &%Objects that they represent.  This &%Class would include symbolic
roadway signs, 'icons' in a graphical computer operating system, etc.")

(subclass MotionPicture Text)
(documentation MotionPicture "A &%ContentBearingObject which depicts motion
(and which may have an audio or text component as well).  This &%Class covers
films, videos, etc.")

(subclass LinguisticExpression ContentBearingObject)
(disjoint LinguisticExpression Icon)
(documentation LinguisticExpression "This is the subclass of
&%ContentBearingObjects which are language-related.  Note that this &%Class
encompasses both &%Language and the the elements of &%Languages,
e.g. &%Words.")

(subclass Language LinguisticExpression)
(disjointDecomposition Language AnimalLanguage HumanLanguage ComputerLanguage)
(documentation Language "A system of signs for expressing thought.  The
system can be either natural or artificial, i.e. something that emerges
gradually as a cultural artifact or something that is intentionally created
by a person or group of people.")

(subclass AnimalLanguage Language)
(documentation AnimalLanguage "The &%subclass of &%Languages used by
&%Animals other than &%Humans.")

(=>
   (and
      (instance ?LANG AnimalLanguage)
      (agent ?PROC ?AGENT)
      (instrument ?PROC ?LANG))
   (and
      (instance ?AGENT Animal)
      (not (instance ?AGENT Human))))

(subclass ArtificialLanguage Language)
(documentation ArtificialLanguage "The &%subclass of &%Languages that are
designed by &%Humans.")

(subclass ComputerLanguage ArtificialLanguage)
(documentation ComputerLanguage "The class of &%Languages designed for
and interpreted by a computer.")

(=>
   (and
      (instance ?LANG ComputerLanguage)
      (agent ?PROC ?AGENT)
      (instrument ?PROC ?LANG))
   (instance ?AGENT Machine))

(subclass HumanLanguage Language)
(documentation HumanLanguage "The &%subclass of &%Languages used by
&%Humans.")

(=>
   (and
      (instance ?LANG HumanLanguage)
      (agent ?PROC ?AGENT)
      (instrument ?PROC ?LANG))
   (instance ?AGENT Human))

(subclass ConstructedLanguage HumanLanguage)
(subclass ConstructedLanguage ArtificialLanguage)
(documentation ConstructedLanguage "The &%subclass of &%HumanLanguages
that did not originate diachronically, but were designed by a &%Human.
This &%Class includes languages like Esperanto that were created to
facilitate international communication.")

(=>
   (instance ?LANG ConstructedLanguage)
   (exists (?PLAN)
      (and
         (instance ?PLAN Planning)
         (result ?PLAN ?LANG))))

(subclass NaturalLanguage HumanLanguage)
(disjoint NaturalLanguage ConstructedLanguage)
(documentation NaturalLanguage "The &%subclass of &%HumanLanguages which
are not designed and which evolve from generation to generation.  This
&%Class includes all of the national languages, e.g. English, Spanish,
Japanese, etc.  Note that this class includes dialects of natural
languages.")

(subclass Word LinguisticExpression)
(documentation Word "A term of a &%Language that represents a concept.")

(subclass Formula Sentence)
(documentation Formula "A syntactically well-formed formula in the
SUO-KIF knowledge representation language.")

;; The following ground facts incorporate the 'Agent' hierarchy from the
;; corresponding ontology on the Ontolingua server.  It also includes
;; predicates defined in the ITBM-CNR ontology "Actors".

(subclass Agent Object)
(documentation Agent "Something or someone that can act on its own and
produce changes in the world.")

(<=>
	(instance ?AGENT Agent)
	(exists (?PROC)
		(agent ?PROC ?AGENT)))

(subclass SentientAgent Agent)
(documentation SentientAgent "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 example of &%SentientAgents that are not
also &%CognitiveAgents.")

(subclass CognitiveAgent SentientAgent)
(documentation CognitiveAgent "A &%SentientAgent with responsibilities
and the ability to reason, deliberate, make plans, etc.  This is
essentially the legal/ethical notion of a person.  Note that, although
&%Human is a subclass of &%CognitiveAgent, there may be instances of
&%CognitiveAgent which are not also instances of &%Human.  For example,
chimpanzees, gorillas, dolphins, whales, and some extraterrestrials
(if they exist) may be &%CognitiveAgents.")

(subclass Process Physical)
(documentation Process "Intuitively, the class of things that happen
and have temporal parts or stages.  Examples include extended events
like a football match or a race, actions like &%Searching and &%Reading,
and biological processes. The formal definition is: anything that lasts
for a time but is not an &%Object.  Note that a &%Process may have
participants 'inside' it which are &%Objects, such as the players
in a football match.  In a 4D ontology, a &%Process is something whose
spatiotemporal extent is thought of as dividing into temporal stages
roughly perpendicular to the time-axis.")

(subclass DualObjectProcess Process)
(documentation DualObjectProcess "Any &%Process that requires two,
nonidentical &%patients.")

(=>
   (instance ?PROCESS DualObjectProcess)
   (exists (?OBJ1 ?OBJ2)
      (and
         (patient ?PROCESS ?OBJ1)
         (patient ?PROCESS ?OBJ2)
         (not (equal ?OBJ1 ?OBJ2)))))

(subclass Abstract Entity)
(disjoint Abstract Physical)
(documentation Abstract "Properties or qualities as distinguished from any
particular embodiment of the properties/qualities in a physical medium.
Instances of Abstract can be said to exist in the same sense as mathematical
objects such as sets and relations, but they cannot exist at a particular
place and time without some physical encoding or embodiment.")

;; Something is Abstract just in case it has neither a spatial nor temporal
;; location.

(<=>
   (instance ?ABS Abstract)
   (not
      (exists (?POINT)
         (or
	      (located ?ABS ?POINT)
            (time ?ABS ?POINT)))))

(subclass Quantity Abstract)
(documentation Quantity "Any specification of how many or how much of
something there is.  Accordingly, there are two subclasses of &%Quantity:
&%Number (how many) and &%PhysicalQuantity (how much).")

(subclass Attribute Abstract)
(disjoint Attribute Quantity)
(partition Attribute InternalAttribute RelationalAttribute)
(documentation Attribute "Qualities which we cannot or choose not to
reify into subclasses of &%Object.")

(instance property BinaryPredicate)
(domain property 1 Entity)
(domain property 2 Attribute)
(documentation property "This &%Predicate holds between an instance of
&%Entity and an instance of &%Attribute.  (property ?ENTITY ?ATTR)
means that ?ENTITY has the &%Attribute ?ATTR.")

(instance attribute AsymmetricRelation)
(instance attribute IrreflexiveRelation)
(subrelation attribute property)
(domain attribute 1 Object)
(domain attribute 2 Attribute)
(documentation attribute "(&%attribute ?OBJECT ?PROPERTY) means that
?PROPERTY is a &%Attribute of ?OBJECT.  For example,
(&%attribute &%MyLittleRedWagon &%Red).")

(instance manner AsymmetricRelation)
(instance manner IrreflexiveRelation)
(subrelation manner property)
(domain manner 1 Process)
(domain manner 2 Attribute)
(disjointRelation manner attribute)
(documentation manner "(&%manner ?PROCESS ?MANNER) means that the
&%Process ?PROCESS is qualified by the &%Attribute ?MANNER.  The &%Attributes
of &%Processes are usually denoted by adverbs and include things like the
speed of the wind, the style of a dance, or the intensity of a sports
competition.")

(instance AbstractionFn UnaryFunction)
(domain AbstractionFn 1 Class)
(range AbstractionFn Attribute)
(documentation AbstractionFn "A &%UnaryFunction that maps a &%Class into
the instance of &%Attribute that specifies the condition(s) for membership
in the &%Class.")

(<=>
   (equal (AbstractionFn ?CLASS) ?ATTR)
   (forall (?INST)
      (<=>
         (instance ?INST ?CLASS)
         (property ?INST ?ATTR))))

(instance ExtensionFn UnaryFunction)
(domain ExtensionFn 1 Attribute)
(range ExtensionFn Class)
(documentation ExtensionFn "A &%UnaryFunction that maps an &%Attribute
into the &%Class whose condition for membership is the &%Attribute.")

(<=>
   (equal (ExtensionFn ?ATTRIBUTE) ?CLASS)
   (equal (AbstractionFn ?CLASS) ?ATTRIBUTE))

(subclass InternalAttribute Attribute)
(documentation InternalAttribute "Any &%Attribute of an &%Entity that is an
internal property of the &%Entity, e.g. its shape, its color, its fragility,
etc.")

(subclass RelationalAttribute Attribute)
(documentation RelationalAttribute "Any &%Attribute that an &%Entity has by
virtue of a relationship that it bears to another &%Entity or set of &%Entities,
e.g. &%SocialRoles and &%PositionalAttributes.")

;; The following formulas incorporate the Number hierarchy from the
;; ontology 'kif-numbers' on the Ontolingua server.

(subclass Number Quantity)
(documentation Number "A measure of how many things there are, or how
much there is, of a certain kind.  &%Numbers are subclassed into
&%RealNumber, &%ComplexNumber, and &%ImaginaryNumber.")

(instance lessThan BinaryPredicate)
(instance lessThan TransitiveRelation)
(instance lessThan IrreflexiveRelation)
(instance lessThan RelationExtendedToQuantities)
(trichotomizingOn lessThan RealNumber)
(domain lessThan 1 Quantity)
(domain lessThan 2 Quantity)
(documentation lessThan "(&%lessThan ?NUMBER1 ?NUMBER2) is true just
in case the &%Quantity ?NUMBER1 is less than the &%Quantity ?NUMBER2.")

(instance greaterThan BinaryPredicate)
(instance greaterThan TransitiveRelation)
(instance greaterThan IrreflexiveRelation)
(instance greaterThan RelationExtendedToQuantities)
(trichotomizingOn greaterThan RealNumber)
(domain greaterThan 1 Quantity)
(domain greaterThan 2 Quantity)
(inverse greaterThan lessThan)
(documentation greaterThan "(&%greaterThan ?NUMBER1 ?NUMBER2) is true
just in case the &%Quantity ?NUMBER1 is greater than the &%Quantity
?NUMBER2.")

(instance lessThanOrEqualTo BinaryPredicate)
(instance lessThanOrEqualTo PartialOrderingRelation)
(instance lessThanOrEqualTo RelationExtendedToQuantities)
(trichotomizingOn lessThanOrEqualTo RealNumber)
(domain lessThanOrEqualTo 1 Quantity)
(domain lessThanOrEqualTo 2 Quantity)
(documentation lessThanOrEqualTo "(&%lessThanOrEqualTo ?NUMBER1 ?NUMBER2)
is true just in case the &%Quantity ?NUMBER1 is less than or equal to
the &%Quantity ?NUMBER2.")

(<=>
	(lessThanOrEqualTo ?NUMBER1 ?NUMBER2)
	(or
		(equal ?NUMBER1 ?NUMBER2)
		(lessThan ?NUMBER1 ?NUMBER2)))

(instance greaterThanOrEqualTo BinaryPredicate)
(instance greaterThanOrEqualTo PartialOrderingRelation)
(instance greaterThanOrEqualTo RelationExtendedToQuantities)
(trichotomizingOn greaterThanOrEqualTo RealNumber)
(domain greaterThanOrEqualTo 1 Quantity)
(domain greaterThanOrEqualTo 2 Quantity)
(inverse greaterThanOrEqualTo lessThanOrEqualTo)
(documentation greaterThanOrEqualTo "(&%greaterThanOrEqualTo ?NUMBER1
?NUMBER2) is true just in case the &%Quantity ?NUMBER1 is greater
than the &%Quantity ?NUMBER2.")

(<=>
	(greaterThanOrEqualTo ?NUMBER1 ?NUMBER2)
	(or
		(equal ?NUMBER1 ?NUMBER2)
		(greaterThan ?NUMBER1 ?NUMBER2)))

(subclass RealNumber Number)
(partition RealNumber NegativeRealNumber NonnegativeRealNumber)
(partition RealNumber RationalNumber IrrationalNumber)
(documentation RealNumber "Any &%Number that can be expressed as a
(possibly infinite) decimal, i.e. any &%Number that has a position
on the number line.")

(subclass ImaginaryNumber Number)
(documentation ImaginaryNumber "Any &%Number that is the result of
multiplying a &%RealNumber by the square root of -1.")

(=>
   (instance ?NUMBER ImaginaryNumber)
   (exists (?REAL)
      (and
         (instance ?REAL RealNumber)
         (equal ?NUMBER (MultiplicationFn ?REAL (SquareRootFn -1))))))

(subclass RationalNumber RealNumber)
(documentation RationalNumber "Any &%RealNumber that is the product of
dividing two &%Integers.")

(subclass IrrationalNumber RealNumber)
(documentation IrrationalNumber "Any &%RealNumber that is not also a
&%RationalNumber.")

(subclass NonnegativeRealNumber RealNumber)
(documentation NonnegativeRealNumber "A &%RealNumber that is greater than
or equal to zero.")

(=>
   (instance ?NUMBER NonnegativeRealNumber)
   (greaterThanOrEqualTo ?NUMBER 0))

(subclass PositiveRealNumber NonnegativeRealNumber)
(documentation PositiveRealNumber "A &%RealNumber that is greater than
zero.")

(=>
   (instance ?NUMBER PositiveRealNumber)
   (greaterThan ?NUMBER 0))

(subclass NegativeRealNumber RealNumber)
(documentation NegativeRealNumber "A &%RealNumber that is less than
zero.")

(=>
   (instance ?NUMBER NegativeRealNumber)
   (lessThan ?NUMBER 0))

(subclass Integer RationalNumber)
(partition Integer OddInteger EvenInteger)
(partition Integer NegativeInteger NonnegativeInteger)
(documentation Integer "A negative or nonnegative whole number.")

(subclass EvenInteger Integer)
(documentation EvenInteger "An &%Integer that is evenly divisible
by 2.")

(subclass OddInteger Integer)
(documentation OddInteger "An &%Integer that is not evenly divisible
by 2.")

(subclass PrimeNumber Integer)
(documentation PrimeNumber "An &%Integer that is evenly divisible only
by itself and 1.")

(subclass NonnegativeInteger Integer)
(subclass NonnegativeInteger NonnegativeRealNumber)
(documentation NonnegativeInteger "An &%Integer that is greater than
or equal to zero.")

(subclass NegativeInteger Integer)
(subclass NegativeInteger NegativeRealNumber)
(documentation NegativeInteger "An &%Integer that is less than zero.")

(subclass PositiveInteger NonnegativeInteger)
(subclass PositiveInteger PositiveRealNumber)
(documentation PositiveInteger "An &%Integer that is greater than zero.")

(subclass BinaryNumber RealNumber)
(documentation BinaryNumber "Elements from the number system with base 2.
Every &%BinaryNumber is expressed as a sequence of the digits 1 and 0.")

(subclass ComplexNumber Number)
(disjoint ComplexNumber RealNumber)
(documentation ComplexNumber "A &%Number that has the form: x + yi, where x
and y are &%RealNumbers and i is the square root of -1.")

(=>
   (instance ?NUMBER ComplexNumber)
   (exists (?REAL1 ?REAL2)
      (and
         (instance ?REAL1 RealNumber)
         (instance ?REAL2 RealNumber)
         (equal ?NUMBER (AdditionFn ?REAL1 (MultiplicationFn ?REAL2 (SquareRootFn -1)))))))

(subclass PhysicalQuantity Quantity)
(partition PhysicalQuantity ConstantQuantity FunctionQuantity)
(documentation PhysicalQuantity "&%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 instances of &%PhysicalQuantity.
&%PhysicalQuantities are distinguished from &%Numbers by the fact that
the former are associated with a dimension of measurement.")

(subclass ConstantQuantity PhysicalQuantity)
(documentation ConstantQuantity "A &%ConstantQuantity is a
&%PhysicalQuantity which has a constant value, e.g. 3 meters and 5 hours.
The magnitude (see &%MagnitudeFn) of every &%ConstantQuantity is a
&%RealNumber.  &%ConstantQuantities are distinguished from
&%FunctionQuantities, which map &%ConstantQuantities to other
&%ConstantQuantities.  All &%ConstantQuantites are expressed with the
&%BinaryFunction &%MeasureFn, which takes a &%Number and a &%UnitOfMeasure
as arguments.  For example, 3 &%Meters can be expressed as (&%MeasureFn 3
&%Meter).  &%ConstantQuantities form a partial order (see
&%PartialOrderingRelation) with the &%lessThan relation, since &%lessThan
is a &%RelationExtendedToQuantities and &%lessThan is defined over the
&%RealNumbers.  The &%lessThan relation is not a total order (see
&%TotalOrderingRelation) over the class &%ConstantQuantity since elements
of some subclasses of &%ConstantQuantity (such as length quantities)
are incomparable to elements of other subclasses of &%ConstantQuantity
(such as mass quantities).")

(subclass TimeMeasure ConstantQuantity)
(documentation TimeMeasure "The class of temporal durations (instances
of &%TimeDuration) and positions of &%TimePoints and &%TimeIntervals along
the universal timeline (instances of &%TimePosition).")

(subclass TimeDuration TimeMeasure)
(documentation TimeDuration "Any measure of length of time,
with or without respect to the universal timeline.")

(subclass TimePosition TimeMeasure)
(partition TimePosition TimeInterval TimePoint)
(documentation TimePosition "Any &%TimePoint or &%TimeInterval
along the universal timeline from &%NegativeInfinity to
&%PositiveInfinity.")

(subclass TimeInterval TimePosition)
(documentation TimeInterval "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.")

(subclass TimePoint TimePosition)
(documentation TimePoint "An extensionless point on the universal timeline.
The &%TimePoints at which &%Processes occur can be known with various
degrees of precision and approximation, but conceptually &%TimePoints are
point-like and not interval-like.  That is, it doesn't make sense to talk
about what happens during a &%TimePoint, or how long the &%TimePoint lasts.")

(subclass FunctionQuantity PhysicalQuantity)
(subclass FunctionQuantity Function)
(documentation FunctionQuantity "A &%FunctionQuantity is a &%Function that
maps from one or more instances of &%ConstantQuantity to another instance
of &%ConstantQuantity.  For example, the velocity of a particle would be
represented by a &%FunctionQuantity mapping values of time (which are
&%ConstantQuantities) to values of distance (also &%ConstantQuantities).
Note that all instances of &%FunctionQuantity are &%Functions with a fixed
arity.  Note too that all elements of the range of a &%FunctionQuantity
have the same physical dimension as the &%FunctionQuantity itself.")

(subclass UnaryConstantFunctionQuantity FunctionQuantity)
(subclass UnaryConstantFunctionQuantity UnaryFunction)
(documentation UnaryConstantFunctionQuantity "The class of &%UnaryFunctions
that map from the &%Class &%ConstantQuantity to the &%Class
&%ConstantQuantity.")

(=>
   (instance ?FUNCTION UnaryConstantFunctionQuantity)
   (and
      (domain ?FUNCTION 1 ConstantQuantity)
      (range ?FUNCTION ConstantQuantity)))

(subclass TimeDependentQuantity UnaryConstantFunctionQuantity)
(subclass TimeDependentQuantity ContinuousFunction)
(documentation TimeDependentQuantity "A &%UnaryConstantFunction of continuous
time.  All instances of this &%Class map a time quantity into another
&%ConstantQuantity such as temperature.  For example, 'the temperature at
the top of the Empire State Building' is a &%TimeDependentQuantity since
its value depends on the time.")

(=>
   (instance ?FUNCTION TimeDependentQuantity)
   (domain ?FUNCTION 1 TimeMeasure))

(subclass SetOrClass Abstract)
(partition SetOrClass Set Class)
(documentation SetOrClass "The &%SetOrClass of &%Sets and &%Classes, i.e. any instance
of &%Abstract that has &%elements or &%instances.")

(subclass Class SetOrClass)
(documentation Class "&%Classes differ from &%Sets in two important respects.
First, &%Classes are not assumed to be extensional.  That is, distinct
&%Classes might well have exactly the same instances.  Second, &%Classes typically
have an associated `condition' that determines the instances of the &%Class.  So,
for example, the condition `human' determines the &%Class of &%Humans.  Note that
some &%Classes might satisfy their own condition (e.g., the &%Class of &%Abstract
things is &%Abstract) and hence be instances of themselves.")

(subclass Set SetOrClass)
(documentation Set "A &%SetOrClass that satisfies extensionality as well as
other constraints specified by some choice of set theory.  &%Sets differ
from &%Classes in two important respects.  First, &%Sets are extensional -
two &%Sets with the same &%elements are identical.  Second, a &%Set can be
an arbitrary stock of objects.  That is, there is no requirement that &%Sets
have an associated condition that determines their membership.")

(subclass Relation Abstract)
(disjointDecomposition Relation BinaryRelation TernaryRelation QuaternaryRelation QuintaryRelation VariableArityRelation)
(partition Relation Predicate Function List)
(partition Relation TotalValuedRelation PartialValuedRelation)
(documentation Relation "The &%Class of relations.  There are three kinds
of &%Relation:  &%Predicate, &%Function, and &%List.  &%Predicates and
&%Functions both denote sets of ordered n-tuples.  The difference between
these two &%Classes is that &%Predicates cover formula-forming operators, while
&%Functions cover term-forming operators.  A &%List, on the other hand, is a
particular ordered n-tuple.")

;; The following part of the ontology covers the various classes under
;; 'Relation'.  Most of the content here is taken from frame-ontology,
;; abstract-algebra, kif-relations, and kif-extensions (ontologies
;; available on the Ontolingua server).

(subclass SingleValuedRelation Relation)
(instance SingleValuedRelation InheritableRelation)
(documentation SingleValuedRelation "A &%Relation is a &%SingleValuedRelation
just in case an assignment of values to every argument position except the last
one determines at most one assignment for the last argument position.  Note
that not all &%SingleValuedRelations are total functions.  To declare that a
&%Relation is a total function, use both &%SingleValuedFunction and
&%TotalValuedFunction.")

(<=>
   (instance ?REL SingleValuedRelation)
   (forall (@ROW ?ITEM1 ?ITEM2)
      (=>
         (and
            (holds ?REL @ROW ?ITEM1)
            (holds ?REL @ROW ?ITEM2))
         (equal ?ITEM1 ?ITEM2))))

(subclass TotalValuedRelation Relation)
(documentation TotalValuedRelation "A &%Relation is a &%TotalValuedRelation
just in case there exists an assignment for the last argument position of the
&%Relation given any assignment of values to every argument position except
the last one.  Note that declaring a &%Relation to be both a &%TotalValuedRelation
and a &%SingleValuedRelation means that it is a total function.")

(<=>
   (instance ?REL TotalValuedRelation)
   (forall (?VALENCE @ROW)
      (=>
         (and
            (valence ?REL ?VALENCE)
            (forall (?NUMBER ?ELEMENT ?CLASS)
               (=>
                  (and
                     (lessThan ?NUMBER ?VALENCE)
                     (domain ?REL ?NUMBER ?CLASS)
                     (equal ?ELEMENT (ListOrderFn (ListFn @ROW) ?NUMBER)))
                  (instance ?ELEMENT ?CLASS))))
         (exists (?ITEM)
            (holds ?REL @ROW ?ITEM)))))

(subclass PartialValuedRelation Relation)
(documentation PartialValuedRelation "A &%Relation is a &%PartialValuedRelation
just in case it is not a &%TotalValuedRelation, i.e. just in case assigning values
to every argument position except the last one does not necessarily mean that there
is a value assignment for the last argument position.  Note that, if a &%Relation
is both a &%PartialValuedRelation and a &%SingleValuedRelation, then it is a partial
function.")

(subclass BinaryRelation Relation)
(instance BinaryRelation InheritableRelation)
(documentation BinaryRelation "&%BinaryRelations are relations that are
true only of pairs of things.  &%BinaryRelations are represented as slots
in frame systems.")

(=>
   (instance ?REL BinaryRelation)
   (not
      (exists (?ITEM1 ?ITEM2 ?ITEM3 @ROW)
         (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 @ROW))))

(subclass ReflexiveRelation BinaryRelation)
(documentation ReflexiveRelation "&%Relation ?REL is reflexive if
(?REL ?INST ?INST) for all ?INST.")

(=>
   (instance ?REL ReflexiveRelation)
   (=>
      (or
         (instance ?INST (DomainFn ?REL))
 	   (instance ?INST (RangeFn ?REL)))
      (holds ?REL ?INST ?INST)))

(subclass IrreflexiveRelation BinaryRelation)
(documentation IrreflexiveRelation "&%Relation ?REL is irreflexive
if (?REL ?INST ?INST) holds for no value of ?INST.")

(=>
   (instance ?REL IrreflexiveRelation)
   (forall (?INST)
      (not
         (holds ?REL ?INST ?INST))))

(subclass SymmetricRelation BinaryRelation)
(documentation SymmetricRelation "A &%BinaryRelation ?REL is
symmetric just in case (?REL ?INST1 ?INST2) imples (?REL
?INST2 ?INST1), for all ?INST1 and ?INST2.")


(=>
   (instance ?REL SymmetricRelation)
   (forall (?INST1 ?INST2)
      (=>
         (holds ?REL ?INST1 ?INST2)
         (holds ?REL ?INST2 ?INST1))))

(subclass AsymmetricRelation IrreflexiveRelation)
(subclass AsymmetricRelation AntisymmetricRelation)
(documentation AsymmetricRelation "A &%BinaryRelation is asymmetric only
if it is both an &%AntisymmetricRelation and an &%IrreflexiveRelation.")

(=>
   (and
      (instance ?REL BinaryRelation)
      (or
         (domain ?REL 1 ?CLASS1)
         (domainSubclass ?REL 1 ?CLASS1))
      (or
         (domain ?REL 2 ?CLASS2)
         (domainSubclass ?REL 2 ?CLASS2)
         (range ?REL ?CLASS2)
         (rangeSubclass ?REL ?CLASS2))
      (disjoint ?CLASS1 ?CLASS2))
   (instance ?REL AsymmetricRelation))

(subclass AntisymmetricRelation BinaryRelation)
(documentation AntisymmetricRelation "&%BinaryRelation ?REL is an
&%AntisymmetricRelation if for distinct ?INST1 and ?INST2, (?REL ?INST1
?INST2) implies not (?REL ?INST2 ?INST1).  In other words, for all ?INST1
and ?INST2, (?REL ?INST1 ?INST2) and (?REL ?INST2 ?INST1) imply that ?INST1
and ?INST2 are identical.  Note that it is possible for an
&%AntisymmetricRelation to be a &%ReflexiveRelation.")

(=>
   (instance ?REL AntisymmetricRelation)
   (forall (?INST1 ?INST2)
      (=>
         (and
            (holds ?REL ?INST1 ?INST2)
            (holds ?REL ?INST2 ?INST1))
         (equal ?INST1 ?INST2))))

(subclass TrichotomizingRelation BinaryRelation)
(documentation TrichotomizingRelation "A &%BinaryRelation ?REL is a
&%TrichotomizingRelation just in case all ordered pairs consisting of
distinct individuals are elements of ?REL.")

(=>
   (instance ?REL TrichotomizingRelation)
   (forall (?INST1 ?INST2)
      (or
         (holds ?REL ?INST1 ?INST2)
         (equal ?INST1 ?INST2)
         (holds ?REL ?INST2 ?INST1))))

(subclass TransitiveRelation BinaryRelation)
(documentation TransitiveRelation "A &%BinaryRelation ?REL is transitive
if (?REL ?INST1 ?INST2) and (?REL ?INST2 ?INST3) imply (?REL ?INST1 ?INST3),
for all ?INST1, ?INST2, and ?INST3.")

(=>
   (instance ?REL TransitiveRelation)
   (forall (?INST1 ?INST2 ?INST3)
      (=>
         (and
            (holds ?REL ?INST1 ?INST2)
            (holds ?REL ?INST2 ?INST3))
         (holds ?REL ?INST1 ?INST3))))

(subclass IntransitiveRelation BinaryRelation)
(documentation IntransitiveRelation "A &%BinaryRelation ?REL is
intransitive only if (?REL ?INST1 ?INST2) and (?REL ?INST2 ?INST3) imply not
(?REL ?INST1 ?INST3), for all ?INST1, ?INST2, and ?INST3.")

(=>
   (instance ?REL IntransitiveRelation)
   (forall (?INST1 ?INST2 ?INST3)
      (=>
         (and
            (holds ?REL ?INST1 ?INST2)
            (holds ?REL ?INST2 ?INST3))
         (not
            (holds ?REL ?INST1 ?INST3)))))

(subclass PartialOrderingRelation TransitiveRelation)
(subclass PartialOrderingRelation AntisymmetricRelation)
(subclass PartialOrderingRelation ReflexiveRelation)
(documentation PartialOrderingRelation "A &%BinaryRelation is a partial
ordering if it is a &%ReflexiveRelation, an &%AntisymmetricRelation, and
a &%TransitiveRelation.")

(subclass TotalOrderingRelation PartialOrderingRelation)
(subclass TotalOrderingRelation TrichotomizingRelation)
(documentation TotalOrderingRelation  "A &%BinaryRelation is a
&%TotalOrderingRelation if it is a &%PartialOrderingRelation
and a &%TrichotomizingRelation.")

(=>
   (instance ?REL TotalOrderingRelation)
   (forall (?INST1 ?INST2)
      (or
         (holds ?REL ?INST1 ?INST2)
         (holds ?REL ?INST2 ?INST1))))

(subclass EquivalenceRelation TransitiveRelation)
(subclass EquivalenceRelation SymmetricRelation)
(subclass EquivalenceRelation ReflexiveRelation)
(documentation EquivalenceRelation "A &%BinaryRelation is an equivalence
relation if it is a &%ReflexiveRelation, a &%SymmetricRelation, and a
&%TransitiveRelation.")

(subclass CaseRole BinaryPredicate)
(instance CaseRole InheritableRelation)
(subclass CaseRole AsymmetricRelation)
(documentation CaseRole "The &%Class of &%Predicates relating the
spatially distinguished parts of a &%Process. &%CaseRoles include, for
example, the &%agent, &%patient or &%destination of an action, the flammable
substance in a burning process, or the water that falls in rain.")

(instance agent CaseRole)
(domain agent 1 Process)
(domain agent 2 Agent)
(documentation agent "(&%agent ?PROCESS ?AGENT) means that ?AGENT is
an active determinant, either animate or inanimate, of the &%Process
?PROCESS, with or without voluntary intention.  For example, water is
the &%agent of erosion in the following proposition:  the water
eroded the coastline.  For another example, Eve is an &%agent in the
following proposition: Eve bit an apple.")

(=>
   (instance ?PROCESS Process)
   (exists (?CAUSE)
      (agent ?PROCESS ?CAUSE)))

(instance destination CaseRole)
(domain destination 1 Process)
(domain destination 2 Entity)
(documentation destination "(destination ?PROCESS ?GOAL) means that
?GOAL is the target or goal of the Process ?PROCESS.  For example,
Danbury would be the destination in the following proposition:  Bob went
to Danbury.  Note that this is a very general &%CaseRole and, in
particular, that it covers the concepts of 'recipient' and 'beneficiary'.
Thus, John would be the &%destination in the following proposition:
Tom gave a book to John.")

(instance experiencer CaseRole)
(domain experiencer 1 Process)
(domain experiencer 2 Agent)
(documentation experiencer "(&%experiencer ?PROCESS ?AGENT) means
that ?AGENT experiences the &%Process ?PROCESS.  For example, Yojo
is the &%experiencer of seeing in the following proposition:  Yojo
sees the fish.  Note that &%experiencer, unlike &%agent, does
not entail a causal relation between its arguments.")

(subrelation instrument patient)
(domain instrument 1 Process)
(domain instrument 2 Object)
(documentation instrument "(instrument ?EVENT ?TOOL) means that ?TOOL
is used by an agent in bringing about ?EVENT and that ?TOOL is not
changed by ?EVENT.  For example, the key is an &%instrument in the
following proposition: The key opened the door.  Note that &%instrument
and &%resource cannot be satisfied by the same ordered pair.")

(instance origin CaseRole)
(domain origin 1 Process)
(domain origin 2 Object)
(documentation origin "(&%origin ?PROCESS ?SOURCE) means that ?SOURCE
indicates where the ?Process began.  Note that this relation implies
that ?SOURCE is present at the beginning of the process, but need not
participate throughout the process.  For example, the submarine is the
&%origin in the following proposition: the missile was launched from a
submarine.")

(instance patient CaseRole)
(domain patient 1 Process)
(domain patient 2 Entity)
(documentation patient "(&%patient ?PROCESS ?ENTITY) means that ?ENTITY
is a participant in ?PROCESS that may be moved, said, experienced, etc.
For example, the direct objects in the sentences 'The cat swallowed the
canary' and 'Billy likes the beer' would be examples of &%patients.  Note
that the &%patient of a &%Process may or may not undergo structural
change as a result of the &%Process.  The &%CaseRole of &%patient is used
when one wants to specify as broadly as possible the object of a
&%Process.")

(subrelation resource patient)
(domain resource 1 Process)
(domain resource 2 Object)
(disjointRelation resource result instrument)
(documentation resource "(&%resource ?PROCESS ?RESOURCE) means that
?RESOURCE is present at the beginning of ?PROCESS, is used by ?PROCESS,
and as a consequence is changed by ?PROCESS.  For example, soap is a
&%resource in the following proposition:  the gun was carved out of soap.
Note that &%resource differs from &%instrument, another subrelation of
&%patient, in that its internal or physical properties are altered in
some way by the &%Process.")

(subrelation result patient)
(domain result 1 Process)
(domain result 2 Object)
(documentation result "(result ?ACTION ?OUTPUT) means that ?OUTPUT is
a product of ?ACTION.  For example, house is a &%result in the
following proposition: Eric built a house.")

(instance InheritableRelation Class)
(documentation InheritableRelation "This is a &%Class of &%Classes.  Each
&%instance of &%InheritableRelation is a &%subclass of &%Relation whose
properties can be inherited downward in the class hierarchy via the
&%subrelation &%Predicate.")

(subclass ProbabilityRelation Relation)
(instance ProbabilityRelation InheritableRelation)
(documentation ProbabilityRelation "The &%Class of &%Relations that
permit assessment of the probability of an event or situation.")

(instance ProbabilityFn ProbabilityRelation)
(instance ProbabilityFn UnaryFunction)
(domain ProbabilityFn 1 Formula)
(range ProbabilityFn RealNumber)
(instance ProbabilityFn AsymmetricRelation)
(documentation ProbabilityFn "One of the basic &%ProbabilityRelations,
&%ProbabilityFn is used to state the a priori probability of a state of
affairs.  (&%ProbabilityFn ?FORMULA) denotes the a priori probability
of ?FORMULA.")

(instance conditionalProbability ProbabilityRelation)
(instance conditionalProbability TernaryPredicate)
(domain conditionalProbability 1 Formula)
(domain conditionalProbability 2 Formula)
(domain conditionalProbability 3 RealNumber)
(documentation conditionalProbability "One of the basic &%ProbabilityRelations.
&%conditionalProbability is used to state the numeric value of a conditional
probability.  (&%conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER) means
that the probability of ?FORMULA2 being true given that ?FORMULA1 is true is
?NUMBER.")

(instance increasesLikelihood ProbabilityRelation)
(instance increasesLikelihood BinaryPredicate)
(instance increasesLikelihood IrreflexiveRelation)
(domain increasesLikelihood 1 Formula)
(domain increasesLikelihood 2 Formula)
(disjointRelation increasesLikelihood decreasesLikelihood independentProbability)
(documentation increasesLikelihood "One of the basic &%ProbabilityRelations.
(&%increasesLikelihood ?FORMULA1 ?FORMULA2) means that ?FORMULA2 is more
likely to be true if ?FORMULA1 is true.")

(=>
   (and
      (increasesLikelihood ?FORMULA1 ?FORMULA2)
      (equal (ProbabilityFn ?FORMULA2) ?NUMBER1)
      (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
   (greaterThan ?NUMBER2 ?NUMBER1))

(instance decreasesLikelihood ProbabilityRelation)
(instance decreasesLikelihood BinaryPredicate)
(instance decreasesLikelihood IrreflexiveRelation)
(domain decreasesLikelihood 1 Formula)
(domain decreasesLikelihood 2 Formula)
(documentation decreasesLikelihood "One of the basic &%ProbabilityRelations.
(&%decreasesLikelihood ?FORMULA1 ?FORMULA2) means that ?FORMULA2 is less
likely to be true if ?FORMULA1 is true.")

(=>
   (and
      (decreasesLikelihood ?FORMULA1 ?FORMULA2)
      (equal (ProbabilityFn ?FORMULA2) ?NUMBER1)
      (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
   (lessThan ?NUMBER2 ?NUMBER1))

(instance independentProbability ProbabilityRelation)
(instance independentProbability BinaryPredicate)
(instance independentProbability SymmetricRelation)
(domain independentProbability 1 Formula)
(domain independentProbability 2 Formula)
(documentation independentProbability "One of the basic &%ProbabilityRelations.
(&%independentProbability ?FORMULA1 ?FORMULA2) means that the probabilities of
?FORMULA1 and ?FORMULA2 being true are independent.")

(=>
   (and
      (independentProbability ?FORMULA1 ?FORMULA2)
      (equal (ProbabilityFn ?FORMULA2) ?NUMBER1)
      (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
   (equal ?NUMBER2 ?NUMBER1))

(or
   (increasesLikelihood ?FORMULA1 ?FORMULA2)
   (decreasesLikelihood ?FORMULA1 ?FORMULA2)
   (independentProbability ?FORMULA1 ?FORMULA2))

(subclass SpatialRelation Relation)
(instance SpatialRelation InheritableRelation)
(documentation SpatialRelation "The &%Class of &%Relations that are
spatial in a wide sense.  This &%Class includes mereological relations
and topological relations.")

(subclass TemporalRelation Relation)
(instance TemporalRelation InheritableRelation)
(documentation TemporalRelation "The &%Class of temporal &%Relations.
This &%Class includes notions of (temporal) topology of intervals,
(temporal) schemata, and (temporal) extension.")

(instance IntentionalRelation InheritableRelation)
(documentation IntentionalRelation "The &%Class of &%Relations between
an &%Agent and one or more &%Entities, where the &%Relation requires that
the &%Agent have awareness of the &%Entity.")

(=>
   (and
      (instance ?REL IntentionalRelation)
      (holds ?REL ?AGENT @ROW)
      (inList ?OBJ (ListFn @ROW)))
   (inScopeOfInterest ?AGENT ?OBJ))

(instance prefers TernaryPredicate)
(instance prefers IntentionalRelation)
(domain prefers 1 CognitiveAgent)
(domain prefers 2 Formula)
(domain prefers 3 Formula)
(documentation prefers "(&%prefers ?AGENT ?FORMULA1 ?FORMULA2) means that
&%CognitiveAgent ?AGENT prefers the state of affairs expressed by ?FORMULA1
over the state of affairs expressed by ?FORMULA2 all things being equal.")

(=>
   (prefers ?AGENT ?FORMULA1 ?FORMULA2)
   (=>
      (true ?FORMULA1 True)
      (true ?FORMULA2 False)))

(subclass PropositionalAttitude IntentionalRelation)
(subclass PropositionalAttitude AsymmetricRelation)
(instance PropositionalAttitude InheritableRelation)
(documentation PropositionalAttitude "The &%Class of
&%IntentionalRelations where the &%Agent has awareness of a
&%Proposition.")

(subclass ObjectAttitude IntentionalRelation)
(subclass ObjectAttitude AsymmetricRelation)
(instance ObjectAttitude InheritableRelation)
(disjoint ObjectAttitude PropositionalAttitude)
(documentation ObjectAttitude "The &%Class of &%IntentionalRelations
where the &%Agent has awareness of an instance of &%Physical.")

(instance inScopeOfInterest BinaryPredicate)
(instance inScopeOfInterest IntentionalRelation)
(instance inScopeOfInterest AsymmetricRelation)
(domain inScopeOfInterest 1 CognitiveAgent)
(domain inScopeOfInterest 2 Entity)
(documentation inScopeOfInterest "A very general &%Predicate.
(&%inScopeOfInterest ?AGENT ?ENTITY) means that ?ENTITY is within the
scope of interest of ?AGENT.  Note that the interest indicated can be
either positive or negative, i.e. the ?AGENT can have an interest in
avoiding or promoting ?ENTITY.")

(instance notices ObjectAttitude)
(subrelation notices InScopeOfInterest)
(domain notices 1 CognitiveAgent)
(domain notices 2 Object)
(documentation notices "(&%notices ?AGENT ?OBJECT) means that ?AGENT is
paying attention to ?OBJECT, that ?OBJECT is currently the object of
?AGENT's conscious awareness.")

(instance needs ObjectAttitude)
(subrelation needs inScopeOfInterest)
(domain needs 1 CognitiveAgent)
(domain needs 2 Object)
(documentation needs "(&%needs ?AGENT ?OBJECT) means that ?OBJECT is
physically required for the continued existence of ?AGENT.")

(=>
    (needs ?AGENT ?OBJECT)
    (wants ?AGENT ?OBJECT))

(instance wants ObjectAttitude)
(subrelation wants inScopeOfInterest)
(relatedInternalConcept wants desires)
(domain wants 1 CognitiveAgent)
(domain wants 2 Object)
(documentation wants "(&%wants ?AGENT ?OBJECT) means that ?OBJECT is desired by ?AGENT,
i.e. ?AGENT believes that ?OBJECT will satisfy one of its goals.  Note that there is
no implication that what is wanted by an agent is not already possessed by the agent.")

(=>
   (wants ?AGENT ?OBJ)
   (exists (?PURP)
      (hasPurposeForAgent ?OBJ ?PURP ?AGENT)))

(=>
   (wants ?AGENT ?OBJ)
   (desires ?AGENT (possesses ?AGENT ?OBJ)))

(instance desires PropositionalAttitude)
(subrelation desires inScopeOfInterest)
(relatedInternalConcept desires wants)
(domain desires 1 CognitiveAgent)
(domain desires 2 Formula)
(documentation desires "(&%desires ?AGENT ?FORMULA) means that ?AGENT wants
to bring about the state of affairs expressed by ?FORMULA.  Note that there
is no implication that what is desired by the agent is not already true.
Note too that &%desires is distinguished from &%wants only in that the former
is a &%PropositionalAttitude, while &%wants is an &%ObjectAttitude.")

(instance considers PropositionalAttitude)
(subrelation considers inScopeOfInterest)
(domain considers 1 CognitiveAgent)
(domain considers 2 Formula)
(documentation considers "(&%considers ?AGENT ?FORMULA) means that ?AGENT
considers or wonders about the truth of the proposition expressed by
?FORMULA.")

(instance believes PropositionalAttitude)
(subrelation believes inScopeOfInterest)
(domain believes 1 CognitiveAgent)
(domain believes 2 Formula)
(documentation believes "The epistemic predicate of belief.
(&%believes ?AGENT ?FORMULA) means that ?AGENT believes the proposition
expressed by ?FORMULA.")

(=>
   (believes ?AGENT ?FORMULA)
   (exists (?TIME)
      (holdsDuring ?TIME (considers ?AGENT ?FORMULA))))

(instance knows PropositionalAttitude)
(subrelation knows inScopeOfInterest)
(domain knows 1 CognitiveAgent)
(domain knows 2 Formula)
(documentation knows "The epistemic predicate of knowing.  (&%knows
?AGENT ?FORMULA) means that ?AGENT knows the proposition expressed by
?FORMULA.  Note that &%knows entails conscious awareness, so this
&%Predicate cannot be used to express tacit or subconscious or
unconscious knowledge.")

(=>
    (knows ?AGENT ?FORMULA)
    (believes ?AGENT ?FORMULA))

(=>
   (knows ?AGENT ?FORMULA)
   (true ?FORMULA True))

(subclass TernaryRelation Relation)
(instance TernaryRelation InheritableRelation)
(documentation TernaryRelation "&%TernaryRelations relate three items.
The two &%subclasses of &%TernaryRelation are &%TernaryPredicate and
&%BinaryFunction.")

(=>
   (instance ?REL TernaryRelation)
   (not
      (exists (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
         (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))

(subclass QuaternaryRelation Relation)
(instance QuaternaryRelation InheritableRelation)
(documentation QuaternaryRelation "&%QuaternaryRelations relate four
items.  The two &%subclasses of &%QuaternaryRelation are
&%QuaternaryPredicate and &%TernaryFunction.")

(=>
   (instance ?REL QuaternaryRelation)
   (not
      (exists (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
         (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))

(subclass QuintaryRelation Relation)
(instance QuintaryRelation InheritableRelation)
(documentation QuintaryRelation "&%QuintaryRelations relate five items.
The two &%subclasses of &%QuintaryRelation are &%QuintaryPredicate and
&%QuaternaryFunction.")

(=>
   (instance ?REL QuintaryRelation)
   (not
      (exists (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
         (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))

(subclass List Relation)
(documentation List "Every &%List is a particular ordered n-tuple of
items.  Generally speaking, &%Lists are created by means of the &%ListFn
&%Function, which takes any number of items as arguments and returns a
&%List with the items in the same order.  Anything, including other
&%Lists, may be an item in a &%List.  Note too that &%Lists are
extensional - two lists that have the same items in the same order are
identical.  Note too that a &%List may contain no items.  In that case,
the &%List is the &%NullList.")

(=>
   (instance ?LIST List)
   (exists (?NUMBER1)
      (exists (?ITEM1)
         (and
            (not (equal (ListOrderFn ?LIST ?NUMBER1) ?ITEM1))
            (forall (?NUMBER2)
               (=>
                  (and
                     (instance ?NUMBER2 PositiveInteger)
                     (lessThan ?NUMBER2 ?NUMBER1))
                  (exists (?ITEM2)
                     (equal (ListOrderFn ?LIST ?NUMBER2) ?ITEM2))))))))

(subclass UniqueList List)
(documentation UniqueList "A &%List in which no item appears more than once,
i.e. a &%List for which there are no distinct numbers ?NUMBER1 and ?NUMBER2
such that (&%ListOrderFn ?LIST ?NUMBER1) and (&%ListOrderFn ?LIST ?NUMBER2)
return the same value.")

(<=>
   (instance ?LIST UniqueList)
   (forall (?NUMBER1 ?NUMBER2)
      (=>
         (equal (ListOrderFn ?LIST ?NUMBER1) (ListOrderFn ?LIST ?NUMBER2))
         (equal ?NUMBER1 ?NUMBER2))))

(instance NullList List)
(documentation NullList "The &%List that has no items.  The uniqueness of
&%NullList follows from the extensionality of &%Lists, i.e. the fact that
two &%Lists with the same items in the same order are identical.")

(<=>
   (equal ?LIST NullList)
   (not
      (exists (?ITEM)
         (inList ?ITEM ?LIST))))

(instance ListFn Function)
(instance ListFn VariableArityRelation)
(range ListFn List)
(documentation ListFn "A &%Function that takes any number of arguments and
returns the &%List containing those arguments in exactly the same order.")

(=>
   (exhaustiveDecomposition ?CLASS @ROW)
   (forall (?OBJ)
      (=>
         (instance ?OBJ ?CLASS)
         (exists (?ITEM)
            (and
               (inList ?ITEM (ListFn @ROW))
               (instance ?OBJ ?ITEM))))))

(=>
   (disjointDecomposition ?CLASS @ROW)
   (forall (?ITEM)
      (=>
         (inList ?ITEM (ListFn @ROW))
         (subclass ?ITEM ?CLASS))))

(=>
   (disjointDecomposition ?CLASS @ROW)
   (forall (?ITEM1 ?ITEM2)
      (=>
         (and
            (inList ?ITEM1 (ListFn @ROW))
            (inList ?ITEM2 (ListFn @ROW))
            (not
               (equal ?ITEM1 ?ITEM2)))
         (disjoint ?ITEM1 ?ITEM2))))

(instance ListOrderFn BinaryFunction)
(domain ListOrderFn 1 List)
(domain ListOrderFn 2 PositiveInteger)
(range ListOrderFn Entity)
(documentation ListOrderFn "(&%ListOrderFn ?LIST ?NUMBER) denotes the item
that is in the ?NUMBER position in the &%List ?LIST.  For example,
(&%ListOrderFn (&%ListFn &%Monday &%Tuesday &%Wednesday) 2) would return the
value &%Tuesday.")

(=>
   (and
      (instance ?LIST1 List)
      (instance ?LIST2 List)
      (forall (?NUMBER)
         (equal (ListOrderFn ?LIST1 ?NUMBER) (ListOrderFn ?LIST2 ?NUMBER))))
   (equal ?LIST1 ?LIST2))

(=>
   (and
      (domain ?REL ?NUMBER ?CLASS)
      (holds ?REL @ROW))
   (instance (ListOrderFn (ListFn @ROW) ?NUMBER) ?CLASS))

(=>
   (and
      (domainSubclass ?REL ?NUMBER ?CLASS)
      (holds ?REL @ROW))
   (subclass (ListOrderFn (ListFn @ROW) ?NUMBER) ?CLASS))

(instance ListLengthFn UnaryFunction)
(domain ListLengthFn 1 List)
(range ListLengthFn NonnegativeInteger)
(documentation ListLengthFn "A &%Function that takes a &%List as its sole
argument and returns the number of items in the &%List.  For example,
(&%ListLengthFn (&%ListFn &%Monday &%Tuesday &%Wednesday)) would return the
value 3.")

(=>
   (equal (ListLengthFn ?LIST) ?NUMBER1)
   (forall (?NUMBER2)
      (<=>
         (exists (?ITEM)
            (equal (ListOrderFn ?LIST ?NUMBER2) ?ITEM))
         (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))

(equal (ListLengthFn (ListFn @ROW ?ITEM)) (SuccessorFn (ListLengthFn (ListFn @ROW))))

(equal (ListOrderFn (ListFn @ROW ?ITEM) (ListLengthFn (ListFn @ROW ?ITEM))) ?ITEM)

(=>
   (valence ?REL ?NUMBER)
   (forall (@ROW)
      (=>
         (holds ?REL @ROW)
         (equal (ListLengthFn (ListFn @ROW)) ?NUMBER))))

(=>
   (equal (ListLengthFn ?LIST1) ?NUMBER)
   (exists (?LIST2)
      (and
         (initialList ?LIST1 ?LIST2)
         (equal (SuccessorFn ?NUMBER) (ListLengthFn ?LIST2))
         (equal (ListOrderFn ?LIST2 (SuccessorFn ?NUMBER)) ?ITEM))))

(instance ListConcatenateFn BinaryFunction)
(domain ListConcatenateFn 1 List)
(domain ListConcatenateFn 2 List)
(range ListConcatenateFn List)
(documentation ListConcatenateFn "A &%Function that returns the concatenation
of the two &%Lists that are given as arguments.  For example, the value of
(&%ListConcatenateFn (&%ListFn &%Monday &%Tuesday) (&%ListFn &%Wednesday
&%Thursday)) would be (&%ListFn &%Monday &%Tuesday &%Wednesday &%Thursday).")

(<=>
   (equal ?LIST3 (ListConcatenateFn ?LIST1 ?LIST2))
   (forall (?NUMBER1 ?NUMBER2)
      (=>
         (and
            (lessThanOrEqualTo ?NUMBER1 (ListLengthFn ?LIST1))
            (lessThanOrEqualTo ?NUMBER2 (ListLengthFn ?LIST2))
            (instance ?NUMBER1 PositiveInteger)
            (instance ?NUMBER2 PositiveInteger))
         (and
            (equal (ListOrderFn ?LIST3 ?NUMBER1) (ListOrderFn ?LIST1 ?NUMBER1))
            (equal (ListOrderFn ?LIST3 (AdditionFn (ListLengthFn ?LIST1) ?NUMBER2)) (ListOrderFn ?LIST2 ?NUMBER2))))))

(instance inList BinaryPredicate)
(instance inList IrreflexiveRelation)
(instance inList AsymmetricRelation)
(domain inList 1 Entity)
(domain inList 2 List)
(documentation inList "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.")

(<=>
   (inList ?ITEM ?LIST)
   (exists (?NUMBER)
      (equal (ListOrderFn ?LIST ?NUMBER) ?ITEM)))

(instance subList BinaryPredicate)
(instance subList PartialOrderingRelation)
(domain subList 1 List)
(domain subList 2 List)
(documentation subList "(&%subList ?LIST1 ?LIST2) means that ?LIST1 is a
sublist of ?LIST2, i.e. every element of ?LIST1 is an element of ?LIST2 and
the elements that are common to both &%Lists have the same order in both
&%Lists.")

(=>
   (subList ?LIST1 ?LIST2)
   (forall (?ITEM)
      (=>
         (inList ?ITEM ?LIST1)
         (inList ?ITEM ?LIST2))))

(=>
   (subList ?LIST1 ?LIST2)
   (exists (?NUMBER3)
      (forall (?ITEM)
         (=>
            (inList ?ITEM ?LIST1)
            (exists (?NUMBER1 ?NUMBER2)
               (and
                  (equal (ListOrderFn ?LIST1 ?NUMBER1) ?ITEM)
                  (equal (ListOrderFn ?LIST2 ?NUMBER2) ?ITEM)
                  (equal ?NUMBER2 (AdditionFn ?NUMBER1 ?NUMBER3))))))))

(instance initialList BinaryPredicate)
(subrelation initialList subList)
(documentation initialList "(&%initialList ?LIST1 ?LIST2) means that ?LIST1
is a &%subList of ?LIST2 and (&%ListOrderFn ?LIST1 ?NUMBER) returns the same
value as (&%ListOrderFn ?LIST2 ?NUMBER) for all of the values of ?NUMBER over
which (&%ListOrderFn ?LIST1 ?NUMBER) is defined.")

(=>
   (initialList ?LIST1 ?LIST2)
   (forall (?NUMBER1 ?NUMBER2)
      (=>
         (and
            (equal (ListLengthFn ?LIST1) ?NUMBER1)
            (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))
         (equal (ListOrderFn ?LIST1 ?NUMBER2) (ListOrderFn ?LIST2 ?NUMBER2)))))

(initialList (ListFn @ROW) (ListFn @ROW ?ITEM))

(subclass Predicate Relation)
(instance Predicate InheritableRelation)
(documentation Predicate "A &%Predicate is a sentence-forming &%Relation.
Each tuple in the &%Relation is a finite, ordered sequence of objects.
The fact that a particular tuple is an element of a &%Predicate is denoted
by '(*predicate* arg_1 arg_2 .. arg_n)', where the arg_i are the
objects so related.  In the case of &%BinaryPredicates, the fact can
be read as `arg_1 is *predicate* arg_2' or `a *predicate* of
arg_1 is arg_2'.")

(subclass Function SingleValuedRelation)
(instance Function InheritableRelation)
(documentation Function "A &%Function is a term-forming &%Relation that
maps from a n-tuple of arguments to a range and that associates this
n-tuple with at most one range element.  Note that the range is a &%SetOrClass,
and each element of the range is an instance of the &%SetOrClass.")

(subclass UnaryFunction Function)
(subclass UnaryFunction BinaryRelation)
(instance UnaryFunction InheritableRelation)
(documentation UnaryFunction "The &%Class of &%Functions that require a
single argument.")

(=>
   (instance ?FUNCTION UnaryFunction)
   (valence ?FUNCTION 1))

(subclass OneToOneFunction UnaryFunction)
(documentation OneToOneFunction "The &%Class of &%UnaryFunctions which
are one to one.  A function F is one to one just in case for all X, Y in the
domain of F, if X is not identical to Y, then F(X) is not identical to F(Y).")

(<=>
   (instance ?FUN OneToOneFunction)
   (forall (?ARG1 ?ARG2)
      (=>
         (and
            (instance ?ARG1 (DomainFn ?FUN))
            (instance ?ARG2 (DomainFn ?FUN))
            (not (equal ?ARG1 ?ARG2)))
         (not (equal (AssignmentFn ?FUN ?ARG1) (AssignmentFn ?FUN ?ARG2))))))

(subclass SequenceFunction OneToOneFunction)
(documentation SequenceFunction "The &%Class of &%OneToOneFunctions whose range
is a subclass of the &%PositiveIntegers.")

(=>
   (instance ?SEQ SequenceFunction)
   (subclass (RangeFn ?SEQ) Integer))

(subclass BinaryFunction Function)
(subclass BinaryFunction TernaryRelation)
(instance BinaryFunction InheritableRelation)
(documentation BinaryFunction "The &%Class of &%Functions that require
two arguments.")

(=>
	(instance ?FUNCTION BinaryFunction)
	(valence ?FUNCTION 2))

(subclass AssociativeFunction BinaryFunction)
(documentation AssociativeFunction "A &%BinaryFunction is associative if
bracketing has no effect on the value returned by the &%Function.  More
precisely, a &%Function ?FUNCTION is associative just in case
(?FUNCTION ?INST1 (?FUNCTION ?INST2 ?INST3)) is equal to
(?FUNCTION (?FUNCTION ?INST1 ?INST2) ?INST3), for all ?INST1, ?INST2,
and ?INST3.")

(=>
   (instance ?FUNCTION AssociativeFunction)
   (forall (?INST1 ?INST2 ?INST3)
      (=>
         (and
            (instance ?INST1 (DomainFn ?FUNCTION))
            (instance ?INST2 (DomainFn ?FUNCTION))
            (instance ?INST3 (DomainFn ?FUNCTION)))
         (equal (AssignmentFn ?FUNCTION ?INST1 (AssignmentFn ?FUNCTION ?INST2 ?INST3))
             (AssignmentFn ?FUNCTION (AssignmentFn ?FUNCTION ?INST1 ?INST2) ?INST3)))))

(subclass CommutativeFunction BinaryFunction)
(documentation CommutativeFunction "A &%BinaryFunction is commutative if
the ordering of the arguments of the function has no effect on the value
returned by the function.  More precisely, a function ?FUNCTION is
commutative just in case (?FUNCTION ?INST1 ?INST2) is equal to (?FUNCTION
?INST2 ?INST1), for all ?INST1 and ?INST2.")

(=>
   (instance ?FUNCTION CommutativeFunction)
   (forall (?INST1 ?INST2)
      (=>
         (and
            (instance ?INST1 (DomainFn ?FUNCTION))
            (instance ?INST2 (DomainFn ?FUNCTION)))
         (equal (AssignmentFn ?FUNCTION ?INST1 ?INST2)
                (AssignmentFn ?FUNCTION ?INST2 ?INST1)))))

(subclass TernaryFunction Function)
(subclass TernaryFunction QuaternaryRelation)
(instance TernaryFunction InheritableRelation)
(documentation TernaryFunction "The &%Class of &%Functions that require
exactly three arguments.")

(=>
	(instance ?FUNCTION TernaryFunction)
	(valence ?FUNCTION 3))

(subclass QuaternaryFunction Function)
(subclass QuaternaryFunction QuintaryRelation)
(instance QuaternaryFunction InheritableRelation)
(documentation QuaternaryFunction "The &%Class of &%Functions that require
exactly four arguments.")

(=>
	(instance ?FUNCTION QuaternaryFunction)
	(valence ?FUNCTION 4))

(subclass ContinuousFunction Function)
(documentation ContinuousFunction "&%Functions which are continuous.
This concept is taken as primitive until representations for limits
are devised.")

(subclass LogicalOperator Predicate)
(documentation LogicalOperator "This &%Class currently comprises all
of the logical operators (viz. 'and', 'or', 'not', '=>', and '<=>').")

(subclass BinaryPredicate Predicate)
(subclass BinaryPredicate BinaryRelation)
(instance BinaryPredicate InheritableRelation)
(documentation BinaryPredicate "A &%Predicate relating two items - its
valence is two.")

(=>
	(instance ?REL BinaryPredicate)
	(valence ?REL 2))

(subclass TernaryPredicate Predicate)
(subclass TernaryPredicate TernaryRelation)
(instance TernaryPredicate InheritableRelation)
(documentation TernaryPredicate "The &%Class of &%Predicates that require
exactly three arguments.")

(=>
	(instance ?REL TernaryPredicate)
	(valence ?REL 3))

(subclass QuaternaryPredicate Predicate)
(subclass QuaternaryPredicate QuaternaryRelation)
(instance QuaternaryPredicate InheritableRelation)
(documentation QuaternaryPredicate "The &%Class of &%Predicates that
require four arguments.")

(=>
	(instance ?REL QuaternaryPredicate)
	(valence ?REL 4))

(subclass QuintaryPredicate Predicate)
(subclass QuintaryPredicate QuintaryRelation)
(instance QuintaryPredicate InheritableRelation)
(documentation QuintaryPredicate "The &%Class of &%Predicates that
require five arguments.")

(=>
	(instance ?REL QuintaryPredicate)
	(valence ?REL 5))

(subclass VariableArityRelation Relation)
(documentation VariableArityRelation "The &%Class of &%Relations that
do not have a fixed number of arguments.")

(=>
        (instance ?REL VariableArityRelation)
        (not
           (exists (?INT)
              (valence ?REL ?INT))))

(subclass RelationExtendedToQuantities Relation)
(instance RelationExtendedToQuantities InheritableRelation)
(documentation RelationExtendedToQuantities "A
&%RelationExtendedToQuantities is a &%Relation that, when it is true on
a sequence of arguments that are &%RealNumbers, it is also true on a
sequence of &%ConstantQuantites with those magnitudes in some unit of
measure.  For example, the &%lessThan relation is extended to quantities.
This means that for all pairs of quantities ?QUANTITY1 and ?QUANTITY2,
(lessThan ?QUANTITY1 ?QUANTITY2) if and only if, for some ?NUMBER1,
?NUMBER2, and ?UNIT, ?QUANTITY1 = (MeasureFn ?NUMBER1 ?UNIT),
?QUANTITY2 = (MeasureFn ?NUMBER2 ?UNIT), and (lessThan ?NUMBER1 ?NUMBER2),
for all units ?UNIT on which ?QUANTITY1 and ?QUANTITY2 can be measured.
Note that, when a &%RelationExtendedToQuantities is extended from
&%RealNumbers to &%ConstantQuantities, the &%ConstantQuantities must be
measured along the same physical dimension.")

(subclass Proposition Abstract)
(documentation Proposition "&%Propositions are &%Abstract entities that
express a complete thought or a set of such thoughts.  As an example,
the formula '(instance Yojo Cat)' expresses the &%Proposition that the
entity named Yojo is an element of the &%Class of Cats.  Note that
propositions are not restricted to the content expressed by individual
sentences of a &%Language.  They may encompass the content expressed by
theories, books, and even whole libraries.  It is important to distinguish
&%Propositions from the &%ContentBearingObjects that express them.  A
&%Proposition is a piece of information, e.g. that the cat is on the mat,
but a &%ContentBearingObject is an &%Object that represents this information.
A &%Proposition is an abstraction that may have multiple representations:
strings, sounds, icons, etc.  For example, the &%Proposition that the cat is
on the mat is represented here as a string of graphical characters displayed
on a monitor and/or printed on paper, but it can be represented by a sequence
of sounds or by some non-latin alphabet or by some cryptographic form")

(instance closedOn BinaryPredicate)
(instance closedOn AsymmetricRelation)
(domain closedOn 1 Function)
(domain closedOn 2 SetOrClass)
(documentation closedOn "A &%BinaryFunction is closed on a &%SetOrClass
if it is defined for all instances of the &%SetOrClass and its value is
always an instance of the &%SetOrClass.")

(=>
   (and
      (closedOn ?FUNCTION ?CLASS)
      (instance ?FUNCTION UnaryFunction))
   (forall (?INST)
      (=>
         (instance ?INST ?CLASS)
         (instance (AssignmentFn ?FUNCTION ?INST) ?CLASS))))

(=>
   (and
      (closedOn ?FUNCTION ?CLASS)
      (instance ?FUNCTION BinaryFunction))
   (forall (?INST1 ?INST2)
      (=>
         (and
            (instance ?INST1 ?CLASS)
            (instance ?INST2 ?CLASS))
         (instance (AssignmentFn ?FUNCTION ?INST1 ?INST2) ?CLASS))))

(instance reflexiveOn BinaryPredicate)
(instance reflexiveOn AsymmetricRelation)
(domain reflexiveOn 1 BinaryRelation)
(domain reflexiveOn 2 SetOrClass)
(documentation reflexiveOn "A &%BinaryRelation is reflexive on a
&%SetOrClass only if every instance of the &%SetOrClass bears the relation
to itself.")

(=>
   (reflexiveOn ?RELATION ?CLASS)
   (forall (?INST)
      (=>
         (instance ?INST ?CLASS)
         (holds ?RELATION ?INST ?INST))))

(instance irreflexiveOn BinaryPredicate)
(instance irreflexiveOn AsymmetricRelation)
(domain irreflexiveOn 1 BinaryRelation)
(domain irreflexiveOn 2 SetOrClass)
(documentation irreflexiveOn "A &%BinaryRelation is irreflexive on a
&%SetOrClass only if no instance of the &%SetOrClass bears the relation to
itself.")

(=>
   (irreflexiveOn ?RELATION ?CLASS)
   (forall (?INST)
      (=>
         (instance ?INST ?CLASS)
         (not
            (holds ?RELATION ?INST ?INST)))))

(instance partialOrderingOn BinaryPredicate)
(instance partialOrderingOn AsymmetricRelation)
(domain partialOrderingOn 1 BinaryRelation)
(domain partialOrderingOn 2 SetOrClass)
(documentation partialOrderingOn "A &%BinaryRelation is a partial
ordering on a &%SetOrClass only if the relation is &%reflexiveOn the
&%SetOrClass, and it is both an &%AntisymmetricRelation, and a
&%TransitiveRelation.")

(=>
   (partialOrderingOn ?RELATION ?CLASS)
   (and
      (reflexiveOn ?RELATION ?CLASS)
      (instance ?RELATION TransitiveRelation)
      (instance ?RELATION AntisymmetricRelation)))

(instance totalOrderingOn BinaryPredicate)
(instance totalOrderingOn AsymmetricRelation)
(domain totalOrderingOn 1 BinaryRelation)
(domain totalOrderingOn 2 SetOrClass)
(documentation totalOrderingOn "A &%BinaryRelation ?REL is a total
ordering on a &%SetOrClass only if it is a partial ordering for which either
(?REL ?INST1 ?INST2) or (?REL ?INST2 ?INST1) for every ?INST1 and ?INST2
in the &%SetOrClass.")

(<=>
     (totalOrderingOn ?RELATION ?CLASS)
     (and
          (partialOrderingOn ?RELATION ?CLASS)
          (trichotomizingOn ?RELATION ?CLASS)))

(instance trichotomizingOn BinaryPredicate)
(instance trichotomizingOn AsymmetricRelation)
(domain trichotomizingOn 1 BinaryRelation)
(domain trichotomizingOn 2 SetOrClass)
(documentation trichotomizingOn "A &%BinaryRelation ?REL is
trichotomizing on a &%SetOrClass only if, for all instances ?INST1 and ?INST2
of the &%SetOrClass, at least one of the following holds:  (?REL ?INST1 ?INST2),
(?REL ?INST2 ?INST1) or (equal ?INST1 ?INST2).")

(=>
   (trichotomizingOn ?RELATION ?CLASS)
   (forall (?INST1 ?INST2)
      (=>
         (and
            (instance ?INST1 ?CLASS)
            (instance ?INST2 ?CLASS))
         (or
            (holds ?RELATION ?INST1 ?INST2)
            (holds ?RELATION ?INST2 ?INST1)
            (equal ?INST1 ?INST2)))))

(instance equivalenceRelationOn BinaryPredicate)
(instance equivalenceRelationOn AsymmetricRelation)
(domain equivalenceRelationOn 1 BinaryRelation)
(domain equivalenceRelationOn 2 SetOrClass)
(documentation equivalenceRelationOn "A &%BinaryRelation is an
&%equivalenceRelationOn a &%SetOrClass only if the relation is &%reflexiveOn
the &%SetOrClass and it is both a &%TransitiveRelation and a
&%SymmetricRelation.")

(=>
   (equivalenceRelationOn ?RELATION ?CLASS)
   (and
      (instance ?RELATION TransitiveRelation)
      (instance ?RELATION SymmetricRelation)
      (reflexiveOn ?RELATION ?CLASS)))

(instance distributes BinaryPredicate)
(instance distributes BinaryRelation)
(domain distributes 1 BinaryFunction)
(domain distributes 2 BinaryFunction)
(documentation distributes "A &%BinaryFunction ?FUNCTION1 is
distributive over another &%BinaryFunction ?FUNCTION2 just in case
(?FUNCTION1 ?INST1 (?FUNCTION2 ?INST2 ?INST3)) is equal to
(?FUNCTION2 (?FUNCTION1 ?INST1 ?INST2) (?FUNCTION1 ?INST1 ?INST3)),
for all ?INST1, ?INST2, and ?INST3.")

(=>
   (distributes ?FUNCTION1 ?FUNCTION2)
   (forall (?INST1 ?INST2 ?INST3)
      (=>
         (and
            (instance ?INST1 (DomainFn ?FUNCTION1))
            (instance ?INST2 (DomainFn ?FUNCTION1))
            (instance ?INST3 (DomainFn ?FUNCTION1))
            (instance ?INST1 (DomainFn ?FUNCTION2))
            (instance ?INST2 (DomainFn ?FUNCTION2))
            (instance ?INST3 (DomainFn ?FUNCTION2)))
         (equal (AssignmentFn ?FUNCTION1 ?INST1
                        (AssignmentFn ?FUNCTION2 ?INST2 ?INST3))
                (AssignmentFn ?FUNCTION2
                        (AssignmentFn ?FUNCTION1 ?INST1 ?INST2)
                        (AssignmentFn ?FUNCTION1 ?INST1 ?INST3))))))

(instance causes BinaryPredicate)
(instance causes AsymmetricRelation)
(domain causes 1 Process)
(domain causes 2 Process)
(relatedInternalConcept causes causesSubclass)
(documentation causes "The causation relation between instances of &%Process.
(&%causes ?PROCESS1 ?PROCESS2) means that the instance of &%Process ?PROCESS1
brings about the instance of &%Process ?PROCESS2, e.g. (&%causes &%Killing &%Death).")

(=>
   (instance ?PROC1 Process)
   (exists (?PROC2)
      (causes ?PROC2 ?PROC1)))

(instance causesSubclass BinaryPredicate)
(instance causesSubclass AsymmetricRelation)
(domainSubclass causesSubclass 1 Process)
(domainSubclass causesSubclass 2 Process)
(documentation causesSubclass "The causation relation between subclasses of &%Process.
(&%causesSubclass ?PROCESS1 ?PROCESS2) means that the subclass of &%Process ?PROCESS1
brings about the subclass of &%Process ?PROCESS2, e.g. (&%causes &%Killing &%Death).")

(=>
   (causesSubclass ?PROC1 ?PROC2)
   (forall (?INST2)
      (=>
         (instance ?INST2 ?PROC2)
         (exists (?INST1)
		(and
		   (instance ?INST1 ?PROC1)
		   (causes ?INST1 ?INST2))))))

(instance copy BinaryPredicate)
(instance copy EquivalenceRelation)
(domain copy 1 Object)
(domain copy 2 Object)
(documentation copy "relates an &%Object to an exact copy of the
&%Object, where an exact copy is indistinguishable from the original
with regard to every property except (possibly) spatial and/or temporal
location.")

(=>
   (copy ?OBJ1 ?OBJ2)
   (forall (?ATTR)
      (=>
         (attribute ?OBJ1 ?ATTR)
         (attribute ?OBJ2 ?ATTR))))

(instance time BinaryPredicate)
(instance time TemporalRelation)
(instance time AsymmetricRelation)
(domain time 1 Physical)
(domain time 2 TimePosition)
(documentation time "This relation holds between an instance of
&%Physical and an instance of &%TimePosition just in case the temporal
lifespan of the former includes the latter.  The constants &%located
and &%time are the basic spatial and temporal predicates,
respectively.")

(instance holdsDuring BinaryPredicate)
(instance holdsDuring AsymmetricRelation)
(domain holdsDuring 1 TimePosition)
(domain holdsDuring 2 Formula)
(documentation holdsDuring "(&%holdsDuring ?TIME ?FORMULA) means that the
proposition denoted by ?FORMULA is true in the time frame ?TIME.  Note
that this implies that ?FORMULA is true at every &%TimePoint which is a
&%temporalPart of ?TIME.")

(=>
   (and
      (holdsDuring ?TIME ?SITUATION1)
      (entails ?SITUATION1 ?SITUATION2))
   (holdsDuring ?TIME ?SITUATION2))

(=>
   (holdsDuring ?TIME (not ?SITUATION))
   (not (holdsDuring ?TIME ?SITUATION)))

(instance capability TernaryPredicate)
(domainSubclass capability 1 Process)
(domain capability 2 CaseRole)
(domain capability 3 Object)
(documentation capability "(&%capability ?PROCESS ?ROLE ?OBJ) means
that ?OBJ has the ability to play the role of ?ROLE in &%Processes of
type ?PROCESS.")

(=>
   (and
      (instance ?ROLE CaseRole)
      (holds ?ROLE ?ARG1 ?ARG2)
      (instance ?ARG1 ?PROC))
   (capability ?PROC ?ROLE ?ARG2))

(instance exploits BinaryPredicate)
(instance exploits AsymmetricRelation)
(domain exploits 1 Object)
(domain exploits 2 Agent)
(documentation exploits "(&%exploits ?OBJ ?AGENT) means that ?OBJ is used
by ?AGENT as a &%resource in an unspecified instance of &%Process.  This
&%Predicate, as its corresponding axiom indicates, is a composition of the
relations &%agent and &%resource.")

(=>
     (exploits ?OBJ ?AGENT)
     (exists (?PROCESS)
          (and
               (agent ?PROCESS ?AGENT)
               (resource ?PROCESS ?OBJ))))

(instance hasPurpose BinaryPredicate)
(instance hasPurpose AsymmetricRelation)
(domain hasPurpose 1 Physical)
(domain hasPurpose 2 Formula)
(documentation hasPurpose "This &%Predicate expresses the concept of a
conventional goal, i.e. a goal with a neutralized agent's intention.
Accordingly, (&%hasPurpose ?THING ?FORMULA) means that the instance of
&%Physical ?THING has, as its purpose, the &%Proposition expressed by
?FORMULA.  Note that there is an important difference in meaning between
the &%Predicates &%hasPurpose and &%result.  Although the second argument
of the latter can satisfy the second argument of the former,
a conventional goal is an expected and desired outcome, while a result
may be neither expected nor desired.  For example, a machine process may
have outcomes but no goals, aimless wandering may have an outcome but no
goal; a learning process may have goals with no outcomes, and so on.")

(instance hasPurposeForAgent TernaryPredicate)
(domain hasPurposeForAgent 1 Physical)
(domain hasPurposeForAgent 2 Formula)
(domain hasPurposeForAgent 3 Agent)
(documentation hasPurposeForAgent "Expresses a cognitive attitude of an
agent with respect to a particular instance of Physical.  More precisely,
(&%hasPurposeForAgent ?THING ?FORMULA ?AGENT) means that the purpose of
?THING for ?AGENT is the proposition expressed by ?FORMULA.  Very complex
issues are involved here.  In particular, the rules of inference of the
first order predicate calculus are not truth-preserving for the second
argument position of this &%Predicate.")

(=>
   (hasPurpose ?THING ?PURPOSE)
   (exists (?AGENT)
      (hasPurposeForAgent ?THING ?PURPOSE ?AGENT)))

(instance hasSkill BinaryPredicate)
(instance hasSkill AsymmetricRelation)
(domainSubclass hasSkill 1 Process)
(domain hasSkill 2 Agent)
(documentation hasSkill "Similar to the &%capability &%Predicate
with the additional restriction that the ability be practised/
demonstrated to some measurable degree.")

(=>
   (hasSkill ?PROC ?AGENT)
   (capability ?PROC agent ?AGENT))

(instance holdsRight BinaryPredicate)
(instance holdsRight AsymmetricRelation)
(domainSubclass holdsRight 1 Process)
(domain holdsRight 2 CognitiveAgent)
(documentation holdsRight "Expresses a relationship between a subclass
of &%Process and a &%CognitiveAgent whereby the &%CognitiveAgent has
the right to perform instances of the &%Process type specified,
i.e. to be an &%agent of instances of the &%Process type.")

(=>
    (holdsRight ?PROCESS ?AGENT)
    (capability ?PROCESS agent ?AGENT))

(instance confersRight TernaryPredicate)
(domainSubclass confersRight 1 Process)
(domain confersRight 2 Entity)
(domain confersRight 3 CognitiveAgent)
(documentation confersRight "Expresses the relationship between a subclass
of &%Process, an &%Entity, and a &%CognitiveAgent when the &%Entity
authorizes the &%CognitiveAgent to perform instances of the &%Process type
specified, i.e. to be an &%agent of instances of the &%Process type.")

(=>
   (confersRight ?PROCESS ?AGENT1 ?AGENT2)
   (holdsRight ?PROCESS ?AGENT2))

(instance holdsObligation BinaryPredicate)
(instance holdsObligation AsymmetricRelation)
(domainSubclass holdsObligation 1 Process)
(domain holdsObligation 2 CognitiveAgent)
(relatedInternalConcept holdsObligation holdsRight)
(documentation holdsObligation "Expresses a relationship between a
subclass of &%Process and a &%CognitiveAgent whereby the &%CognitiveAgent
has the obligation to perform instances of the &%Process type specified,
i.e. to be an &%agent of instances of the &%Process type.")

(=>
    (holdsObligation ?PROCESS ?AGENT)
    (capability ?PROCESS agent ?AGENT))

(instance confersObligation TernaryPredicate)
(domainSubclass confersObligation 1 Process)
(domain confersObligation 2 Entity)
(domain confersObligation 3 CognitiveAgent)
(relatedInternalConcept confersObligation confersRight)
(documentation confersObligation "Expresses the relationship between a
subclass of &%Process, an &%Entity, and a &%CognitiveAgent when the
&%Entity obligates the &%CognitiveAgent to perform instances of the &%Process
type specified, i.e. to be an &%agent of instances of the &%Process type.")

(=>
   (confersObligation ?PROCESS ?AGENT1 ?AGENT2)
   (holdsObligation ?PROCESS ?AGENT2))

(instance located PartialOrderingRelation)
(subrelation located partlyLocated)
(domain located 1 Physical)
(domain located 2 Object)
(relatedInternalConcept located time)
(documentation located "A very general predicate.  (&%located
?PHYS ?OBJ) means that ?PHYS is situated at ?OBJ, in some sense.  The
&%Predicates &%located and &%time are spatial and temporal
predicates, respectively.")

(=>
   (located ?OBJ ?REGION)
   (forall (?SUBOBJ)
      (=>
         (part ?SUBOBJ ?OBJ)
         (located ?SUBOBJ ?REGION))))

(instance partlyLocated SpatialRelation)
(instance partlyLocated ReflexiveRelation)
(instance partlyLocated BinaryPredicate)
(domain partlyLocated 1 Object)
(domain partlyLocated 2 Region)
(documentation partlyLocated "The predicate of partial localization.
For example, Istanbul is partly located in Asia.  Note that this is the
most basic localization relation:  &%located and &%exactlyLocated
are both subrelations of &%partlyLocated.")

(=>
   (partlyLocated ?OBJ ?REGION)
   (exists (?SUBOBJ)
      (and
         (part ?SUBOBJ ?OBJ)
         (exactlyLocated ?SUBOBJ ?REGION))))

(subrelation exactlyLocated located)
(documentation exactlyLocated "The actual, minimal location of an
Object.  This is a subrelation of the more general Predicate
&%located.")

(=>
   (exactlyLocated ?OBJ ?REGION)
   (not
      (exists (?OTHEROBJ)
         (and
            (exactlyLocated ?OTHEROBJ ?REGION)
            (not
               (equal ?OTHEROBJ ?OBJ))))))


(instance between SpatialRelation)
(instance between TernaryPredicate)
(domain between 1 Object)
(domain between 2 Object)
(domain between 3 Object)
(documentation between "(between ?OBJ1 ?OBJ2 ?OBJ3) means that ?OBJ2 is
spatially located between ?OBJ1 and ?OBJ3.  Note that this implies that
?OBJ2 is directly between ?OBJ1 and ?OBJ3, i.e. the projections of ?OBJ1
and ?OBJ3 overlap with ?OBJ2.")

(instance traverses SpatialRelation)
(domain traverses 1 Object)
(domain traverses 2 Object)
(documentation traverses "(&%traverses ?OBJ1 ?OBJ2) means that ?OBJ1
crosses or extends across ?OBJ2.  Note that &%crosses and
&%penetrates are subrelations of &%traverses.")

(=>
   (traverses ?OBJ1 ?OBJ2)
   (or
      (crosses ?OBJ1 ?OBJ2)
      (penetrates ?OBJ1 ?OBJ2)))

(subrelation crosses traverses)
(instance crosses AsymmetricRelation)
(instance crosses TransitiveRelation)
(disjointRelation crosses connected)
(documentation crosses "(crosses ?OBJ1 ?OBJ2) means that
&%Object ?OBJ1 &%traverses Object ?OBJ2, without being &%connected
to it.")

;; Workaround for mysterious Loom error
;; (subrelation penetrates traverses)
(subrelation penetrates meetsSpatially)
(instance penetrates AsymmetricRelation)
(instance penetrates IntransitiveRelation)
(documentation penetrates "(penetrates ?OBJ1 ?OBJ2) means that
?OBJ1 is &%connected to ?OBJ2 along at least one whole dimension (length,
width or depth).")

(instance WhereFn BinaryFunction)
(instance WhereFn SpatialRelation)
(domain WhereFn 1 Physical)
(domain WhereFn 2 TimePoint)
(range WhereFn Region)
(relatedInternalConcept WhereFn WhenFn)
(documentation WhereFn "Maps an &%Object and a &%TimePoint at which the
&%Object exists to the &%Region where the &%Object existed at that
&%TimePoint.")

(<=>
   (equal (WhereFn ?THING ?TIME) ?REGION)
   (holdsDuring ?TIME (exactlyLocated ?THING ?REGION)))

(instance possesses BinaryPredicate)
(instance possesses AsymmetricRelation)
(domain possesses 1 Agent)
(domain possesses 2 Object)
(documentation possesses "&%Relation that holds between an &%Agent and
an &%Object when the &%Agent has ownership of the &%Object.")

(=>
   (possesses ?PERSON ?OBJ)
   (exists (?TYPE)
      (and
         (holdsRight ?PERSON ?TYPE)
         (forall (?PROCESS)
            (=>
               (instance ?PROCESS ?TYPE)
               (patient ?PROCESS ?OBJ))))))

(=>
   (and
      (instance ?TIME TimePosition)
      (holdsDuring ?TIME (possesses ?AGENT1 ?OBJ))
      (holdsDuring ?TIME (possesses ?AGENT2 ?OBJ)))
   (equal ?AGENT1 ?AGENT2))

(instance PropertyFn UnaryFunction)
(domain PropertyFn 1 Agent)
(range PropertyFn Set)
(documentation PropertyFn "A &%UnaryFunction that maps an &%Agent to the &%Set of &%Property owned by the &%Agent.")

(<=>
   (instance ?OBJ (PropertyFn ?PERSON))
   (possesses ?PERSON ?OBJ))

(instance precondition BinaryPredicate)
(instance precondition AsymmetricRelation)
(instance precondition TransitiveRelation)
(domainSubclass precondition 1 Process)
(domainSubclass precondition 2 Process)
(documentation precondition "A very general &%Predicate.  (&%precondition
?PROC1 ?PROC2) means that ?PROC2 can exist or be true only if
?PROC1 exists or is true.  At some point, this &%Predicate should
probably be broken up into more specific &%Predicates with more
restrictive &%domain restrictions.")

(=>
   (precondition ?PROC1 ?PROC2)
   (=>
      (exists (?INST2) (instance ?INST2 ?PROC2))
      (exists (?INST1) (instance ?INST1 ?PROC1))))

(instance inhibits BinaryPredicate)
(instance inhibits IrreflexiveRelation)
(domainSubclass inhibits 1 Process)
(domainSubclass inhibits 2 Process)
(documentation inhibits "A very general &%Predicate.  (&%inhibits
?PROC1 ?PROC2) means that the &%Process ?PROC1 inhibits or hinders
the occurrence of the &%Process ?PROC2.  For example, obstructing an
object inhibits moving it.  Note that this is a relation between types
of &%Processes, not between instances.")

(=>
   (inhibits ?PROC1 ?PROC2)
   (forall (?TIME ?PLACE)
      (decreasesLikelihood
		(holdsDuring ?TIME (exists (?INST1) (and (instance ?INST1 ?PROC1) (located ?INST1 ?PLACE))))
            (holdsDuring ?TIME (exists (?INST2) (and (instance ?INST2 ?PROC2) (located ?INST2 ?PLACE)))))))

(instance prevents BinaryPredicate)
(instance prevents IrreflexiveRelation)
(domainSubclass prevents 1 Process)
(domainSubclass prevents 2 Process)
(relatedInternalConcept prevents inhibits)
(documentation prevents "A very general &%Predicate.  (&%prevents ?PROC1
?PROC2) means that ?PROC1 prevents the occurrence of ?PROC2.  In other
words, if ?PROC1 is occurring in a particular time and place, ?PROC2
cannot occur at the same time and place.  For example, innoculating
prevents contracting disease.  Note that this is a relation between types
of &%Processes, not between instances.")

(=>
   (prevents ?PROC1 ?PROC2)
   (forall (?TIME ?PLACE)
      (=>
         (holdsDuring ?TIME (exists (?INST1) (and (instance ?INST1 ?PROC1) (located ?INST1 ?PLACE))))
         (not (holdsDuring ?TIME (exists (?INST2) (and (instance ?INST2 ?PROC2) (located ?INST2 ?PLACE))))))))

(instance refers BinaryPredicate)
(domain refers 1 Physical)
(domain refers 2 Entity)
(documentation refers "(&%refers ?OBJ1 ?OBJ2) means that ?OBJ1
mentions or includes a reference to ?OBJ2. Note that &%refers is
more general in meaning than &%represents, because presumably something
can represent something else only if it refers to this other thing.
For example, an article whose topic is a recent change in the price of
oil may refer to many other things, e.g. the general state of the economy,
the weather in California, the prospect of global warming, the options
for alternative energy sources, the stock prices of various oil companies,
etc.")

(subrelation names refers)
(domain names 1 SymbolicString)
(documentation names "(&%names ?STRING ?ENTITY) means that the thing ?ENTITY
has the &%SymbolicString ?STRING as its name.  Note that &%names and &%represents
are the two immediate &%subrelations of &%refers.  The predicate &%names is used
when the referring item is merely a tag without connotative content, while the
predicate &%represents is used for referring items that have such content.")

(subrelation uniqueIdentifier names)
(instance uniqueIdentifier SingleValuedRelation)
(documentation uniqueIdentifier "The class of &%names that uniquely identify
an instance of &%Entity.  Some examples of &%uniqueIdentifiers are the keys
of tables in database applications and the ISBN (International Standard Book
Number).")

(subrelation represents refers)
(documentation represents "A very general semiotics &%Predicate.
(&%represents ?THING ?ENTITY) means that ?THING in some way indicates,
expresses, connotes, pictures, describes, etc. ?ENTITY.  The &%Predicates
&%containsInformation and &%realization are subrelations of &%represents.
Note that &%represents is a subrelation of &%refers, since something can
represent something else only if it refers to this other thing.  See the
documentation string for &%names.")

(instance representsForAgent TernaryPredicate)
(domain representsForAgent 1 Physical)
(domain representsForAgent 2 Entity)
(domain representsForAgent 3 Agent)
(documentation representsForAgent "A very general predicate.
(&%representsForAgent ?THING ?ENTITY ?AGENT) means that the ?AGENT
chooses to use the &%instance of &%Physical ?THING to 'stand for'
?ENTITY.")

(=>
   (representsForAgent ?REP ?ENTITY ?AGENT)
   (represents ?REP ?ENTITY))

(instance representsInLanguage TernaryPredicate)
(domain representsInLanguage 1 Physical)
(domain representsInLanguage 2 Entity)
(domain representsInLanguage 3 Language)
(documentation representsInLanguage "A very general predicate.
(&%representsInLanguage ?THING ?ENTITY ?LANGUAGE) means that the
&%instance of &%Physical ?THING stands for ?ENTITY in the language
?LANGUAGE.")

(=>
   (representsInLanguage ?REP ?ENTITY ?LANGUAGE)
   (exists (?AGENT)
      (representsForAgent ?REP ?ENTITY ?AGENT)))

(subrelation equivalentContentClass subsumesContentClass)
(instance equivalentContentClass EquivalenceRelation)
(domainSubclass equivalentContentClass 1 ContentBearingObject)
(domainSubclass equivalentContentClass 2 ContentBearingObject)
(documentation equivalentContentClass "A &%BinaryPredicate that relates two
subclasses of &%ContentBearingObject.  (&%equivalentContentClass ?CLASS1
?CLASS2) means that the content expressed by each instance of ?CLASS1 is
also expressed by each instance of ?CLASS2, and vice versa.  An example
would be the relationship between English and Russian editions of Agatha
Christie's 'Murder on the Orient Express'.  Note that
(&%equivalentContentClass ?CLASS1 ?CLASS2) implies (&%subsumesContentClass
?CLASS1 ?CLASS2) and (&%subsumesContentClass ?CLASS2 ?CLASS1).")

(<=>
   (and
      (subsumesContentClass ?CLASS1 ?CLASS2)
      (subsumesContentClass ?CLASS2 ?CLASS1))
   (equivalentContentClass ?CLASS1 ?CLASS2))

(instance subsumesContentClass BinaryPredicate)
(instance subsumesContentClass PartialOrderingRelation)
(domainSubclass subsumesContentClass 1 ContentBearingObject)
(domainSubclass subsumesContentClass 2 ContentBearingObject)
(documentation subsumesContentClass "A &%BinaryPredicate that relates two
subclasses of &%ContentBearingObject.  (&%subsumesContentClass ?CLASS1
?CLASS2) means that the content expressed by each instance of ?CLASS2 is
also expressed by each instance of ?CLASS1.  Examples include the
relationship between a poem and one of its stanzas or between a book and
one of its chapters.  Note that this is a relation between subclasses of
&%ContentBearingObject, rather than instances.  If one wants to relate
instances, the &%Predicate &%subsumesContentInstance can be used.  Note
that &%subsumesContentClass is needed in many cases.  Consider, for
example, the relation between the King James edition of the Bible and its
Book of Genesis.  This relation holds for every copy of this edition and
not just for a single instance.")

(<=>
   (subsumesContentClass ?CLASS1 ?CLASS2)
   (forall (?OBJ2 ?INFO)
      (=>
         (and
	      (instance ?OBJ2 ?CLASS2)
              (containsInformation ?OBJ2 ?INFO))
         (exists (?OBJ1)
            (and
               (instance ?OBJ1 ?CLASS1)
               (containsInformation ?OBJ1 ?INFO))))))

(subrelation equivalentContentInstance subsumesContentInstance)
(instance equivalentContentInstance EquivalenceRelation)
(domain equivalentContentInstance 1 ContentBearingObject)
(domain equivalentContentInstance 2 ContentBearingObject)
(relatedInternalConcept equivalentContentInstance equivalentContentClass)
(documentation equivalentContentInstance "A &%BinaryPredicate relating two
instances of &%ContentBearingObject.  (&%equivalentContentInstance
?OBJ1 ?OBJ2) means that the content expressed by ?OBJ1 is identical to
the content expressed by ?OBJ2.  An example would be the relationship
between a handwritten draft of a letter to one's lawyer and a typed
copy of the same letter.  Note that (&%equivalentContentInstance ?OBJ1
?OBJ2) implies (&%subsumesContentInstance ?OBJ1 ?OBJ2) and
(&%subsumesContentInstance ?OBJ2 ?OBJ2).")

(<=>
   (and
      (subsumesContentInstance ?OBJ1 ?OBJ2)
      (subsumesContentInstance ?OBJ2 ?OBJ1))
   (equivalentContentInstance ?OBJ1 ?OBJ2))

(instance subsumesContentInstance BinaryPredicate)
(instance subsumesContentInstance PartialOrderingRelation)
(domain subsumesContentInstance 1 ContentBearingObject)
(domain subsumesContentInstance 2 ContentBearingObject)
(relatedInternalConcept subsumesContentInstance subsumesContentClass)
(documentation subsumesContentInstance "A &%BinaryPredicate relating two
instances of &%ContentBearingObject.  (&%subsumesContentInstance ?OBJ1 ?OBJ2)
means that the content expressed by ?OBJ2 is part of the content expressed
by ?OBJ1.  An example is the relationship between a handwritten poem and
one of its stanzas.  Note that this is a relation between instances,
rather than &%Classes.  If one wants to assert a content relationship
between &%Classes, e.g. between the version of an intellectual work and a
part of that work, the relation &%subsumesContentClass should be used.")

(<=>
   (subsumesContentInstance ?OBJ1 ?OBJ2)
   (forall (?INFO)
      (=>
         (containsInformation ?OBJ2 ?INFO)
         (containsInformation ?OBJ1 ?INFO))))

(subrelation realization represents)
(instance realization AsymmetricRelation)
(domain realization 1 Process)
(domain realization 2 Proposition)
(relatedInternalConcept realization equivalentContentInstance)
(relatedInternalConcept realization containsInformation)
(documentation realization "A subrelation of &%represents.
(&%realization ?PROCESS ?PROP) means that ?PROCESS is a Process which
expresses the content of ?PROP. Examples include a particular musical
performance, which realizes the content of a musical score, or the
reading of a poem.")

(=>
   (realization ?PROCESS ?PROP)
   (exists (?OBJ)
      (and
         (instance ?OBJ ContentBearingObject)
         (containsInformation ?OBJ ?PROP))))

(instance expressedInLanguage BinaryPredicate)
(instance expressedInLanguage AsymmetricRelation)
(domain expressedInLanguage 1 LinguisticExpression)
(domain expressedInLanguage 2 Language)
(documentation expressedInLanguage "(&%expressedInLanguage ?EXPRESS ?LANG)
means that ?EXPRESS is expressed in &%Language ?LANG.")

(<=>
	(expressedInLanguage ?EXPRESS ?LANGUAGE)
	(exists (?PROP)
		(representsInLanguage ?EXPRESS ?PROP ?LANGUAGE)))

(instance subProposition BinaryPredicate)
(instance subProposition TransitiveRelation)
(instance subProposition IrreflexiveRelation)
(domain subProposition 1 Proposition)
(domain subProposition 2 Proposition)
(documentation subProposition "(&%subProposition ?PROP1 ?PROP2) means that
?PROP1 is a &%Proposition which is a proper part of the &%Proposition ?PROP2.
In other words, &%subProposition is the analogue of &%properPart for chunks
of abstract content.")

(=>
   (subProposition ?PROP1 ?PROP2)
   (forall (?OBJ1 ?OBJ2)
      (=>
         (and
            (containsInformation ?OBJ1 ?PROP1)
            (containsInformation ?OBJ2 ?PROP2))
         (subsumesContentInstance ?OBJ2 ?OBJ1))))

(subrelation subPlan subProposition)
(instance subPlan TransitiveRelation)
(instance subPlan IrreflexiveRelation)
(domain subPlan 1 Plan)
(domain subPlan 2 Plan)
(documentation subPlan "(&%subPlan ?PLAN1 ?PLAN2) means that ?PLAN1
is a &%Plan which is a proper part of ?PLAN2.  This relation is generally
used to relate a supporting &%Plan to the overall &%Plan in a particular
context.")

(instance uses BinaryPredicate)
(instance uses AsymmetricRelation)
(domain uses 1 Object)
(domain uses 2 Agent)
(documentation uses "(&%uses ?OBJECT AGENT) means that ?OBJECT is used by
?AGENT as an instrument in an unspecified &%Process.  This &%Predicate,
as its corresponding axiom indicates, is a composition of the &%CaseRoles
&%agent and &%instrument.")

(=>
     (uses ?OBJ ?AGENT)
     (exists (?PROC)
          (and
               (agent ?PROC ?AGENT)
               (instrument ?PROC ?OBJ))))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  NUMERIC FUNCTIONS   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'STRUCTURAL ONTOLOGY'
;; INCLUDES 'BASE ONTOLOGY'

(instance MultiplicationFn BinaryFunction)
(instance MultiplicationFn AssociativeFunction)
(instance MultiplicationFn CommutativeFunction)
(instance MultiplicationFn RelationExtendedToQuantities)
(domain MultiplicationFn 1 Quantity)
(domain MultiplicationFn 2 Quantity)
(range MultiplicationFn Quantity)
(documentation MultiplicationFn "If ?NUMBER1 and ?NUMBER2 are &%Numbers,
then (&%MultiplicationFn ?NUMBER1 ?NUMBER2) is the arithmetical product
of these numbers.")

(instance AdditionFn BinaryFunction)
(instance AdditionFn AssociativeFunction)
(instance AdditionFn CommutativeFunction)
(instance AdditionFn RelationExtendedToQuantities)
(domain AdditionFn 1 Quantity)
(domain AdditionFn 2 Quantity)
(range AdditionFn Quantity)
(documentation AdditionFn "If ?NUMBER1 and ?NUMBER2 are &%Numbers, then
(&%AdditionFn ?NUMBER1 ?NUMBER2) is the arithmetical sum of these
numbers.")

(instance SubtractionFn BinaryFunction)
(instance SubtractionFn AssociativeFunction)
(instance SubtractionFn RelationExtendedToQuantities)
(domain SubtractionFn 1 Quantity)
(domain SubtractionFn 2 Quantity)
(range SubtractionFn Quantity)
(documentation SubtractionFn "If ?NUMBER1 and ?NUMBER2 are &%Numbers,
then (&%SubtractionFn ?NUMBER1 ?NUMBER2) is the arithmetical difference
between ?NUMBER1 and ?NUMBER2, i.e. ?NUMBER1 minus ?NUMBER2.  An
exception occurs when ?NUMBER1 is equal to 0, in which case
(&%SubtractionFn ?NUMBER1 ?NUMBER2) is the negation of ?NUMBER2.")

(instance DivisionFn BinaryFunction)
(instance DivisionFn AssociativeFunction)
(instance DivisionFn RelationExtendedToQuantities)
(domain DivisionFn 1 Quantity)
(domain DivisionFn 2 Quantity)
(range DivisionFn Quantity)
(documentation DivisionFn "If ?NUMBER1 and ?NUMBER2 are &%Numbers, then
(&%DivisionFn ?NUMBER1 ?NUMBER2) is the result of dividing ?NUMBER1 by
?NUMBER2.  An exception occurs when ?NUMBER1 = 1, in which case
(&%DivisionFn ?NUMBER1 ?NUMBER2) is the reciprocal of ?NUMBER2.")

(=>
   (instance ?NUMBER RationalNumber)
   (exists (?INT1 ?INT2)
      (and
         (instance ?INT1 Integer)
         (instance ?INT2 Integer)
         (equal ?NUMBER (DivisionFn ?INT1 ?INT2)))))

(instance AbsoluteValueFn UnaryFunction)
(domain AbsoluteValueFn 1 RealNumber)
(range AbsoluteValueFn NonnegativeRealNumber)
(documentation AbsoluteValueFn "The value of (&%AbsoluteValueFn ?NUMBER)
is the absolute value of the &%RealNumber ?NUMBER.")

(<=>
     (equal (AbsoluteValueFn ?NUMBER1) ?NUMBER2)
     (or
         (and
              (instance ?NUMBER1 PositiveInteger)
              (equal ?NUMBER1 ?NUMBER2))
         (and
              (instance ?NUMBER1 NegativeInteger)
              (equal ?NUMBER2 (SubtractionFn 0 ?NUMBER1)))))

(instance ArcCosineFn UnaryFunction)
(inverse ArcCosineFn CosineFn)
(domain ArcCosineFn 1 RealNumber)
(range ArcCosineFn PlaneAngleMeasure)
(documentation ArcCosineFn "(&%ArcCosineFn ?NUMBER) returns the arc
cosine of the &%RealNumber ?NUMBER.  It is the &%inverse of &%CosineFn.")

(instance ArcSineFn UnaryFunction)
(inverse ArcSineFn SineFn)
(domain ArcSineFn 1 RealNumber)
(range ArcSineFn PlaneAngleMeasure)
(documentation ArcSineFn "(&%ArcSineFn ?NUMBER) returns the arc sine of
the &%RealNumber ?NUMBER.  It is the &%inverse of &%SineFn.")

(instance ArcTangentFn UnaryFunction)
(inverse ArcTangentFn TangentFn)
(domain ArcTangentFn 1 RealNumber)
(range ArcTangentFn PlaneAngleMeasure)
(documentation ArcTangentFn "(&%ArcTangentFn ?NUMBER) returns the arc
tangent of the &%RealNumber ?NUMBER.  It is the &%inverse of &%TangentFn.")

(instance CeilingFn UnaryFunction)
(domain CeilingFn 1 RealNumber)
(range CeilingFn Integer)
(documentation CeilingFn "(&%CeilingFn ?NUMBER) returns the smallest
&%Integer greater than or equal to the &%RealNumber ?NUMBER.")

(=>
   (equal (CeilingFn ?NUMBER) ?INT)
   (not
      (exists (?OTHERINT)
         (and
            (instance ?OTHERINT Integer)
            (greaterThanOrEqualTo ?OTHERINT ?NUMBER)
            (lessThan ?OTHERINT ?INT)))))

(instance CosineFn UnaryFunction)
(domain CosineFn 1 PlaneAngleMeasure)
(range CosineFn RealNumber)
(documentation CosineFn "(&%CosineFn ?DEGREE) returns the cosine of the
&%PlaneAngleMeasure ?DEGREE.  The cosine of ?DEGREE is the ratio of the
side next to ?DEGREE to the hypotenuse in a right-angled triangle.")

(instance DenominatorFn UnaryFunction)
(domain DenominatorFn 1 RealNumber)
(range DenominatorFn Integer)
(documentation DenominatorFn "(&%DenominatorFn ?NUMBER) returns the
denominator of the canonical reduced form of the &%RealNumber ?NUMBER.")

(instance ExponentiationFn BinaryFunction)
(instance ExponentiationFn RelationExtendedToQuantities)
(domain ExponentiationFn 1 Quantity)
(domain ExponentiationFn 2 Integer)
(range ExponentiationFn Quantity)
(documentation ExponentiationFn "(&%ExponentiationFn ?NUMBER ?INT) returns
the &%RealNumber ?NUMBER raised to the power of the &%Integer ?INT.")

(instance FloorFn UnaryFunction)
(domain FloorFn 1 RealNumber)
(range FloorFn Integer)
(documentation FloorFn "(&%FloorFn ?NUMBER) returns the largest &%Integer
less than or equal to the &%RealNumber ?NUMBER.")

(=>
   (equal (FloorFn ?NUMBER) ?INT)
   (not
      (exists (?OTHERINT)
         (and
            (instance ?OTHERINT Integer)
            (lessThanOrEqualTo ?OTHERINT ?NUMBER)
            (greaterThan ?OTHERINT ?INT)))))

(instance GreatestCommonDivisorFn Function)
(instance GreatestCommonDivisorFn VariableArityRelation)
(range GreatestCommonDivisorFn Integer)
(documentation GreatestCommonDivisorFn "(&%GreatestCommonDivisorFn
?NUMBER1 ?NUMBER2 ... ?NUMBER) returns the greatest common divisor of
?NUMBER1 through ?NUMBER.")

(=>
   (equal (GreatestCommonDivisorFn @ROW) ?NUMBER)
   (forall (?ELEMENT)
      (=>
         (inList ?ELEMENT (ListFn @ROW))
         (equal (RemainderFn ?ELEMENT ?NUMBER) 0))))

(=>
   (equal (GreatestCommonDivisorFn @ROW) ?NUMBER)
   (not (exists (?GREATER)
      (and
         (greaterThan ?GREATER ?NUMBER)
         (forall (?ELEMENT)
            (=>
               (inList ?ELEMENT (ListFn @ROW))
               (equal (RemainderFn ?ELEMENT ?GREATER) 0)))))))

(instance ImaginaryPartFn UnaryFunction)
(domain ImaginaryPartFn 1 ComplexNumber)
(range ImaginaryPartFn ImaginaryNumber)
(documentation ImaginaryPartFn "(&%ImaginaryPartFn ?NUMBER) returns
the part of ?NUMBER that has the square root of -1 as its factor.")

(=>
   (instance ?NUMBER ComplexNumber)
   (exists (?PART1 ?PART2)
      (and
         (equal ?PART1 (RealNumberFn ?NUMBER))
         (equal ?PART2 (ImaginaryPartFn ?NUMBER)))))

(instance IntegerSquareRootFn UnaryFunction)
(domain IntegerSquareRootFn 1 RealNumber)
(range IntegerSquareRootFn NonnegativeInteger)
(documentation IntegerSquareRootFn "(&%IntegerSquareRootFn ?NUMBER)
returns the integer square root of ?NUMBER.")

(instance LeastCommonMultipleFn Function)
(instance LeastCommonMultipleFn VariableArityRelation)
(range LeastCommonMultipleFn Integer)
(documentation LeastCommonMultipleFn "(&%LeastCommonMultipleFn
?NUMBER1 ?NUMBER2 ... ?NUMBER) returns the least common multiple of
?NUMBER1 through ?NUMBER.")

(=>
   (equal (LeastCommonMultipleFn @ROW) ?NUMBER)
   (forall (?ELEMENT)
      (=>
         (inList ?ELEMENT (ListFn @ROW))
         (equal (RemainderFn ?NUMBER ?ELEMENT) 0))))

(=>
   (equal (LeastCommonMultipleFn @ROW) ?NUMBER)
   (not (exists (?LESS)
      (and
         (lessThan ?LESS ?NUMBER)
         (forall (?ELEMENT)
            (=>
               (inList ?ELEMENT (ListFn @ROW))
               (equal (RemainderFn ?LESS ?ELEMENT) 0)))))))

(instance LogFn BinaryFunction)
(domain LogFn 1 RealNumber)
(domain LogFn 2 PositiveInteger)
(range LogFn RealNumber)
(documentation LogFn "(LogFn ?NUMBER ?INT) returns the logarithm of the
&%RealNumber ?NUMBER in the base denoted by the &%Integer ?INT.")

(instance MaxFn BinaryFunction)
(instance MaxFn AssociativeFunction)
(instance MaxFn CommutativeFunction)
(instance MaxFn RelationExtendedToQuantities)
(domain MaxFn 1 Quantity)
(domain MaxFn 2 Quantity)
(range MaxFn Quantity)
(documentation MaxFn "(&%MaxFn ?NUMBER1 ?NUMBER2) is the largest of
?NUMBER1 and ?NUMBER2.  In cases where ?NUMBER1 is equal to ?NUMBER2,
&%MaxFn returns one of its arguments.")

(=>
   (equal (MaxFn ?NUMBER1 ?NUMBER2) ?NUMBER)
   (or
      (and
         (equal ?NUMBER ?NUMBER1)
         (greaterThan ?NUMBER1 ?NUMBER2))
      (and
         (equal ?NUMBER ?NUMBER2)
         (greaterThan ?NUMBER2 ?NUMBER1))
      (and
         (equal ?NUMBER ?NUMBER1)
         (equal ?NUMBER ?NUMBER2))))

(instance MinFn BinaryFunction)
(instance MinFn AssociativeFunction)
(instance MinFn CommutativeFunction)
(instance MinFn RelationExtendedToQuantities)
(domain MinFn 1 Quantity)
(domain MinFn 2 Quantity)
(range MinFn Quantity)
(documentation MinFn "(&%MinFn ?NUMBER1 ?NUMBER2) is the smallest of
?NUMBER1 and ?NUMBER2.  In cases where ?NUMBER1 is equal to ?NUMBER2,
&%MinFn returns one of its arguments.")

(=>
   (equal (MinFn ?NUMBER1 ?NUMBER2) ?NUMBER)
   (or
      (and
         (equal ?NUMBER ?NUMBER1)
         (lessThan ?NUMBER1 ?NUMBER2))
      (and
         (equal ?NUMBER ?NUMBER2)
         (lessThan ?NUMBER2 ?NUMBER1))
      (and
         (equal ?NUMBER ?NUMBER1)
         (equal ?NUMBER ?NUMBER2))))

(instance NumeratorFn UnaryFunction)
(domain NumeratorFn 1 RealNumber)
(range NumeratorFn Integer)
(documentation NumeratorFn "(&%NumeratorFn ?NUMBER) returns the numerator
of the canonical reduced form ?NUMBER.")

(instance Pi PositiveRealNumber)
(documentation Pi "&%Pi is the &%RealNumber that
is the ratio of the perimeter of a circle to its diameter.  It is
approximately equal to 3.141592653589793.")

(instance NumberE PositiveRealNumber)
(documentation NumberE "&%NumberE is the &%RealNumber that is the base for
natural logarithms.  It is approximately equal to 2.718282.")

(instance RationalNumberFn UnaryFunction)
(domain RationalNumberFn 1 Number)
(range RationalNumberFn RationalNumber)
(documentation RationalNumberFn "(&%RationalNumberFn ?NUMBER) returns
the rational representation of ?NUMBER.")

(instance RealNumberFn UnaryFunction)
(domain RealNumberFn 1 Number)
(range RealNumberFn RealNumber)
(documentation RealNumberFn "(RealNumberFn ?NUMBER) returns the part of
?NUMBER that is a &%RealNumber.")

(instance ReciprocalFn UnaryFunction)
(instance ReciprocalFn RelationExtendedToQuantities)
(domain ReciprocalFn 1 Quantity)
(range ReciprocalFn Quantity)
(documentation ReciprocalFn "(ReciprocalFn ?NUMBER) is the reciprocal
element of ?NUMBER with respect to the multiplication operator
(&%MultiplicationFn), i.e. 1/?NUMBER.  Not all numbers have a reciprocal
element.  For example the number 0 does not.  If a number ?NUMBER has a
reciprocal ?RECIP, then the product of ?NUMBER and ?RECIP will be
1, e.g. 3*1/3 = 1.  The reciprocal of an element is &%equal to
applying the &%ExponentiationFn function to the element to the power
-1.")

(=>
   (instance ?NUMBER Quantity)
   (equal (ReciprocalFn ?NUMBER) (ExponentiationFn ?NUMBER -1)))

(=>
   (instance ?NUMBER Quantity)
   (equal 1 (MultiplicationFn ?NUMBER (ReciprocalFn ?NUMBER))))

(instance RemainderFn BinaryFunction)
(instance RemainderFn RelationExtendedToQuantities)
(domain RemainderFn 1 Quantity)
(domain RemainderFn 2 Quantity)
(range RemainderFn Quantity)
(documentation RemainderFn "(RemainderFn ?NUMBER ?DIVISOR) is the
remainder of the number ?NUMBER divided by the number ?DIVISOR.
The result has the same sign as ?DIVISOR.")

(<=>
   (equal (RemainderFn ?NUMBER1 ?NUMBER2) ?NUMBER)
   (equal (AdditionFn (MultiplicationFn (FloorFn (DivisionFn ?NUMBER1 ?NUMBER2)) ?NUMBER2) ?NUMBER) ?NUMBER1))

(=>
   (equal (RemainderFn ?NUMBER1 ?NUMBER2) ?NUMBER)
   (equal (SignumFn ?NUMBER2) (SignumFn ?NUMBER)))


(=>
	(instance ?NUMBER EvenInteger)
	(equal (RemainderFn ?NUMBER 2) 0))

(=>
	(instance ?NUMBER OddInteger)
	(equal (RemainderFn ?NUMBER 2) 1))

(=>
   (instance ?PRIME PrimeNumber)
   (forall (?NUMBER)
      (=>
         (equal (RemainderFn ?PRIME ?NUMBER) 0)
         (or
            (equal ?NUMBER 1)
            (equal ?NUMBER ?PRIME)))))

(instance RoundFn UnaryFunction)
(instance RoundFn RelationExtendedToQuantities)
(domain RoundFn 1 Quantity)
(range RoundFn Quantity)
(documentation RoundFn "(&%RoundFn ?NUMBER) is the &%Integer closest
to ?NUMBER on the number line.  If ?NUMBER is halfway between two
&%Integers (for example 3.5), it denotes the larger &%Integer.")

(=>
   (equal (RoundFn ?NUMBER1) ?NUMBER2)
   (or
      (=>
         (lessThan (SubtractionFn ?NUMBER1 (FloorFn ?NUMBER1)) 0.5)
         (equal ?NUMBER2 (FloorFn ?NUMBER1)))
      (=>
         (greaterThanOrEqualTo (SubtractionFn ?NUMBER1 (FloorFn ?NUMBER1)) 0.5)
         (equal ?NUMBER2 (CeilingFn ?NUMBER1)))))

(instance SignumFn UnaryFunction)
(domain SignumFn 1 RealNumber)
(range SignumFn Integer)
(documentation SignumFn "(SignumFn ?NUMBER) denotes the sign of ?NUMBER.
This is one of the following values:  -1, 1, or 0.")

(=>
   (instance ?NUMBER NonnegativeRealNumber)
   (or
      (equal (SignumFn ?NUMBER) 1)
      (equal (SignumFn ?NUMBER) 0)))

(=>
   (instance ?NUMBER PositiveRealNumber)
   (equal (SignumFn ?NUMBER) 1))

(=>
   (instance ?NUMBER NegativeRealNumber)
   (equal (SignumFn ?NUMBER) -1))

(instance SineFn UnaryFunction)
(domain SineFn 1 PlaneAngleMeasure)
(range SineFn RealNumber)
(documentation SineFn "(&%SineFn ?DEGREE) is the sine of the
&%PlaneAngleMeasure ?DEGREE.  The sine of ?DEGREE is the ratio of the side
opposite ?DEGREE to the hypotenuse in a right-angled triangle.")

(instance SquareRootFn UnaryFunction)
(domain SquareRootFn 1 RealNumber)
(range SquareRootFn Number)
(documentation SquareRootFn "(SquareRootFn ?NUMBER) is the principal
square root of ?NUMBER.")

(=>
   (equal (SquareRootFn ?NUMBER1) ?NUMBER2)
   (equal (MultiplicationFn ?NUMBER2 ?NUMBER2) ?NUMBER1))

(instance TangentFn UnaryFunction)
(domain TangentFn 1 PlaneAngleMeasure)
(range TangentFn RealNumber)
(documentation TangentFn "(&%TangentFn ?DEGREE) is the tangent of the
&%PlaneAngleMeasure ?DEGREE.  The tangent of ?DEGREE is the ratio of
the side opposite ?DEGREE to the side next to ?DEGREE in a right-angled
triangle.")

(=>
   (instance ?DEGREE PlaneAngleMeasure)
   (equal (TangentFn ?DEGREE) (DivisionFn (SineFn ?DEGREE) (CosineFn ?DEGREE))))

(instance IdentityFn UnaryFunction)
(domain IdentityFn 1 Entity)
(range IdentityFn Entity)
(documentation IdentityFn "The value of the identity function is
just its argument.")

(equal (IdentityFn ?INST) ?INST)

(instance identityElement BinaryPredicate)
(instance identityElement AsymmetricRelation)
(domain identityElement 1 BinaryFunction)
(domain identityElement 2 Entity)
(documentation identityElement "An object ?ID is the identity element
for BinaryFunction ?FUNCTION just in case, for every instance ?INST,
applying ?FUNCTION to ?INST and ?ID results in ?INST.")

(=>
   (identityElement ?FUNCTION ?ID)
   (forall (?INST)
      (=>
         (instance ?INST (DomainFn ?FUNCTION))
         (equal (AssignmentFn ?FUNCTION ?ID ?INST) ?INST))))

(identityElement MultiplicationFn 1)
(identityElement AdditionFn 0)
(identityElement SubtractionFn 0)
(identityElement DivisionFn 1)

(instance SuccessorFn UnaryFunction)
(domain SuccessorFn 1 Integer)
(range SuccessorFn Integer)
(documentation SuccessorFn "A &%UnaryFunction that maps an &%Integer to
its successor, e.g. the successor of 5 is 6.")

(=>
   (equal (SuccessorFn ?INT1) (SuccessorFn ?INT2))
   (equal ?INT1 ?INT2))

(=>
   (instance ?INT Integer)
   (lessThan ?INT (SuccessorFn ?INT)))

(=>
   (and
      (instance ?INT1 Integer)
      (instance ?INT2 Integer))
   (not
      (and
         (lessThan ?INT1 ?INT2)
         (lessThan ?INT2 (SuccessorFn ?INT1)))))

(=>
   (instance ?INT Integer)
   (equal ?INT (SuccessorFn (PredecessorFn ?INT))))

(=>
   (instance ?INT Integer)
   (equal ?INT (PredecessorFn (SuccessorFn ?INT))))

(instance PredecessorFn UnaryFunction)
(domain PredecessorFn 1 Integer)
(range PredecessorFn Integer)
(documentation PredecessorFn "A &%UnaryFunction that maps an &%Integer to
its predecessor, e.g. the predecessor of 5 is 4.")

(=>
   (equal (PredecessorFn ?INT1) (PredecessorFn ?INT2))
   (equal ?INT1 ?INT2))

(=>
   (instance ?INT Integer)
   (greaterThan ?INT (PredecessorFn ?INT)))

(=>
   (and
      (instance ?INT1 Integer)
      (instance ?INT2 Integer))
   (not
      (and
         (lessThan ?INT2 ?INT1)
         (lessThan (PredecessorFn ?INT1) ?INT2))))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;     SET/CLASS THEORY      ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'STRUCTURAL ONTOLOGY'
;; INCLUDES 'BASE ONTOLOGY'

;; The following part of the ontology covers set-theoretic predicates
;; and functions.  Most of the content here is taken from the kif-sets
;; ontology (available on the Ontolingua server).

(subrelation subset subclass)
(domain subset 1 Set)
(domain subset 2 Set)
(documentation subset "(subset ?SET1 ?SET2) is true just in case the
&%elements of the &%Set ?SET1 are also &%elements of the &%Set ?SET2.")

(=>
   (subset ?SUBSET ?SET)
   (forall (?ELEMENT)
      (=>
         (element ?ELEMENT ?SUBSET)
         (element ?ELEMENT ?SET))))

(instance element BinaryPredicate)
(instance element AsymmetricRelation)
(instance element IntransitiveRelation)
(subrelation element instance)
(domain element 1 Entity)
(domain element 2 Set)
(documentation element "(element ?ENTITY ?SET) is true just in case
?ENTITY is contained in the &%Set ?SET.  An &%Entity can be an &%element
of another &%Entity only if the latter is a &%Set.")

(=>
   (forall (?ELEMENT)
         (<=>
            (element ?ELEMENT ?SET1)
            (element ?ELEMENT ?SET2)))
   (equal ?SET1 ?SET2))

(instance UnionFn BinaryFunction)
(domain UnionFn 1 SetOrClass)
(domain UnionFn 2 SetOrClass)
(range UnionFn SetOrClass)
(documentation UnionFn "A &%BinaryFunction that maps two &%Classes to
the union of these &%Classes.  An object is an instance of the union of
two &%Classes just in case it is an instance of either &%SetOrClass.")

(<=>
   (instance ?ENTITY (UnionFn ?CLASS1 ?CLASS2))
   (or
      (instance ?ENTITY ?CLASS1)
      (instance ?ENTITY ?CLASS2)))

(instance IntersectionFn BinaryFunction)
(domain IntersectionFn 1 SetOrClass)
(domain IntersectionFn 2 SetOrClass)
(range IntersectionFn SetOrClass)
(documentation IntersectionFn "A &%BinaryFunction that maps two
%Classes to the intersection of these &%Classes.  An object is an instance
of the intersection of two &%Classes just in case it is an instance of
both of those &%Classes.")

(<=>
   (instance ?ENTITY (IntersectionFn ?CLASS1 ?CLASS2))
   (and
      (instance ?ENTITY ?CLASS1)
      (instance ?ENTITY ?CLASS2)))

(instance RelativeComplementFn BinaryFunction)
(domain RelativeComplementFn 1 SetOrClass)
(domain RelativeComplementFn 2 SetOrClass)
(range RelativeComplementFn SetOrClass)
(documentation RelativeComplementFn "A &%BinaryFunction that maps two
&%Classes to the difference between these &%Classes.  More precisely,
the relative complement of one class C1 relative to another C2 consists
of the instances of C1 that are instances of the &%ComplementFn of C2.")

(=>
   (and
      (instance ?CLASS1 SetOrClass)
      (instance ?CLASS2 SetOrClass))
   (equal (RelativeComplementFn ?CLASS1 ?CLASS2) (IntersectionFn ?CLASS1 (ComplementFn ?CLASS2))))

(=>
   (instance ?NUMBER ImaginaryNumber)
   (instance ?NUMBER (RelativeComplementFn Number RealNumber)))

(instance ComplementFn UnaryFunction)
(domain ComplementFn 1 SetOrClass)
(range ComplementFn SetOrClass)
(documentation ComplementFn "The complement of a given &%SetOrClass C is the
&%SetOrClass of all things that are not instances of C.  In other words, an
object is an instance of the complement of a &%SetOrClass C just in case it
is not an instance of C.")

(<=>
   (instance ?ENTITY (ComplementFn ?CLASS))
   (not
      (instance ?ENTITY ?CLASS)))

(instance GeneralizedUnionFn UnaryFunction)
(domainSubclass GeneralizedUnionFn 1 SetOrClass)
(range GeneralizedUnionFn SetOrClass)
(documentation GeneralizedUnionFn "A &%UnaryFunction that takes a &%SetOrClass
of &%Classes as its single argument and returns a &%SetOrClass which is the
merge of all of the &%Classes in the original &%SetOrClass, i.e. the &%SetOrClass
containing just those instances which are instances of an instance of the
original &%SetOrClass.")

(<=>
   (instance ?ENTITY (GeneralizedUnionFn ?SUPERCLASS))
   (exists (?CLASS)
      (and
         (instance ?CLASS ?SUPERCLASS)
         (instance ?ENTITY ?CLASS))))

(instance GeneralizedIntersectionFn UnaryFunction)
(domainSubclass GeneralizedIntersectionFn 1 SetOrClass)
(range GeneralizedIntersectionFn SetOrClass)
(documentation GeneralizedIntersectionFn "A &%UnaryFunction that takes a
&%SetOrClass of &%Classes as its single argument and returns a &%SetOrClass which
is the intersection of all of the &%Classes in the original &%SetOrClass, i.e.
the &%SetOrClass containing just those instances which are instances of all
instances of the original &%SetOrClass.")

(<=>
   (instance ?ENTITY (GeneralizedIntersectionFn ?SUPERCLASS))
   (forall (?CLASS)
         (=>
            (instance ?CLASS ?SUPERCLASS)
            (instance ?ENTITY ?CLASS))))

(instance CardinalityFn UnaryFunction)
(instance CardinalityFn AsymmetricRelation)
(domain CardinalityFn 1 (UnionFn SetOrClass Collection))
(domain CardinalityFn 2 Number)
(documentation CardinalityFn "(CardinalityFn ?CLASS) returns the
number of instances in the &%SetOrClass or &%Collection ?CLASS.")

(instance NullSet Set)
(documentation NullSet "The &%Set that contains no instances.")

(equal NullSet (ComplementFn Entity))

(subclass FiniteSet Set)
(documentation FiniteSet "A &%Set containing a finite number of elements.")

(=>
   (instance ?SET FiniteSet)
   (exists (?NUMBER)
      (and
         (instance ?NUMBER NonnegativeInteger)
         (equal ?NUMBER (CardinalityFn ?SET)))))

(subclass PairwiseDisjointClass SetOrClass)
(documentation PairwiseDisjointClass "A &%SetOrClass of &%Classes is a
&%PairwiseDisjointClass just in case every instance of the &%SetOrClass
is either &%equal to or &%disjoint from every other instance of the
&%SetOrClass.")

(=>
   (instance ?SUPERCLASS PairwiseDisjointClass)
   (forall (?CLASS1 ?CLASS2)
      (=>
         (and
            (instance ?CLASS1 ?SUPERCLASS)
            (instance ?CLASS2 ?SUPERCLASS))
         (or
            (equal ?CLASS1 ?CLASS2)
            (disjoint ?CLASS1 ?CLASS2)))))

(subclass MutuallyDisjointClass SetOrClass)
(documentation MutuallyDisjointClass "A &%SetOrClass of &%Classes is a
&%MutuallyDisjointClass just in case there exists no instance of an
instance of the original &%SetOrClass which is an instance of all of the
instances of the original &%SetOrClass.")

(=>
   (instance ?CLASS MutuallyDisjointClass)
   (equal (GeneralizedIntersectionFn ?CLASS) NullSet))

(instance KappaFn BinaryFunction)
(domain KappaFn 1 SymbolicString)
(domain KappaFn 2 Formula)
(range KappaFn SetOrClass)
(documentation KappaFn "A class-forming operator that takes two
arguments:  a variable and a formula containing at least one unbound
occurrence of the variable.  The result of applying &%KappaFn to a
variable and a formula is the &%SetOrClass of things that satisfy the formula.
For example, we can denote the &%SetOrClass of prime numbers that are less
than 100 with the following expression:  (KappaFn ?NUMBER
(and (instance ?NUMBER PrimeNumber) (lessThan ?NUMBER 100))).  Note that
the use of this function is discouraged, since there is currently no
axiomatic support for it.")

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;
;;  GRAPH THEORY   ;;
;;;;;;;;;;;;;;;;;;;;;

(subclass Graph Abstract)
(documentation Graph "The &%Class of graphs, where a graph is understood
to be a set of &%GraphNodes connected by &%GraphArcs.  Note that this
&%Class includes only connected graphs, i.e. graphs in which there is a
&%GraphPath between any two &%GraphNodes.  Note too that every &%Graph
is assumed to contain at least two &%GraphArcs and three &%GraphNodes.")

(=>
   (and
      (instance ?GRAPH Graph)
      (instance ?NODE1 GraphNode)
      (instance ?NODE2 GraphNode)
      (graphPart ?NODE1 ?GRAPH)
      (graphPart ?NODE2 ?GRAPH)
      (not (equal ?NODE1 ?NODE2)))
   (exists (?ARC ?PATH)
      (or
         (links ?NODE1 ?NODE2 ?ARC)
         (and
            (subGraph ?PATH ?GRAPH)
            (instance ?PATH GraphPath)
            (or
               (and
                  (equal (BeginNodeFn ?PATH) ?NODE1)
                  (equal (EndNodeFn ?PATH) ?NODE2))
               (and
                  (equal (BeginNodeFn ?PATH) ?NODE2)
                  (equal (EndNodeFn ?PATH) ?NODE1)))))))

(=>
   (instance ?GRAPH Graph)
   (exists (?NODE1 ?NODE2 ?NODE3 ?ARC1 ?ARC2)
      (and
         (graphPart ?NODE1 ?GRAPH)
         (graphPart ?NODE2 ?GRAPH)
         (graphPart ?NODE3 ?GRAPH)
         (graphPart ?ARC1 ?GRAPH)
         (graphPart ?ARC2 ?GRAPH)
         (links ?ARC1 ?NODE1 ?NODE2)
         (links ?ARC2 ?NODE2 ?NODE3)
         (not (equal ?NODE1 ?NODE2))
         (not (equal ?NODE2 ?NODE3))
	   (not (equal ?NODE1 ?NODE3))
         (not (equal ?ARC1 ?ARC2)))))

(subclass DirectedGraph Graph)
(documentation DirectedGraph "The &%Class of directed graphs.  A
directed graph is a &%Graph in which all &%GraphArcs
have direction, i.e. every &%GraphArc has an initial node (see
&%InitialNodeFn) and a terminal node (see &%TerminalNodeFn).")

(=>
   (and
      (instance ?GRAPH DirectedGraph)
      (instance ?ARC GraphArc)
      (graphPart ?ARC ?GRAPH))
   (exists (?NODE1 ?NODE2)
      (and
         (equal (InitialNodeFn ?ARC) ?NODE1)
         (equal (TerminalNodeFn ?ARC) ?NODE2))))

(subclass Tree Graph)
(documentation Tree "A Tree is a &%DirectedGraph that has no
&%GraphLoops.")

(=>
   (instance ?GRAPH Tree)
   (not (exists (?LOOP)
      (and
         (instance ?LOOP GraphLoop)
         (graphPart ?LOOP ?GRAPH)))))

(subclass GraphPath DirectedGraph)
(documentation GraphPath "Informally, a single, directed route between
two &%GraphNodes in a &%Graph.  Formally, a &%DirectedGraph that is a
&%subGraph of the original &%Graph and such that no two &%GraphArcs in
the &%DirectedGraph have the same intial node (see &%InitialNodeFn) or
the same terminal node (see &%TerminalNodeFn).")

(=>
   (and
      (instance ?GRAPH GraphPath)
      (instance ?ARC GraphArc)
      (graphPart ?ARC ?GRAPH))
   (=>
      (equal (InitialNodeFn ?ARC) ?NODE)
      (not (exists (?OTHER)
         (and
            (equal (InitialNodeFn ?OTHER) ?NODE)
            (not (equal ?OTHER ?ARC)))))))

(=>
   (and
      (instance ?GRAPH GraphPath)
      (instance ?ARC GraphArc)
      (graphPart ?ARC ?GRAPH))
   (=>
      (equal (TerminalNodeFn ?ARC) ?NODE)
      (not (exists (?OTHER)
         (and
            (equal (TerminalNodeFn ?OTHER) ?NODE)
            (not (equal ?OTHER ?ARC)))))))

(subclass GraphCircuit GraphPath)
(documentation GraphCircuit "A &%GraphPath that begins (see
&%BeginNodeFn) and ends (see &%EndNodeFn) at the same
&%GraphNode.")

(<=>
   (instance ?GRAPH GraphCircuit)
   (exists (?NODE)
      (and
         (equal (BeginNodeFn ?GRAPH) ?NODE)
         (equal (EndNodeFn ?GRAPH) ?NODE))))

(subclass MultiGraph Graph)
(documentation MultiGraph "The &%Class of multigraphs.  A multigraph
is a &%Graph containing at least one pair of &%GraphNodes that are
connected by more than one &%GraphArc.")

(<=>
   (instance ?GRAPH MultiGraph)
   (exists (?ARC1 ?ARC2 ?NODE1 ?NODE2)
      (and
         (graphPart ?ARC1 ?GRAPH)
         (graphPart ?ARC2 ?GRAPH)
         (graphPart ?NODE1 ?GRAPH)
         (graphPart ?NODE2 ?GRAPH)
         (links ?NODE1 ?NODE2 ?ARC1)
         (links ?NODE1 ?NODE2 ?ARC2)
         (not (equal ?ARC1 ?ARC2)))))

(subclass PseudoGraph Graph)
(documentation PseudoGraph "The &%Class of pseudographs.  A pseudograph
is a &%Graph containing at least one &%GraphLoop.")

(<=>
   (instance ?GRAPH PseudoGraph)
   (exists (?LOOP)
      (and
         (instance ?LOOP GraphLoop)
         (graphPart ?LOOP ?GRAPH))))

(subclass GraphElement Abstract)
(disjoint GraphElement Graph)
(partition GraphElement GraphNode GraphArc)
(documentation GraphElement "Noncompositional parts of &%Graphs.
These parts are restricted to &%GraphNodes and &%GraphArcs.")

(=>
   (instance ?PART GraphElement)
   (exists (?GRAPH)
      (and
         (instance ?GRAPH Graph)
         (graphPart ?PART ?GRAPH))))

(subclass GraphNode GraphElement)
(documentation GraphNode "&%Graphs are comprised of &%GraphNodes
and &%GraphArcs.  Every &%GraphNode is linked by a &%GraphArc.")

(=>
   (instance ?NODE GraphNode)
   (exists (?OTHER ?ARC)
      (links ?NODE ?OTHER ?ARC)))

(subclass GraphArc GraphElement)
(documentation GraphArc "&%Graphs are comprised of &%GraphNodes
and &%GraphArcs.  Every &%GraphArc links two &%GraphNodes.")

(=>
   (instance ?ARC GraphArc)
   (exists (?NODE1 ?NODE2)
      (links ?NODE1 ?NODE2 ?ARC)))

(subclass GraphLoop GraphArc)
(documentation GraphLoop "A &%GraphArc in which a &%GraphNode is
linked to itself.")

(<=>
   (instance ?LOOP GraphLoop)
   (exists (?NODE)
      (links ?NODE ?NODE ?LOOP)))

(=>
   (and
      (equal (InitialNodeFn ?ARC) ?NODE)
      (equal (TerminalNodeFn ?ARC) ?NODE))
   (instance ?ARC GraphLoop))

(instance links TernaryPredicate)
(domain links 1 GraphNode)
(domain links 2 GraphNode)
(domain links 3 GraphArc)
(documentation links "a &%TernaryPredicate that specifies the
&%GraphArc connecting two &%GraphNodes.")

(=>
   (links ?NODE1 ?NODE2 ?ARC)
   (links ?NODE2 ?NODE1 ?ARC))

(instance graphPart BinaryPredicate)
(instance graphPart AsymmetricRelation)
(instance graphPart IrreflexiveRelation)
(domain graphPart 1 GraphElement)
(domain graphPart 2 Graph)
(documentation graphPart "A basic relation for &%Graphs and their
parts.  (&%graphPart ?PART ?GRAPH) means that ?PART is a &%GraphArc
or &%GraphNode of the &%Graph ?GRAPH.")

(instance subGraph BinaryPredicate)
(instance subGraph ReflexiveRelation)
(instance subGraph TransitiveRelation)
(domain subGraph 1 Graph)
(domain subGraph 2 Graph)
(documentation subGraph "The relation between two &%Graphs when one
&%Graph is a part of the other.  (&%subGraph ?GRAPH1 ?GRAPH2) means
that ?GRAPH1 is a part of ?GRAPH2.")

(=>
   (and
      (subGraph ?GRAPH1 ?GRAPH2)
      (graphPart ?ELEMENT ?GRAPH1))
   (graphPart ?ELEMENT ?GRAPH2))

(instance pathLength BinaryPredicate)
(instance pathLength AsymmetricRelation)
(instance pathLength IrreflexiveRelation)
(domain pathLength 1 GraphPath)
(domain pathLength 2 PositiveInteger)
(documentation pathLength "A &%BinaryPredicate that specifies the
length (in number of &%GraphNodes) of a &%GraphPath.
(&%pathLength ?PATH ?NUMBER) means that there are ?NUMBER nodes in
the &%GraphPath ?PATH.")

(instance InitialNodeFn UnaryFunction)
(domain InitialNodeFn 1 GraphArc)
(range InitialNodeFn GraphNode)
(documentation InitialNodeFn "A &%UnaryFunction that maps a
&%GraphArc to the initial node of the &%GraphArc.  Note
that this is a partial function.  In particular, the function is
undefined for &%GraphArcs that are not part of a &%DirectedGraph.")

(instance TerminalNodeFn UnaryFunction)
(domain TerminalNodeFn 1 GraphArc)
(range TerminalNodeFn GraphNode)
(documentation TerminalNodeFn "A &%UnaryFunction that maps a
&%GraphArc to the terminal node of the &%GraphArc.  Note that this
is a partial function.  In particular, the function is undefined
for &%GraphArcs that are not part of a &%DirectedGraph.")

(instance BeginNodeFn UnaryFunction)
(domain BeginNodeFn 1 GraphPath)
(range BeginNodeFn GraphNode)
(relatedInternalConcept BeginNodeFn InitialNodeFn)
(documentation BeginNodeFn "A &%UnaryFunction that maps a &%GraphPath
to the &%GraphNode that is the beginning of the &%GraphPath.  Note that,
unlike &%InitialNodeFn (which relates a &%GraphArc to a &%GraphNode),
&%BeginNodeFn is a total function - every &%GraphPath has a beginning.")

(instance EndNodeFn UnaryFunction)
(domain EndNodeFn 1 GraphPath)
(range EndNodeFn GraphNode)
(relatedInternalConcept EndNodeFn TerminalNodeFn)
(documentation EndNodeFn "A &%UnaryFunction that maps a &%GraphPath
to the &%GraphNode that is the end of the &%GraphPath.  Note that, unlike
&%TerminalNodeFn (which relates a &%GraphArc to a &%GraphNode),
&%EndNodeFn is a total function - every &%GraphPath has a end.")

(instance arcWeight BinaryPredicate)
(domain arcWeight 1 GraphArc)
(domain arcWeight 2 RealNumber)
(documentation arcWeight "This predicate indicates the value of a
&%GraphArc in a &%Graph.  This could map to the length of a road in
a road network or the flow rate of a pipe in a plumbing system.")

(instance PathWeightFn UnaryFunction)
(domain PathWeightFn 1 GraphPath)
(range PathWeightFn RealNumber)
(documentation PathWeightFn "A &%UnaryFunction that maps a
&%GraphPath to the sum of the &%arcWeights on the &%GraphArcs in
the &%GraphPath.")

(=>
   (and
      (equal (PathWeightFn ?PATH) ?SUM)
      (subGraph ?SUBPATH ?PATH)
      (graphPart ?ARC1 ?PATH)
      (arcWeight ?ARC1 ?NUMBER1)
      (forall (?ARC2)
         (=>
            (graphPart ?ARC2 ?PATH)
            (or
               (graphPart ?ARC2 ?SUBPATH)
               (equal ?ARC2 ?ARC1)))))
   (equal ?SUM (AdditionFn (PathWeightFn ?SUBPATH) ?NUMBER1)))

(=>
   (and
      (equal (PathWeightFn ?PATH) ?SUM)
      (graphPart ?ARC1 ?PATH)
      (graphPart ?ARC2 ?PATH)
      (arcWeight ?ARC1 ?NUMBER1)
      (arcWeight ?ARC2 ?NUMBER2)
      (forall (?ARC3)
         (=>
            (graphPart ?ARC3 ?PATH)
            (or
               (equal ?ARC3 ?ARC1)
               (equal ?ARC3 ?ARC2)))))
   (equal (PathWeightFn ?PATH) (AdditionFn ?NUMBER1 ?NUMBER2)))

(instance MinimalWeightedPathFn BinaryFunction)
(domain MinimalWeightedPathFn 1 GraphNode)
(domain MinimalWeightedPathFn 2 GraphNode)
(range MinimalWeightedPathFn GraphPath)
(documentation MinimalWeightedPathFn "This &%BinaryFunction assigns two
&%GraphNodes to the &%GraphPath with the smallest sum of weighted arcs
between the two &%GraphNodes.")

(=>
   (equal (MinimalWeightedPathFn ?NODE1 ?NODE2) ?PATH)
   (instance ?PATH (GraphPathFn ?NODE1 ?NODE2)))

(=>
   (and
      (equal (MinimalWeightedPathFn ?NODE1 ?NODE2) ?PATH)
      (equal (PathWeightFn ?PATH) ?NUMBER))
   (forall (?PATH2)
      (=>
         (and
            (instance ?PATH2 (GraphPathFn ?NODE1 ?NODE2))
            (equal (PathWeightFn ?PATH2) ?NUMBER2))
         (greaterThanOrEqualTo ?NUMBER2 ?NUMBER1))))

(instance MaximalWeightedPathFn BinaryFunction)
(domain MaximalWeightedPathFn 1 GraphNode)
(domain MaximalWeightedPathFn 2 GraphNode)
(range MaximalWeightedPathFn GraphPath)
(documentation MaximalWeightedPathFn "This &%BinaryFunction assigns two
&%GraphNodes to the &%GraphPath with the largest sum of weighted arcs
between the two &%GraphNodes.")

(=>
   (equal (MaximalWeightedPathFn ?NODE1 ?NODE2) ?PATH)
   (instance ?PATH (GraphPathFn ?NODE1 ?NODE2)))

(=>
   (and
      (equal (MaximalWeightedPathFn ?NODE1 ?NODE2) ?PATH)
      (equal (PathWeightFn ?PATH) ?NUMBER))
   (forall (?PATH2)
      (=>
         (and
            (instance ?PATH2 (GraphPathFn ?NODE1 ?NODE2))
            (equal (PathWeightFn ?PATH2) ?NUMBER2))
         (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))

(instance GraphPathFn BinaryFunction)
(domain GraphPathFn 1 GraphNode)
(domain GraphPathFn 2 GraphNode)
(rangeSubclass GraphPathFn GraphPath)
(documentation GraphPathFn "A &%BinaryFunction that maps two &%GraphNodes
to the &%Class of &%GraphPaths between those two nodes.  Note that the two
&%GraphNodes must belong to the same &%Graph.")

(=>
   (and
      (graphPart ?PATH ?GRAPH)
      (not (instance ?GRAPH DirectedGraph)))
   (<=>
      (equal (GraphPathFn ?NODE1 ?NODE2) ?PATH)
      (equal (GraphPathFn ?NODE2 ?NODE1) ?PATH)))

(instance CutSetFn UnaryFunction)
(domain CutSetFn 1 Graph)
(rangeSubclass CutSetFn GraphPath)
(documentation CutSetFn "A &%UnaryFunction that assigns a &%Graph the
&%Class of &%GraphPaths that partition the graph into two separate
graphs if cut.  There may be more than one cutset for a given graph.")

(instance MinimalCutSetFn UnaryFunction)
(domain MinimalCutSetFn 1 Graph)
(rangeSubclass MinimalCutSetFn GraphPath)
(relatedInternalConcept MinimalCutSetFn CutSetFn)
(documentation MinimalCutSetFn "A &%UnaryFunction that assigns a &%Graph
the &%Class of &%GraphPaths which comprise cutsets for the &%Graph and
which have the least number of &%GraphArcs.")

(=>
   (instance ?GRAPH Graph)
   (subclass (MinimalCutSetFn ?GRAPH) (CutSetFn ?GRAPH)))

(=>
   (equal (MinimalCutSetFn ?GRAPH) ?PATHCLASS)
   (exists (?NUMBER)
      (forall (?PATH)
         (=>
            (instance ?PATH ?PATHCLASS)
            (pathLength ?PATH ?NUMBER)))))

(not (exists (?PATH1 ?PATH2)
   (and
      (instance ?PATH1 (CutSetFn ?GRAPH))
      (instance ?PATH2 (MinimalCutSetFn ?GRAPH))
      (pathLength ?PATH1 ?NUMBER1)
      (pathLength ?PATH2 ?NUMBER2)
      (lessThan ?NUMBER1 ?NUMBER2))))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;;;
;;  UNITS OF MEASURE   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'NUMERIC FUNCTIONS'

;; This section was originally based on the relations in the Quantities
;; ontology (developed by ITBM-CNR) and the units of measure in the
;; "Standard Units" and "Standard Dimensions" ontologies on the Ontolingua
;; server.  This content has been extensively revised by Helena Sofia Pinto
;; of the Instituto Superior Tecnico in Portugal.  The sources for these
;; revisions were:
;; - Barry Taylor, NIST Special Publication 811, Guide for the Use of the
;;   International System of Units (SI), 1995.
;; - Encyclopaedia Britannica (on-line version at http://www.britannica.com)

(subclass UnitOfMeasure PhysicalQuantity)
(documentation UnitOfMeasure "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.")

(subclass SystemeInternationalUnit UnitOfMeasure)
(documentation SystemeInternationalUnit "The &%Class of Systeme
International (SI) units.")

(subclass LengthMeasure ConstantQuantity)
(documentation LengthMeasure "The &%Class of &%ConstantQuantities relating
to length.")

(subclass MassMeasure ConstantQuantity)
(documentation MassMeasure "The &%Class of &%ConstantQuantities relating
to the amount of matter in an &%Object.")

(subclass AreaMeasure ConstantQuantity)
(documentation AreaMeasure "Measures of the amount of space in two
dimensions.")

(subclass VolumeMeasure ConstantQuantity)
(documentation VolumeMeasure "Measures of the amount of space in three
dimensions.")

(subclass TemperatureMeasure ConstantQuantity)
(documentation TemperatureMeasure "Measures of temperature.
In scientific circles, the temperature of something is understood as the
average velocity of the atoms or molecules that make up the thing.")

(subclass CurrencyMeasure ConstantQuantity)
(documentation CurrencyMeasure "Includes all standard measures of monetary
value, including &%UnitedStatesDollar, &%UnitedStatesCent, Lire, Yen, etc.")

(subclass AngleMeasure ConstantQuantity)
(documentation AngleMeasure "The value of an angle in a plane or in a
solid.")

(subclass PlaneAngleMeasure AngleMeasure)
(documentation PlaneAngleMeasure "The value of an angle in a plane.")

(subclass SolidAngleMeasure AngleMeasure)
(disjoint SolidAngleMeasure PlaneAngleMeasure)
(documentation SolidAngleMeasure "The value of an angle in a solid.")

(instance MeasureFn BinaryFunction)
(domain MeasureFn 1 RealNumber)
(domain MeasureFn 2 UnitOfMeasure)
(range MeasureFn ConstantQuantity)
(documentation MeasureFn "This &%BinaryFunction maps a &%RealNumber and
a &%UnitOfMeasure to that &%Number of units.  It is used for expressing
&%ConstantQuantities.  For example, the concept of three meters is
represented as (&%MeasureFn 3 &%Meter).")

(=>
   (and
      (equal (MeasureFn ?NUMBER ?UNIT) ?QUANT)
      (instance ?UNIT ?QUANTTYPE)
      (not (equal ?QUANTTYPE UnitOfMeasure)))
   (instance ?QUANT ?QUANTTYPE))

(=>
   (and
      (instance ?REL RelationExtendedToQuantities)
      (instance ?REL TernaryRelation)
      (instance ?NUMBER1 RealNumber)
      (instance ?NUMBER2 RealNumber)
      (holds ?REL ?NUMBER1 ?NUMBER2 ?VALUE))
   (forall (?UNIT)
      (=>
         (instance ?UNIT UnitOfMeasure)
         (holds ?REL (MeasureFn ?NUMBER1 ?UNIT) (MeasureFn ?NUMBER2 ?UNIT) (MeasureFn ?VALUE ?UNIT)))))

(=>
   (and
      (instance ?REL RelationExtendedToQuantities)
      (instance ?REL BinaryRelation)
      (instance ?NUMBER1 RealNumber)
      (instance ?NUMBER2 RealNumber)
      (holds ?REL ?NUMBER1 ?NUMBER2))
   (forall (?UNIT)
      (=>
         (instance ?UNIT UnitOfMeasure)
         (holds ?REL (MeasureFn ?NUMBER1 ?UNIT) (MeasureFn ?NUMBER2 ?UNIT)))))

(instance KiloFn UnaryFunction)
(domain KiloFn 1 UnitOfMeasure)
(range KiloFn UnitOfMeasure)
(documentation KiloFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to 1,000 units of the original &%UnitOfMeasure.
For example, (&%KiloFn &%Gram) is 1,000 &%Grams.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (KiloFn ?UNIT) (MeasureFn 1000 ?UNIT)))

(instance MegaFn UnaryFunction)
(domain MegaFn 1 UnitOfMeasure)
(range MegaFn UnitOfMeasure)
(documentation MegaFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to 1,000,000 units of the original
&%UnitOfMeasure.  For example, (&%KiloFn &%Hertz) is 1,000,000 &%Hertz.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (MegaFn ?UNIT) (MeasureFn 1000000 ?UNIT)))

(instance GigaFn UnaryFunction)
(domain GigaFn 1 UnitOfMeasure)
(range GigaFn UnitOfMeasure)
(documentation GigaFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to 1,000,000,000 units of the original
&%UnitOfMeasure.  For example, (&%GigaFn &%Hertz) is 1,000,000,000 &%Hertz.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (GigaFn ?UNIT) (MeasureFn 1000000000 ?UNIT)))

(instance TeraFn UnaryFunction)
(domain TeraFn 1 UnitOfMeasure)
(range TeraFn UnitOfMeasure)
(documentation TeraFn "A &%UnaryFunction that maps a &%UnitOfMeasure
into a &%UnitOfMeasure that is equal to 1,000,000,000,000 units of the original
&%UnitOfMeasure.  For example, (&%TeraFn &%Hertz) is 1,000,000,000,000 &%Hertz.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (TeraFn ?UNIT) (MeasureFn 1000000000000 ?UNIT)))

(instance MilliFn UnaryFunction)
(domain MilliFn 1 UnitOfMeasure)
(range MilliFn UnitOfMeasure)
(documentation MilliFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to .001 units of the original &%UnitOfMeasure.
For example, (&%MilliFn &%Ampere) is .001 &%Amperes.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (MilliFn ?UNIT) (MeasureFn 0.001 ?UNIT)))

(instance MicroFn UnaryFunction)
(domain MicroFn 1 UnitOfMeasure)
(range MicroFn UnitOfMeasure)
(documentation MicroFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to .000001 units of the original &%UnitOfMeasure.
For example, (&%MicroFn &%Meter) is .000001 &%Meters.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (MicroFn ?UNIT) (MeasureFn 0.000001 ?UNIT)))

(instance NanoFn UnaryFunction)
(domain NanoFn 1 UnitOfMeasure)
(range NanoFn UnitOfMeasure)
(documentation NanoFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to .000000001 units of the original
&%UnitOfMeasure.  For example, (&%MicroFn &%SecondDuration) is .000000001
&%SecondDurations.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (NanoFn ?UNIT) (MeasureFn 0.000000001 ?UNIT)))

(instance PicoFn UnaryFunction)
(domain PicoFn 1 UnitOfMeasure)
(range PicoFn UnitOfMeasure)
(documentation PicoFn "A &%UnaryFunction that maps a &%UnitOfMeasure into
a &%UnitOfMeasure that is equal to .000000000001 units of the original
&%UnitOfMeasure.  For example, (&%PicoFn &%Ampere) is .000000000001
&%Amperes.")

(=>
   (instance ?UNIT UnitOfMeasure)
   (equal (PicoFn ?UNIT) (MeasureFn 0.000000000001 ?UNIT)))

(instance IntervalFn BinaryFunction)
(domain IntervalFn 1 ConstantQuantity)
(domain IntervalFn 2 ConstantQuantity)
(rangeSubclass IntervalFn ConstantQuantity)
(relatedInternalConcept IntervalFn RecurrentTimeIntervalFn)
(documentation IntervalFn "A &%BinaryFunction that maps two &%ConstantQuantities
to the &%Class of &%ConstantQuantities that comprise the interval from the first
&%ConstantQuantity to the second &%ConstantQuantity.  For example, (&%IntervalFn
(&%MeasureFn 8 &%Meter) (&%MeasureFn 14 &%Meter)) would return the &%Class of
&%ConstantQuantities between 8 and 14 meters in length.")

(<=>
   (instance ?QUANTITY (IntervalFn ?FROM ?TO))
   (and
        (greaterThanOrEqualTo ?QUANTITY ?FROM)
        (lessThanOrEqualTo ?QUANTITY ?TO)))

(instance MagnitudeFn UnaryFunction)
(domain MagnitudeFn  1 ConstantQuantity)
(range MagnitudeFn RealNumber)
(documentation MagnitudeFn "The magnitude of a &%ConstantQuantity is the
numeric value for the quantity.  In other words, &%MagnitudeFn converts
a &%ConstantQuantity with an associated &%UnitOfMeasure into an ordinary
&%RealNumber.  For example, the magnitude of the &%ConstantQuantity 2
&%Kilometers is the &%RealNumber 2.   Note that the magnitude of a
quantity in a given unit times that unit is equal to the original
quantity.")

(=>
   (and
      (instance ?NUMBER RealNumber)
      (instance ?UNIT UnitOfMeasure))
(equal (MagnitudeFn (MeasureFn ?NUMBER ?UNIT)) ?NUMBER))

(instance DensityFn BinaryFunction)
(domain DensityFn 1 MassMeasure)
(domain DensityFn 2 VolumeMeasure)
(range DensityFn FunctionQuantity)
(documentation DensityFn "&%DensityFn maps an instance of &%MassMeasure
and an instance of &%VolumeMeasure to the density represented by this
proportion of mass and volume.  For example, (&%DensityFn (&%MeasureFn 3 &%Gram)
(&%MeasureFn 1 &%Liter)) represents the density of 3 grams per liter.")

(instance SpeedFn BinaryFunction)
(domain SpeedFn 1 LengthMeasure)
(domain SpeedFn 2 TimeDuration)
(range SpeedFn FunctionQuantity)
(documentation SpeedFn "Maps an instance of &%LengthMeasure and an instance of
&%TimeDuration to the speed represented by this proportion of distance and time.
For example, (&%SpeedFn (&%MeasureFn 55 &%Mile)(&%MeasureFn 1 &%HourDuration))
represents the velocity of 55 miles per hour.")

(instance VelocityFn QuaternaryFunction)
(domain VelocityFn 1 LengthMeasure)
(domain VelocityFn 2 TimeDuration)
(domain VelocityFn 3 Region)
(domain VelocityFn 4 DirectionalAttribute)
(range VelocityFn FunctionQuantity)
(documentation VelocityFn "Specifies the velocity of an object, i.e. the speed
and the direction of the speed.  For example (&%VelocityFn (&%MeasureFn 55 &%Mile)
(&%MeasureFn 2 &%HourDuration) ?REFERENCE &%North) denotes the velocity of 55 miles
per hour North of the given reference point ?REFERENCE.")

(=>
   (measure ?OBJECT (VelocityFn ?DISTANCE ?TIME ?REF ?DIRECTION))
   (measure ?OBJECT (SpeedFn ?DISTANCE ?TIME)))

;; Now the units of measure:

;; First base units for the SI system. No conversion functions are
;; provided for these units.

;; Length Base Unit

(subclass Meter LengthMeasure)
(instance Meter SystemeInternationalUnit)
(documentation Meter "SI &%LengthMeasure.  Symbol:  m. It is one of the
base units in SI, and it is currently defined as follows: the &%Meter
is the length of the path traveled by light in a vacuum during a time
interval of 1/299792458 of a &%SecondDuration.")

;; Mass Base Unit

(subclass Gram MassMeasure)
(instance Gram SystemeInternationalUnit)
(documentation Gram "Submultiple of kilogram.  Symbol: g.
1 kilogram = 1000 &%Grams.")

;; Time Base Unit

(subclass SecondDuration TimeDuration)
(instance SecondDuration SystemeInternationalUnit)
(documentation SecondDuration "SI &%TimeDuration.  Symbol: s.
It is one of the base units in SI, and it is currently defined as
follows: the &%SecondDuration is the duration of 9192631770 periods of
the radiation corresponding to the transition between the two hyperfine
levels of the ground state of the cesium 133 atom.")

;; Electric Current Base Unit

(subclass Ampere FunctionQuantity)
(instance Ampere SystemeInternationalUnit)
(documentation Ampere "SI electric current measure.  Symbol: A. It is
one of the base units in SI. It is defined as follows: the &%Ampere is
that constant current which, if maintained in two straight parallel
conductors of infinite length, of negligible circular cross-section, and
placed 1 &%Meter apart in a vacuum, would produce between these conductors
a force equal to 2*10^(-7) &%Newton per &%Meter of length.")

;; Thermodynamic Temperature Base Unit

(subclass KelvinDegree TemperatureMeasure)
(instance KelvinDegree SystemeInternationalUnit)
(documentation KelvinDegree "SI &%TemperatureMeasure.  Symbol: K.
It is one of the base units in SI (it is also a unit in the ITS system).
Kelvin differs from the Celsius scale in that the triple point of water
is defined to be 273.16 &%KelvinDegrees while it is 0 &%CelsiusDegrees.
The magnitudes of intervals in the two scales are the same.  By definition
the conversion constant is 273.15.")

;; Amount Of Substance Base Unit

(subclass Mole MassMeasure)
(instance Mole SystemeInternationalUnit)
(documentation Mole "SI amount of substance unit. symbol: mol. It is one
of the base units in SI. It is defined as follows:  the &%Mole is the
amount of substance of a system which contains as many elementary entities
as there are atoms in 0.012 &%Kilograms of carbon 12.  Note that, when this
&%UnitOfMeasure is used, the elementary entities must be specified - they
may be atoms, molecules, ions, electrons, etc. or groups of such
particles.")

;; Luminosity Intensity Base Unit

(subclass Candela FunctionQuantity)
(instance Candela SystemeInternationalUnit)
(documentation Candela "SI luminosity intensity measure.  Symbol: cd.
It is one of the base units in SI, and it is currently defined as
follows:  the &%Candela is the luminous intensity, in a given direction,
of a source that emits monochromatic radiation of frequency 540*10^12
&%Hertz and that has a radiant intensity in that direction of 1/683
&%Watt per &%Steradian.")

(subclass Liter VolumeMeasure)
(instance Liter UnitOfMeasure)
(documentation Liter "Unit of volume in the metric system.  It is currently
defined to be equal to one cubic decimeter (0.001 cubic meter).  Symbol: l.")

(subclass Centimeter LengthMeasure)
(instance Centimeter UnitOfMeasure)
(documentation Centimeter "Submultiple of &%Meter.  Symbol: cm. It is
the 100th part of a &%Meter")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Centimeter)
        (MeasureFn (MultiplicationFn ?NUMBER 0.01) Meter)))

;; What follows are derived SI units with special names and symbols
;; (multiples and submultiples are together since they represent
;; quantities of the same kind).

;; Plane angle unit

(subclass Radian PlaneAngleMeasure)
(instance Radian SystemeInternationalUnit)
(documentation Radian "SI plane angle measure.  Symbol: rad.  It is the
angle of a circle subtended by an arc equal in length to the circle's
radius. Another definition is:  the plane angle between two radii of a
circle which cut off on the circumference an arc equal in length to the
radius.  &%Radian = m/m = 1.")

;; Solid angle unit

(subclass Steradian SolidAngleMeasure)
(instance Steradian SystemeInternationalUnit)
(documentation Steradian "SI solid angle measure.  Symbol: sr.  It is
the solid angle of a sphere subtended by a portion of the surface whose
area is equal to the square of the sphere's radius.  Another definition
is: the solid angle which, having its vertex in the center of the sphere,
cuts off an area of the surface of the sphere equal to that of a square
with sides of length equal to the radius of the sphere.  &%Steradian =
m^2/m^2 = 1.")

;; Frequency units

(subclass Hertz TimeDependentQuantity)
(instance Hertz SystemeInternationalUnit)
(documentation Hertz "SI frequency measure.  Symbol: Hz. It is the
number of cycles per second.  &%Hertz = s^(-1).  Note that &%Hertz
does not have a conversion function.")

; Force Unit

(subclass Newton FunctionQuantity)
(instance Newton SystemeInternationalUnit)
(documentation Newton "SI force measure.  Symbol: N. It is that force
which gives to a mass of 1 kilogram an acceleration of 1 &%Meter per
&%SecondDuration.  &%Newton = m*kg*s^(-2).")

; Pressure unit

(subclass Pascal FunctionQuantity)
(instance Pascal SystemeInternationalUnit)
(documentation Pascal "SI pressure measure.  Symbol:Pa. It is the
pressure of one &%Newton per square &%Meter.  &%Pascal = N/m^2
= m^(-1)*kg*s^(-2).")

; Energy Unit

(subclass Joule FunctionQuantity)
(instance Joule SystemeInternationalUnit)
(documentation Joule "SI energy measure.  Symbol: J.  It is the work
done when the point of application of 1 &%Newton is displaced a distance
of 1 &%Meter in the direction of the force.  &%Joule = N*m =
m^2*kg*s^(-2).")

; Power Units

(subclass Watt FunctionQuantity)
(instance Watt SystemeInternationalUnit)
(documentation Watt "SI power measure.  Symbol: W.  A &%UnitOfMeasure
that measures power, i.e. energy produced or expended divided by
&%TimeDuration. It is the power which gives rise to the production
of energy (or work) at the rate of one &%Joule per &%SecondDuration.
&%Watt = J/s = m^2*kg*s^(-3).")

;;; Note: According to SI one should not use the expression "per unit of."

; Electric Charge Units

(subclass Coulomb TimeDependentQuantity)
(instance Coulomb SystemeInternationalUnit)
(documentation Coulomb "SI electric charge measure.  Symbol: C. It is
the quantity of electric charge transported through a cross section of
a conductor in an electric circuit during each &%SecondDuration by a
current of 1 &%Ampere.  Coulomb = s*A.")

; Electric Potential Units

(subclass Volt FunctionQuantity)
(instance Volt SystemeInternationalUnit)
(documentation Volt "SI electric potential measure.  Symbol: V.  It is
the difference of electric potential between two points of a conducting
wire carrying a constant current of 1 &%Ampere, when the power dissipated
between these points is equal to 1 &%Watt.  &%Volt = W/A =
m^2*kg*s^(-3)*A^(-1).")

; Capacitance Units

(subclass Farad FunctionQuantity)
(instance  Farad SystemeInternationalUnit)
(documentation Farad "SI capacitance measure.  Symbol: F.  It is the
capacitance of a capacitator between the plates of which there appears
a difference of potential of 1 &%Volt when it is charged by a quantity
of electricity equal to 1 Coulomb.  &%Farad = C/V =
m^(-2)*kg(-1)*s^4*A^2.")

;Electric Resistance Units

(subclass Ohm FunctionQuantity)
(instance Ohm SystemeInternationalUnit)
(documentation Ohm "SI electric resistance measure. It is the electric
resistance between two points of a conductor when a constant difference
of potential of 1 &%Volt, applied between these two points,
produces in this conductor a current of 1 &%Ampere, this conductor not
being the force of any electromotive force.  &%Ohm = V/A =
m^2*kg*s^(-3)*A^(-2).")

; Electric Conductance Units

(subclass Siemens FunctionQuantity)
(instance Siemens SystemeInternationalUnit)
(documentation Siemens "SI electric conductance measure.  Symbol:  S.
In the case of direct current, the conductance in &%Siemens is the
reciprocal of the resistance in &%Ohms; in the case of alternating current,
it is the reciprocal of the impedance in ohms.  siemens = A/V =
m^(-2)*kg(-1)*s^(3)*A^2.")

; Magnetic Flux Units

(subclass Weber FunctionQuantity)
(instance  Weber SystemeInternationalUnit)
(documentation Weber "SI magnetic flux measure.  Symbol: Wb. It is the
magnetic flux which, linking a circuit of one turn, produces in it an
electromotive force of 1 &%Volt as it is reduced to zero at a uniform
rate in 1 &%SecondDuration.  &%Weber = V*s = m^2*kg*s^(-2)*A^(-1)." )

; Magnetic Flux Density Units

(subclass Tesla FunctionQuantity)
(instance Tesla SystemeInternationalUnit)
(documentation Tesla "SI magnetic flux density measure.  Symbol:  T.
One &%Tesla equals one &%Weber per square &%Meter.  &%Tesla = Wb/m^2 =
kg*s^(-2)*A^(-1).")

; Inductance Units

(subclass Henry FunctionQuantity)
(instance Henry SystemeInternationalUnit)
(documentation Henry "SI inductance measure.  Symbol: H.  One &%Henry
is equivalent to one &%Volt divided by one &%Ampere per &%SecondDuration.
If a current changing at the rate of one &%Ampere per &%SecondDuration
induces an electromotive force of one &%Volt, the circuit has an
inductance of one &%Henry.  &%Henry = Wb/A = m^2*kg*s^(-2)*A^(-2).")

; Celsius Temperature unit

(subclass CelsiusDegree TemperatureMeasure)
(instance CelsiusDegree SystemeInternationalUnit)
(documentation CelsiusDegree "A &%TemperatureMeasure.  The freezing point
and the boiling point of water are, respectively, 0 &%CelsiusDegrees and 100
&%CelsiusDegrees.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER CelsiusDegree)
        (MeasureFn (SubtractionFn ?NUMBER 273.15) KelvinDegree)))

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER CelsiusDegree)
        (MeasureFn (DivisionFn (SubtractionFn ?NUMBER 32) 1.8) FahrenheitDegree)))

; Luminous Flux Units

(subclass Lumen FunctionQuantity)
(instance Lumen SystemeInternationalUnit)
(documentation Lumen "SI luminous flux measure.  Symbol: lm.  It is the
amount streaming outward through one solid angle of 1 &%Steradian from a
uniform point source having an intensity of one &%Candela.  &%Lumen =
cd*sr = cd * 1.")

; Illuminance Units

(subclass Lux FunctionQuantity)
(instance Lux SystemeInternationalUnit)
(documentation Lux "SI illuminance measure.  Symbol: lx.  It is the
amount of illumination provided when one &%Lumen is evenly distributed
over an area of 1 square &%Meter. This is also equivalent to the
illumination that would exist on a surface all points of which are one
&%Meter from a point source of one &%Candela.  &%Lux = lm/m^2 =
m^(-2)*cd.")

; Activity Units

(subclass Becquerel TimeDependentQuantity)
(instance Becquerel SystemeInternationalUnit)
(documentation Becquerel "SI activity measure.  Symbol: Bq.  It measures
the amount of radioactivity contained in a given sample of matter. It is
that quantity of a radioactive element in which there is one atomic
disintegration per &%SecondDuration.  &%Becquerel = s^(-1).")

; Absorbed Dose Units

(subclass Gray FunctionQuantity)
(instance Gray SystemeInternationalUnit)
(documentation Gray "SI absorbed dose measure.  Symbol: Gy.  It measures
the dose of radiation absorbed in living tissue. It is equal approximately
to the absorbed dose delivered when the energy per unit mass imparted to
matter by ionizing radiation is 1 &%Joule per kilogram.  &%Gray = J/kg
= m^2*s^(-2).")

; Dose Equivalent Units

(subclass Sievert FunctionQuantity)
(instance Sievert SystemeInternationalUnit)
(documentation Sievert "SI dose equivalent measure.  Symbol: Sv.  It is
a unit of biologic dose of ionizing radiation.  The &%Sievert makes it
possible to normalize doses of different types of radiation. It takes
into account the relative biologic effectiveness of ionizing radiation,
since each form of such radiation--e.g., X rays, gamma rays, neutrons--
has a slightly different effect on living tissue for a given absorbed
dose. The dose equivalent of a given type of radiation (in &%Sievert) is
the dose of the radiation in &%Gray multiplied by a quality factor that
is based on the relative biologic effectiveness of the radiation.
Accordingly, one &%Sievert is generally defined as the amount of radiation
roughly equivalent in biologic effectiveness to one &%Gray of gamma
radiation.  &%Sievert = J/kg = m^2*s^(-2)")

; Units that are accepted for -use- with SI

(subclass DayDuration TimeDuration)
(instance DayDuration UnitOfMeasure)
(documentation DayDuration "Time unit. 1 day = 24 hours.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
	(MeasureFn ?NUMBER DayDuration)
	(MeasureFn (MultiplicationFn ?NUMBER 24) HourDuration)))

(subclass HourDuration TimeDuration)
(instance HourDuration UnitOfMeasure)
(documentation HourDuration "Time unit. 1 hour = 60 minutes.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
	(MeasureFn ?NUMBER HourDuration)
	(MeasureFn (MultiplicationFn ?NUMBER 60) MinuteDuration)))

(subclass MinuteDuration TimeDuration)
(instance MinuteDuration UnitOfMeasure)
(documentation MinuteDuration "Time unit. 1 minute = 60 seconds. ")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER MinuteDuration)
        (MeasureFn (MultiplicationFn ?NUMBER 60) SecondDuration)))

(subclass WeekDuration TimeDuration)
(instance WeekDuration UnitOfMeasure)
(documentation WeekDuration "Time unit.  A week's duration is seven days.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER WeekDuration)
        (MeasureFn (MultiplicationFn ?NUMBER 7) DayDuration)))

(subclass YearDuration TimeDuration)
(instance YearDuration UnitOfMeasure)
(documentation YearDuration "Time unit. one calendar year. 1 year =
365 days = 31536000 seconds.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
	(MeasureFn ?NUMBER YearDuration)
	(MeasureFn (MultiplicationFn ?NUMBER 365) DayDuration)))

;; What follows are units that are also accepted for use with SI.  The
;; SI equivalents for these units are obtained experimentally.

(subclass Amu MassMeasure)
(instance Amu UnitOfMeasure)
(documentation Amu "Atomic mass unit.  Symbol: u. It is the mass of
the twelfth part of an atom of the Carbon 12 isotope.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Amu)
        (MeasureFn (MultiplicationFn ?NUMBER 1.6605402E-24) Gram)))

(subclass ElectronVolt FunctionQuantity)
(instance ElectronVolt UnitOfMeasure)
(documentation ElectronVolt "The &%ElectronVolt is an energy measure.
Symbol: eV.  It is the kinetic energy acquired by an electron in passing
through a potential difference of 1 &%Volt in a vacuum.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER ElectronVolt)
        (MeasureFn (MultiplicationFn ?NUMBER 1.60217733E-19) Joule)))

;; The following units have been temporarily accepted for use with
;; SI units.

(subclass Angstrom LengthMeasure)
(instance Angstrom UnitOfMeasure)
(documentation Angstrom "The &%Angstrom is a &%LengthMeasure.
1 &%Angstrom = 10^(-10) m")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Angstrom)
        (MeasureFn (MultiplicationFn ?NUMBER 1.0E-10) Meter)))

;; The following units are unacceptable in SI but are part of other
;; systems of measurement that are widely used.

;; More Length units

(subclass Foot LengthMeasure)
(instance Foot UnitOfMeasure)
(documentation Foot "English length unit of feet.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Foot)
        (MeasureFn (MultiplicationFn ?NUMBER 0.3048) Meter)))

(subclass Inch LengthMeasure)
(instance Inch UnitOfMeasure)
(documentation Inch "English length unit of inches.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Inch)
        (MeasureFn (MultiplicationFn ?NUMBER 0.0254) Meter)))

(subclass Mile LengthMeasure)
(instance Mile UnitOfMeasure)
(documentation Mile "English length unit of miles.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Mile)
        (MeasureFn (MultiplicationFn ?NUMBER 1609.344) Meter)))

;; More Volume units

(subclass UnitedStatesGallon VolumeMeasure)
(instance UnitedStatesGallon UnitOfMeasure)
(relatedInternalConcept UnitedStatesGallon UnitedKingdomGallon)
(documentation UnitedStatesGallon "Unit of volume commonly used in the
United States.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER UnitedStatesGallon)
        (MeasureFn (MultiplicationFn ?NUMBER 3.785411784) Liter)))

(subclass Quart VolumeMeasure)
(instance Quart UnitOfMeasure)
(documentation Quart "English unit of volume equal to 1/4 of a
&%UnitedStatesGallon.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Quart)
        (MeasureFn (DivisionFn ?NUMBER 4) UnitedStatesGallon)))

(subclass Pint VolumeMeasure)
(instance Pint UnitOfMeasure)
(documentation Pint "English unit of volume equal to 1/2 of a
&%Quart.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Pint)
        (MeasureFn (DivisionFn ?NUMBER 2) Quart)))

(subclass Cup VolumeMeasure)
(instance Cup UnitOfMeasure)
(documentation Cup "English unit of volume equal to 1/2 of a
&%Pint.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Cup)
        (MeasureFn (DivisionFn ?NUMBER 2) Pint)))

(subclass Ounce VolumeMeasure)
(instance Ounce UnitOfMeasure)
(documentation Ounce "English unit of volume equal to 1/8 of a
&%Cup.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Ounce)
        (MeasureFn (DivisionFn ?NUMBER 8) Cup)))

(subclass UnitedKingdomGallon VolumeMeasure)
(instance UnitedKingdomGallon UnitOfMeasure)
(documentation UnitedKingdomGallon "Unit of volume commonly used in the
United Kingdom.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER UnitedKingdomGallon)
        (MeasureFn (MultiplicationFn ?NUMBER 4.54609) Liter)))

;; More Mass units

(subclass AtomGram MassMeasure)
(instance AtomGram UnitOfMeasure)
(documentation AtomGram "&%MassMeasure that is also known as the gram-atom.
Defined as the mass in grams of 1 &%Mole of pure substance.  For example,
1 &%AtomGram of Carbon 12 will be 12 &%Grams of pure Carbon 12.  2 &%AtomGrams
of the same substance will be 24 &%Grams of it.  This is an unusual unit in
that it is essentially 1 &%Mole of 'stuff' measured in grams, so that the
actual value (i.e. mass) depends on the type of substance.")

(subclass PoundMass MassMeasure)
(instance PoundMass UnitOfMeasure)
(documentation PoundMass "English mass unit of pounds.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER PoundMass)
        (MeasureFn (MultiplicationFn ?NUMBER 453.59237) Gram)))

(subclass Slug MassMeasure)
(instance Slug UnitOfMeasure)
(documentation Slug "English mass unit of slugs.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Slug)
        (MeasureFn (MultiplicationFn ?NUMBER 14593.90) Gram)))

;; More Temperature units

(subclass RankineDegree TemperatureMeasure)
(instance RankineDegree UnitOfMeasure)
(documentation RankineDegree "A &%TemperatureMeasure.  Note
that 0 &%RankineDegrees is the same as the absolute zero (i.e. 0
&%KelvinDegrees).")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Rankine)
        (MeasureFn (MultiplicationFn ?NUMBER 1.8) Kelvin)))

(subclass FahrenheitDegree TemperatureMeasure)
(instance FahrenheitDegree UnitOfMeasure)
(documentation FahrenheitDegree "A &%TemperatureMeasure that is commonly
used in the United States.  On the Fahrenheit scale, the freezing point
of water is 32 &%FahrenheitDegrees, and the boiling point of water is
212 &%FahrenheitDegrees.")

;; More Force units

(subclass PoundForce FunctionQuantity)
(instance PoundForce UnitOfMeasure)
(documentation PoundForce "English pound of force. The conversion
factor depends on the local value of the acceleration of free fall. A
mean value is used in the conversion axiom associated with this
constant.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER PoundForce)
        (MeasureFn (MultiplicationFn ?NUMBER 4.448222) Newton)))

;; More Energy units

(subclass Calorie FunctionQuantity)
(instance Calorie UnitOfMeasure)
(documentation Calorie "A &%Calorie is an energy measure.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Calorie)
        (MeasureFn (MultiplicationFn ?NUMBER 4.1868) Joule)))

(subclass BritishThermalUnit FunctionQuantity)
(instance BritishThermalUnit UnitOfMeasure)
(documentation BritishThermalUnit "An energy measure.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER BritishThermalUnit)
        (MeasureFn (MultiplicationFn ?NUMBER 1055.05585262) Joule)))

;; More plane angle units

(subclass AngularDegree PlaneAngleMeasure)
(instance AngularDegree UnitOfMeasure)
(documentation AngularDegree "A plane angle measure.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
	(MeasureFn ?NUMBER AngularDegree)
	(MeasureFn (MultiplicationFn ?NUMBER (DivisionFn Pi 180)) Radian)))

; Other interesting units of measure

; Currency units

(subclass UnitedStatesDollar CurrencyMeasure)
(instance UnitedStatesDollar UnitOfMeasure)
(documentation UnitedStatesDollar "A currency measure.")

(subclass UnitedStatesCent CurrencyMeasure)
(instance UnitedStatesCent UnitOfMeasure)
(documentation UnitedStatesCent "A currency measure.  1 &%UnitedStatesCent is
equal to .01 &%UnitedStatesDollars.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER UnitedStatesCent)
        (MeasureFn (MultiplicationFn ?NUMBER 0.01) UnitedStatesDollar)))

(subclass EuroDollar CurrencyMeasure)
(instance EuroDollar UnitOfMeasure)
(documentation EuroDollar "A currency measure of most European Union countries.
It is based on the &%UnitedStatesDollar.")

(subclass EuroCent CurrencyMeasure)
(instance EuroCent UnitOfMeasure)
(documentation EuroCent "A currency measure.  1 &%EuroCent is equal to .01
&%EuroDollars.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER EuroCent)
        (MeasureFn (MultiplicationFn ?NUMBER 0.01) EuroDollar)))

; Information units

(subclass InformationMeasure ConstantQuantity)
(documentation InformationMeasure "Measures of the amount of information.
Includes &%Bit, &%Byte, and multiples of these, e.g. &%KiloByte and
&%MegaByte.")

(subclass Bit InformationMeasure)
(instance Bit UnitOfMeasure)
(documentation Bit "One &%Bit of information.  A one or a zero.")

(subclass Byte InformationMeasure)
(instance Byte UnitOfMeasure)
(documentation Byte "One &%Byte of information.  A &%Byte is eight
&%Bits.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER Byte)
        (MeasureFn (MultiplicationFn ?NUMBER 8) Bit)))

(subclass KiloByte InformationMeasure)
(instance KiloByte UnitOfMeasure)
(documentation KiloByte "One &%KiloByte (KB) of information.  One
&%KiloByte is 1024 &%Bytes.  Note that this sense of 'kilo' is
different from the one accepted in the SI system.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER KiloByte)
        (MeasureFn (MultiplicationFn ?NUMBER 1024) Byte)))

(subclass MegaByte InformationMeasure)
(instance MegaByte UnitOfMeasure)
(documentation MegaByte "One &%MegaByte (MB) of information.  One
&%MegaByte is 1024 &%KiloBytes.  Note that this sense of 'mega' is
different from the one accepted in the SI system.")

(=>
   (instance ?NUMBER RealNumber)
   (equal
        (MeasureFn ?NUMBER MegaByte)
        (MeasureFn (MultiplicationFn ?NUMBER 1024) KiloByte)))

;; The following content was inspired by the Quantities ontology
;; developed by ITBM-CNR.

(instance measure BinaryPredicate)
(instance measure AsymmetricRelation)
(domain measure 1 Object)
(domain measure 2 PhysicalQuantity)
(documentation measure "A very general &%Predicate for asserting that a
particular &%Object is measured by a particular &%ConstantQuantity.
In general, the second argument of this &%Predicate will be an instance
of the &%Function &%MeasureFn.")

(instance age SingleValuedRelation)
(subrelation age measure)
(domain age 2 TimeDuration)
(documentation age "Simply relates an &%Object to a &%ConstantQuantity
specifying the age of the &%Object.")

(subrelation length measure)
(domain length 2 LengthMeasure)
(documentation length "&%BinaryPredicate that is used to state the measure
of an &%Object from one point to another point along its surface.")

(instance width SingleValuedRelation)
(subrelation width length)
(documentation width "&%BinaryPredicate that is used to state the measure
of an &%Object from side to side at its widest span.")

(subrelation diameter width)
(documentation diameter "&%BinaryPredicate that is used to state the
measure of a circular &%Object from side to side.")

(instance altitude SingleValuedRelation)
(subrelation altitude length)
(documentation altitude "&%BinaryPredicate that is used to state the &%length
between an &%Object from its highest point to sea level.  Note that this
&%Predicate can be used to specify, for example, the height of geographic
features, e.g. mountains, the altitude of aircraft, and the orbit of satellites
around the Earth.")

(instance distance SingleValuedRelation)
(instance distance SpatialRelation)
(instance distance TernaryPredicate)
(domain distance 1 Physical)
(domain distance 2 Physical)
(domain distance 3 LengthMeasure)
(documentation distance "(&%distance ?OBJ1 ?OBJ2 ?QUANT) means that the
shortest distance between the two objects ?OBJ1 and ?OBJ2 is ?QUANT.")

(instance larger BinaryPredicate)
(instance larger SpatialRelation)
(instance larger TransitiveRelation)
(instance larger IrreflexiveRelation)
(domain larger 1 Object)
(domain larger 2 Object)
(documentation larger "(&%larger ?OBJ1 ?OBJ2) simply means that ?OBJ1 is
larger, with respect to all &%LengthMeasures, than ?OBJ2.")

(=>
   (larger ?OBJ1 ?OBJ2)
   (forall (?QUANT1 ?QUANT2)
      (=>
         (and
            (measure ?OBJ1 (MeasureFn ?QUANT1 LengthMeasure))
            (measure ?OBJ2 (MeasureFn ?QUANT2 LengthMeasure)))
         (greaterThan ?QUANT1 ?QUANT2))))

(instance smaller BinaryPredicate)
(instance smaller SpatialRelation)
(instance smaller TransitiveRelation)
(instance smaller IrreflexiveRelation)
(domain smaller 1 Object)
(domain smaller 2 Object)
(inverse smaller larger)
(documentation smaller "(&%smaller ?OBJ1 ?OBJ2) simply means that ?OBJ1
is smaller, with respect to all &%LengthMeasures, than ?OBJ2.")

(instance monetaryValue SingleValuedRelation)
(subrelation monetaryValue measure)
(domain monetaryValue 1 Object)
(domain monetaryValue 2 CurrencyMeasure)
(documentation monetaryValue "A &%BinaryPredicate that associates an
&%Object with its value expressed as an instance of &%CurrencyMeasure.")

(instance WealthFn UnaryFunction)
(domain WealthFn 1 Agent)
(range WealthFn CurrencyMeasure)
(documentation WealthFn "A &%UnaryFunction that maps an &%Agent to a &%CurrencyMeasure specifying the value of the property owned by the &%Agent.  Note that this &%Function is generally used in conjunction with the &%Function &%PropertyFn, e.g. (&%WealthFn (&%PropertyFn BillGates)) would return the monetary value of the sum of Bill Gates' holdings.")

(<=>
   (equal (WealthFn ?PERSON) ?AMOUNT)
   (monetaryValue (PropertyFn ?PERSON) ?AMOUNT))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;;;
;; TEMPORAL CONCEPTS ;;
;;;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'STRUCTURAL ONTOLOGY'
;; INCLUDES 'BASE ONTOLOGY'

;; The first part of this section contains definitions relations involving
;; temporal notions.  Most of these definitions and axioms were derived from
;; James Allen's work.  This part of the section was extensively revised on
;; the basis of comments from Pat Hayes.  The second part of this section
;; is an attempt to incorporate the Simple-Time ontology from the
;; Ontolingua server into the SUMO.

(instance PositiveInfinity TimePoint)
(documentation PositiveInfinity "The &%TimePoint that is after
all other &%TimePoints.")

(=>
   (and
      (instance ?POINT TimePoint)
      (not (equal ?POINT PositiveInfinity)))
   (before ?POINT PositiveInfinity))

(=>
   (and
      (instance ?POINT TimePoint)
      (not (equal ?POINT PositiveInfinity)))
   (exists (?OTHERPOINT)
      (temporallyBetween ?POINT ?OTHERPOINT PositiveInfinity)))

(instance NegativeInfinity TimePoint)
(documentation NegativeInfinity "The &%TimePoint that is before
all other &%TimePoints.")

(=>
   (and
      (instance ?POINT TimePoint)
      (not (equal ?POINT NegativeInfinity)))
    (before NegativeInfinity ?POINT))

(=>
   (and
      (instance ?POINT TimePoint)
      (not (equal ?POINT NegativeInfinity)))
   (exists (?OTHERPOINT)
      (temporallyBetween NegativeInfinity ?OTHERPOINT ?POINT)))

(instance duration BinaryPredicate)
(instance duration AsymmetricRelation)
(instance duration TotalValuedRelation)
(domain duration 1 TimeInterval)
(domain duration 2 TimeDuration)
(documentation duration "(&%duration ?POS ?TIME) means that the
duration of the &%TimePosition ?POS is ?TIME.  Note that this
&%Predicate can be used in conjunction with the &%Function &%WhenFn
to specify the duration of any instance of &%Physical.")

(instance frequency BinaryPredicate)
(instance frequency AsymmetricRelation)
(domainSubclass frequency 1 Process)
(domain frequency 2 TimeDuration)
(documentation frequency "(frequency ?PROC ?TIME) means that the
&%Process type of ?PROC recurs after every interval of ?TIME.")

(=>
   (frequency ?PROC ?TIME1)
   (forall (?TIME2)
      (=>
         (duration ?TIME2 ?TIME1)
         (exists (?POSITION)
            (and
               (temporalPart ?POSITION ?TIME2)
               (holdsDuring ?POSITION (exists (?INST) (instance ?INST ?PROC))))))))

(instance temporalPart BinaryPredicate)
(instance temporalPart AsymmetricRelation)
(domain temporalPart 1 TimePosition)
(domain temporalPart 2 TimePosition)
(documentation temporalPart "(&%temporalPart ?POS1 ?POS2)
means that &%TimePosition ?POS1 is part of &%TimePosition ?POS2.")

(=>
   (instance ?POINT TimePoint)
   (exists (?INTERVAL)
      (and
         (instance ?INTERVAL TimeInterval)
         (temporalPart ?POINT ?INTERVAL))))

(=>
   (instance ?INTERVAL TimeInterval)
   (exists (?POINT)
      (and
         (instance ?POINT TimePoint)
         (temporalPart ?POINT ?INTERVAL))))

(=>
   (and
      (holdsDuring ?TIME1 ?SITUATION)
      (temporalPart ?TIME2 ?TIME1))
   (holdsDuring ?TIME2 ?SITUATION))

(=>
   (and
      (holdsDuring ?INTERVAL (holds ?REL ?INST1 ?INST2))
      (instance ?INST1 Physical)
      (instance ?INST2 Physical))
   (and
      (time ?INST1 ?INTERVAL)
      (time ?INST2 ?INTERVAL)))

(<=>
   (temporalPart ?POS (WhenFn ?THING))
   (time ?THING ?POS))

(instance BeginFn TemporalRelation)
(instance BeginFn UnaryFunction)
(domain BeginFn 1 TimeInterval)
(range BeginFn TimePoint)
(documentation BeginFn "A &%UnaryFunction that maps a &%TimeInterval to
the &%TimePoint at which the interval begins.")

(=>
   (equal (BeginFn ?INTERVAL) ?POINT)
   (forall (?OTHERPOINT)
      (=>
         (and
            (temporalPart ?OTHERPOINT ?INTERVAL)
            (not (equal ?OTHERPOINT ?POINT)))
         (before ?POINT ?OTHERPOINT))))

(=>
   (origin ?PROCESS ?OBJ)
   (located (WhereFn ?PROCESS (BeginFn (WhenFn ?PROCESS))) (WhereFn ?OBJ (BeginFn (WhenFn ?OBJ)))))

(instance EndFn TemporalRelation)
(instance EndFn UnaryFunction)
(domain EndFn 1 TimeInterval)
(range EndFn TimePoint)
(documentation EndFn "A &%UnaryFunction that maps a &%TimeInterval to
the &%TimePoint at which the interval ends.")

(=>
   (equal (EndFn ?INTERVAL) ?POINT)
   (forall (?OTHERPOINT)
      (=>
         (and
            (temporalPart ?OTHERPOINT ?INTERVAL)
            (not (equal ?OTHERPOINT ?POINT)))
         (before ?OTHERPOINT ?POINT))))

(instance starts BinaryPredicate)
(instance starts TemporalRelation)
(instance starts TransitiveRelation)
(instance starts IrreflexiveRelation)
(domain starts 1 TimeInterval)
(domain starts 2 TimeInterval)
(documentation starts "(&%starts ?INTERVAL1 ?INTERVAL2) means that
?INTERVAL1 and ?INTERVAL2 are both &%TimeIntervals that have the same
initial &%TimePoint and that ?INTERVAL1 ends before ?INTERVAL2.")

(<=>
   (starts ?INTERVAL1 ?INTERVAL2)
   (and
      (equal
         (BeginFn ?INTERVAL1)
	   (BeginFn ?INTERVAL2))
      (before
         (EndFn ?INTERVAL1)
  	   (EndFn ?INTERVAL2))))

(instance finishes BinaryPredicate)
(instance finishes TemporalRelation)
(instance finishes TransitiveRelation)
(instance finishes IrreflexiveRelation)
(domain finishes 1 TimeInterval)
(domain finishes 2 TimeInterval)
(documentation finishes "(&%finishes ?INTERVAL1 ?INTERVAL2) means that
?INTERVAL1 and ?INTERVAL2 are both &%TimeIntervals that have the same
ending &%TimePoint and that ?INTERVAL2 begins before ?INTERVAL1.")

(<=>
   (finishes ?INTERVAL1 ?INTERVAL2)
   (and
      (before
         (BeginFn ?INTERVAL2)
         (BeginFn ?INTERVAL1))
      (equal
         (EndFn ?INTERVAL2)
         (EndFn ?INTERVAL1))))

(instance before TemporalRelation)
(instance before IrreflexiveRelation)
(instance before TransitiveRelation)
(subrelation before beforeOrEqual)
(relatedInternalConcept before earlier)
(domain before 1 TimePoint)
(domain before 2 TimePoint)
(documentation before "(&%before ?POINT1 ?POINT2) means that ?POINT1
precedes ?POINT2 on the universal timeline.")

;; An Object exists (and, hence, retains its identity) over time, i.e.,
;; an object exists at every point over some interval of time.

(=>
    (instance ?OBJ Object)
    (exists (?TIME1 ?TIME2)
       (and
          (instance ?TIME1 TimePoint)
          (instance ?TIME2 TimePoint)
          (before ?TIME1 ?TIME2)
          (forall (?TIME)
             (=>
	         (and
		     (beforeOrEqual ?TIME1 ?TIME)
                 (beforeOrEqual ?TIME ?TIME2))
               (time ?OBJ ?TIME))))))

(=>
   (result ?PROC ?OBJ)
   (forall (?TIME)
      (=>
         (before ?TIME (BeginFn (WhenFn ?PROC)))
         (not
            (time ?OBJ ?TIME)))))

(instance beforeOrEqual BinaryPredicate)
(instance beforeOrEqual PartialOrderingRelation)
(domain beforeOrEqual 1 TimePoint)
(domain beforeOrEqual 2 TimePoint)
(documentation beforeOrEqual "(&%beforeOrEqual ?POINT1 ?POINT2) means that ?POINT1
is identical with ?POINT2 or occurs before it on the universal timeline.")

(=>
   (beforeOrEqual ?POINT1 ?POINT2)
   (or
       (before ?POINT1 ?POINT2)
       (equal ?POINT1 ?POINT2)))

(instance temporallyBetween TemporalRelation)
(instance temporallyBetween TernaryPredicate)
(subrelation temporallyBetween temporallyBetweenOrEqual)
(domain temporallyBetween 1 TimePoint)
(domain temporallyBetween 2 TimePoint)
(domain temporallyBetween 3 TimePoint)
(documentation temporallyBetween "(&%temporallyBetween ?POINT1 ?POINT2
?POINT3) means that the &%TimePoint ?POINT2 is between the &%TimePoints
?POINT1 and ?POINT3, i.e. ?POINT1 is before ?POINT2 and ?POINT2 is before
?POINT3.")

(<=>
   (temporallyBetween ?POINT1 ?POINT2 ?POINT3)
   (and
      (before ?POINT1 ?POINT2)
      (before ?POINT2 ?POINT3)))

(instance temporallyBetweenOrEqual TemporalRelation)
(instance temporallyBetweenOrEqual TernaryPredicate)
(domain temporallyBetweenOrEqual 1 TimePoint)
(domain temporallyBetweenOrEqual 2 TimePoint)
(domain temporallyBetweenOrEqual 3 TimePoint)
(documentation temporallyBetweenOrEqual "(&%temporallyBetweenOrEqual ?POINT1 ?POINT2
?POINT3) means that the &%TimePoint ?POINT1 is before or equal to the
&%TimePoint ?POINT2 and ?POINT2 is before or equal to the &%TimePoint
?POINT3.")

(<=>
   (temporallyBetweenOrEqual ?POINT1 ?POINT2 ?POINT3)
   (and
      (beforeOrEqual ?POINT1 ?POINT2)
      (beforeOrEqual ?POINT2 ?POINT3)))

(<=>
   (and
      (time ?PHYS ?TIME)
      (instance ?TIME TimePoint))
   (temporallyBetweenOrEqual (BeginFn (WhenFn ?PHYS)) ?TIME (EndFn (WhenFn ?PHYS))))

(instance overlapsTemporally BinaryPredicate)
(instance overlapsTemporally TemporalRelation)
(instance overlapsTemporally PartialOrderingRelation)
(domain overlapsTemporally 1 TimeInterval)
(domain overlapsTemporally 2 TimeInterval)
(documentation overlapsTemporally "(&%overlapsTemporally ?INTERVAL1
?INTERVAL2) means that the &%TimeInterval ?INTERVAL1 subsumes the
&%TimeInterval ?INTERVAL2, i.e. the starting point of ?INTERVAL2 is
equal to or after the starting point of ?INTERVAL1 and the ending
point of ?INTERVAL2 is equal to or before the ending point of ?INTERVAL1.")

(<=>
   (overlapsTemporally ?INTERVAL1 ?INTERVAL2)
   (or
      (equal ?INTERVAL1 ?INTERVAL2)
      (during ?INTERVAL1 ?INTERVAL2)
      (starts ?INTERVAL1 ?INTERVAL2)
      (finishes ?INTERVAL1 ?INTERVAL2)))

(=>
   (and
      (instance ?REL SpatialRelation)
      (holds ?REL ?OBJ1 ?OBJ2))
   (overlapsTemporally (WhenFn ?OBJ1) (WhenFn ?OBJ2)))

(instance during TemporalRelation)
(instance during TransitiveRelation)
(instance during IrreflexiveRelation)
(subrelation during overlapsTemporally)
(domain during 1 TimeInterval)
(domain during 2 TimeInterval)
(documentation during "(&%during ?INTERVAL1 ?INTERVAL2) means that
?INTERVAL1 starts after and ends before ?INTERVAL2.")

(=>
   (during ?INTERVAL1 ?INTERVAL2)
   (and
      (before (EndFn ?INTERVAL1) (EndFn ?INTERVAL2))
      (before (BeginFn ?INTERVAL2) (BeginFn ?INTERVAL1))))

(instance meetsTemporally BinaryPredicate)
(instance meetsTemporally TemporalRelation)
(instance meetsTemporally AsymmetricRelation)
(instance meetsTemporally IntransitiveRelation)
(domain meetsTemporally 1 TimeInterval)
(domain meetsTemporally 2 TimeInterval)
(documentation meetsTemporally "(&%meetsTemporally ?INTERVAL1 ?INTERVAL2)
means that the terminal point of the &%TimeInterval ?INTERVAL1 is the
initial point of the &%TimeInterval ?INTERVAL2.")

(<=>
   (meetsTemporally ?INTERVAL1 ?INTERVAL2)
   (equal
      (EndFn ?INTERVAL1)
      (BeginFn ?INTERVAL2)))

(=>
  (and
    (equal
      (BeginFn ?INTERVAL1)
      (BeginFn ?INTERVAL2))
    (equal
      (EndFn ?INTERVAL1)
      (EndFn ?INTERVAL2)))
    (equal ?INTERVAL1 ?INTERVAL2))

(instance earlier BinaryPredicate)
(instance earlier TemporalRelation)
(instance earlier TransitiveRelation)
(instance earlier IrreflexiveRelation)
(domain earlier 1 TimeInterval)
(domain earlier 2 TimeInterval)
(documentation earlier "(earlier INTERVAL1 INTERVAL2) means that
INTERVAL1 ends before INTERVAL2 begins.")

(<=>
    (earlier ?INTERVAL1 ?INTERVAL2)
    (before (EndFn ?INTERVAL1) (BeginFn ?INTERVAL2)))

(instance cooccur BinaryPredicate)
(instance cooccur TemporalRelation)
(instance cooccur EquivalenceRelation)
(domain cooccur 1 Physical)
(domain cooccur 2 Physical)
(documentation cooccur "(&%cooccur ?THING1 ?THING2) means that the
&%Object or &%Process ?THING1 occurs at the same time as, together with,
or jointly with the &%Object or &%Process ?THING2.  This covers the
following temporal relations:  is co-incident with, is concurrent with,
is contemporaneous with, and is concomitant with.")

(<=>
   (cooccur ?PHYS1 ?PHYS2)
   (equal (WhenFn ?PHYS1) (WhenFn ?PHYS2)))

;; The following functions generate &%TimeIntervals.

(instance TimeIntervalFn BinaryFunction)
(instance TimeIntervalFn TemporalRelation)
(domain TimeIntervalFn 1 TimePoint)
(domain TimeIntervalFn 2 TimePoint)
(range TimeIntervalFn TimeInterval)
(documentation TimeIntervalFn "A &%BinaryFunction that takes two &%TimePoints
as arguments and returns the &%TimeInterval defined by these two &%TimePoints.
Note that the first &%TimePoint must occur earlier than the second &%TimePoint.")

(=>
   (equal (TimeIntervalFn ?POINT1 ?POINT2) ?INTERVAL)
   (and
      (equal (BeginFn ?INTERVAL) ?POINT1)
      (equal (EndFn ?INTERVAL) ?POINT2)))

(=>
   (equal (TimeIntervalFn ?POINT1 ?POINT2) ?INTERVAL)
   (forall (?POINT)
      (<=>
         (temporallyBetweenOrEqual ?POINT1 ?POINT ?POINT2)
         (temporalPart ?POINT ?INTERVAL))))

(instance RecurrentTimeIntervalFn TemporalRelation)
(instance RecurrentTimeIntervalFn BinaryFunction)
(domainSubclass RecurrentTimeIntervalFn 1 TimeInterval)
(domainSubclass RecurrentTimeIntervalFn 2 TimeInterval)
(rangeSubclass RecurrentTimeIntervalFn TimeInterval)
(documentation RecurrentTimeIntervalFn "A function that is useful for generating
recurring time intervals.  For example, (&%RecurrentTimeIntervalFn (&%HourFn 6 &%Day)
(&%HourFn 12 &%Day)) returns the &%Class of &%TimeIntervals beginning at 6 in the
morning and ending at 12 noon.  For another example, (&%RecurrentTimeInterval
&%Saturday &%Sunday) returns the &%Class of all weekends.  For still another example,
(&%RecurrentTimeInterval &%June &%August) returns the &%Class containing the academic
summer period.")

(=>
   (instance ?INTERVAL (RecurrentTimeIntervalFn ?TIMECLASS1 ?TIMECLASS2))
   (exists (?TIME1 ?TIME2)
      (and
         (instance ?TIME1 ?TIMECLASS1)
         (instance ?TIME2 ?TIMECLASS2)
         (starts ?TIME1 ?INTERVAL)
         (finishes ?TIME2 ?INTERVAL))))

(instance WhenFn TemporalRelation)
(instance WhenFn UnaryFunction)
(domain WhenFn 1 Physical)
(range WhenFn TimeInterval)
(documentation WhenFn "A &%UnaryFunction that maps an &%Object or
&%Process to the exact &%TimeInterval during which it exists.  Note
that, for every &%TimePoint ?TIME outside of the &%TimeInterval
(WhenFn ?THING), (time ?THING ?TIME) does not hold.")

(=>
   (instance ?THING Physical)
   (before (BeginFn (WhenFn ?THING)) (EndFn (WhenFn ?THING))))

(instance PastFn TemporalRelation)
(instance PastFn UnaryFunction)
(domain PastFn 1 TimePosition)
(range PastFn TimeInterval)
(documentation PastFn "A &%UnaryFunction that maps a &%TimePosition
to the &%TimeInterval that meets it and that begins at
&%NegativeInfinity.")

(=>
   (instance ?THING Physical)
   (meetsTemporally (PastFn (WhenFn ?THING)) (WhenFn ?THING)))

(=>
   (instance ?PROCESS Physical)
   (equal (PastFn (WhenFn ?PROCESS)) (TimeIntervalFn NegativeInfinity (BeginFn (WhenFn ?PROCESS)))))

(instance ImmediatePastFn TemporalRelation)
(instance ImmediatePastFn UnaryFunction)
(domain ImmediatePastFn 1 TimePosition)
(range ImmediatePastFn TimeInterval)
(documentation ImmediatePastFn "A &%UnaryFunction that maps a
&%TimePosition to a short, indeterminate &%TimeInterval that
immediately precedes the &%TimePosition.")

(=>
   (instance ?THING Physical)
   (finishes (ImmediatePastFn (WhenFn ?THING)) (PastFn (WhenFn ?THING))))

(=>
     (and
          (resource ?PROC ?OBJ)
          (holdsDuring (ImmediatePastFn (WhenFn ?PROC)) (measure ?OBJ ?QUANT1))
          (holdsDuring (ImmediateFutureFn (WhenFn ?PROC)) (measure ?OBJ ?QUANT2)))
     (greaterThan ?QUANT1 ?QUANT2))

(instance FutureFn TemporalRelation)
(instance FutureFn UnaryFunction)
(domain FutureFn 1 TimePosition)
(range FutureFn TimeInterval)
(documentation FutureFn "A &%UnaryFunction that maps a &%TimePosition
to the &%TimeInterval which it meets and which ends at
&%PositiveInfinity.")

(=>
   (instance ?THING Physical)
   (meetsTemporally (WhenFn ?THING) (FutureFn (WhenFn ?THING))))

(=>
   (instance ?PROCESS Physical)
   (equal (FutureFn (WhenFn ?PROCESS)) (TimeIntervalFn (EndFn (WhenFn ?PROCESS)) PositiveInfinity)))

(instance ImmediateFutureFn TemporalRelation)
(instance ImmediateFutureFn UnaryFunction)
(domain ImmediateFutureFn 1 TimePosition)
(range ImmediateFutureFn TimeInterval)
(documentation ImmediateFutureFn "A &%UnaryFunction that maps a
&%TimePosition to a short, indeterminate &%TimeInterval that
immediately follows the &%TimePosition.")

(=>
   (instance ?THING Physical)
   (starts (ImmediateFutureFn (WhenFn ?THING)) (FutureFn (WhenFn ?THING))))

;; The following definitions and axioms (down to the next section break)
;; cover the content in the Simple-Time ontology on the Ontolingua server.

(instance date BinaryPredicate)
(instance date SingleValuedRelation)
(instance date AsymmetricRelation)
(domain date 1 Physical)
(domain date 2 Day)
(subrelation date time)
(documentation date "A &%BinaryPredicate that specifies a
&%TimePosition in absolute calendar time, at the resolution
of one day, for a particular &%Object or &%Process.")

(instance YearFn TemporalRelation)
(instance YearFn UnaryFunction)
(domain YearFn 1 Integer)
(rangeSubclass YearFn Year)
(documentation YearFn "A &%UnaryFunction that maps a number to the corresponding calendar
&%Year.  For example, (&%YearFn 1912) returns the &%Class containing just one instance,
the year of 1912.  As might be expected, positive integers return years in the Common Era,
while negative integers return years in B.C.E.  Note that this function returns a &%Class
as a value.  The reason for this is that the related functions, viz. &%MonthFn, &%DayFn,
&%HourFn, &%MinuteFn, and &%SecondFn, are used to generate both specific &%TimeIntervals
and recurrent intervals, and the only way to do this is to make the domains and ranges of
these functions classes rather than individuals.")

(instance MonthFn TemporalRelation)
(instance MonthFn BinaryFunction)
(domainSubclass MonthFn 1 Month)
(domainSubclass MonthFn 2 Year)
(rangeSubclass MonthFn Month)
(documentation MonthFn "A &%BinaryFunction that maps a subclass of &%Month and a
subclass of &%Year to the class containing the &%Months corresponding to thos &%Years.
For example (&%MonthFn &%January (&%YearFn 1912)) is the class containing the eighth
&%Month, i.e. August, of the &%Year 1912.  For another example, (&%MonthFn &%August
&%Year) is equal to &%August, the class of all months of August.  Note that this function
returns a &%Class as a value.  The reason for this is that the related functions, viz.
DayFn, HourFn, MinuteFn, and SecondFn, are used to generate both specific &%TimeIntervals
and recurrent intervals, and the only way to do this is to make the domains and ranges of
these functions classes rather than individuals.")

(instance DayFn TemporalRelation)
(instance DayFn BinaryFunction)
(domain DayFn 1 PositiveRealNumber)
(domainSubclass DayFn 2 Month)
(rangeSubclass DayFn Day)
(documentation DayFn "A &%BinaryFunction that assigns a &%PositiveRealNumber and
a subclass of &%Months to the &%Days within each &%Month corresponding to that
&%PositiveRealNumber.  For example, (&%DayFn 16 &%August) is the &%Class of all
sixteenth days of August.  For another example, (&%DayFn 9 &%Month) would return
the class of all ninth days of any month.  For still another example, (&%DayFn 18
(&%MonthFn 8 (YearFn 1912))) denotes the 18th day of August 1912.")

(=>
   (instance ?DAY (DayFn ?NUMBER ?MONTH))
   (lessThanOrEqualTo ?NUMBER 31))

(=>
   (and
      (instance ?DAY1 (DayFn ?NUMBER1 ?MONTH))
      (instance ?DAY2 (DayFn ?NUMBER2 ?MONTH))
      (equal (SubtractionFn ?NUMBER2 ?NUMBER1) 1))
   (meetsTemporally ?DAY1 ?DAY2))

(instance HourFn TemporalRelation)
(instance HourFn BinaryFunction)
(domain HourFn 1 PositiveRealNumber)
(domainSubclass HourFn 2 Day)
(rangeSubclass HourFn Hour)
(documentation HourFn "A &%BinaryFunction that assigns a &%PositiveRealNumber and
a subclass of &%Days to the &%Hours within each &%Day corresponding to that
&%PositiveRealNumber.  For example, (&%HourFn 12 &%Thursday) is the &%Class of all
instances of noon Thursday.  For another example, (&%HourFn 24 &%Day) would return
the class of all instances of midnight.  For still another example, (&%HourFn 14
(&%DayFn 18 (&%MonthFn 8 (YearFn 1912)))) denotes 2 PM on the 18th day of August
1912.")

(=>
   (instance ?HOUR (HourFn ?NUMBER ?DAY))
   (lessThan ?NUMBER 24))

(=>
   (and
      (instance ?HOUR1 (HourFn ?NUMBER1 ?DAY))
      (instance ?HOUR2 (HourFn ?NUMBER2 ?DAY))
      (equal (SubtractionFn ?NUMBER2 ?NUMBER1) 1))
   (meetsTemporally ?HOUR1 ?HOUR2))

(instance MinuteFn TemporalRelation)
(instance MinuteFn BinaryFunction)
(domain MinuteFn 1 PositiveRealNumber)
(domainSubclass MinuteFn 2 Hour)
(rangeSubclass MinuteFn Minute)
(documentation MinuteFn "A &%BinaryFunction that assigns a &%PositiveRealNumber and
a subclass of &%Hours to the &%Minutes within each &%Hour corresponding to that
&%PositiveRealNumber.  For example, (&%MinuteFn 30 (&%HourFn 17 &%Day)) is the &%Class
of all 5:30's in the afternoon.  For another example, (&%MinuteFn 15 &%Hour) would return
the class of all instances of quarter past the hour.  For still another example,
(&%MinuteFn 15 (&%HourFn 14 (&%DayFn 18 (&%MonthFn 8 (YearFn 1912))))) denotes 15
minutes after 2 PM on the 18th day of August 1912.")

(=>
   (instance ?MINUTE (MinuteFn ?NUMBER ?HOUR))
   (lessThan ?NUMBER 60))

(=>
   (and
      (instance ?MINUTE1 (MinuteFn ?NUMBER1 ?HOUR))
      (instance ?MINUTE2 (MinuteFn ?NUMBER2 ?HOUR))
      (equal (SubtractionFn ?NUMBER2 ?NUMBER1) 1))
   (meetsTemporally ?MINUTE1 ?MINUTE2))

(instance SecondFn TemporalRelation)
(instance SecondFn BinaryFunction)
(domain SecondFn 1 PositiveRealNumber)
(domainSubclass SecondFn 2 Minute)
(rangeSubclass SecondFn Second)
(documentation SecondFn "A &%BinaryFunction that assigns a &%PositiveRealNumber and a
subclass of &%Minutes to the &%Seconds within each &%Minute corresponding to that
&%PositiveRealNumber.  For example, (&%SecondFn 4 (&%MinuteFn 5 &%Hour)) is the &%Class
of all fourth &%Seconds of every fifth &%Minute of every hour.  For another example,
(&%SecondFn 8 &%Minute) would return the eighth second of every minute.  For still
another example, (&%SecondFn 9 (&%MinuteFn 15 (&%HourFn 14 (&%DayFn 18 (&%MonthFn 8
(YearFn 1912)))))) denotes 9 seconds and 15 minutes after 2 PM on the 18th day of
August 1912.")

(=>
   (instance ?SECOND (SecondFn ?NUMBER ?MINUTE))
   (lessThan ?NUMBER 60))

(=>
   (and
      (instance ?SECOND1 (SecondFn ?NUMBER1 ?MINUTE))
      (instance ?SECOND2 (SecondFn ?NUMBER2 ?MINUTE))
      (equal (SubtractionFn ?NUMBER2 ?NUMBER1) 1))
   (meetsTemporally ?SECOND1 ?SECOND2))

(subclass Year TimeInterval)
(relatedInternalConcept Year YearFn)
(relatedInternalConcept Year YearDuration)
(documentation Year "The &%Class of all calendar &%Years.")

(=>
   (instance ?YEAR Year)
   (duration ?YEAR (MeasureFn 1 YearDuration)))

(=>
   (and
      (instance ?YEAR1 Year)
      (instance ?YEAR2 Year)
      (equal (SubtractionFn ?YEAR2 ?YEAR1) 1))
   (meetsTemporally ?YEAR1 ?YEAR2))

(subclass LeapYear Year)
(documentation LeapYear "The &%Class of all leap years.  These are years
which are either (i.) evenly divisible by 4 and not by 100 or (ii.) evenly
divisible by 400 (this latter case is known as a leap century).")

(=>
   (and
      (instance ?LEAP LeapYear)
      (equal ?LEAP (MeasureFn ?NUMBER Year)))
   (or
      (and
         (equal (RemainderFn ?NUMBER 4) 0)
         (not (equal (RemainderFn ?NUMBER 100) 0)))
      (equal (RemainderFn ?NUMBER 400) 0)))

(subclass Month TimeInterval)
(relatedInternalConcept Month MonthFn)
(documentation Month "The &%Class of all calendar &%Months.")

(subclass January Month)
(documentation January "The &%Class of all &%Months which are January.")

(=>
   (instance ?MONTH January)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn January ?YEAR))
      (equal ?MONTH2 (MonthFn February ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass February Month)
(documentation February "The &%Class of all &%Months which are February.")

(=>
   (and
      (equal (MonthFn February ?YEAR) ?MONTH)
      (not (instance ?YEAR LeapYear)))
   (duration ?MONTH (MeasureFn 28 DayDuration)))

(=>
   (and
      (equal (MonthFn February ?YEAR) ?MONTH)
      (instance ?YEAR LeapYear))
   (duration ?MONTH (MeasureFn 29 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn February ?YEAR))
      (equal ?MONTH2 (MonthFn March ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass March Month)
(documentation March "The &%Class of all &%Months which are March.")

(=>
   (instance ?MONTH March)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn March ?YEAR))
      (equal ?MONTH2 (MonthFn April ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass April Month)
(documentation April "The &%Class of all &%Months which are April.")

(=>
   (instance ?MONTH April)
   (duration ?MONTH (MeasureFn 30 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn April ?YEAR))
      (equal ?MONTH2 (MonthFn May ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass May Month)
(documentation May "The &%Class of all &%Months which are May.")

(=>
   (instance ?MONTH May)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn May ?YEAR))
      (equal ?MONTH2 (MonthFn June ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass June Month)
(documentation June "The &%Class of all &%Months which are June.")

(=>
   (instance ?MONTH June)
   (duration ?MONTH (MeasureFn 30 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn June ?YEAR))
      (equal ?MONTH2 (MonthFn July ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass July Month)
(documentation July "The &%Class of all &%Months which are July.")

(=>
   (instance ?MONTH July)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn July ?YEAR))
      (equal ?MONTH2 (MonthFn August ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass August Month)
(documentation August "The &%Class of all &%Months which are August.")

(=>
   (instance ?MONTH August)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn August ?YEAR))
      (equal ?MONTH2 (MonthFn September ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass September Month)
(documentation September "The &%Class of all &%Months which are September.")

(=>
   (instance ?MONTH September)
   (duration ?MONTH (MeasureFn 30 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn September ?YEAR))
      (equal ?MONTH2 (MonthFn October ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass October Month)
(documentation October "The &%Class of all &%Months which are October.")

(=>
   (instance ?MONTH October)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn October ?YEAR))
      (equal ?MONTH2 (MonthFn November ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass November Month)
(documentation November "The &%Class of all &%Months which are November.")

(=>
   (instance ?MONTH November)
   (duration ?MONTH (MeasureFn 30 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn November ?YEAR))
      (equal ?MONTH2 (MonthFn December ?YEAR)))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass December Month)
(documentation December "The &%Class of all &%Months which are December.")

(=>
   (instance ?MONTH December)
   (duration ?MONTH (MeasureFn 31 DayDuration)))

(=>
   (and
      (equal ?MONTH1 (MonthFn December ?YEAR1))
      (equal ?MONTH2 (MonthFn January ?YEAR2))
      (meetsTemporally ?YEAR1 ?YEAR2))
   (meetsTemporally ?MONTH1 ?MONTH2))

(subclass Day TimeInterval)
(relatedInternalConcept Day DayFn)
(relatedInternalConcept Day DayDuration)
(documentation Day "The &%Class of all calendar &%Days.")

(=>
   (instance ?DAY Day)
   (duration ?DAY (MeasureFn 1 DayDuration)))

(subclass Monday Day)
(documentation Monday "The &%Class of all calendar Mondays.")

(subclass Tuesday Day)
(documentation Tuesday "The &%Class of all calendar Tuesdays.")

(=>
   (and
      (instance ?DAY1 Monday)
      (instance ?DAY2 Tuesday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Wednesday Day)
(documentation Wednesday "The &%Class of all calendar Wednesdays.")

(=>
   (and
      (instance ?DAY1 Tuesday)
      (instance ?DAY2 Wednesday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Thursday Day)
(documentation Thursday "The &%Class of all calendar Thursdays.")

(=>
   (and
      (instance ?DAY1 Wednesday)
      (instance ?DAY2 Thursday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Friday Day)
(documentation Friday "The &%Class of all calendar Fridays.")

(=>
   (and
      (instance ?DAY1 Thursday)
      (instance ?DAY2 Friday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Saturday Day)
(documentation Saturday "The &%Class of all calendar Saturdays.")

(=>
   (and
      (instance ?DAY1 Friday)
      (instance ?DAY2 Saturday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Sunday Day)
(documentation Sunday "The &%Class of all calendar Sundays.")

(=>
   (and
      (instance ?DAY1 Saturday)
      (instance ?DAY2 Sunday)
      (instance ?WEEK Week)
      (temporalPart ?DAY1 ?WEEK)
      (temporalPart ?DAY2 ?WEEK))
   (meetsTemporally ?DAY1 ?DAY2))

(=>
   (and
      (instance ?DAY1 Sunday)
      (instance ?DAY2 Monday)
      (instance ?WEEK1 Week)
      (instance ?WEEK2 Week)
      (temporalPart ?DAY1 ?WEEK1)
      (temporalPart ?DAY2 ?WEEK2)
      (meetsTemporally ?WEEK1 ?WEEK2))
   (meetsTemporally ?DAY1 ?DAY2))

(subclass Week TimeInterval)
(documentation Week "The &%Class of all calendar weeks.")

(=>
   (instance ?WEEK Week)
   (duration ?WEEK (MeasureFn 1 WeekDuration)))

(subclass Hour TimeInterval)
(relatedInternalConcept Hour HourFn)
(relatedInternalConcept Hour HourDuration)
(documentation Hour "The &%Class of all clock &%Hours.")

(=>
   (instance ?HOUR Hour)
   (duration ?HOUR (MeasureFn 1 HourDuration)))

(subclass Minute TimeInterval)
(relatedInternalConcept Minute MinuteFn)
(relatedInternalConcept Minute MinuteDuration)
(documentation Minute "The &%Class of all clock &%Minutes.")

(=>
   (instance ?MINUTE Minute)
   (duration ?MINUTE (MeasureFn 1 MinuteDuration)))

(subclass Second TimeInterval)
(relatedInternalConcept Second SecondDuration)
(relatedInternalConcept Second SecondFn)
(documentation Second "The &%Class of all clock &%Seconds.")

(=>
   (instance ?SECOND Second)
   (duration ?SECOND (MeasureFn 1 SecondDuration)))

(instance TemporalCompositionFn TemporalRelation)
(instance TemporalCompositionFn BinaryFunction)
(domain TemporalCompositionFn 1 TimeInterval)
(domainSubclass TemporalCompositionFn 2 TimeInterval)
(rangeSubclass TemporalCompositionFn TimeInterval)
(documentation TemporalCompositionFn "The basic &%Function for expressing
the composition of larger &%TimeIntervals out of smaller &%TimeIntervals.
For example, if &%ThisSeptember is an &%instance of &%September,
(&%TemporalCompositionFn &%ThisSeptember &%Day) denotes the &%Class of
consecutive days that make up &%ThisSeptember.  Note that one can obtain
the number of instances of this &%Class by using the function &%CardinalityFn.")

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (forall (?TIME1 ?TIME2)
      (=>
         (and
            (instance ?TIME1 ?INTERVAL-TYPE)
            (instance ?TIME2 ?CLASS))
         (exists (?DURATION)
            (and
               (duration ?TIME1 ?DURATION)
               (duration ?TIME2 ?DURATION))))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (forall (?TIME1 ?TIME2)
      (=>
         (and
            (instance ?TIME1 ?CLASS)
            (instance ?TIME2 ?CLASS)
            (not (equal ?TIME1 ?TIME2)))
         (or
            (meetsTemporally ?TIME1 ?TIME2)
            (meetsTemporally ?TIME2 ?TIME1)
            (earlier ?TIME1 ?TIME2)
            (earlier ?TIME2 ?TIME1)))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (exists (?TIME)
      (and
         (instance ?TIME ?CLASS)
         (starts ?TIME ?INTERVAL))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (exists (?TIME)
      (and
         (instance ?TIME ?CLASS)
         (finishes ?TIME ?INTERVAL))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (forall (?TIME1)
      (=>
         (and
            (instance ?TIME1 ?CLASS)
            (not (finishes ?TIME1 ?INTERVAL)))
         (exists (?TIME2)
            (and
               (instance ?TIME2 ?CLASS)
               (meetsTemporally ?TIME1 ?TIME2))))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (forall (?TIME1)
      (=>
         (and
            (instance ?TIME1 ?CLASS)
            (not (starts ?TIME1 ?INTERVAL)))
         (exists (?TIME2)
            (and
               (instance ?TIME2 ?CLASS)
               (meetsTemporally ?TIME2 ?TIME1))))))

(=>
   (equal (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE) ?CLASS)
   (forall (?TIME)
      (=>
         (and
            (instance ?TIME TimePoint)
            (temporalPart ?TIME ?INTERVAL))
         (exists (?INSTANCE)
            (and
               (instance ?INSTANCE ?CLASS)
               (temporalPart ?TIME ?INSTANCE))))))

(=>
   (instance ?YEAR Year)
   (equal (CardinalityFn (TemporalCompositionFn ?YEAR Month)) 12))

(=>
   (and
      (instance ?MONTH Month)
      (duration ?MONTH (MeasureFn ?NUMBER DayDuration)))
   (equal (CardinalityFn (TemporalCompositionFn ?MONTH Day)) ?NUMBER))

(=>
   (instance ?WEEK Week)
   (equal (CardinalityFn (TemporalCompositionFn ?WEEK Day)) 7))

(=>
   (instance ?DAY Day)
   (equal (CardinalityFn (TemporalCompositionFn ?DAY Hour)) 24))

(=>
   (instance ?HOUR Hour)
   (equal (CardinalityFn (TemporalCompositionFn ?HOUR Minute)) 60))

(=>
   (instance ?MINUTE Minute)
   (equal (CardinalityFn (TemporalCompositionFn ?MINUTE Second)) 60))


;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;
;; MEREOTOPOLOGY ;;
;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'STRUCTURAL ONTOLOGY'
;; INCLUDES 'BASE ONTOLOGY'

;; Most of this content is taken from Barry Smith's and Nicola Guarino's
;; papers on the subject.

(instance connected BinaryPredicate)
(instance connected SpatialRelation)
(instance connected ReflexiveRelation)
(instance connected SymmetricRelation)
(domain connected 1 Object)
(domain connected 2 Object)
(documentation connected "(connected ?OBJ1 ?OBJ2) means that ?OBJ1
&%meetsSpatially ?OBJ2 or that ?OBJ1 &%overlapsSpatially ?OBJ2.")

(=>
     (connected ?OBJ1 ?OBJ2)
     (or
          (meetsSpatially ?OBJ1 ?OBJ2)
          (overlapsSpatially ?OBJ1 ?OBJ2)))

(<=>
	(instance ?OBJ SelfConnectedObject)
	(forall (?PART1 ?PART2)
		(=>
			(equal ?OBJ (MereologicalSumFn ?PART1 ?PART2))
			(connected ?PART1 ?PART2))))

(instance connects SpatialRelation)
(instance connects TernaryPredicate)
(domain connects 1 SelfConnectedObject)
(domain connects 2 SelfConnectedObject)
(domain connects 3 SelfConnectedObject)
(documentation connects "The relationship between three things, when one of
the three things connects the other two.  More formally, (&%connects ?OBJ1
?OBJ2 ?OBJ3) means that (&%connected ?OBJ1 ?OBJ2) and (&%connected ?OBJ1 ?OBJ3)
and not (&%connected ?OBJ2 ?OBJ3).")

(<=>
   (connects ?OBJ1 ?OBJ2 ?OBJ3)
   (and
      (connected ?OBJ1 ?OBJ2)
      (connected ?OBJ1 ?OBJ3)
      (not
         (connected ?OBJ2 ?OBJ3))))

(subrelation meetsSpatially connected)
(instance meetsSpatially IrreflexiveRelation)
(instance meetsSpatially SymmetricRelation)
(disjointRelation meetsSpatially overlapsSpatially)
(documentation meetsSpatially "(&%meetsSpatially ?OBJ1 ?OBJ2) means that
?OBJ1 and ?OBJ2 are &%connected but that neither ?OBJ1 nor ?OBJ2
&%overlapsSpatially the other.")

(subrelation overlapsSpatially connected)
(instance overlapsSpatially ReflexiveRelation)
(instance overlapsSpatially SymmetricRelation)
(documentation overlapsSpatially "(&%overlapsSpatially ?OBJ1 ?OBJ2) means
that the &%Objects ?OBJ1 and ?OBJ2 have some parts in common.  This is a
reflexive and symmetric (but not transitive) relation.")

(<=>
	(overlapsSpatially ?OBJ1 ?OBJ2)
     	(exists (?OBJ3)
          	(and
               	(part ?OBJ3 ?OBJ1)
               	(part ?OBJ3 ?OBJ2))))

(=>
   (partlyLocated ?OBJ ?REGION)
   (overlapsSpatially ?OBJ ?REGION))

(=>
   (and
      (member ?OBJ1 ?COLL)
      (member ?OBJ2 ?COLL))
   (not
         (overlapsSpatially ?OBJ1 ?OBJ2)))

(=>
   (and
      (instance ?REL CaseRole)
      (holds ?REL ?PROCESS ?OBJ))
   (exists (?TIME)
      (overlapsSpatially (WhereFn ?PROCESS ?TIME) ?OBJ)))

(instance overlapsPartially SymmetricRelation)
(instance overlapsPartially IrreflexiveRelation)
(subrelation overlapsPartially overlapsSpatially)
(documentation overlapsPartially "(&%overlapsPartially ?OBJ1 ?OBJ2) means
that ?OBJ1 and ?OBJ2 have part(s) in common, but neither ?OBJ1 nor ?OBJ2
is a &%part of the other.")

(<=>
   (overlapsPartially ?OBJ1 ?OBJ2)
      (and
         (not (part ?OBJ1 ?OBJ2))
         (not (part ?OBJ2 ?OBJ1))
         (exists (?OBJ3)
            (and
               (part ?OBJ3 ?OBJ1)
               (part ?OBJ3 ?OBJ2)))))

(subrelation superficialPart part)
(instance superficialPart IrreflexiveRelation)
(instance superficialPart TransitiveRelation)
(documentation superficialPart "(&%superficialPart ?OBJ1 ?OBJ2)
means that ?OBJ1 is a part of ?OBJ2 that has no interior parts of its own
(or, intuitively, that only overlaps those parts of ?OBJ2 that are
externally connected with the mereological complement of ?OBJ2). This too
is a transitive relation closed under &%MereologicalSumFn and
&%MereologicalProductFn.")

(=>
	(superficialPart ?OBJ1 ?OBJ2)
	(and
		(not
			(interiorPart ?OBJ1 ?OBJ2))
		(not
			(exists (?OBJ3)
				(interiorPart ?OBJ3 ?OBJ1)))))

(instance surface AsymmetricRelation)
(subrelation surface superficialPart)
(domain surface 1 SelfConnectedObject)
(domain surface 2 SelfConnectedObject)
(documentation surface "(&%surface ?OBJ1 ?OBJ2) means that ?OBJ1
is a maximally connected &%superficialPart of ?OBJ2.  Note that some
&%SelfConnectedObjects have more than one surface, e.g. a hollow
object like a tennis ball has both an inner and an outer surface.")

(=>
   (surface ?OBJ1 ?OBJ2)
   (forall (?OBJ3)
      (=>
	   (superficialPart ?OBJ3 ?OBJ2)
	   (part ?OBJ3 ?OBJ1))))

(subrelation interiorPart part)
(instance interiorPart IrreflexiveRelation)
(instance interiorPart TransitiveRelation)
(documentation interiorPart "(&%interiorPart ?OBJ1 ?OBJ2) means
that ?OBJ1 is part ?OBJ2 and there is no overlap between ?OBJ1 and
any &%superficialPart ?OBJ2.")

(=>
	(interiorPart ?OBJ1 ?OBJ2)
     	(forall (?PART)
               	(=>
                    	(superficialPart ?PART ?OBJ2)
                    	(not
                         	(overlapsSpatially ?OBJ1 ?PART)))))

(subrelation bottom superficialPart)
(domain bottom 1 SelfConnectedObject)
(domain bottom 2 SelfConnectedObject)
(documentation bottom "(&%bottom ?BOTTOM ?OBJECT) holds if ?BOTTOM is the
lowest or deepest maximal superficial part of ?OBJECT.")

(=>
	(and
		(bottom ?BOTTOM ?OBJECT)
		(part ?PART ?OBJECT)
		(not (connected ?PART ?BOTTOM)))
	(orientation ?PART ?BOTTOM Above))

(subrelation top superficialPart)
(domain top 1 SelfConnectedObject)
(domain top 2 SelfConnectedObject)
(documentation top "(&%top ?TOP ?OBJECT) means that ?TOP is the highest maximal
superficial part of ?OBJECT.")

(=>
	(and
		(top ?TOP ?OBJECT)
		(part ?PART ?OBJECT)
		(not (connected ?PART ?TOP)))
	(orientation ?PART ?TOP Below))

(subrelation side superficialPart)
(domain side 1 SelfConnectedObject)
(domain side 2 SelfConnectedObject)
(documentation side "(&%side ?SIDE ?OBJECT) means that ?SIDE is a side of the object,
as opposed to the &%top or &%bottom.")

(=>
	(and
		(side ?SIDE ?OBJECT)
		(part ?PART ?OBJECT)
		(not (connected ?PART ?SIDE)))
      (or
	      (orientation ?SIDE ?PART Left)
            (orientation ?SIDE ?PART Right)))

(<=>
	(width ?OBJECT ?WIDTH)
	(exists (?SIDE1 ?SIDE2)
		(and
			(side ?SIDE1 ?OBJECT)
			(side ?SIDE2 ?OBJECT)
			(distance ?SIDE1 ?SIDE2 ?WIDTH))))

(subrelation height length)
(domain height 1 SelfConnectedObject)
(domain height 2 LengthMeasure)
(documentation height "The height of an &%Object is the distance between
its &%top and its &%bottom.")

(=>
	(and
		(height ?OBJECT ?HEIGHT)
		(top ?TOP ?OBJECT)
            (bottom ?BOTTOM ?OBJECT))
	(distance ?TOP ?BOTTOM ?HEIGHT))

(instance MereologicalSumFn SpatialRelation)
(instance MereologicalSumFn BinaryFunction)
(domain MereologicalSumFn 1 Object)
(domain MereologicalSumFn 2 Object)
(range MereologicalSumFn Object)
(relatedInternalConcept MereologicalSumFn MereologicalProductFn)
(relatedInternalConcept MereologicalSumFn MereologicalDifferenceFn)
(documentation MereologicalSumFn "(&%MereologicalSumFn ?OBJ1 ?OBJ2)
denotes the &%Object consisting of the parts which belong to either
?OBJ1 or ?OBJ2.")

(=>
     (equal ?OBJ3 (MereologicalSumFn ?OBJ1 ?OBJ2))
     (forall (?PART)
	       (<=>
	            (part ?PART ?OBJ3)
		      (or
	  	           (part ?PART ?OBJ1)
			     (part ?PART ?OBJ2)))))

(instance MereologicalProductFn SpatialRelation)
(instance MereologicalProductFn BinaryFunction)
(domain MereologicalProductFn 1 Object)
(domain MereologicalProductFn 2 Object)
(range MereologicalProductFn Object)
(relatedInternalConcept MereologicalProductFn MereologicalDifferenceFn)
(documentation MereologicalProductFn "(&%MereologicalProductFn ?OBJ1 ?OBJ2)
denotes the &%Object consisting of the parts which belong to both ?OBJ1
and ?OBJ2.")

(=>
     (equal ?OBJ3 (MereologicalProductFn ?OBJ1 ?OBJ2))
     (forall (?PART)
	       (<=>
	            (part ?PART ?OBJ3)
		      (and
	  	           (part ?PART ?OBJ1)
			     (part ?PART ?OBJ2)))))

(instance MereologicalDifferenceFn SpatialRelation)
(instance MereologicalDifferenceFn BinaryFunction)
(domain MereologicalDifferenceFn 1 Object)
(domain MereologicalDifferenceFn 2 Object)
(range MereologicalDifferenceFn Object)
(documentation MereologicalDifferenceFn "(&%MereologicalDifferenceFn ?OBJ1
?OBJ2) denotes the &%Object consisting of the parts which belong to ?OBJ1
and not to ?OBJ2.")

(=>
     (equal ?OBJ3 (MereologicalDifferenceFn ?OBJ1 ?OBJ2))
     (forall (?PART)
	       (<=>
	            (part ?PART ?OBJ3)
		      (and
	  	           (part ?PART ?OBJ1)
                       (not
			          (part ?PART ?OBJ2))))))

;; What follows is an alignment of Casati and Varzi's formal theory of
;; holes with the SUMO.

(instance hole BinaryPredicate)
(instance hole SpatialRelation)
(instance hole AsymmetricRelation)
(domain hole 1 Hole)
(domain hole 2 SelfConnectedObject)
(documentation hole "(&%hole ?HOLE ?OBJ) means that ?HOLE is a
&%Hole in ?OBJ.  A &%Hole is a fillable body located at the
&%surface an &%Object.")

(subclass Hole Region)
(documentation Hole "A hole is an immaterial body located at the surface
of an &%Object.  Since every &%Hole is ontologically dependent on its host
(i.e., the object in which it is a hole), being a &%Hole is defined as
being a &%hole in something.  Note that two &%Holes may occupy the same
region, or part of the same region, without sharing any parts.")

(<=>
	(instance ?HOLE Hole)
	(exists (?OBJ)
		(hole ?HOLE ?OBJ)))

(=>
	(hole ?HOLE ?OBJ)
      (not
		(instance ?OBJ Hole)))

(=>
	(hole ?HOLE ?OBJ)
          (not
		 (overlapsSpatially ?HOLE ?OBJ)))

;; Any two hosts of a hole have a common proper part that entirely hosts
;; the hole.

(=>
	(and
		(hole ?HOLE ?OBJ1)
            (hole ?HOLE ?OBJ2))
      (exists (?OBJ3)
             (and
			(properPart ?OBJ3 (MereologicalProductFn ?OBJ1 ?OBJ2))
                  (hole ?HOLE ?OBJ3))))

;; A common host of two holes hosts all parts of the sum of those holes.

(=>
	(and
		(hole ?HOLE1 ?OBJ)
      	(hole ?HOLE2 ?OBJ))
     	(forall (?HOLE3)
        	(=>
			(part ?HOLE3 (MereologicalSumFn ?HOLE1 ?HOLE2))
                  (hole ?HOLE3 ?OBJ))))

;; Any object that includes the host of a hole is a host of that hole,
;; unless its parts also include parts of that very hole.

(=>
	(and
		(hole ?HOLE ?OBJ1)
            (part ?OBJ1 ?OBJ2))
      (or
		(overlapsSpatially ?HOLE ?OBJ2)
            (hole ?HOLE ?OBJ2)))

;; Overlapping holes have overlapping hosts.

(=>
	(and
		(hole ?HOLE1 ?OBJ1)
            (hole ?HOLE2 ?OBJ2)
            (overlapsSpatially ?HOLE1 ?HOLE2))
      (overlapsSpatially ?OBJ1 ?OBJ2))

;; No hole is atomic

(=>
	(instance ?HOLE1 Hole)
      (exists (?HOLE2)
      	(properPart ?HOLE2 ?HOLE1)))

;; Topological Definitions

;; Definition of 'PrincipalHostFn'

(instance PrincipalHostFn SpatialRelation)
(instance PrincipalHostFn UnaryFunction)
(instance PrincipalHostFn AsymmetricRelation)
(domain PrincipalHostFn 1 Hole)
(range PrincipalHostFn Object)
(documentation PrincipalHostFn "A &%UnaryFunction that maps a &%Hole to
the &%Object which is its principal host.  The principle host of a &%Hole
is its maximally connected host (a notion taken here to be defined only
when the argument is a hole).")

(=>
     (equal ?OBJ1 (PrincipalHostFn ?HOLE))
     (forall (?OBJ2)
		(<=>
			(overlapsSpatially ?OBJ2 ?OBJ1)
			(exists (?OBJ3)
				(and
					(hole ?HOLE ?OBJ3)
				      (overlapsSpatially ?OBJ2 ?OBJ3))))))

;; Holes are connected with their hosts.

(=>
	(hole ?HOLE ?OBJ)
      (connected ?HOLE ?OBJ))

;; No hole can have a proper part that is externally connected
;; with exactly the same things as the hole itself.

(=>
	(and
		(instance ?HOLE1 Hole)
            (properPart ?HOLE2 ?HOLE1))
      (exists (?OBJ)
            (and
			(meetsSpatially ?HOLE1 ?OBJ)
                  (not
				(meetsSpatially ?HOLE2 ?OBJ)))))

(instance Fillable ShapeAttribute)
(documentation Fillable "Something is &%Fillable if it can be filled by
something else.  Note that 'filled' here means perfectly filled.")

(=>
   (exists (?TIME)
      (holdsDuring ?TIME
         (fills ?OBJ ?HOLE)))
     (attribute ?HOLE Fillable))

;; Something is fillable just in case it is part of a hole; i.e.,
;; fillability is an exclusive property of holes and their parts.

(<=>
	(attribute ?HOLE1 Fillable)
       	(exists (?HOLE2)
        	(and
			(instance ?HOLE2 Hole)
                  (part ?HOLE1 ?HOLE2))))

(subrelation partiallyFills located)
(instance partiallyFills SpatialRelation)
(instance partiallyFills AsymmetricRelation)
(domain partiallyFills 1 Object)
(domain partiallyFills 2 Hole)
(documentation partiallyFills "(&%partiallyFills ?OBJ ?HOLE) means that
?OBJ &%completelyFills some part of ?HOLE. Note that if (&%partiallyFills
?OBJ1 ?HOLE) and (&%part ?OBJ1 ?OBJ2), then (&%partiallyFills ?OBJ2 ?HOLE).
Note too that a partial filler need not be wholly inside a hole (it may
stick out), which means that every complete filler also qualifies as
(is a limit case of) a partial one.")

(=>
	(partiallyFills ?OBJ ?HOLE1)
	(exists (?HOLE2)
		(and
			(part ?HOLE2 ?HOLE1)
			(completelyFills ?OBJ ?HOLE2))))

(instance properlyFills AsymmetricRelation)
(subrelation properlyFills partiallyFills)
(domain properlyFills 1 Object)
(domain properlyFills 2 Hole)
(documentation properlyFills "(&%properlyFills ?OBJ ?HOLE)
means that ?HOLE is properly (though perhaps incompletely) filled by
?OBJ, i.e. some part of ?HOLE is perfectly filled by ?OBJ.  Note that
&%properlyFills is the dual of &%completelyFills, and is so
related to &%partiallyFills that ?OBJ &%properlyFills ?HOLE just in
case ?OBJ &%partiallyFills every part of ?HOLE.  (Thus, every perfect
filler is both complete and proper in this sense).")

(=>
	(properlyFills ?OBJ ?HOLE1)
	(exists (?HOLE2)
		(and
			(part ?HOLE2 ?HOLE1)
			(fills ?OBJ ?HOLE2))))

(instance completelyFills AsymmetricRelation)
(subrelation completelyFills partiallyFills)
(documentation completelyFills "(&%completelyFills ?OBJ ?HOLE)
means that some &%part of the &%Object ?OBJ fills the &%Hole ?HOLE.
Note that if (&%completelyFills ?OBJ1 ?HOLE) and (&%part
?OBJ1 ?OBJ2), then (&%completelyFills ?OBJ2 ?HOLE).")

(=>
	(completelyFills ?OBJ1 ?HOLE)
	(exists (?OBJ2)
		(and
			(part ?OBJ2 ?OBJ1)
			(fills ?OBJ2 ?HOLE))))

(instance fills AsymmetricRelation)
(subrelation fills completelyFills)
(subrelation fills properlyFills)
(domain fills 1 Object)
(domain fills 2 Hole)
(relatedInternalConcept fills Fillable)
(documentation fills "Holes can be filled.  (&%fills ?OBJ ?HOLE)
means that the &%Object ?OBJ fills the &%Hole ?HOLE.  Note that
&%fills here means perfectly filled.")

;; Perfect fillers and fillable entities have no parts in common (rather,
;; they may occupy the same spatial region).

(=>
	(and
		(fills ?OBJ1 ?HOLE)
           	(attribute ?OBJ2 Fillable))
      (not
		(overlapsSpatially ?OBJ1 ?OBJ2)))

;; A complete filler of (a part of) a hole is connected with everything
;; with which (that part of) the hole itself is connected.

(=>
   (completelyFills ?OBJ1 ?HOLE)
      (forall (?OBJ2)
   	   (=>
	      (connected ?OBJ2 ?HOLE)
            (connected ?OBJ2 ?OBJ1))))

;; Every hole is connected with everything with which a proper filler
;; of the hole is connected.

(=>
	(and
		(properlyFills ?OBJ1 ?HOLE)
          	(connected ?OBJ2 ?OBJ1))
     	(connected ?HOLE ?OBJ2))

;; A perfect filler of (a part of) a hole completely fills every proper
;; part of (that part of) that hole.

(=>
	(and
		(fills ?OBJ ?HOLE1)
            (properPart ?HOLE2 ?HOLE1))
     	(completelyFills ?OBJ ?HOLE2))

;; Every proper part of a perfect filler of (a part of) a hole properly
;; fills (that part of) that hole.

(=>
	(and
		(fills ?OBJ1 ?HOLE)
            (properPart ?OBJ2 ?OBJ1))
     	(properlyFills ?OBJ2 ?HOLE))

(instance SkinFn SpatialRelation)
(instance SkinFn UnaryFunction)
(instance SkinFn AsymmetricRelation)
(domain SkinFn 1 Hole)
(range SkinFn Object)
(documentation SkinFn "A &%UnaryFunction that maps a &%Hole to the skin
of the &%Hole.  The skin of a &%Hole is the fusion of those superficial
parts (see &%superficialPart) of the &%Hole's principal host (see
&%PrincipalHostFn) with which the &%Hole is externally connected.")

(=>
     (equal ?OBJ1 (SkinFn ?HOLE))
     (forall (?OBJ2)
		(<=>
			(overlapsSpatially ?OBJ2 ?OBJ1)
			(exists (?OBJ3)
				(and
				      (superficialPart ?OBJ3 (PrincipalHostFn ?HOLE))
				      (meetsSpatially ?HOLE ?OBJ3)
				      (overlapsSpatially ?OBJ2 ?OBJ3))))))

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;;;
;;    PROCESSES    ;;
;;;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'TEMPORAL CONCEPTS'
;; INCLUDES 'OBJECTS'
;; INCLUDES 'QUALITIES'

(instance subProcess BinaryPredicate)
(instance subProcess PartialOrderingRelation)
(domain subProcess 1 Process)
(domain subProcess 2 Process)
(documentation subProcess "(&%subProcess ?SUBPROC ?PROC) means that ?SUBPROC
is a subprocess of ?PROC.  A subprocess is here understood as a temporally
distinguished part (proper or not) of a &%Process.")

(=>
   (subProcess ?SUBPROC ?PROC)
      (or
         (equal (WhenFn ?SUBPROC) (WhenFn ?PROC))
         (during (WhenFn ?SUBPROC) (WhenFn ?PROC))))

(=>
   (subProcess ?SUBPROC ?PROC)
   (forall (?REGION)
      (=>
         (located ?PROC ?REGION)
         (located ?SUBPROC ?REGION))))

;; Each temporal part of a Process exists at some timepoint.

(=>
	(and
            (instance ?PROC Process)
            (subProcess ?SUBPROC ?PROC))
     	(exists (?TIME)
      	    (time ?SUBPROC ?TIME)))

;; The following formulas cover the hierarchy of &%Classes under
;; &%BiologicalProcess.

(subclass BiologicalProcess InternalChange)
(documentation BiologicalProcess "A &%Process embodied in an &%Organism.")

(=>
   (instance ?PROC BiologicalProcess)
   (exists (?OBJ)
      (and
         (instance ?OBJ Organism)
         (located ?PROC ?OBJ))))

(=>
   (and
      (instance ?PROC BiologicalProcess)
      (experiencer ?PROC ?ORG))
   (instance ?ORG Organism))

(subclass PhysiologicProcess BiologicalProcess)
(documentation PhysiologicProcess "A normal process of an &%Organism
or part of an &%Organism.")

(subclass OrganismProcess PhysiologicProcess)
(documentation OrganismProcess "A physiologic function of the
&%Organism as a whole, of multiple organ systems or of multiple
&%Organs or &%Tissues.")

(subclass Birth OrganismProcess)
(documentation Birth "The &%Process of being born.")

(=>
   (and
      (instance ?BIRTH Birth)
      (experiencer ?BIRTH ?AGENT))
   (exists (?DEATH)
      (and
         (instance ?DEATH Death)
         (experiencer ?DEATH ?AGENT))))

(subclass Death OrganismProcess)
(documentation Death "The &%Process of dying.")

(=>
   (and
      (instance ?DEATH Death)
      (experiencer ?DEATH ?AGENT))
   (holdsDuring (FutureFn (WhenFn ?DEATH)) (attribute ?AGENT Dead)))

(=>
   (and
      (instance ?DEATH Death)
      (instance ?BIRTH Birth)
      (experiencer ?DEATH ?AGENT)
      (experiencer ?BIRTH ?AGENT))
   (exists (?TIME)
      (and
         (meetsTemporally (WhenFn ?BIRTH) ?TIME)
         (meetsTemporally ?TIME (WhenFn ?DEATH))
         (holdsDuring ?TIME (attribute ?AGENT Living)))))

(subclass Breathing OrganismProcess)
(documentation Breathing "The &%Process of respiration, by which oxygen
is made available to an &%Animal.  This covers processes of inhalation,
exhalation, and alternations between the two.")

(subclass Ingesting OrganismProcess)
(documentation Ingesting "The &%Process by which &%Food is
incorporated into an &%Animal.")

(=>
   (and
      (instance ?ACT Ingesting)
      (patient ?ACT ?FOOD))
   (instance ?FOOD Food))

(subclass Eating Ingesting)
(documentation Eating "The &%Process by which solid &%Food is
incorporated into an &%Animal.")

(=>
   (and
      (instance ?ACT Eating)
      (patient ?ACT ?FOOD))
   (attribute ?FOOD Solid))

(subclass Drinking Ingesting)
(documentation Drinking "The &%Process by which liquid &%Food, i.e.
&%Beverages, are incorporated into an &%Animal.")

(subclass Growth OrganismProcess)
(documentation Growth "The &%Process of biological development in which
an &%Organism or part of an &%Organism changes its form or its size.")

(subclass Replication OrganismProcess)
(documentation Replication "The &%Process of biological reproduction.
This can be either a sexual or an asexual process.")

(=>
   (and
      (instance ?REP Replication)
      (agent ?REP ?PARENT)
      (result ?REP ?CHILD))
   (parent ?CHILD ?PARENT))

(=>
   (instance ?REP Replication)
   (exists (?BODY)
      (and
         (instance ?BODY ReproductiveBody)
         (result ?REP ?BODY))))

(subclass SexualReproduction Replication)
(disjoint SexualReproduction AsexualReproduction)
(documentation SexualReproduction "Sexual &%Processes of biological
reproduction.")

(=>
   (and
      (instance ?REP SexualReproduction)
      (result ?REP ?ORGANISM))
   (not (exists (?MOTHER ?FATHER)
      (and
         (mother ?ORGANISM ?MOTHER)
         (father ?ORGANISM ?FATHER)))))

(subclass AsexualReproduction Replication)
(documentation AsexualReproduction "Asexual &%Processes of biological
reproduction.")

(=>
   (and
      (instance ?REP AsexualReproduction)
      (result ?REP ?ORGANISM))
   (not (exists (?PARENT1 ?PARENT2)
      (and
         (parent ?ORGANISM ?PARENT1)
         (parent ?ORGANISM ?PARENT2)
         (not (equal ?PARENT1 ?PARENT2))))))

(subclass PsychologicalProcess BiologicalProcess)
(documentation PsychologicalProcess "A &%BiologicalProcess which takes place in
the mind or brain of an &%Organism and which may be manifested in the behavior
of the &%Organism.")

(=>
    (instance ?PROCESS PsychologicalProcess)
    (exists (?ANIMAL)
        (and
            (instance ?ANIMAL Animal)
            (experiencer ?PROCESS ?ANIMAL))))

(subclass OrganOrTissueProcess PhysiologicProcess)
(disjoint OrganOrTissueProcess OrganismProcess)
(documentation OrganOrTissueProcess "A &%PhysiologicProcess of a
particular &%Organ or &%Tissue.")

(=>
    (instance ?PROC OrganOrTissueProcess)
    (exists (?THING)
        (and
            (located ?PROC ?THING)
            (or
                (instance ?THING Organ)
                (instance ?THING Tissue)))))

(subclass PathologicProcess BiologicalProcess)
(disjoint PathologicProcess PhysiologicProcess)
(documentation PathologicProcess "A disordered process, activity, or
state of the &%Organism as a whole, of a body system or systems, or of
multiple &%Organs or &%Tissues. Included here are normal responses to a
negative stimulus as well as patholologic conditions or states that are
less specific than a disease. Pathologic functions frequently have
systemic effects.")

(=>
   (and
      (instance ?PATH PathologicProcess)
      (experiencer ?PATH ?ORG))
   (exists (?PART ?DISEASE)
      (and
         (part ?PART ?ORG)
         (instance ?DISEASE DiseaseOrSyndrome)
         (attribute ?PART ?DISEASE))))

(subclass Injuring PathologicProcess)
(subclass Injuring Damaging)
(documentation Injuring "The process of creating a traumatic wound or
injury.  Since &%Injuring is not possible without some biologic function
of the organism being injured, it is a subclass of &%BiologicalProcess.")

(=>
    (instance ?INJ Injuring)
    (exists (?STRUCT)
        (and
            (instance ?STRUCT AnatomicalStructure)
            (patient ?INJ ?STRUCT))))

(<=>
   (instance ?INJ Injuring)
   (and
      (instance ?INJ Damaging)
      (patient ?INJ Organism)))

(subclass Poisoning Injuring)
(documentation Poisoning "A &%Poisoning is caused by an external
substance.  Since &%Poisoning is not possible without some biologic
function which affects the &%Organism being injured, it is a subclass
of &%BiologicalProcess.")

(=>
    (instance ?POISON Poisoning)
    (exists (?THING)
        (and
            (patient ?POISON ?THING)
            (or
                (instance ?THING Organism)
                (instance ?THING AnatomicalStructure)))))

(=>
    (instance ?POISON Poisoning)
    (exists (?SUBSTANCE)
        (and
		(instance ?SUBSTANCE BiologicallyActiveSubstance)
            (instrument ?POISON ?SUBSTANCE))))

(subclass IntentionalProcess Process)
(documentation IntentionalProcess "A &%Process that is
deliberately set in motion by a &%CognitiveAgent.")

(=>
   (and
      (instance ?PROC IntentionalProcess)
      (agent ?PROC ?AGENT))
   (and
      (instance ?AGENT CognitiveAgent)
      (exists (?PURP)
         (hasPurposeForAgent ?PROC ?PURP ?AGENT))))

(=>
   (instance ?PROC IntentionalProcess)
   (exists (?AGENT)
      (and
         (instance ?AGENT CognitiveAgent)
         (agent ?PROC ?AGENT))))

(subclass IntentionalPsychologicalProcess IntentionalProcess)
(subclass IntentionalPsychologicalProcess PsychologicalProcess)
(documentation IntentionalPsychologicalProcess "An &%IntentionalProcess that
can be realized entirely within the mind or brain of an &%Organism.  Thus,
for example, &%Reasoning is a subclass of &%IntentionalPsychologicalProcess,
because one can reason simply by exercising one's mind/brain.  On the other
hand, &%RecreationOrExercise is not a subclass of &%IntentionalPsychologicalProcess,
because many instances of &%RecreationOrExercise necessarily have &%subProcesses
of &%BodyMotion.")

(subclass RecreationOrExercise IntentionalProcess)
(documentation RecreationOrExercise "A &%Process that is carried out for
the purpose of recreation or exercise.")

(subclass OrganizationalProcess IntentionalProcess)
(documentation OrganizationalProcess "An &%IntentionalProcess that
is carried out within or by an &%Organization.")

(=>
   (and
      (instance ?ACT OrganizationalProcess)
      (agent ?ACT ?AGENT))
   (or
      (instance ?AGENT Organization)
      (exists (?ORG)
         (and
            (instance ?ORG Organization)
            (member ?AGENT ?ORG)))))

(subclass EducationalProcess OrganizationalProcess)
(subclass EducationalProcess Guiding)
(documentation EducationalProcess "Any &%Process which occurs in an
organizational setting and which is intended to result in &%Learning.")

(=>
   (and
      (instance ?EDUCATION EducationalProcess)
      (patient ?EDUCATION ?PERSON))
   (hasPurpose ?EDUCATION (exists (?LEARN)
                             (and
                                (instance ?LEARN Learning)
                                (patient ?LEARN ?PERSON)))))

(subclass ReligiousProcess OrganizationalProcess)
(documentation ReligiousProcess "An &%OrganizationalProcess that is
carried out within or by a &%ReligiousOrganization.")

(=>
   (and
      (instance ?ACT ReligiousProcess)
      (agent ?ACT ?AGENT))
   (or
      (instance ?AGENT ReligiousOrganization)
      (exists (?ORG)
         (and
            (member ?AGENT ?ORG)
            (instance ?ORG ReligiousOrganization)))))

(subclass JoiningAnOrganization OrganizationalProcess)
(documentation JoiningAnOrganization "The &%OrganizationalProcess of
becoming a &%member of an &%Organization.")

(=>
   (and
      (instance ?JOIN JoiningAnOrganization)
      (instance ?ORG Organization)
      (agent ?JOIN ?ORG)
      (patient ?JOIN ?PERSON))
   (holdsDuring (ImmediateFutureFn (WhenFn ?JOIN)) (member ?PERSON ?ORG)))

(subclass LeavingAnOrganization OrganizationalProcess)
(disjoint LeavingAnOrganization JoiningAnOrganization)
(documentation LeavingAnOrganization "The &%OrganizationalProcess of
leaving an &%Organization, whether voluntarily or involuntarily.")

(=>
   (and
      (instance ?LEAVE LeavingAnOrganization)
      (instance ?ORG Organization)
      (agent ?LEAVE ?ORG)
      (patient ?LEAVE ?PERSON))
   (holdsDuring (ImmediateFutureFn (WhenFn ?LEAVE)) (not (member ?PERSON ?ORG))))

(subclass Graduation LeavingAnOrganization)
(documentation Graduation "The &%OrganizationalProcess of graduating
from an &%EducationalOrganization.")

(=>
   (and
      (instance ?GRAD Graduation)
      (agent ?GRAD ?ORG)
      (patient ?GRAD ?PERSON))
   (instance ?ORG EducationalOrganization))

(subclass Matriculation JoiningAnOrganization)
(documentation Matriculation "The &%OrganizationalProcess of joining an
&%EducationalOrganization as a student.")

(=>
   (and
      (instance ?MAT Matriculation)
      (agent ?MAT ?ORG)
      (patient ?MAT ?PERSON))
   (instance ?ORG EducationalOrganization))

(subclass Hiring JoiningAnOrganization)
(documentation Hiring "&%OrganizationalProcesses where someone is made an
employee of an &%Organization.")

(=>
   (and
      (instance ?HIRE Hiring)
      (instance ?ORG Organization)
      (agent ?HIRE ?ORG)
      (patient ?HIRE ?PERSON))
   (holdsDuring (ImmediateFutureFn (WhenFn ?HIRE)) (employs ?ORG ?PERSON)))

(subclass TerminatingEmployment LeavingAnOrganization)
(documentation TerminatingEmployment "&%OrganizationalProcesses where someone
ceases to be an employee of an &%Organization.  Note that this covers being
laid off, being fired, and voluntarily leaving a job.")

(=>
   (and
      (instance ?FIRE TerminatingEmployment)
      (instance ?ORG Organization)
      (agent ?FIRE ?ORG)
      (patient ?FIRE ?PERSON))
   (holdsDuring (ImmediateFutureFn (WhenFn ?FIRE)) (not (employs ?ORG ?PERSON))))

(subclass PoliticalProcess OrganizationalProcess)
(documentation PoliticalProcess "An &%OrganizationalProcess carried
out by officially constituted governments or with the aim of overthrowing
or modifying such a government.")

(=>
   (instance ?PROC PoliticalProcess)
   (exists (?GOV)
      (and
         (instance ?GOV Government)
         (or
            (agent ?PROC ?GOV)
            (patient ?PROC ?GOV)))))

(subclass MilitaryProcess PoliticalProcess)
(documentation MilitaryProcess "Any &%Process that is carried out by a
military organization.  Note that this class covers &%Processes, e.g.
military operations, that are the result of careful planning, as well as
those which are unscripted.")

(subclass RegulatoryProcess OrganizationalProcess)
(documentation RegulatoryProcess "an &%OrganizationalProcess whose aim is
the enforcement of rules or regulations.")

(subclass Managing OrganizationalProcess)
(subclass Managing Guiding)
(documentation Managing "&%OrganizationalProcesses that involve overseeing
the activities of others.")

(subclass Planning IntentionalPsychologicalProcess)
(documentation Planning "Specifying a set of actions in order to meet a
set of goals or objectives.")

(subclass QuantityChange InternalChange)
(partition QuantityChange Increasing Decreasing)
(documentation QuantityChange "Any &%InternalChange where a &%PhysicalQuantity
associated with the &%patient is altered.")

(subclass Increasing QuantityChange)
(relatedInternalConcept Increasing Putting)
(documentation Increasing "Any &%QuantityChange where the &%PhysicalQuantity
is increased.")

(=>
   (and
      (instance ?INCREASE Increasing)
      (patient ?INCREASE ?OBJ))
   (exists (?UNIT ?QUANT1 ?QUANT2)
   	(and
         (holdsDuring (ImmediatePastFn (WhenFn ?INCREASE)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT1))
	   (holdsDuring (ImmediateFutureFn (WhenFn ?INCREASE)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT2))
	   (greaterThan ?QUANT2 ?QUANT1))))

(subclass Heating Increasing)
(disjoint Heating Cooling)
(documentation Heating "Any &%Increasing &%Process where the &%PhysicalQuantity
increased is a &%TemperatureMeasure.")

(=>
   (and
      (instance ?HEAT Heating)
      (patient ?HEAT ?OBJ))
   (exists (?UNIT ?QUANT1 ?QUANT2)
   	(and
         (instance ?UNIT TemperatureMeasure)
         (holdsDuring (ImmediatePastFn (WhenFn ?HEAT)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT1))
	   (holdsDuring (ImmediateFutureFn (WhenFn ?HEAT)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT2))
	   (greaterThan ?QUANT2 ?QUANT1))))

(subclass Decreasing QuantityChange)
(relatedInternalConcept Decreasing Removing)
(documentation Decreasing "Any &%QuantityChange where the &%PhysicalQuantity
is decreased.")

(=>
   (and
      (instance ?DECREASE Decreasing)
      (patient ?DECREASE ?OBJ))
   (exists (?UNIT ?QUANT1 ?QUANT2)
   	(and
         (holdsDuring (ImmediatePastFn (WhenFn ?DECREASE)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT1))
	   (holdsDuring (ImmediateFutureFn (WhenFn ?DECREASE)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT2))
	   (lessThan ?QUANT2 ?QUANT1))))

(subclass Cooling Decreasing)
(documentation Cooling "Any &%Decreasing &%Process where the &%PhysicalQuantity
decreased is a &%TemperatureMeasure.")

(=>
   (and
      (instance ?COOL Cooling)
      (patient ?COOL ?OBJ))
   (exists (?UNIT ?QUANT1 ?QUANT2)
   	(and
         (instance ?UNIT TemperatureMeasure)
         (holdsDuring (ImmediatePastFn (WhenFn ?COOL)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT1))
	   (holdsDuring (ImmediateFutureFn (WhenFn ?COOL)) (equal (MeasureFn ?OBJ ?UNIT) ?QUANT2))
	   (lessThan ?QUANT2 ?QUANT1))))

(subclass Motion Process)
(documentation Motion "Any &%Process of movement.")

(=>
   (and
      (instance ?MOTION Motion)
      (patient ?MOTION ?OBJ)
      (origin ?MOTION ?PLACE))
   (holdsDuring (ImmediatePastFn (WhenFn ?MOTION)) (located ?OBJ ?PLACE)))

(=>
   (and
      (instance ?MOTION Motion)
      (patient ?MOTION ?OBJ)
      (destination ?MOTION ?PLACE))
   (holdsDuring (ImmediateFutureFn (WhenFn ?MOTION)) (located ?OBJ ?PLACE)))

(instance path CaseRole)
(domain path 1 Motion)
(domain path 2 Region)
(documentation path "(&%path ?MOTION ?PATH) means that ?PATH is a route
along which ?MOTION occurs.  For example, Highway 101 is the path in the
following proposition:  the car drove up Highway 101.")

(=>
   (and
      (path ?PROCESS ?PATH1)
      (origin ?PROCESS ?SOURCE)
      (destination ?PROCESS ?DEST)
      (length ?PATH1 ?MEASURE1)
      (not
         (exists (?PATH2 ?MEASURE2)
            (and
               (path ?PROCESS ?PATH2)
               (origin ?PROCESS ?ORIGIN)
               (destination ?PROCESS ?DEST)
               (length ?PATH2 ?MEASURE2)
               (lessThan ?MEASURE2 ?MEASURE1)))))
   (forall (?OBJ)
      (=>
         (part ?OBJ ?PATH1)
         (between ?SOURCE ?OBJ ?DEST))))

(subclass BodyMotion Motion)
(documentation BodyMotion "Any &%Motion where the &%agent is an &%Organism
and the &%patient is a &%BodyPart.")

(=>
   (instance ?MOTION BodyMotion)
   (exists (?OBJ ?AGENT)
      (and
         (instance ?OBJ BodyPart)
         (patient ?MOTION ?OBJ)
         (instance ?AGENT Organism)
         (agent ?MOTION ?AGENT))))

(subclass Walking BodyMotion)
(documentation Walking "Any &%BodyMotion which is accomplished by
means of the legs of an &%Organism on land for the purpose of moving
from one point to another.")

(=>
   (and
      (instance ?WALK Walking)
      (agent ?WALK ?AGENT))
   (exists (?AREA)
      (and
         (instance ?AREA LandArea)
         (located ?AGENT ?AREA))))

(subclass Swimming BodyMotion)
(documentation Swimming "Any deliberate and controlled &%BodyMotion
through water that is accomplished by an &%Organism.")

(=>
   (and
      (instance ?SWIM Swimming)
      (agent ?SWIM ?AGENT))
   (exists (?AREA)
      (and
         (instance ?AREA WaterArea)
         (located ?AGENT ?AREA))))

(subclass Dancing BodyMotion)
(documentation Dancing "Any &%BodyMotion of &%Humans which is
deliberately coordinated with music.")

(subclass DirectionChange Motion)
(documentation DirectionChange "The act of changing the direction in
which the &%patient of the act is oriented.")

(=>
   (instance ?PROC DirectionChange)
   (exists (?ATTR)
      (and
         (instance ?ATTR DirectionalAttribute)
         (or
            (and
               (holdsDuring (ImmediatePastFn (WhenFn ?PROC)) (manner ?PROC ?ATTR))
               (holdsDuring (ImmediateFutureFn (WhenFn ?PROC)) (not (manner ?PROC ?ATTR))))
            (and
               (holdsDuring (ImmediateFutureFn (WhenFn ?PROC)) (manner ?PROC ?ATTR))
               (holdsDuring (ImmediatePastFn (WhenFn ?PROC)) (not (manner ?PROC ?ATTR))))))))

(subclass Transfer Motion)
(documentation Transfer "Any &%instance of &%Motion where the &%agent
of the &%Motion and the &%patient of the &%Motion are not the same
thing.")

(=>
   (and
      (instance ?TRANSFER Transfer)
      (agent ?TRANSFER ?AGENT)
      (patient ?TRANSFER ?PATIENT))
   (not
      (equal ?AGENT ?PATIENT)))

(subclass Removing Transfer)
(documentation Removing "The &%Class of &%Processes where something is
taken away from a location.  Note that the thing removed and the location
are specified with the &%CaseRoles &%patient and &%origin, respectively.")

(=>
   (and
      (instance ?REMOVE Removing)
      (origin ?REMOVE ?PLACE)
      (patient ?REMOVE ?OBJ))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?REMOVE)) (located ?OBJ ?PLACE))
      (holdsDuring (ImmediateFutureFn (WhenFn ?REMOVE)) (not (located ?OBJ ?PLACE)))))

(subclass Uncovering Removing)
(disjoint Uncovering Covering)
(documentation Uncovering "The &%Class of &%Removing processes where the &%agent
uncovers the &%patient, either completely or only partially.")

(subclass Putting Transfer)
(documentation Putting "The &%Class of &%Processes where something is put
in a location.  Note that the location is specified with the &%CaseRole
&%destination.")

(=>
   (and
      (instance ?PUT Putting)
      (destination ?PUT ?PLACE)
      (patient ?PUT ?OBJ))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?PUT)) (not (located ?OBJ ?PLACE)))
      (holdsDuring (ImmediateFutureFn (WhenFn ?PUT)) (located ?OBJ ?PLACE))))

(subclass Covering Putting)
(documentation Covering "The &%Class of &%Putting processes where the &%agent
covers the &%patient, either completely or only partially, with something
else.")

(subclass Substituting Transfer)
(subclass Substituting DualObjectProcess)
(documentation Substituting "The &%Class of &%Transfers where one thing is
replaced with something else.")

(=>
   (instance ?SUB Substituting)
   (exists (?PUT ?REMOVE ?OBJ1 ?OBJ2 ?PLACE)
      (and
         (instance ?PUT Putting)
         (instance ?REMOVE Removing)
         (subProcess ?PUT ?SUB)
         (subProcess ?REMOVE ?SUB)
         (patient ?REMOVE ?OBJ1)
         (origin ?REMOVE ?PLACE)
         (patient ?PUT ?OBJ2)
         (destination ?PUT ?PLACE)
         (not (equal ?OBJ1 ?OBJ2)))))

(subclass Impelling Transfer)
(documentation Impelling "The &%subclass of &%Transfer where the &%patient
travels through space by means of a sudden, forceful event.  Some examples
would be shooting, throwing, tossing, etc.")

(subclass Shooting Impelling)
(documentation Shooting "The &%subclass of &%Impelling where the &%patient
is a projectile that is fired through the air by means of some sort of
&%Device.")

(subclass Touching Transfer)
(documentation Touching "Any &%Transfer where two &%Objects are
brought into immediate physical contact with one another.")

(=>
   (and
      (instance ?TOUCH Touching)
      (agent ?TOUCH ?OBJ1)
      (patient ?TOUCH ?OBJ2))
   (holdsDuring (ImmediateFutureFn (WhenFn ?TOUCH)) (connected ?OBJ1 ?OBJ2)))

(subclass Impacting Touching)
(documentation Impacting "Any &%Touching where something comes into
sudden, forceful, physical contact with something else.  Some examples
would be striking, knocking, whipping etc.")

(=>
   (and
      (instance ?IMPACT Impacting)
      (patient ?IMPACT ?OBJ))
   (exists (?IMPEL)
      (and
         (instance ?IMPEL Impelling)
         (patient ?IMPEL ?OBJ)
         (earlier (WhenFn ?IMPEL) (WhenFn ?IMPACT)))))

(subclass Transportation Motion)
(relatedInternalConcept Transportation TransportationDevice)
(documentation Transportation "&%Motion from one point to another by means
of a &%TransportationDevice.")

(=>
   (instance ?TRANS Transportation)
   (exists (?DEVICE)
         (and
            (instance ?DEVICE TransportationDevice)
            (instrument ?TRANS ?DEVICE))))

(subclass Guiding IntentionalProcess)
(documentation Guiding "Any &%IntentionalProcess where the &%agent tries to
direct the movements of another &%Object, whether an &%Agent or not.")

(subclass Steering Guiding)
(documentation Steering "Controlling the direction and/or speed of a
&%TransportationDevice.  This includes navigating a ship, driving a car
or truck, operating a train, etc.")

(=>
   (instance ?STEER Steering)
   (exists (?VEHICLE)
      (and
         (instance ?VEHICLE TransportationDevice)
         (patient ?STEER ?VEHICLE))))

(subclass ChangeOfPossession SocialInteraction)
(relatedInternalConcept ChangeOfPossession possesses)
(documentation ChangeOfPossession "The &%Class of &%Processes where
ownership of something is transferred from one &%Agent to another.")

(=>
   (and
      (instance ?CHANGE ChangeOfPossession)
      (patient ?CHANGE ?OBJ)
      (holdsDuring (ImmediatePastFn (WhenFn ?CHANGE)) (possesses ?AGENT1 ?OBJ))
      (holdsDuring (ImmediateFutureFn (WhenFn ?CHANGE)) (possesses ?AGENT2 ?OBJ)))
   (not
      (equal ?AGENT1 ?AGENT2)))

(subclass Giving ChangeOfPossession)
(documentation Giving "The &%subclass of &%ChangeOfPossession where the
&%agent gives the &%destination something.")

(=>
   (and
      (instance ?GIVE Giving)
      (agent ?GIVE ?AGENT1)
      (destination ?GIVE ?AGENT2)
      (instance ?AGENT2 Agent)
      (patient ?GIVE ?OBJ))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?GIVE)) (possesses ?AGENT1 ?OBJ))
      (holdsDuring (ImmediateFutureFn (WhenFn ?GIVE)) (possesses ?AGENT2 ?OBJ))))

(=>
   (and
      (instance ?GIVE Giving)
      (agent ?GIVE ?AGENT1)
      (destination ?GIVE ?AGENT2)
      (instance ?AGENT2 Agent)
      (patient ?GIVE ?OBJ))
   (exists (?GET)
      (and
         (instance ?GET Getting)
         (agent ?GET ?AGENT2)
         (origin ?GET ?AGENT1)
         (patient ?GET ?OBJ))))

(subclass UnilateralGiving Giving)
(documentation UnilateralGiving "Any instance of &%Giving that is not part
of a &%Transaction.  In other words, any instance of &%Giving where nothing
is received in return.  Some examples of &%UnilateralGiving are:  honorary
awards, gifts, and financial grants.")

(=>
   (instance ?GIVE UnilateralGiving)
   (not
      (exists (?TRANS)
         (and
            (instance ?TRANS Transaction)
            (subProcess ?GIVE ?TRANS)))))

(subclass Lending Giving)
(documentation Lending "The &%subclass of &%Giving &%Processes where
the &%agent gives the &%destination something for a limited period of
time with the expectation that it will be returned later (perhaps with
interest).")

(<=>
   (and
      (instance ?BORROW Borrowing)
      (agent ?BORROW ?AGENT1)
      (origin ?BORROW ?AGENT2)
      (patient ?BORROW ?OBJECT))
   (and
      (instance ?LEND Lending)
      (agent ?LEND ?AGENT2)
      (destination ?LEND ?AGENT1)
      (patient ?LEND ?OBJECT)))

(subclass Getting ChangeOfPossession)
(documentation Getting "The &%subclass of &%ChangeOfPossession where the
&%agent gets something.  Note that the source from which something is
obtained is specified with the &%origin &%CaseRole.")

(subclass UnilateralGetting Getting)
(relatedInternalConcept UnilateralGetting UnilateralGiving)
(documentation UnilateralGetting "Any instance of &%Getting that is not part
of a &%Transaction.  In other words, any instance of &%Getting where nothing
is given in return.  Some examples of &%UnilateralGetting are:  appropriating,
commandeering, stealing, etc.")

(=>
   (instance ?GET UnilateralGetting)
   (not
      (exists (?TRANS)
         (and
            (instance ?TRANS Transaction)
            (subProcess ?GET ?TRANS)))))

(subclass Borrowing Getting)
(documentation Borrowing "The &%subclass of &%Getting &%Processes where
the &%agent gets something for a limited period of time with the expectation
that it will be returned later (perhaps with interest).")

(subclass Transaction ChangeOfPossession)
(subclass Transaction DualObjectProcess)
(documentation Transaction "The &%subclass of &%ChangeOfPossession where
something is exchanged for something else.")

(=>
   (instance ?TRANS Transaction)
   (exists (?AGENT1 ?AGENT2 ?GIVE1 ?GIVE2 ?OBJ1 ?OBJ2)
      (and
         (instance ?GIVE1 Giving)
         (instance ?GIVE2 Giving)
	   (subProcess ?GIVE1 ?TRANS)
   	   (subProcess ?GIVE2 ?TRANS)
         (agent ?GIVE1 ?AGENT1)
         (agent ?GIVE2 ?AGENT2)
         (patient ?GIVE1 ?OBJ1)
         (patient ?GIVE2 ?OBJ2)
         (destination ?GIVE1 ?AGENT2)
         (destination ?GIVE2 ?AGENT1)
         (not
            (equal ?AGENT1 ?AGENT2))
         (not
            (equal ?OBJ1 ?OBJ2)))))

(subclass FinancialTransaction Transaction)
(documentation FinancialTransaction "A &%Transaction where an instance
of &%CurrencyMeasure is exchanged for something else.")

(=>
   (instance ?TRANS FinancialTransaction)
   (exists (?OBJ)
      (and
         (patient ?TRANS ?OBJ)
         (instance ?OBJ Currency))))

(subclass Betting FinancialTransaction)
(documentation Betting "A &%FinancialTransaction where an instance of
&%CurrencyMeasure is exchanged for the possibility of winning a larger
instance of &%CurrencyMeasure within the context of some sort of
&%Game.")

(subclass Buying FinancialTransaction)
(relatedInternalConcept Buying Selling)
(documentation Buying "A &%FinancialTransaction in which an instance of
&%CurrencyMeasure is exchanged for an instance of &%Physical.")

(subclass Selling FinancialTransaction)
(documentation Selling "A &%FinancialTransaction in which an instance of
&%Physical is exchanged for an instance of &%CurrencyMeasure.")

(<=>
   (and
      (instance ?BUY Buying)
      (agent ?BUY ?AGENT1)
      (origin ?BUY ?AGENT2)
      (patient ?BUY ?OBJECT))
   (and
      (instance ?SELL Selling)
      (agent ?SELL ?AGENT2)
      (destination ?SELL ?AGENT1)
      (patient ?SELL ?OBJECT)))

(subclass Learning IntentionalPsychologicalProcess)
(documentation Learning "The &%Class of &%Processes which relate to the
acquisition of information.")

(=>
   (and
      (instance ?LEARN Learning)
      (agent ?LEARN ?AGENT))
   (instance ?AGENT CognitiveAgent))

(=>
   (holdsDuring ?TIME
      (exists (?LEARN)
         (and
            (instance ?LEARN Learning)
            (agent ?LEARN ?AGENT)
            (patient ?LEARN ?PROP))))
   (holdsDuring (ImmediateFutureFn ?TIME)
      (believes ?AGENT ?PROP)))

(subclass Classifying IntentionalPsychologicalProcess)
(documentation Classifying "The &%Class of &%IntentionalPsychologicalProcesses
which involve attaching a name or category to a thing or set of things.
Note that &%Classifying is distinguished from &%Learning by the fact
that the latter covers the acquisition by a &%CognitiveAgent of any
&%Proposition, while the former involves the assignment of a label
or category.")

(subclass Reasoning IntentionalPsychologicalProcess)
(documentation Reasoning "The &%Class of &%IntentionalPsychologicalProcesses
which involve concluding, on the basis of either deductive or inductive
evidence, that a particular &%Proposition or &%Sentence is true.")

(=>
   (instance ?AGENT CognitiveAgent)
   (capability Reasoning agent ?AGENT))

(subclass Selecting IntentionalPsychologicalProcess)
(documentation Selecting "The &%Class of &%IntentionalPsychologicalProcesses
which involve opting for one or more &%Entity out of a larger set of &%Entities.")

(subclass Comparing IntentionalPsychologicalProcess)
(subclass Comparing DualObjectProcess)
(documentation Comparing "The &%Class of &%IntentionalPsychologicalProcesses
which involve comparing, relating, contrasting, etc. the properties of
two or more &%Entities.")

(subclass Calculating IntentionalPsychologicalProcess)
(documentation Calculating "&%IntentionalPsychologicalProcesses which involve
the consideration and/or manipulation of instances of &%Quantity.")

(subclass Measuring Calculating)
(documentation Measuring "The &%Class of &%Calculating &%Processes where
the aim is to determine the &%PhysicalQuantity of some aspect of the &%patient.")

(=>
   (and
      (instance ?MEAS Measuring)
      (agent ?MEAS ?AGENT)
      (patient ?MEAS ?OBJ))
   (exists (?QUANT ?UNIT)
      (holdsDuring (ImmediateFutureFn (WhenFn ?MEAS))
         (knows ?AGENT (measure ?OBJ (MeasureFn ?QUANT ?UNIT))))))

(subclass Counting Calculating)
(documentation Counting "Enumerating something.  The &%Class of &%Calculating
&%Processes where the aim is to determine the &%Number corresponding to the
&%patient.")

(=>
   (and
      (instance ?COUNT Counting)
      (agent ?COUNT ?AGENT)
      (patient ?COUNT ?ENTITY))
   (exists (?NUMBER)
      (knows ?AGENT (equal (CardinalityFn ?ENTITY) ?NUMBER))))

(subclass Predicting IntentionalPsychologicalProcess)
(documentation Predicting "The &%Class of &%IntentionalPsychologicalProcesses
which involve the formulation of a &%Proposition about a state of affairs
which might be realized in the future.")

(=>
   (and
      (instance ?PREDICT Predicting)
      (patient ?PREDICT ?FORMULA))
   (exists (?TIME)
      (and
         (holdsDuring ?TIME ?FORMULA)
         (or
            (before ?TIME (WhenFn ?PREDICT))
            (earlier ?TIME (WhenFn ?PREDICT))))))

(subclass Remembering PsychologicalProcess)
(documentation Remembering "The &%Class of &%PsychologicalProcesses which
involve the recollection of prior experiences and/or of knowledge
which was previously acquired.")

(=>
   (and
      (instance ?REMEMBER Remembering)
      (patient ?REMEMBER ?FORMULA))
   (exists (?TIME)
      (and
         (holdsDuring ?TIME ?FORMULA)
         (or
            (before ?TIME (WhenFn ?REMEMBER))
            (earlier ?TIME (WhenFn ?REMEMBER))))))

(subclass Keeping IntentionalProcess)
(documentation Keeping "The &%Class of &%Processes where the &%agent
keeps something in a particular location for an extended period of time.")

(=>
   (and
      (instance ?KEEP Keeping)
      (agent ?KEEP ?AGENT)
      (patient ?KEEP ?OBJ))
   (exists (?PUT)
      (and
         (instance ?PUT Putting)
         (agent ?PUT ?AGENT)
         (patient ?PUT ?OBJ)
         (earlier (WhenFn ?PUT) (WhenFn ?KEEP)))))

(=>
   (and
      (instance ?KEEP Keeping)
      (patient ?KEEP ?OBJ))
   (exists (?PLACE)
      (forall (?TIME)
         (=>
            (temporalPart ?TIME (WhenFn ?KEEP))
            (holdsDuring ?TIME (located ?OBJ ?PLACE))))))

(subclass Confining Keeping)
(documentation Confining "The &%Class of &%Keeping &%Processes where the
&%patient is &%Human and is kept against his/her will.  This covers
imprisonment, being jailed, held in custody, etc.")

(=>
   (instance ?CONFINE Confining)
   (exists (?HUMAN)
      (and
         (instance ?HUMAN Human)
         (patient ?CONFINE ?HUMAN))))

(=>
   (and
      (instance ?CONFINE Confining)
      (patient ?CONFINE ?PERSON))
   (not (desires ?PERSON (patient ?CONFINE ?PERSON))))

(subclass Maintaining IntentionalProcess)
(documentation Maintaining "The &%Class of &%Processes where the &%agent
cares for or maintains the &%Object.")

(subclass Repairing IntentionalProcess)
(relatedInternalConcept Repairing Maintaining)
(documentation Repairing "The &%Class of &%Processes where the &%agent
makes a modification or series of modifications to an &%Object that is not
functioning as intended so that it works properly.")

(=>
   (and
      (instance ?REPAIR Repairing)
      (patient ?REPAIR ?OBJ))
   (exists (?DAMAGE)
      (and
         (instance ?DAMAGE Damaging)
         (patient ?DAMAGE ?OBJ)
         (earlier (WhenFn ?DAMAGE) (WhenFn ?REPAIR)))))

(subclass TherapeuticProcess Repairing)
(documentation TherapeuticProcess "A &%Process that is carried out
for the purpose of curing, improving or reducing the pain associated
with a &%DiseaseOrSyndrome.")

(=>
   (and
      (instance ?PROC TherapeuticProcess)
      (patient ?PROC ?BIO))
   (or
      (instance ?BIO Organism)
      (exists (?ORG)
         (and
            (instance ?ORG Organism)
            (part ?BIO ?ORG)))))

(subclass Surgery TherapeuticProcess)
(documentation Surgery "Any &%TherapeuticProcess that involves making an
incision in the &%Animal that is the &%patient of the &%TherapeuticProcess.")

(=>
   (and
      (instance ?ACT Surgery)
      (patient ?ACT ?ANIMAL))
   (exists (?SUBACT)
      (and
         (instance ?SUBACT Cutting)
         (instance ?ANIMAL Animal)
         (patient ?ANIMAL ?CUTTING)
         (subProcess ?SUBACT ?ACT))))

(subclass Damaging InternalChange)
(disjoint Damaging Repairing)
(documentation Damaging "The &%Class of &%Processes where the &%agent
brings about a situation where the &%patient no longer functions normally
or as intended.")

(subclass Destruction Damaging)
(documentation Destruction "The &%subclass of &%Damagings in which
the &%patient (or an essential element of the &%patient) is destroyed.
Note that the difference between this concept and its superclass is solely
one of extent.")

(<=>
   (instance ?PROCESS Destruction)
   (exists (?PATIENT)
      (and
         (patient ?PROCESS ?PATIENT)
         (time ?PATIENT (ImmediatePastFn(WhenFn ?PROCESS)))
         (not
            (time ?PATIENT (ImmediateFutureFn (WhenFn ?PROCESS)))))))

(subclass Killing Destruction)
(documentation Killing "The &%subclass of &%Destruction in which the
death of an &%Organism is caused by an &%Organism.  Note that in cases
of suicide the &%Organism would be the same in both cases.")

(=>
   (and
      (instance ?KILL Killing)
      (agent ?KILL ?AGENT)
      (patient ?KILL ?PATIENT))
   (and
      (instance ?AGENT Organism)
      (instance ?PATIENT Organism)))

(=>
   (and
      (instance ?KILL Killing)
      (patient ?KILL ?PATIENT))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?KILL)) (attribute ?PATIENT Living))
      (holdsDuring (FutureFn (WhenFn ?KILL)) (attribute ?PATIENT Dead))))

(subclass Poking IntentionalProcess)
(documentation Poking "The &%Class of &%Processes where the &%agent
pierces the surface of the &%Object with an &%instrument.")

(=>
   (and
      (instance ?POKE Poking)
      (agent ?POKE ?AGENT)
      (patient ?POKE ?OBJ)
      (instrument ?POKE ?INST))
   (holdsDuring (WhenFn ?POKE) (connects ?INST ?AGENT ?OBJ)))

(subclass Cutting Poking)
(documentation Cutting "The &%subclass of &%Poking &%Processes which
involve a sharp &%instrument.")

(subclass Attaching DualObjectProcess)
(disjoint Attaching Detaching)
(relatedInternalConcept Attaching Putting)
(documentation Attaching "A &%Process where one &%Object becomes attached
to another &%Object.  Note that this differs from &%Putting in that two
things which are attached may already be in the same location.")

(=>
   (and
      (instance ?ATTACH Attaching)
      (patient ?ATTACH ?OBJ1)
      (patient ?ATTACH ?OBJ2))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?ATTACH)) (not (connected ?OBJ1 ?OBJ2)))
      (holdsDuring (ImmediateFutureFn (WhenFn ?ATTACH)) (connected ?OBJ1 ?OBJ2))))

(subclass Detaching DualObjectProcess)
(documentation Detaching "A &%Process where the &%agent detaches one thing
from something else.  Note that this is different from &%Removing in that
neither of the two things which are detached may be removed from the location
where it was attached.")

 (=>
   (and
      (instance ?DETACH Detaching)
      (patient ?DETACH ?OBJ1)
      (patient ?DETACH ?OBJ2))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?DETACH)) (connected ?OBJ1 ?OBJ2))
      (holdsDuring (ImmediateFutureFn (WhenFn ?DETACH)) (not (connected ?OBJ1 ?OBJ2)))))

(subclass Combining DualObjectProcess)
(documentation Combining "A &%Process where two or more things are combined
into a single thing.")

(<=>
   (and
      (instance ?COMBINE Combining)
      (resource ?COMBINE ?OBJ1)
      (result ?COMBINE ?OBJ2))
   (and
      (holdsDuring (ImmediatePastFn (WhenFn ?COMBINE)) (not (part ?OBJ1 ?OBJ2)))
      (holdsDuring (ImmediateFutureFn (WhenFn ?COMBINE)) (part ?OBJ1 ?OBJ2))))

(subclass Separating DualObjectProcess)
(disjoint Separating Combining)
(documentation Separating "A &%Process where something is disassembled
into (some of) its parts.")

(subclass ChemicalProcess InternalChange)
(documentation ChemicalProcess "A &%ChemicalProcess occurs whenever
chemical compounds (&%CompoundSubstances) are formed or decomposed.
For example, reactants disappear as chemical change occurs, and products
appear as chemical change occurs.  In a chemical change a chemical
reaction takes place.  Catalysts in a &%ChemicalProcess may speed up the
reaction, but aren't themselves produced or consumed.  Examples: rusting of
iron and the decomposition of water, induced by an electric current, to
gaseous hydrogen and gaseous oxygen.")

(=>
   (and
      (instance ?PROC ChemicalProcess)
      (or
         (resource ?PROC ?STUFF)
         (result ?PROC ?STUFF)))
   (instance ?STUFF PureSubstance))

(subclass ChemicalSynthesis ChemicalProcess)
(subclass ChemicalSynthesis Combining)
(documentation ChemicalSynthesis "The &%Class of &%ChemicalProcesses in
which a &%CompoundSubstance is formed from simpler reactants.")

(=>
   (and
      (resource ?PROC ?SUBSTANCE1)
      (result ?PROC ?SUBSTANCE2)
      (instance ?SUBSTANCE1 ElementalSubstance)
      (instance ?SUBSTANCE2 CompoundSubstance))
   (instance ?PROC ChemicalSynthesis))

(<=>
   (instance ?COMPOUND CompoundSubstance)
   (exists (?ELEMENT1 ?ELEMENT2 ?PROCESS)
      (and
         (instance ?ELEMENT1 ElementalSubstance)
         (instance ?ELEMENT2 ElementalSubstance)
         (not (equal ?ELEMENT1 ?ELEMENT2))
 	   (instance ?PROCESS ChemicalSynthesis)
         (resource ?PROCESS ?ELEMENT1)
         (resource ?PROCESS ?ELEMENT2)
         (result ?PROCESS ?COMPOUND))))

(subclass ChemicalDecomposition ChemicalProcess)
(subclass ChemicalDecomposition Separating)
(documentation ChemicalDecomposition "The &%Class of &%ChemicalProcesses
in which a &%CompoundSubstance breaks down into simpler products.")

(=>
   (and
      (resource ?PROC ?SUBSTANCE1)
      (result ?PROC ?SUBSTANCE2)
      (instance ?SUBSTANCE1 CompoundSubstance)
      (instance ?SUBSTANCE2 ElementalSubstance))
   (instance ?PROC ChemicalDecomposition))

(subclass Combustion ChemicalDecomposition)
(documentation Combustion "The &%Class of &%ChemicalProcesses in which an &%Object
reacts with oxygen and gives off heat.  This includes all &%Processes in which
something is burning.")

(=>
   (instance ?COMBUSTION Combustion)
   (exists (?HEAT ?LIGHT)
      (and
         (instance ?HEAT Heating)
         (instance ?LIGHT RadiatingLight)
         (subProcess ?HEAT ?COMBUSTION)
         (subProcess ?LIGHT ?COMBUSTION))))

(subclass InternalChange Process)
(documentation InternalChange "&%Processes which involve altering an internal
property of an &%Object, e.g. the shape of the &%Object, its coloring, its
structure, etc.  &%Processes that are not instances of this class include
changes that only affect the relationship to other objects, e.g. changes in
spatial or temporal location.")

(=>
   (and
      (instance ?CHANGE InternalChange)
      (patient ?CHANGE ?OBJ))
   (exists (?PROPERTY)
      (or
         (and
            (holdsDuring (ImmediatePastFn (WhenFn ?CHANGE)) (attribute ?OBJ ?PROPERTY))
            (holdsDuring (ImmediateFutureFn (WhenFn ?CHANGE)) (not (attribute ?OBJ ?PROPERTY))))
         (and
            (holdsDuring (ImmediatePastFn (WhenFn ?CHANGE)) (not (attribute ?OBJ ?PROPERTY)))
            (holdsDuring (ImmediateFutureFn (WhenFn ?CHANGE)) (attribute ?OBJ ?PROPERTY))))))

(subclass SurfaceChange InternalChange)
(documentation SurfaceChange "&%Processes which involve altering
the properties that apply to the surface of an &%Object.")

(=>
   (and
      (instance ?ALT SurfaceChange)
      (patient ?ALT ?OBJ))
   (exists (?PART ?PROPERTY)
      (and
         (superficialPart ?PART ?OBJ)
         (holdsDuring (ImmediatePastFn (WhenFn ?ALT)) (attribute ?PART ?PROPERTY))
         (holdsDuring (ImmediateFutureFn (WhenFn ?ALT)) (not (attribute ?PART ?PROPERTY))))))

(subclass ShapeChange Process)
(documentation ShapeChange "The &%Process of changing the shape of an &%Object.")

(=>
   (and
      (instance ?ALT ShapeChange)
      (patient ?ALT ?OBJ))
   (exists (?PROPERTY)
      (and
         (instance ?PROPERTY ShapeAttribute)
         (or
            (and
               (holdsDuring (ImmediatePastFn (WhenFn ?ALT)) (attribute ?OBJ ?PROPERTY))
               (holdsDuring (ImmediateFutureFn (WhenFn ?ALT)) (not (attribute ?OBJ ?PROPERTY))))
            (and
               (holdsDuring (ImmediatePastFn (WhenFn ?ALT)) (not (attribute ?OBJ ?PROPERTY)))
               (holdsDuring (ImmediateFutureFn (WhenFn ?ALT)) (attribute ?OBJ ?PROPERTY)))))))

(subclass Coloring SurfaceChange)
(documentation Coloring "The &%subclass of &%SurfaceChange where a
&%ColorAttribute of the &%patient is altered.")

(=>
   (and
      (instance ?COLORING Coloring)
      (patient ?COLORING ?OBJ))
   (exists (?PROPERTY)
      (and
         (instance ?PROPERTY ColorAttribute)
         (holdsDuring (ImmediatePastFn (WhenFn ?COLORING)) (attribute ?OBJ ?PROPERTY))
         (holdsDuring (ImmediateFutureFn (WhenFn ?COLORING)) (not (attribute ?OBJ ?PROPERTY))))))

(subclass ContentDevelopment IntentionalProcess)
(documentation ContentDevelopment "A &%subclass of &%IntentionalProcess in
which content is modified, its form is altered or it is created anew.")

(=>
   (instance ?DEVELOP ContentDevelopment)
   (exists (?OBJ)
      (and
         (instance ?OBJ ContentBearingObject)
         (patient ?DEVELOP ?OBJ))))

(subclass Reading ContentDevelopment)
(documentation Reading "A &%subclass of &%ContentDevelopment in which
content is converted from a written form into a spoken or mental representation.")

(=>
   (instance ?READ Reading)
   (exists (?TEXT ?PROP)
      (and
         (instance ?TEXT Text)
         (containsInformation ?TEXT ?PROP)
         (realization ?READ ?PROP))))

(subclass Writing ContentDevelopment)
(documentation Writing "A &%subclass of &%ContentDevelopment in which
content is converted from one form (e.g. uttered, written or represented
mentally) into a written form.  Note that this class covers both
transcription and original creation of written &%Texts.")

(subclass Encoding Writing)
(documentation Encoding "Converting a document or message into a formal
language or into a code that can be understood only by a relatively small
body of &%Agents.  Generally speaking, this hinders wide dissemination of
the content in the original document or message.")

(subclass Decoding Writing)
(disjoint Decoding Encoding)
(documentation Decoding "Converting a document or message that has previously
been encoded (see &%Encoding) into a &%Language that can be understood by a
relatively large number of speakers.")

(=>
   (and
      (instance ?DECODE Decoding)
      (patient ?DECODE ?DOC1))
   (exists (?ENCODE ?DOC2 ?TIME)
      (and
         (containsInformation ?DOC2 ?PROP)
         (containsInformation ?DOC1 ?PROP)
 	   (temporalPart ?TIME (PastFn (WhenFn ?DECODE)))
         (holdsDuring ?TIME
            (and
               (instance ?ENCODE Encoding)
               (patient ?ENCODE ?DOC2))))))

(subclass Wetting Combining)
(documentation Wetting "The &%Class of &%Processes where a &%Liquid is
added to an &%Object.")

(=>
   (and
      (instance ?WET Wetting)
      (patient ?WET ?OBJ))
   (holdsDuring (ImmediateFutureFn (WhenFn ?WET))
      (or
         (attribute ?OBJ Wet)
         (attribute ?OBJ Damp))))

(=>
   (instance ?WET Wetting)
   (exists (?OBJ)
      (and
         (attribute ?OBJ Liquid)
         (patient ?WET ?OBJ))))

(subclass Drying Separating)
(documentation Drying "The &%Class of &%Processes where a &%Liquid is removed
from an &%Object.")

(=>
   (and
      (instance ?DRY Drying)
      (patient ?DRY ?OBJ))
   (holdsDuring (ImmediateFutureFn (WhenFn ?DRY))
      (attribute ?OBJ Dry)))

(subclass Creation InternalChange)
(relatedInternalConcept Creation Destruction)
(documentation Creation "The &%subclass of &%Process in which
something is created.  Note that the thing created is specified
with the &%result &%CaseRole.")

(=>
   (instance ?ACTION Creation)
   (exists (?RESULT)
      (result ?ACTION ?RESULT)))

(<=>
   (instance ?PROCESS Creation)
   (exists (?PATIENT)
      (and
         (patient ?PROCESS ?PATIENT)
         (time ?PATIENT (ImmediateFutureFn(WhenFn ?PROCESS)))
         (not
            (time ?PATIENT (ImmediatePastFn (WhenFn ?PROCESS)))))))

(subclass Making Creation)
(subclass Making IntentionalProcess)
(documentation Making "The &%subclass of &%Creation in which an individual
&%Artifact or a type of &%Artifact is made.")

(=>
   (instance ?MAKE Making)
   (exists (?ARTIFACT)
      (and
         (instance ?ARTIFACT Artifact)
         (result ?MAKE ?ARTIFACT))))

(subclass Constructing Making)
(documentation Constructing "The &%subclass of &%Making in which a
&%StationaryArtifact is built.")

(<=>
   (exists (?BUILD)
      (and
         (instance ?BUILD Constructing)
         (result ?BUILD ?ARTIFACT)))
   (instance ?ARTIFACT StationaryArtifact))

(subclass Manufacture Making)
(documentation Manufacture "The &%Making of &%Artifacts on a mass
scale.")

(subclass Publication Manufacture)
(documentation Publication "The &%Manufacture of &%Texts.  Note that
there is no implication that the &%Texts are distributed.  Such
distribution, when it occurs, is an instance of &%Dissemination.")

(=>
   (and
      (instance ?PUB Publication)
      (patient ?PUB ?TEXT))
   (subclass ?TEXT Text))

(subclass Cooking Making)
(documentation Cooking "The &%Making of an &%instance of &%Food.")

(=>
   (instance ?COOK Cooking)
   (exists (?FOOD)
      (and
         (instance ?FOOD Food)
         (result ?COOK ?FOOD))))

(subclass Searching IntentionalProcess)
(documentation Searching "Any &%Process where the aim is to find
something, whether it be information (i.e. a &%Proposition) or an
&%Object.")

(=>
   (and
      (instance ?SEARCH Searching)
      (agent ?SEARCH ?AGENT)
      (patient ?SEARCH ?ENTITY))
   (inScopeOfInterest ?AGENT ?ENTITY))

(subclass Pursuing Searching)
(documentation Pursuing "The &%subclass of &%Searching where the thing
sought is an &%Object.  Some examples would be hunting, shopping,
trawling, and stalking.")

(=>
   (and
      (instance ?PURSUE Pursuing)
      (agent ?PURSUE ?AGENT)
      (patient ?PURSUE ?OBJ))
   (holdsDuring ?PURSUE (wants ?AGENT ?OBJ)))

(=>
   (and
      (instance ?PURSUE Pursuing)
      (agent ?PURSUE ?AGENT)
      (patient ?PURSUE ?OBJ))
   (holdsDuring ?PURSUE (not (possesses ?AGENT ?OBJ))))

(subclass Investigating Searching)
(documentation Investigating "The &%subclass of &%Searching where the
thing sought is a piece of information (i.e. a &%Proposition denoted by
a &%Formula).")

(=>
   (and
      (instance ?INVESTIGATE Investigating)
      (patient ?INVESTIGATE ?PROP))
   (instance ?PROP Formula))

(=>
   (and
      (instance ?INVESTIGATE Investigating)
      (agent ?INVESTIGATE ?AGENT)
      (patient ?INVESTIGATE ?PROP))
   (holdsDuring (WhenFn ?INVESTIGATE) (not (knows ?AGENT ?PROP))))

(subclass DiagnosticProcess Investigating)
(documentation DiagnosticProcess "A &%Process that is carried out for
the purpose of determining the nature of a &%DiseaseOrSyndrome.")

(=>
   (and
      (instance ?PROC DiagnosticProcess)
      (agent ?PROC ?AGENT))
   (exists (?CAUSE)
      (hasPurposeForAgent ?PROC (knows ?AGENT (causes ?CAUSE ?PROC)) ?AGENT)))

(subclass SocialInteraction IntentionalProcess)
(documentation SocialInteraction "The &%subclass of
&%IntentionalProcess that involves interactions between
&%CognitiveAgents.")

(=>
   (instance ?INTERACTION SocialInteraction)
   (exists (?AGENT1 ?AGENT2)
      (and
         (agent ?INTERACTION ?AGENT1)
         (agent ?INTERACTION ?AGENT2)
         (not
            (equal ?AGENT1 ?AGENT2)))))

(subclass Pretending SocialInteraction)
(documentation Pretending "Any &%SocialInteraction where a
&%CognitiveAgent or &%Group of &%CognitiveAgents attempts to make
another &%CognitiveAgent or &%Group of &%CognitiveAgents believe
something that is false.  This covers deceit, affectation,
impersonation, and entertainment productions, to give just a few
examples.")

(=>
   (instance ?PRETEND Pretending)
   (exists (?PERSON ?PROP)
      (and
         (hasPurpose ?PRETEND (believes ?PERSON ?PROP))
         (true ?PROP True))))

(subclass Communication SocialInteraction)
(relatedInternalConcept Communication ContentDevelopment)
(documentation Communication "A &%SocialInteraction that involves
the transfer of information between two or more &%CognitiveAgents
via a &%ContentBearingObject.  Note that &%Communication is closely
related to, but essentially different from, &%ContentDevelopment.
The latter involves the creation or modification of a &%ContentBearingObject,
while &%Communication is the transfer of such an object for the purpose
of conveying a message.")

(=>
   (instance ?COMMUNICATE Communication)
   (exists (?OBJ ?AGENT1 ?AGENT2)
      (and
         (instance ?OBJ ContentBearingObject)
         (patient ?COMMUNICATE ?OBJ)
         (instance ?AGENT1 CognitiveAgent)
         (agent ?COMMUNICATE ?AGENT1)
         (instance ?AGENT2 CognitiveAgent)
         (destination ?COMMUNICATE ?AGENT2))))

(subclass Disseminating Communication)
(documentation Disseminating "Any &%Communication that involves a
single &%agent and many &%destinations.  This covers the release
of a published book, broadcasting, a theatrical performance, giving
orders to assembled troops, delivering a public lecture, etc.")

(=>
   (instance ?DISSEMINATE Disseminating)
   (exists (?AGENT1 ?AGENT2)
      (and
         (destination ?DISSEMINATE ?AGENT1)
         (instance ?AGENT1 CognitiveAgent)
         (destination ?DISSEMINATE ?AGENT2)
         (instance ?AGENT2 CognitiveAgent)
         (not (equal ?AGENT1 ?AGENT2)))))

(subclass Advertising Disseminating)
(documentation Advertising "A &%Disseminating whose purpose is to
promote the sale of an &%Object represented in a &%Text or &%Icon
(the advertisement).")

(=>
   (instance ?ADVERT Advertising)
   (exists (?OBJ)
      (and
         (refers ?ADVERT ?OBJ)
         (hasPurpose ?ADVERT (exists (?SALE) (and (instance ?SALE Selling) (patient ?SALE ?OBJ)))))))

(subclass Stating Communication)
(documentation Stating "Instances of this &%Class commit a sender to some truth.
Example: John concluded that Peter was not present, and predicted that he would
arrive soon.")

(=>
   (and
      (instance ?STATE Stating)
      (agent ?STATE ?AGENT)
      (patient ?STATE ?FORMULA)
      (instance ?FORMULA Formula))
   (holdsDuring (WhenFn ?STATE) (believes ?AGENT ?FORMULA)))

(subclass Directing Communication)
(documentation Directing "Instances of this &%Class urge some further action
among the receivers.  Example: The 5th Battalion requested air support from
the 3rd Bomber Group.")

(subclass Ordering Directing)
(documentation Ordering "A &%Directing in which the receiver is
commanded to realize the content of a &%ContentBearingObject.  Orders
are injunctions, the disobedience of which involves sanctions, or
which express an obligation upon the part of the orderee.")

(=>
   (and
      (instance ?ORDER Ordering)
      (patient ?ORDER ?FORMULA))
   (modalAttribute ?FORMULA Obligation))

(subclass Requesting Directing)
(documentation Requesting "A request expresses a desire by the &%agent of the
request that the &%destination of the request perform some future action.")

(=>
   (and
      (instance ?REQUEST Requesting)
      (agent ?REQUEST ?AGENT)
      (patient ?REQUEST ?FORMULA)
      (instance ?FORMULA Formula))
   (desires ?AGENT ?FORMULA))

(subclass Questioning Directing)
(documentation Questioning "A request for information.")

(=>
   (and
      (instance ?QUESTION Questioning)
      (agent ?QUESTION ?AGENT)
      (patient ?QUESTION ?FORMULA)
      (instance ?FORMULA Formula))
   (holdsDuring (WhenFn ?QUESTION) (not (knows ?AGENT ?FORMULA))))

(subclass Committing Communication)
(documentation Committing "Instances of this &%Class commit the sender to some
future course. Example: Bob promised Susan that he would be home by 11pm.")

(=>
   (and
      (instance ?COMMIT Committing)
      (patient ?COMMIT ?FORMULA)
      (instance ?FORMULA Formula))
   (modalAttribute ?FORMULA Promise))

(subclass Expressing Communication)
(documentation Expressing "Instances of this &%Class express a state of the sender.
Example: Jane thanked Barbara for the present she had given her.")

(=>
   (and
      (instance ?EXPRESS Expressing)
      (agent ?EXPRESS ?AGENT))
   (exists (?STATE)
      (and
         (instance ?STATE StateOfMind)
         (attribute ?AGENT ?STATE)
         (represents ?EXPRESS ?STATE))))

(subclass Declaring Communication)
(documentation Declaring "The &%Class of &%Communications that effect an
institutional alteration when performed by competent authority.  Some
examples are nominating, marrying, and excommunicating.")

(=>
   (and
      (instance ?DECLARE Declaring)
      (agent ?DECLARE ?AGENT1))
   (exists (?PROC ?AGENT2)
      (or
         (confersRight ?PROC ?DECLARE ?AGENT2)
         (confersObligation ?PROC ?DECLARE ?AGENT2))))

(subclass Cooperation SocialInteraction)
(documentation Cooperation "The &%subclass of &%SocialInteraction where
the participants involved work together for the achievement of a common
goal.")

(=>
   (instance ?COOPERATE Cooperation)
   (exists (?PURP)
      (forall (?AGENT)
         (=>
            (agent ?COOPERATE ?AGENT)
            (hasPurposeForAgent ?COOPERATE ?PURP ?AGENT)))))

(subclass Meeting SocialInteraction)
(documentation Meeting "The coming together of two or more
&%CognitiveAgents for the purpose of &%Communication.  This covers informal
meetings, e.g. visits with family members, and formal meetings, e.g. a board
of directors meeting.")

(=>
   (and
      (instance ?MEET Meeting)
      (agent ?MEET ?AGENT1)
      (agent ?MEET ?AGENT2))
   (holdsDuring (WhenFn ?MEET) (orientation ?AGENT1 ?AGENT2 Near)))

(=>
   (instance ?MEET Meeting)
   (exists (?AGENT1 ?AGENT2)
      (and
         (agent ?MEET ?AGENT1)
         (agent ?MEET ?AGENT2)
         (hasPurpose ?MEET (exists (?COMM) (and (instance ?COMM Communication) (agent ?COMM ?AGENT1) (agent ?COMM ?AGENT2)))))))

(subclass Contest SocialInteraction)
(documentation Contest "A &%SocialInteraction where the &%agent and
&%patient are &%CognitiveAgents who are trying to defeat one another.
Note that this concept is often applied in a metaphorical sense in natural
language, when we speak, e.g., of the struggle of plants for space or
sunlight, or of bacteria for food resources in some environment.")

(=>
   (instance ?CONTEST Contest)
   (exists (?AGENT1 ?AGENT2 ?PURP1 ?PURP2)
      (and
         (agent ?CONTEST ?AGENT1)
         (agent ?CONTEST ?AGENT2)
         (hasPurposeForAgent ?CONTEST ?PURP1 ?AGENT1)
         (hasPurposeForAgent ?CONTEST ?PURP2 ?AGENT2)
         (not
            (equal ?AGENT1 ?AGENT2))
         (not
            (equal ?PURP1 ?PURP2)))))

(subclass ViolentContest Contest)
(documentation ViolentContest "A &%Contest where one participant attempts to
physically injure another participant.")

(subclass War ViolentContest)
(documentation War "A military confrontation between two or more
&%Nations or &%Organizations whose members are &%Nations.  As the
corresponding axiom specifies, a &%War is made up of &%Battles.")

(=>
   (instance ?WAR War)
   (exists (?BATTLE)
      (and
         (instance ?BATTLE Battle)
         (subProcess ?BATTLE ?WAR))))

(=>
   (and
      (instance ?WAR War)
      (agent ?WAR ?AGENT))
   (or
      (instance ?AGENT Nation)
      (and
         (instance ?AGENT Organization)
         (forall (?MEMBER)
            (=>
               (member ?MEMBER ?AGENT)
               (instance ?MEMBER Nation))))))

(subclass Battle ViolentContest)
(documentation Battle "A &%ViolentContest between two or more military
units within the context of a war.  Note that this does not cover the
metaphorical sense of 'battle', which simply means a struggle of some
sort.  This sense should be represented with the more general concept of
&%Contest.")

(=>
   (instance ?BATTLE Battle)
   (exists (?WAR)
      (and
         (instance ?WAR War)
         (subProcess ?BATTLE ?WAR))))

(=>
   (instance ?BATTLE Battle)
   (exists (?ATTACK)
      (and
         (instance ?ATTACK ViolentContest)
         (subProcess ?ATTACK ?BATTLE))))

(subclass Game Contest)
(subclass Game RecreationOrExercise)
(documentation Game "A &%Contest whose purpose is the
enjoyment/stimulation of the participants or spectators of the &%Game.")

(subclass Sport Game)
(documentation Sport "A &%Game which requires some degree of physical
exercion from the participants of the game.")

(subclass LegalAction Contest)
(documentation LegalAction "Any &%Process where a &%CognitiveAgent seeks
to obtain something from another &%CognitiveAgent through a court of law.")

(subclass Maneuver IntentionalProcess)
(documentation Maneuver "An intentional move or play within a &%Contest.
In many cases, a &%Maneuver is part of a strategy for winning the
larger &%Contest of which the &%Maneuver is a part.")

(=>
   (instance ?MOVE Maneuver)
   (exists (?CONTEST)
      (and
         (instance ?CONTEST Contest)
         (subProcess ?MOVE ?CONTEST))))

(subclass Perception PsychologicalProcess)
(documentation Perception "Sensing some aspect of the material world.
Note that the &%agent of this sensing is assumed to be an &%Animal.")

(=>
   (and
      (instance ?PERCEPT Perception)
      (agent ?PERCEPT ?AGENT))
   (instance ?AGENT Animal))

(=>
   (and
      (instance ?PERCEPT Perception)
      (agent ?PERCEPT ?AGENT)
      (patient ?PERCEPT ?OBJECT))
   (notices ?AGENT ?OBJECT))

(=>
   (instance ?AGENT SentientAgent)
   (capability Perception experiencer ?AGENT))

(subclass Seeing Perception)
(documentation Seeing "The &%subclass of &%Perception in which the
sensing is done by an ocular &%Organ.")

(=>
   (and
      (instance ?SEE Seeing)
      (agent ?SEE ?AGENT)
      (patient ?SEE ?OBJ))
   (and
      (attribute ?OBJ Illuminated)
      (exists (?PROP)
         (and
            (instance ?PROP ColorAttribute)
            (knows ?AGENT (attribute ?OBJ ?PROP))))))

(subclass Smelling Perception)
(documentation Smelling "The &%subclass of &%Perception in which the
sensing is done by an olefactory &%Organ.")

(=>
   (and
      (instance ?SMELL Smelling)
      (patient ?SMELL ?OBJ))
   (exists (?ATTR)
      (and
         (instance ?ATTR OlfactoryAttribute)
         (attribute ?OBJ ?ATTR))))

(subclass Tasting Perception)
(documentation Tasting "The &%subclass of &%Perception in which the
sensing is done by of an &%Organ which can discriminate various tastes.")

(=>
   (and
      (instance ?TASTE Tasting)
      (patient ?TASTE ?OBJ))
   (exists (?ATTR)
      (and
         (instance ?ATTR TasteAttribute)
         (attribute ?OBJ ?ATTR))))

(subclass Hearing Perception)
(documentation Hearing "The &%subclass of &%Perception in which the
sensing is done by an auditory &%Organ.")

(=>
   (and
      (instance ?HEAR Hearing)
      (patient ?HEAR ?OBJ))
   (exists (?ATTR)
      (and
         (instance ?ATTR SoundAttribute)
         (attribute ?OBJ ?ATTR))))

(subclass TactilePerception Perception)
(documentation TactilePerception "The &%subclass of &%Perception in which
the sensing is done by &%Touching.  Note that &%Touching need not involve
&%TactilePerception.  For example, a person who has lost all sensation in
both of his legs would have no &%TactilePerception of anything his legs
were &%Touching.")

(=>
   (instance ?TACTILE TactilePerception)
   (exists (?TOUCH)
      (and
         (instance ?TOUCH Touching)
         (subProcess ?TOUCH ?TACTILE))))

(subclass Radiating Motion)
(documentation Radiating "Processes in which some form of radiation,
e.g. radio waves, light waves, electrical energy, etc., is given off
or absorbed by something else.")

(subclass RadiatingLight Radiating)
(documentation RadiatingLight "The &%subclass of &%Radiating in which
light is given off or absorbed.  Some examples include blinking, flashing,
and glittering.")

(<=>
   (exists (?EMIT)
      (and
         (instance ?EMIT RadiatingLight)
         (patient ?EMIT ?REGION)
         (instance ?REGION Region)))
   (attribute ?REGION Illuminated))

(subclass RadiatingSound Radiating)
(documentation RadiatingSound "The &%subclass of &%Radiating in which
sound waves are given off or absorbed.  Some examples include creaking,
roaring, and whistling.")

(=>
   (and
      (instance ?EMIT RadiatingSound)
      (agent ?EMIT ?SOUND))
   (exists (?ATTR)
      (and
         (instance ?ATTR SoundAttribute)
         (attribute ?SOUND ?ATTR))))

(subclass Music RadiatingSound)
(documentation Music "The &%subclass of &%RadiatingSound where the
sound is intended to be melodic and is produced deliberately.")

(subclass StateChange InternalChange)
(documentation StateChange "Any &%Process where the &%PhysicalState
of &%part of the &%patient of the &%Process changes.")

(=>
   (and
      (instance ?PROCESS StateChange)
      (patient ?PROCESS ?OBJ))
   (exists (?PART ?STATE1 ?STATE2)
      (and
         (part ?PART ?OBJ)
         (instance ?STATE1 PhysicalState)
         (instance ?STATE2 PhysicalState)
         (not (equal ?STATE1 ?STATE2))
         (holdsDuring (ImmediatePastFn (WhenFn ?PROCESS)) (attribute ?PART ?STATE1))
         (holdsDuring (ImmediateFutureFn (WhenFn ?FREEZE)) (attribute ?PART ?STATE2)))))

(subclass Melting StateChange)
(documentation Melting "The &%Class of &%Processes where an &%Object is
heated and converted from a &%Solid to a &%Liquid.")

(=>
   (instance ?MELT Melting)
   (exists (?HEAT)
      (and
         (instance ?HEAT Heating)
         (subProcess ?HEAT ?MELT))))

(=>
   (and
      (instance ?MELT Melting)
      (patient ?MELT ?OBJ))
   (exists (?PART)
      (and
         (part ?PART ?OBJ)
         (holdsDuring (ImmediatePastFn (WhenFn ?MELT)) (attribute ?PART Solid))
         (holdsDuring (ImmediateFutureFn (WhenFn ?MELT)) (attribute ?PART Liquid)))))

(subclass Boiling StateChange)
(documentation Boiling "The &%Class of &%Processes where an &%Object is
heated and converted from a &%Liquid to a &%Gas.")

(=>
   (instance ?BOIL Boiling)
   (exists (?HEAT)
      (and
         (instance ?HEAT Heating)
         (subProcess ?HEAT ?BOIL))))

(=>
   (and
      (instance ?BOIL Boiling)
      (patient ?BOIL ?OBJ))
   (exists (?PART)
      (and
         (part ?PART ?OBJ)
         (holdsDuring (ImmediatePastFn (WhenFn ?BOIL)) (attribute ?PART Liquid))
         (holdsDuring (ImmediateFutureFn (WhenFn ?BOIL)) (attribute ?PART Gas)))))

(subclass Condensing StateChange)
(documentation Condensing "The &%Class of &%Processes where an &%Object is
cooled and converted from a &%Gas to a &%Liquid.")

(=>
   (instance ?COND Condensing)
   (exists (?COOL)
      (and
         (instance ?COOL Cooling)
         (subProcess ?COOL ?COND))))

(=>
   (and
      (instance ?COND Condensing)
      (patient ?COND ?OBJ))
   (exists (?PART)
      (and
         (part ?PART ?OBJ)
         (holdsDuring (ImmediatePastFn (WhenFn ?COND)) (attribute ?PART Gas))
         (holdsDuring (ImmediateFutureFn (WhenFn ?COND)) (attribute ?PART Liquid)))))

(subclass Freezing StateChange)
(documentation Freezing "The &%Class of &%Processes where an &%Object is
cooled and converted from a &%Liquid to a &%Solid.")

(=>
   (instance ?FREEZE Freezing)
   (exists (?COOL)
      (and
         (instance ?COOL Cooling)
         (subProcess ?COOL ?FREEZE))))

(=>
   (and
      (instance ?FREEZE Freezing)
      (patient ?FREEZE ?OBJ))
   (exists (?PART)
      (and
         (part ?PART ?OBJ)
         (holdsDuring (ImmediatePastFn (WhenFn ?FREEZE)) (attribute ?PART Liquid))
         (holdsDuring (ImmediateFutureFn (WhenFn ?FREEZE)) (attribute ?PART Solid)))))



;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;
;;    OBJECTS    ;;
;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'MEREOTOPOLOGY'
;; INCLUDES 'PROCESSES'
;; INCLUDES 'QUALITIES'

(subclass AstronomicalBody Region)
(disjoint AstronomicalBody GeographicArea)
(documentation AstronomicalBody "The &%Class of all astronomical
objects of significant size.  It includes &%SelfConnectedObjects
like planets, stars, and asteroids, as well as &%Collections like
nebulae, galaxies, and constellations.  Note that the planet Earth
is an &%AstronomicalBody, but every &%Region of Earth is a
&%GeographicArea.")

(subclass GeographicArea Region)
(partition GeographicArea WaterArea LandArea)
(documentation GeographicArea "A geographic location, generally having
definite boundaries.  Note that this differs from its immediate superclass
&%Region in that a &%GeographicArea is a three-dimensional &%Region of the
earth.  Accordingly, all astronomical objects other than earth and all
one-dimensional and two-dimensional &%Regions are not classed under
&%GeographicArea.")

(subclass GeopoliticalArea GeographicArea)
(subclass GeopoliticalArea Agent)
(documentation GeopoliticalArea "Any &%GeographicArea which is associated
with some sort of political structure.  This class includes &%Lands,
&%Cities, districts of cities, counties, etc.  Note that the identity
of a &%GeopoliticalArea may remain constant after a change in borders.")

(subclass WaterArea GeographicArea)
(documentation WaterArea "A body which is made up predominantly of water,
e.g. rivers, lakes, oceans, etc.")

(=>
   (instance ?AREA WaterArea)
   (exists (?BED ?HOLE ?WATER)
      (and
         (equal (PrincipalHostFn ?HOLE) ?BED)
         (instance ?WATER Water)
         (properlyFills ?WATER ?HOLE)
         (equal (MereologicalSumFn ?BED ?WATER) ?AREA))))

(subclass SaltWaterArea WaterArea)
(disjoint SaltWaterArea FreshWaterArea)
(documentation SaltWaterArea "A &%WaterArea whose &%Water is saline, e.g.
oceans and seas.")

(subclass FreshWaterArea WaterArea)
(documentation FreshWaterArea "A &%WaterArea whose &%Water is not saline,
e.g. most rivers and lakes.")

(subclass StreamWaterArea WaterArea)
(disjoint StreamWaterArea StaticWaterArea)
(documentation StreamWaterArea "A relatively narrow &%WaterArea where the
water flows constantly and in the same direction, e.g. a river, a stream,
etc.")

(subclass StaticWaterArea WaterArea)
(documentation StaticWaterArea "A &%WaterArea in which water does not flow
constantly or in the same direction, e.g. most lakes and ponds.")

(subclass LandArea GeographicArea)
(documentation LandArea "An area which is predominantly solid ground,
e.g. a &%Nation, a mountain, a desert, etc.  Note that a &%LandArea may
contain some relatively small &%WaterAreas.  For example, Australia is
a &%LandArea even though it contains various rivers and lakes.")

(=>
   (instance ?LAND1 LandArea)
   (exists (?LAND2)
      (and
         (part ?LAND1 ?LAND2)
         (or
            (instance ?LAND2 Continent)
            (instance ?LAND2 Island)))))

(subclass Continent LandArea)
(documentation Continent "One of the seven largest &%LandAreas on earth.")

(equal (CardinalityFn Continent) 7)

(subclass Island LandArea)
(documentation Island "A &%LandArea that is completely surrounded by a &%WaterArea.")

(=>
   (instance ?ISLAND Island)
   (not
      (exists (?AREA ?PART1 ?PART2)
         (and
            (instance ?AREA LandArea)
            (part ?PART1 ?ISLAND)
            (part ?PART2 ?AREA)
            (not
               (part ?ISLAND ?AREA))
            (not
               (part ?AREA ?ISLAND))
            (connected ?PART1 ?PART2)))))

(subclass Nation GeopoliticalArea)
(subclass Nation LandArea)
(documentation Nation "The broadest &%GeopoliticalArea, i.e. &%Nations are
&%GeopoliticalAreas that are not part of any other overarching and
comprehensive governance structure (excepting commonwealths and other sorts
of loose international organizations).")

(subclass StateOrProvince GeopoliticalArea)
(subclass StateOrProvince LandArea)
(documentation StateOrProvince "Administrative subdivisions of a
&%Nation that are broader than any other political subdivisions that
may exist.  This &%Class includes the states of the United States, as
well as the provinces of Canada and European countries.")

(=>
   (instance ?STATE StateOrProvince)
   (exists (?LAND)
      (and
         (instance ?LAND Nation)
         (properPart ?STATE ?LAND))))

(subclass Address LandArea)
(documentation Address "A &%LandArea of relatively small size.  This
concept represents the state of 'being at an address'.")

(subclass City GeopoliticalArea)
(subclass City LandArea)
(documentation City "A &%LandArea of relatively small size, inhabited
by a community of people, and having some sort of political structure.
Note that this class includes both large cities and small settlements
like towns, villages, hamlets, etc.")

(subclass Water CompoundSubstance)
(documentation Water "The &%Class of samples of the compound H20.  Note
that this &%Class covers both pure and impure &%Water.")

(subclass Mineral Mixture)
(documentation Mineral " 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.")

(instance developmentalForm BinaryPredicate)
(instance developmentalForm AsymmetricRelation)
(instance developmentalForm TransitiveRelation)
(subrelation developmentalForm attribute)
(domain developmentalForm 1 OrganicObject)
(domain developmentalForm 2 DevelopmentalAttribute)
(documentation developmentalForm "(&%developmentalForm ?OBJECT ?FORM)
means that ?FORM is an earlier stage in the individual maturation of
?OBJECT.  For example, tadpole and caterpillar are &%developmentalForms
of frogs and butterflies, respectively.")

(=>
   (and
      (holdsDuring ?TIME1 (developmentalForm ?OBJ ?ATTR1))
      (successorAttributeClosure ?ATTR2 ?ATTR1))
   (exists (?TIME2)
      (and
         (earlier ?TIME2 ?TIME1)
         (holdsDuring ?TIME2 (developmentalForm ?OBJ ?ATTR2)))))

(subclass OrganicObject CorpuscularObject)
(partition OrganicObject Organism AnatomicalStructure)
(documentation OrganicObject "This class encompasses &%Organisms,
&%CorpuscularObjects that are parts of &%Organisms, i.e. &%BodyParts,
and &%CorpuscularObjects that are nonintentionally produced by
&%Organisms, e.g. &%ReproductiveBodies.")

(subclass Organism OrganicObject)
(subclass Organism Agent)
(partition Organism Animal Plant Microorganism)
(documentation Organism "Generally, a living individual, including all
&%Plants and &%Animals.")

(=>
   (instance ?ORGANISM Organism)
   (exists (?BIRTH)
      (and
         (instance ?BIRTH Birth)
         (experiencer ?BIRTH ?ORGANISM))))

(instance inhabits BinaryPredicate)
(instance inhabits AsymmetricRelation)
(domain inhabits 1 Organism)
(domain inhabits 2 Object)
(documentation inhabits "A very basic notion of living within something
else.  (&%inhabits ?ORGANISM ?OBJECT) means that ?OBJECT is the residence,
nest, home, etc. of ?ORGANISM.")

(=>
   (inhabits ?ORGANISM ?OBJ)
   (exists (?TIME)
      (holdsDuring ?TIME (located ?ORGANISM ?OBJ))))

(instance parent BinaryPredicate)
(subrelation parent familyRelation)
(instance parent AsymmetricRelation)
(instance parent IntransitiveRelation)
(domain parent 1 Organism)
(domain parent 2 Organism)
(documentation parent "The general relationship of parenthood.
(&%parent ?CHILD ?PARENT) means that ?PARENT is a biological parent
of ?CHILD.")

(=>
   (parent ?CHILD ?PARENT)
   (before (BeginFn (WhenFn ?PARENT)) (BeginFn (WhenFn ?CHILD))))

(=>
   (and
      (parent ?CHILD ?PARENT)
      (subclass ?CLASS Organism)
      (instance ?PARENT ?CLASS))
   (instance ?CHILD ?CLASS))

(=>
   (parent ?CHILD ?PARENT)
   (or
      (mother ?CHILD ?PARENT)
      (father ?CHILD ?PARENT)))

(=>
   (instance ?ORGANISM Organism)
   (exists (?PARENT)
      (parent ?ORGANISM ?PARENT)))

(instance mother SingleValuedRelation)
(subrelation mother parent)
(domain mother 1 Organism)
(domain mother 2 Organism)
(documentation mother "The general relationship of motherhood.
(&%mother ?CHILD ?MOTHER) means that ?MOTHER is the biological mother
of ?CHILD.")

(=>
   (mother ?CHILD ?MOTHER)
   (attribute ?MOTHER Female))

(instance father SingleValuedRelation)
(subrelation father parent)
(domain father 1 Organism)
(domain father 2 Organism)
(documentation father "The general relationship of fatherhood.
(&%father ?CHILD ?FATHER) means that ?FATHER is the biological father
of ?CHILD.")

(=>
   (father ?CHILD ?FATHER)
   (attribute ?FATHER Male))

(instance sibling BinaryPredicate)
(subrelation sibling familyRelation)
(instance sibling SymmetricRelation)
(instance sibling IrreflexiveRelation)
(domain sibling 1 Organism)
(domain sibling 2 Organism)
(documentation sibling "The relationship between two &%Organisms that
have the same &%mother and &%father.  Note that this relationship does
not hold between half-brothers, half-sisters, etc.")

(<=>
   (sibling ?ANIMAL1 ?ANIMAL2)
   (exists (?FATHER ?MOTHER)
      (and
         (father ?ANIMAL1 ?FATHER)
         (father ?ANIMAL2 ?FATHER)
         (mother ?ANIMAL1 ?MOTHER)
         (mother ?ANIMAL2 ?MOTHER))))

;; The following formulas incorporate the content in the Natural-Kinds
;; ontology developed by ITBM-CNR.  This content is essentially a set of
;; high-level biological categories.

(subclass Plant Organism)
(documentation Plant "An &%Organism having cellulose cell walls, growing
by synthesis of &%Substances, generally distinguished by the presence of
chlorophyll, and lacking the power of locomotion.")

(subclass FloweringPlant Plant)
(documentation FloweringPlant "A &%Plant that produces seeds and flowers.
This class includes trees, shrubs, herbs, and flowers.")

(subclass NonFloweringPlant Plant)
(disjoint NonFloweringPlant FloweringPlant)
(disjointDecomposition NonFloweringPlant Alga Fern Fungus Moss)
(documentation NonFloweringPlant "A &%Plant that reproduces with spores and
does not produce flowers.")

(subclass Alga NonFloweringPlant)
(documentation Alga "A chiefly aquatic plant that contains chlorophyll,
but does not form embryos during development and lacks vascular tissue.")

(=>
	(instance ?ALGA Alga)
	(exists (?WATER)
		(and
			(inhabits ?ALGA ?WATER)
			(instance ?WATER Water))))

(subclass Fungus NonFloweringPlant)
(documentation Fungus "A eukaryotic &%Organism characterized by the
absence of chlorophyll and the presence of rigid cell walls. Included
here are both slime molds and true fungi such as yeasts, molds, mildews,
and mushrooms.")

(=>
	(and
		(instance ?FUNGUS Fungus)
		(inhabits ?FUNGUS ?OBJ))
	(instance ?OBJ Organism))

(subclass Moss NonFloweringPlant)
(documentation Moss "A &%NonFloweringPlant without true roots and little
if any vascular tissue.")

(subclass Fern NonFloweringPlant)
(documentation Fern "A &%NonFloweringPlant that contains vascular tissue.
This class includes true ferns, as well as horsetails, club mosses, and
whisk ferns.")

(subclass Animal Organism)
(documentation Animal "An &%Organism with eukaryotic &%Cells, and lacking
stiff cell walls, plastids, and photosynthetic pigments.")

(subclass Microorganism Organism)
(documentation Microorganism "An &%Organism that can be seen only with
the aid of a microscope.")

(subclass Bacterium Microorganism)
(documentation Bacterium "A small, typically one-celled, prokaryotic
&%Microorganism.")

(=>
   (instance ?BACTERIUM Bacterium)
   (exists (?CELL1)
      (and
         (component ?CELL1 ?BACTERIUM)
         (instance ?CELL1 Cell)
         (forall (?CELL2)
            (=>
               (and
                  (component ?CELL2 ?BACTERIUM)
                  (instance ?CELL2 Cell))
               (equal ?CELL1 ?CELL2))))))

(=>
	(and
		(instance ?BACTERIUM Bacterium)
		(inhabits ?BACTERIUM ?OBJ))
	(instance ?OBJ Organism))

(subclass Virus Microorganism)
(documentation Virus "An &%Organism consisting of a core of a single
nucleic acid enclosed in a protective coat of protein. A virus may replicate
only inside a host living cell. A virus exhibits some but not all of the
usual characteristics of living things.")

(=>
   (instance ?VIRUS Virus)
   (exists (?MOL1)
      (and
         (component ?MOL1 ?VIRUS)
         (instance ?MOL1 Molecule)
         (forall (?MOL2)
            (=>
               (and
                  (component ?MOL2 ?VIRUS)
                  (instance ?MOL2 Molecule))
               (equal ?MOL1 ?MOL2))))))

(=>
	(and
		(instance ?VIRUS Virus)
		(inhabits ?VIRUS ?OBJ))
	(instance ?OBJ Organism))

(=>
	(and
		(instance ?VIRUS Virus)
		(instance ?PROC Replication)
		(agent ?PROC ?VIRUS))
	(exists (?CELL)
		(and
			(located ?PROC ?CELL)
			(instance ?CELL Cell))))

(subclass Vertebrate Animal)
(documentation Vertebrate "An &%Animal which has a spinal column.")

(subclass Invertebrate Animal)
(disjoint Invertebrate Vertebrate)
(disjointDecomposition Invertebrate Worm Mollusk Arthropod)
(documentation Invertebrate "An &%Animal which has no spinal column.")

(subclass Worm Invertebrate)
(documentation Worm "Long, narrow, soft-bodied &%Invertebrates.")

(subclass Mollusk Invertebrate)
(documentation Mollusk "Soft-bodied &%Invertebrate that is usually
contained in a shell.  Includes oysters, clams, mussels, snails, slugs,
octopi, and squid.")

(subclass Arthropod Invertebrate)
(disjointDecomposition Arthropod Arachnid Myriapod Insect Crustacean)
(documentation Arthropod "A &%Class of &%Invertebrate that includes
&%Arachnids and &%Insects.")

(subclass Arachnid Arthropod)
(documentation Arachnid "A &%Class of &%Arthropods that includes
ticks and spiders.")

(subclass Myriapod Arthropod)
(documentation Myriapod "A &%Class of &%Arthropods that includes
centipedes and millipedes.")

(subclass Insect Arthropod)
(documentation Insect "A &%Class of small &%Arthropods that are
air-breathing and that are distinguished by appearance.")

(subclass Crustacean Arthropod)
(documentation Crustacean "A &%Class of &%Arthropods that mainly dwells
in water and has a segmented body and a chitinous exoskeleton.  Includes
lobsters, crabs, shrimp, and barnacles.")

(subclass ColdBloodedVertebrate Vertebrate)
(disjointDecomposition ColdBloodedVertebrate Amphibian Fish Reptile)
(documentation ColdBloodedVertebrate "&%Vertebrates whose body temperature
is not internally regulated.")

(subclass WarmBloodedVertebrate Vertebrate)
(disjoint WarmBloodedVertebrate ColdBloodedVertebrate)
(documentation WarmBloodedVertebrate "&%Vertebrates whose body temperature
is internally regulated.")

(subclass Amphibian ColdBloodedVertebrate)
(documentation Amphibian "A cold-blooded, smooth-skinned &%Vertebrate
which characteristically hatches as an aquatic larva, breathing by
gills.  When mature, the &%Amphibian breathes with &%Lungs.")

(subclass Bird WarmBloodedVertebrate)
(disjoint Bird Mammal)
(documentation Bird "A &%Vertebrate having a constant body temperature
and characterized by the presence of feathers.")

(subclass Fish ColdBloodedVertebrate)
(documentation Fish "A cold-blooded aquatic &%Vertebrate characterized by
fins and breathing by gills. Included here are &%Fish having either a bony
skeleton, such as a perch, or a cartilaginous skeleton, such as a shark.
Also included are those &%Fish lacking a jaw, such as a lamprey or
hagfish.")

(=>
	(instance ?FISH Fish)
	(exists (?WATER)
		(and
			(inhabits ?FISH ?WATER)
			(instance ?WATER Water))))

(subclass Mammal WarmBloodedVertebrate)
(disjointDecomposition Mammal AquaticMammal HoofedMammal Marsupial Rodent Primate)
(documentation Mammal "A &%Vertebrate having a constant body temperature
and characterized by the presence of hair, mammary glands, and sweat
glands.")

(subclass AquaticMammal Mammal)
(documentation AquaticMammal "The &%Class of &%Mammals that dwell chiefly
in the water.  Includes whales, dolphins, manatees, seals, and walruses.")

(subclass HoofedMammal Mammal)
(documentation HoofedMammal "The &%Class of &%Mammals with hooves.
Includes horses, cows, sheep, pigs, antelope, etc.")

(subclass Marsupial Mammal)
(documentation Marsupial "The &%Class of &%Mammals which have a pouch for
their young.")

(subclass Carnivore Mammal)
(documentation Carnivore "The &%Class of flesh-eating &%Mammals.  Members
of this &%Class typically have four or five claws on each paw.  Includes
cats, dogs, bears, racoons, and skunks.")

(subclass Canine Carnivore)
(disjoint Canine Feline)
(documentation Canine "The &%Class of &%Carnivores with completely
separable toes, nonretractable claws, and long muzzles.")

(subclass Feline Carnivore)
(documentation Feline "The &%Class of &%Carnivores with completely
separable toes, nonretractable claws, slim bodies, and rounded heads.")

(subclass Rodent Mammal)
(documentation Rodent "The &%Class of &%Mammals with one or two pairs
of incisors for gnawing.  Includes rats, mice, guinea pigs, and
rabbits.")

(subclass Primate Mammal)
(disjointDecomposition Primate Ape Monkey Hominid)
(documentation Primate "The &%Class of &%Mammals which are
&%Primates.")

(subclass Ape Primate)
(documentation Ape "Various &%Primates with no tails or only short
tails.")

(subclass Monkey Primate)
(documentation Monkey "Various &%Primates with relatively long
tails.")

(subclass Hominid Primate)
(documentation Hominid "Includes &%Humans and relatively recent
ancestors of &%Humans.")

(subclass Human Hominid)
(subclass Human CognitiveAgent)
(documentation Human "Modern man, the only remaining species of the Homo
genus.")

(subclass Reptile ColdBloodedVertebrate)
(documentation Reptile "A &%ColdBloodedVertebrate having an external
covering of scales or horny plates.  &%Reptiles breathe by means of
&%Lungs and generally lay eggs.")

;; The following formulas cover biologically related &%Classes under
;; &%Substance.

(subclass BiologicallyActiveSubstance Substance)
(documentation BiologicallyActiveSubstance "A &%Substance that is
capable of inducing a change in the structure or functioning of an
&%Organism.  This &%Class includes &%Substances used in the treatment,
diagnosis, prevention or analysis of normal and abnormal body function.
This &%Class also includes &%Substances that occur naturally in the body
and are administered therapeutically.  Finally, &%BiologicallyActiveSubstance
includes &%Nutrients, most drugs of abuse, and agents that require special
handling because of their toxicity.")

(subclass Nutrient BiologicallyActiveSubstance)
(subclass Nutrient CompoundSubstance)
(disjointDecomposition Nutrient Protein Carbohydrate Vitamin)
(documentation Nutrient "A &%BiologicallyActiveSubstance produced or
required by an &%Organism, of primary interest because of its role in the
biologic functioning of the &%Organism.")

(subclass Protein Nutrient)
(documentation Protein "A &%Nutrient made up of amino acids joined by
peptide bonds.")

(subclass Enzyme Protein)
(documentation Enzyme "A complex &%Protein that is produced by living
cells and which catalyzes specific biochemical reactions. There are six
main types of enzymes:  oxidoreductases, transferases, hydrolases,
lyases, isomerases, and ligases.")

(subclass Carbohydrate Nutrient)
(documentation Carbohydrate "An element of living cells and a source of
energy for &%Animals.  This class includes both simple &%Carbohydrates,
i.e. sugars, and complex &%Carbohydrates, i.e. starches.")

(subclass Vitamin Nutrient)
(documentation Vitamin "A &%Nutrient present in natural products or made
synthetically, which is essential in the diet of &%Humans and other higher
&%Animals.  Included here are &%Vitamin precursors and provitamins.")

(subclass BodySubstance Mixture)
(documentation BodySubstance "Extracellular material and mixtures of
cells and extracellular material that are produced, excreted or accreted
by an &%Organism.  Included here are &%Substances such as saliva, dental
enamel, sweat, and gastric acid.")

(subclass Hormone BodySubstance)
(subclass Hormone BiologicallyActiveSubstance)
(documentation Hormone "In &%Animals, a chemical secreted by an
endocrine gland whose products are released into the circulating fluid.
&%Plant hormones or synthetic hormones which are used only to alter or
control various physiologic processes, e.g., reproductive control agents,
are assigned to the &%Class &%BiologicallyActiveSubstance. &%Hormones act as
chemical messengers and regulate various physiologic processes such as
growth, reproduction, metabolism, etc.  They usually fall into two broad
categories, viz. steroid hormones and peptide hormones.")

(subclass Blood BodySubstance)
(documentation Blood "A fluid present in &%Animals that transports
&%Nutrients to and waste products away from various &%BodyParts.")

(subclass ToxicOrganism Organism)
(documentation ToxicOrganism "The &%Class of &%Organisms which are
poisonous to other &%Organisms.")

(=>
   (instance ?ORGANISM ToxicOrganism)
   (exists (?SUBSTANCE)
      (and
         (instance ?SUBSTANCE BiologicallyActiveSubstance)
         (part ?SUBSTANCE ?ORGANISM))))

(subclass Food SelfConnectedObject)
(disjointDecomposition Food Meat FruitOrVegetable Beverage)
(documentation Food "Any &%SelfConnectedObject containing &%Nutrients,
such as carbohydrates, proteins, and fats, that can be ingested by a
living &%Animal and metabolized into energy and body tissue.")

(=>
    (instance ?FOOD Food)
    (exists (?NUTRIENT)
        (and
            (instance ?NUTRIENT Nutrient)
            (part ?NUTRIENT ?FOOD))))

(=>
   (instance ?FOOD Food)
   (forall (?PART1)
      (=>
         (part ?PART1 ?FOOD)
         (exists (?PART2 ?ANIMAL)
            (and
               (part ?PART1 ?PART2)
               (part ?PART2 ?ANIMAL)
               (instance ?ANIMAL Animal))))))

(subclass Meat Food)
(documentation Meat "Any &%Food which was originally part of an
&%Animal and is not ingested by drinking, including eggs and animal
blood that is eaten as food.  Note that this class covers both raw
meat and meat that has been prepared in some way, e.g. by cooking.
Note too that preparations involving &%Meat and &%FruitOrVegetable
are classed directly under &%Food.")

(=>
   (instance ?MEAT Meat)
   (forall (?PART)
      (=>
         (part ?PART ?MEAT)
         (exists (?SUBPART ?TIME ?ANIMAL)
            (and
               (part ?SUBPART ?PART)
               (holdsDuring ?TIME (and (instance ?ANIMAL Animal) (part ?SUBPART ?ANIMAL))))))))

(subclass FruitOrVegetable Food)
(subclass FruitOrVegetable BodyPart)
(documentation FruitOrVegetable "Any fruit or vegetable, i.e. a
&%Food that was originally part of a &%Plant and is not ingested
by drinking, including nuts, grains, beans, etc.  Note that
preparations involving more than one &%FruitOrVegetable or
something that is not a &%FruitOrVegetable are not classed under
&%FruitOrVegetable.  For example, a salad is not considered to be
a &%FruitOrVegetable because most salads contain more than one kind
of vegetable, and zucchini cooked in lard would not be a &%FruitOrVegetable
because it contains an &%Animal product.")

(=>
   (instance ?VEG FruitOrVegetable)
   (forall (?PART)
      (=>
         (part ?PART ?VEG)
         (exists (?SUBPART ?TIME ?PLANT)
            (and
               (part ?SUBPART ?PART)
               (holdsDuring ?TIME (and (instance ?PLANT Plant) (part ?SUBPART ?PLANT))))))))

(subclass Beverage Food)
(documentation Beverage "Any &%Food that is ingested by &%Drinking.
Note that this class is disjoint with the other subclasses of &%Food,
i.e. &%Meat and &%FruitOrVegetable.")

(=>
   (instance ?BEV Beverage)
   (attribute ?BEV Liquid))

(=>
   (and
      (instance ?DRINK Drinking)
      (patient ?DRINK ?BEV))
   (instance ?BEV Beverage))

(subclass AnatomicalStructure OrganicObject)
(documentation AnatomicalStructure "A normal or pathological part
of the anatomy or structural organization of an &%Organism.  This
class covers &%BodyParts, as well as structures that are given off
by &%Organisms, e.g. &%ReproductiveBodies.")

(=>
    (instance ?ANAT AnatomicalStructure)
    (exists (?ORGANISM)
        (and
            (instance ?ORGANISM Organism)
            (part ?ANAT ?ORGANISM))))

(=>
    (instance ?PART AnatomicalStructure)
    (exists (?CELL)
        (and
            (instance ?CELL Cell)
            (part ?CELL ?PART))))

(subclass ReproductiveBody AnatomicalStructure)
(documentation ReproductiveBody "Reproductive structure of &%Organisms.
Consists of an &%Embryonic &%Object and a nutritive/protective envelope.
Note that this class includes seeds, spores, and &%FruitOrVegetables, as
well as the eggs produced by &%Animals.")

(subclass BodyPart AnatomicalStructure)
(documentation BodyPart "A collection of &%Cells and &%Tissues which
are localized to a specific area of an &%Organism and which are not
pathological. The instances of this &%Class range from gross structures
to small components of complex &%Organs.")

(=>
   (instance ?PART BodyPart)
   (not
      (exists (?PROC)
         (and
            (instance ?PROC PathologicProcess)
            (result ?PROC ?PART)))))

(subclass BodyCovering BodyPart)
(documentation BodyCovering "Any &%BodyPart which is a covering of another
&%BodyPart or of an entire &%Organism.  This would include the rinds of
&%FruitOrVegetables and the skins of &%Animals.")

(=>
   (instance ?COVER BodyCovering)
   (exists (?BODY)
      (and
         (superficialPart ?COVER ?BODY)
         (or
            (instance ?BODY Organism)
            (instance ?BODY BodyPart)))))

(subclass BodyJunction BodyPart)
(documentation BodyJunction "The place where two &%BodyParts
meet or connect.")

(=>
    (instance ?JUNCT BodyJunction)
    (exists (?STRUCT)
        (and
            (instance ?STRUCT BodyPart)
            (component ?JUNCT ?STRUCT))))

(=>
    (instance ?JUNCT BodyJunction)
    (exists (?STRUCT1 ?STRUCT2)
        (and
            (connected ?JUNCT ?STRUCT1)
	      (connected ?JUNCT ?STRUCT2)
            (instance ?STRUCT1 BodyPart)
            (instance ?STRUCT2 BodyPart)
            (not
                (equal ?STRUCT1 ?STRUCT2)))))

(subclass BodyVessel BodyPart)
(documentation BodyVessel "Any tube-like structure which occurs naturally in
an &%Organism and through which a &%BodySubstance can circulate.")

(subclass Cell BodyPart)
(documentation Cell "The fundamental structural and functional unit of
living &%Organisms.")

(subclass Organ BodyPart)
(documentation Organ "A somewhat independent &%BodyPart that performs a
specialized function.")

(=>
   (instance ?ORGAN Organ)
   (exists (?PURP)
      (hasPurpose ?ORGAN ?PURP)))

(subclass Gland Organ)
(documentation Gland "An &%Organ that removes &%Substances from the &%Blood,
alters them in some way, and then releases them.")

(subclass Tissue BodySubstance)
(disjointDecomposition Tissue Bone Muscle FatTissue)
(documentation Tissue "An aggregation of similarly specialized &%Cells
and the associated intercellular substance. &%Tissues are relatively
non-localized in comparison to &%BodyParts, &%Organs or &%Organ components.
The main features of &%Tissues are self-connectivity (see
&%SelfConnectedObject) and being a homogeneous mass (all parts in the
same granularity are instances of &%Tissue as well).")

(=>
    (instance ?STUFF Tissue)
    (exists (?PART)
        (and
            (instance ?PART Cell)
            (part ?PART ?STUFF))))

(=>
    (instance ?STUFF Tissue)
    (exists (?ORGANISM)
        (and
            (instance ?ORGANISM Organism)
            (part ?STUFF ?ORGANISM))))

(subclass Bone Tissue)
(documentation Bone "Rigid &%Tissue composed largely of calcium that makes up
the skeleton of &%Vertebrates.  Note that this &%Class also includes teeth.")

(=>
   (instance ?BONE Bone)
   (exists (?VERT)
      (and
         (instance ?VERT Vertebrate)
         (part ?BONE ?VERT))))

(subclass Muscle Tissue)
(documentation Muscle "Nonrigid &%Tissue appearing only in &%Animals and
composed largely of contractile cells.")

(subclass FatTissue Tissue)
(documentation FatTissue "Nonrigid &%Tissue that is composed largely of
fat cells.")

(subclass Noun Word)
(partition Word Noun Verb Adjective Adverb Particle)
(documentation Noun "One of the parts of speech.  The &%Class of &%Words
that conventionally denote &%Objects.")

(subclass Verb Word)
(documentation Verb "One of the parts of speech.  The &%Class of &%Words
that conventionally denote &%Processes.")

(subclass Adjective Word)
(documentation Adjective "One of the parts of speech.  The &%Class of
&%Words that conventionally denote &%Attributes of &%Objects.")

(subclass Adverb Word)
(documentation Adverb "One of the parts of speech.  The &%Class of &%Words
that conventionally denote &%Attributes of &%Processes.")

(subclass Particle Word)
(documentation Particle "An umbrella &%Class for any &%Word that does not
fit into the other subclasses of &%Word.  A &%Particle is generally a small
term that serves a grammatical or logical function, e.g. 'and', 'of',
'since', etc.  At some point, this class might be broken up into the
subclasses 'Connective', 'Preposition', etc.")

(subclass Morpheme LinguisticExpression)
(documentation Morpheme "Part of a &%Word which cannot be subdivided
and which expresses a meaning.")

(=>
   (instance ?MORPH Morpheme)
   (not
      (exists (?OTHERMORPH)
         (and
            (instance ?OTHERMORPH Morpheme)
            (part ?OTHERMORPH ?MORPH)
            (not (equal ?OTHERMORPH ?MORPH))))))

(=>
   (instance ?MORPH Morpheme)
   (exists (?WORD)
         (and
            (instance ?WORD Word)
            (part ?MORPH ?WORD))))

(=>
    (instance ?WORD Word)
    (exists (?PART)
        (and
            (part ?PART ?WORD)
            (instance ?PART Morpheme))))

(subclass Phrase LinguisticExpression)
(disjointDecomposition Phrase VerbPhrase NounPhrase PrepositionalPhrase)
(documentation Phrase "A set of &%Words in a &%Language which form a unit,
i.e. express a meaning in the &%Language.")

(=>
    (instance ?PHRASE Phrase)
    (exists (?PART1 ?PART2)
        (and
            (part ?PART1 ?PHRASE)
	      (part ?PART2 ?PHRASE)
            (instance ?PART1 Word)
	      (instance ?PART2 Word)
            (not (equal ?PART1 ?PART2)))))

(subclass VerbPhrase Phrase)
(documentation VerbPhrase "A &%Phrase that has the same function as a
&%Verb.")

(subclass NounPhrase Phrase)
(disjoint NounPhrase VerbPhrase)
(documentation NounPhrase "A &%Phrase that has the same function as a
&%Noun.")

(=>
    (instance ?SENTENCE Sentence)
    (exists (?PHRASE1 ?PHRASE2)
        (and
           (instance ?PHRASE1 NounPhrase)
           (instance ?PHRASE2 VerbPhrase)
           (part ?PHRASE1 ?SENTENCE)
           (part ?PHRASE2 ?SENTENCE))))

(subclass PrepositionalPhrase Phrase)
(documentation PrepositionalPhrase "A &%Phrase that begins with a
preposition and that functions as an &%Adjective or an &%Adverb.")

(subclass Text LinguisticExpression)
(subclass Text Artifact)
(documentation Text "A &%Sentence or set of &%Sentences that perform
a specific function related to &%Communication, e.g. express a discourse
about a particular topic.")

(=>
    (instance ?TEXT Text)
    (exists (?PROP)
        (and
            (instance ?PROP Proposition)
            (containsInformation ?TEXT ?PROP))))

(=>
    (instance ?TEXT Text)
    (exists (?PART)
        (and
            (part ?PART ?TEXT)
            (instance ?PART Sentence))))

(=>
   (instance ?TEXT Text)
   (exists (?WRITE)
      (and
         (instance ?WRITE Writing)
         (result ?WRITE ?TEXT))))

(subclass Sentence Text)
(documentation Sentence "A syntactically well-formed formula of a
&%Language.  It includes, at minimum, a predicate and a subject (which
may be explicit or implicit), and it expresses a &%Proposition.")

(=>
   (instance ?SENT Sentence)
   (exists (?NOUN ?VERB)
      (and
         (instance ?NOUN NounPhrase)
         (instance ?VERB VerbPhrase)
         (part ?NOUN ?SENT)
         (part ?VERB ?SENT))))

(instance authors BinaryPredicate)
(instance authors AsymmetricRelation)
(domain authors 1 Agent)
(domainSubclass authors 2 Text)
(documentation authors "(&%authors ?AGENT ?TEXT) means that ?AGENT is
creatively responsible for ?TEXT.  For example, Agatha Christie is
author of Murder_on_the_Orient_Express.")

(=>
     (authors ?AGENT ?TEXT)
     (exists (?PROCESS ?INSTANCE)
          (and
               (agent ?PROCESS ?AGENT)
               (instance ?INSTANCE ?TEXT)
               (result ?PROCESS ?TEXT))))

(instance editor BinaryPredicate)
(instance editor AsymmetricRelation)
(domain editor 1 Agent)
(domainSubclass editor 2 Text)
(documentation editor "(&%editor ?AGENT ?TEXT) means that ?AGENT is
an editor of ?TEXT.")

(instance publishes BinaryPredicate)
(instance publishes AsymmetricRelation)
(domain publishes 1 Organization)
(domainSubclass publishes 2 Text)
(documentation publishes "(&%publishes ?ORG ?TEXT) means that ?ORG
publishes ?TEXT.  For example, Bantam Books publishes Agatha Christie's
Murder_on_the_Orient_Express.")

(<=>
   (publishes ?ORG ?TEXT)
   (exists (?PUB)
      (and
         (instance ?PUB Publication)
         (agent ?PUB ?ORG)
         (patient ?PUB ?TEXT))))

(instance EditionFn BinaryFunction)
(domainSubclass EditionFn 1 ContentBearingObject)
(domain EditionFn 2 PositiveInteger)
(rangeSubclass EditionFn ContentBearingObject)
(documentation EditionFn "A &%BinaryFunction that maps a type of text
(e.g. Agatha Christie's Murder_on_the_Orient_Express) and a number
to the edition of the text type corresponding to the number.")

(=>
   (and
      (equal (EditionFn ?TEXT ?INT1) ?EDITION1)
      (equal (EditionFn ?TEXT ?INT2) ?EDITION2)
      (greaterThan ?INT2 ?INT1)
      (instance ?PUB1 Publication)
      (instance ?PUB2 Publication)
      (patient ?PUB1 ?EDITION1)
      (patient ?PUB2 ?EDITION2)
      (date ?PUB1 ?DATE1)
      (date ?PUB2 ?DATE2))
   (before (EndFn ?DATE1) (EndFn ?DATE2)))

(=>
   (equal (EditionFn ?TEXT1 ?NUMBER) ?TEXT2)
   (subsumesContentClass ?TEXT1 ?TEXT2))

(instance SeriesVolumeFn BinaryFunction)
(domainSubclass SeriesVolumeFn 1 Series)
(domain SeriesVolumeFn 2 PositiveInteger)
(rangeSubclass SeriesVolumeFn Text)
(documentation SeriesVolumeFn "A &%BinaryFunction that maps a type of &%Series
(e.g. the Encyclopedia_Britannica or the Popular_Mechanics periodical) and a
number to the volumes of the text type designated by the number.")

(=>
   (and
      (subclass ?TEXT Periodical)
      (equal (SeriesVolumeFn ?TEXT ?INT1) ?VOLUME1)
      (equal (SeriesVolumeFn ?TEXT ?INT2) ?VOLUME2)
      (greaterThan ?INT2 ?INT1)
      (instance ?PUB1 Publication)
      (instance ?PUB2 Publication)
      (patient ?PUB1 ?VOLUME1)
      (patient ?PUB2 ?VOLUME2)
      (date ?PUB1 ?DATE1)
      (date ?PUB2 ?DATE2))
   (before (EndFn ?DATE1) (EndFn ?DATE2)))

(=>
   (equal (SeriesVolumeFn ?SERIES ?NUMBER) ?VOLUME)
   (subsumesContentClass ?SERIES ?VOLUME))

(instance PeriodicalIssueFn BinaryFunction)
(domainSubclass PeriodicalIssueFn 1 Periodical)
(domain PeriodicalIssueFn 2 PositiveInteger)
(rangeSubclass PeriodicalIssueFn Periodical)
(documentation PeriodicalIssueFn "A &%BinaryFunction that maps a subclass of
&%Periodical and a number to all of the issues of the &%Periodical corresponding
to the number.")

(=>
   (equal (PeriodicalIssueFn ?PERIODICAL ?NUMBER) ?ISSUE)
   (subsumesContentClass ?PERIODICAL ?ISSUE))

(subclass Book Text)
(documentation Book "A &%Text that has pages and is bound.")

(subclass Summary Text)
(documentation Summary "A short &%Text that is a summary of another,
longer &%Text.")

(=>
   (instance ?TEXT Summary)
   (exists (?TEXT2)
      (and
         (instance ?TEXT2 Text)
         (subsumesContentInstance ?TEXT2 ?TEXT))))

(subclass Series ContentBearingObject)
(documentation Series "A &%ContentBearingObject consisting of multiple
self-contained units.  Some examples are an encyclopedia containing a couple
dozen volumes, a television series made up of many dozens of episodes, a
film serial, etc.")

(=>
   (instance ?SERIES Series)
   (exists (?BOOK1 ?BOOK2)
      (and
         (instance ?BOOK1 Book)
         (instance ?BOOK2 Book)
         (subsumesContentInstance ?SERIES ?BOOK1)
         (subsumesContentInstance ?SERIES ?BOOK2)
         (not (equal ?BOOK1 ?BOOK2)))))

(subclass Periodical Series)
(documentation Periodical "A &%Series whose elements are published separately
and on a periodic basis.")

(subclass Article Text)
(documentation Article "An article in a &%Book or &%Series.")

(=>
   (instance ?ARTICLE Article)
   (exists (?BOOK)
      (and
         (instance ?BOOK Book)
         (subsumesContentInstance ?BOOK ?ARTICLE))))

(subclass Certificate Text)
(documentation Certificate "A &%Text that confers a right or obligation
on the holder of the &%Certificate.  Note that the right or obligation
need not be a legal one, as in the case of an academic diploma that grants
certain privileges in the professional world.")

(=>
   (and
      (instance ?DOC Certificate)
      (possesses ?AGENT ?DOC))
   (exists (?PROC)
      (or
         (confersRight ?PROC ?DOC ?AGENT)
         (confersObligation ?PROC ?DOC ?AGENT))))

(subclass Patent Certificate)
(documentation Patent "A &%Certificate that expresses the content of an
invention that has been accorded legal protection by a governemental
entity.")

(subclass Molecule CompoundSubstance)
(documentation Molecule "A molecule is the smallest unit of matter of a
&%CompoundSubstance that retains all the physical and chemical properties
of that substance, e.g., Ne, H2, H2O.  A molecule is two or more &%Atoms
linked by a chemical bond.")

(=>
   (instance ?MOLE Molecule)
   (exists (?ATOM1 ?ATOM2)
      (and
         (instance ?ATOM1 Atom)
         (instance ?ATOM2 Atom)
         (part ?ATOM1 ?MOLE)
         (part ?ATOM2 ?MOLE)
         (not
            (equal ?ATOM1 ?ATOM2)))))

(subclass Artifact CorpuscularObject)
(documentation Artifact "A &%CorpuscularObject that is the product of an
&%IntentionalProcess.")

(=>
   (instance ?ARTIFACT Artifact)
   (exists (?MAKING)
      (and
         (instance ?PROCESS Making)
         (result ?MAKING ?ARTIFACT))))

(subclass Product Artifact)
(documentation Product "An &%Artifact that is produced by &%Manufacture and
that is intended to be sold.")

(=>
   (instance ?PRODUCT Product)
   (exists (?MANUFACTURE)
      (and
         (instance ?MANUFACTURE Manufacture)
         (result ?MANUFACTURE ?PRODUCT))))

(instance version BinaryPredicate)
(instance version AsymmetricRelation)
(instance version TransitiveRelation)
(domainSubclass version 1 Artifact)
(domainSubclass version 2 Artifact)
(documentation version "Some &%Artifacts have a life cycle with discrete
stages or versions.  (&%version ARTIFACT1 ARTIFACT2) means that ARTIFACT1
is a version of ARTIFACT2.  Note that this &%Predicate relates subclasses of
&%Artifact and not instances.")

(=>
    (version ?ARTIFACT1 ?ARTIFACT2)
    (subclass ?ARTIFACT1 ?ARTIFACT2))

;; The following part of the ontology will eventually encompass all
;; artifacts.  For the time being, it is mostly restricted to the content
;; of the Ontolingua ontology component-assemblies, which covers the types
;; of elements used to construct engineering systems.

(subclass StationaryArtifact Artifact)
(documentation StationaryArtifact "A &%StationaryArtifact is an &%Artifact
that has a fixed spatial location.  Most instances of this &%Class are
architectural works, e.g. the Eiffel Tower, the Great Pyramids, office towers,
single-family houses, etc.")

(=>
    (instance ?ARTIFACT StationaryArtifact)
    (exists (?PLACE)
       (forall (?TIME)
          (=>
             (and
                (beforeOrEqual ?TIME (EndFn (WhenFn ?ARTIFACT)))
                (beforeOrEqual (BeginFn (WhenFn ?ARTIFACT)) ?TIME))
             (equal (WhereFn ?ARTIFACT ?TIME) ?PLACE)))))

(subclass Building StationaryArtifact)
(documentation Building "The Class of &%StationaryArtifacts which are
intended to house &%Humans and their activities.")

(=>
   (instance ?BUILDING Building)
   (exists (?HUMAN)
      (and
         (instance ?HUMAN Human)
         (or
            (inhabits ?HUMAN ?BUILDING)
            (exists (?ACT)
               (and
                  (agent ?ACT ?HUMAN)
                  (located ?ACT ?BUILDING)))))))

(subclass Room StationaryArtifact)
(disjoint Room Building)
(documentation Room "A &%properPart of a &%Building which is separated from
the exterior of the &%Building and/or other &%Rooms of the &%Building by walls.
Some &%Rooms may have a specific purpose, e.g. sleeping, bathing, cooking,
entertainment, etc.")

(=>
   (instance ?ROOM Room)
   (exists (?BUILD)
      (and
         (instance ?BUILD Building)
         (properPart ?ROOM ?BUILD))))

(subclass ArtWork Artifact)
(documentation ArtWork "&%Artifacts that are created primarily for
aesthetic appreciation.  Note that this &%Class does not include
most examples of architecture, which belong under &%StationaryArtifact.")

(subclass Fabric Artifact)
(disjoint Fabric StationaryArtifact)
(documentation Fabric "&%Artifacts that are created by weaving together
natural or synthetic fibers or by treating the skins of certain sorts of
&%Animals.  Note that this &%Class includes articles that are created by
stitching together various types of fabrics, e.g. bedspreads.  On the other
hand, &%Clothing is not a &%subclass of &%Fabric, because many clothing items
contain elements that are not fabrics.")

(subclass Clothing Artifact)
(disjoint Clothing StationaryArtifact)
(documentation Clothing "&%Artifact made out of fabrics and possibly other
materials that are used to cover the bodies of &%Humans.")

(=>
   (instance ?CLOTHING Clothing)
   (exists (?FABRIC)
      (and
         (instance ?FABRIC Fabric)
         (part ?FABRIC ?CLOTHING))))

(subclass Device Artifact)
(documentation Device "A &%Device is an &%Artifact whose purpose is to
serve as an &%instrument in a specific type of task.")

(=>
   (instance ?DEVICE Device)
   (exists (?PROC)
      (and
         (subclass ?PROC Process)
         (capability ?PROC instrument ?DEVICE))))

(=>
   (instance ?DEVICE Device)
   (exists (?PROC)
      (and
         (subclass ?PROC Process)
         (hasPurpose ?DEVICE (capability ?PROC instrument ?DEVICE)))))

(subclass MusicalInstrument Device)
(documentation MusicalInstrument "A &%Device which is manipulated by a &%Human
and whose purpose is to produce &%Music.")

(=>
   (instance ?INSTRUMENT MusicalInstrument)
   (capability Music instrument ?INSTRUMENT))

(subclass TransportationDevice Device)
(documentation TransportationDevice "A &%TransportationDevice is a &%Device
which serves as the &%instrument in a &%Transportation &%Process which carries
the &%patient of the &%Process from one point to another.")

(=>
   (instance ?DEVICE TransportationDevice)
   (capability Transportation instrument ?DEVICE))

(subclass Weapon Device)
(documentation Weapon "The &%Class of &%Devices that are designed
primarily to damage or destroy &%Humans/&%Animals, &%StationaryArtifacts or
the places inhabited by &%Humans/&%Animals.")

(=>
   (instance ?WEAPON Weapon)
   (capability Damaging instrument ?WEAPON))

(=>
   (instance ?WEAPON Weapon)
   (hasPurpose ?WEAPON (exists (?DEST ?PATIENT)
                          (and
	 			     (instance ?DEST Damaging)
                             (patient ?DEST ?PATIENT)
                             (or
                                (instance ?PATIENT StationaryArtifact)
                                (instance ?PATIENT Animal)
                                (exists (?ANIMAL)
                                   (and
                                      (instance ?ANIMAL Animal)
                                      (inhabits ?ANIMAL ?PATIENT))))))))

(subclass Machine Device)
(documentation Machine "&%Machines are &%Devices that that have a
well-defined &%resource and &%result and that automatically convert
the &%resource into the &%result.")

(=>
   (instance ?MACHINE Machine)
   (forall (?PROC)
      (=>
         (instrument ?PROC ?MACHINE)
         (exists (?RESOURCE ?RESULT)
            (and
               (resource ?PROC ?RESOURCE)
               (result ?PROC ?RESULT))))))

(subclass EngineeringComponent Device)
(documentation EngineeringComponent "A fundamental concept that applies
in many engineering domains.  An &%EngineeringComponent is an element of
a &%Device that is a physically whole object, such as one might
see listed as standard parts in a catalog.  The main difference betweeen
&%EngineeringComponents and arbitrary globs of matter is that
&%EngineeringComponents are object-like in a modeling sense.  Thus, an
&%EngineeringComponent is not an arbtrary subregion, but a part of a
system with a stable identity.")

(=>
   (instance ?COMP EngineeringComponent)
   (exists (?DEVICE)
      (and
         (instance ?DEVICE Device)
         (component ?COMP ?DEVICE))))

(subrelation engineeringSubcomponent properPart)
(domain engineeringSubcomponent 1 EngineeringComponent)
(domain engineeringSubcomponent 2 EngineeringComponent)
(documentation engineeringSubcomponent "(&%engineeringSubcomponent ?SUB
?SUPER) means that the &%EngineeringComponent ?SUB is structurally a
&%properPart ?SUPER.  This relation is an &%AsymmetricRelation, since
two &%EngineeringComponents cannot be subcomponents of each other.")

(instance connectedEngineeringComponents SymmetricRelation)
(instance connectedEngineeringComponents IrreflexiveRelation)
(subrelation connectedEngineeringComponents connected)
(domain connectedEngineeringComponents 1 EngineeringComponent)
(domain connectedEngineeringComponents 2 EngineeringComponent)
(documentation connectedEngineeringComponents "This is the most general
connection relation between &%EngineeringComponents.  If
(&%connectedEngineeringComponents ?COMP1 ?COMP2), then neither ?COMP1 nor
?COMP2 can be an &%engineeringSubcomponent of the other.  The relation
&%connectedEngineeringComponents is a &%SymmetricRelation; there is no
information in the direction of connection between two components.  It is
also an &%IrreflexiveRelation; no &%EngineeringComponent bears this relation
to itself.  Note that this relation does not associate a name or type
with the connection.")

(=>
   (connectedEngineeringComponents ?COMP1 ?COMP2)
   (and
      (not
         (engineeringSubcomponent ?COMP1 ?COMP2))
      (not
         (engineeringSubcomponent ?COMP2 ?COMP1))))

(=>
   (connectedEngineeringComponents ?COMP1 ?COMP2)
   (not
      (or
         (instance ?COMP1 EngineeringConnection)
         (instance ?COMP2 EngineeringConnection))))

(<=>
   (connectedEngineeringComponents ?COMP1 ?COMP2)
   (exists (?CONNECTION)
      (connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))

(subclass EngineeringConnection EngineeringComponent)
(documentation EngineeringConnection "An &%EngineeringConnection is an
&%EngineeringComponent that represents a connection relationship between
two other &%EngineeringComponents.  It is a reification of the
&%Predicate &%connectedEngineeringComponents.  That means that whenever
this &%Predicate holds between two &%EngineeringComponents, there exists an
&%EngineeringConnection.  The practical reason for reifying a relationship
is to be able to attach other information about it. For example, one
might want to say that a particular connection is associated with some
shared parameters, or that it is of a particular type.
&%EngineeringConnections are &%EngineeringComponents and can therefore be
an &%engineeringSubcomponent of other &%EngineeringComponents.  However,
to provide for modular regularity in component systems,
&%EngineeringConnections cannot be connected.  For each pair of
&%EngineeringComponents related by &%connectedEngineeringComponents, there
exists at least one &%EngineeringConnection.  However, that object may not
be unique, and the same &%EngineeringConnection may be associated with
several pairs of &%EngineeringComponents.")

(=>
   (instance ?CONNECTION EngineeringConnection)
   (exists (?COMP1 ?COMP2)
      (connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))

(subrelation connectsEngineeringComponents connects)
(domain connectsEngineeringComponents 1 EngineeringConnection)
(domain connectsEngineeringComponents 2 EngineeringComponent)
(domain connectsEngineeringComponents 3 EngineeringComponent)
(documentation connectsEngineeringComponents "&%connectsEngineeringComponents
is a &%TernaryPredicate that maps from an &%EngineeringConnection to the
&%EngineeringComponents it connects.  Since &%EngineeringComponents cannot
be connected to themselves and there cannot be an &%EngineeringConnection
without a &%connectedEngineeringComponents &%Predicate, the second and third
arguments of any &%connectsEngineeringComponents relationship will always be
distinct for any given first argument.")

;; This following part contains definitions and axioms relating to social
;; groups and the relations between them.

(subclass Group Collection)
(subclass Group Agent)
(documentation Group "A &%Collection of &%Agents, e.g. a flock
of sheep, a herd of goats, or the local Boy Scout troop.")

(=>
   (and
      (instance ?GROUP Group)
      (member ?MEMB ?GROUP))
   (instance ?MEMB Agent))

(subclass AgeGroup Group)
(documentation AgeGroup "A &%Group whose &%members all have the same &%age.")

(=>
   (instance ?GROUP AgeGroup)
   (forall (?MEMB1 ?MEMB2 ?AGE1 ?AGE2)
      (=>
         (and
            (member ?MEMB1 ?GROUP)
            (member ?MEMB2 ?GROUP)
            (age ?MEMB1 ?AGE1)
            (age ?MEMB2 ?AGE2))
         (equal ?AGE1 ?AGE2))))

(subclass FamilyGroup Group)
(documentation FamilyGroup "A &%Group whose &%members bear
&%familyRelations to one another.")

(=>
   (instance ?GROUP FamilyGroup)
   (forall (?MEMB1 ?MEMB2)
      (=>
         (and
            (member ?MEMB1 ?GROUP)
            (member ?MEMB2 ?GROUP))
         (familyRelation ?MEMB1 ?MEMB2))))

(instance familyRelation BinaryPredicate)
(instance familyRelation EquivalenceRelation)
(domain familyRelation 1 Organism)
(domain familyRelation 2 Organism)
(documentation familyRelation "A very general &%Predicate for biological
relationships. (&%familyRelation ?ORGANISM1 ?ORGANISM2) means that
?ORGANISM1 and ?ORGANISM2 are biologically derived from a common ancestor.")

(=>
   (familyRelation ?ORGANISM1 ?ORGANISM2)
   (exists (?ORGANISM3)
      (and
         (familyRelation ?ORGANISM3 ?ORGANISM1)
         (familyRelation ?ORGANISM3 ?ORGANISM2))))

(subclass EthnicGroup Group)
(documentation EthnicGroup "A &%Group whose &%members originate from
the same &%GeographicArea or share the same &%Language and/or cultural
practices.")

(subclass OrganizationUnit CognitiveAgent)
(documentation OrganizationUnit "An organization, division or department
within an organization. For example, the Shell Corporation, the accounting
department at Shell, etc. would all be instances of &%OrganizationUnit.
The continued existence of an &%OrganizationUnit is not dependent on any of
its members, locations, or facilities. Note that, unlike &%Organization, an
&%OrganizationUnit may have no members.")

(subclass Organization Group)
(documentation Organization "An &%Organization is a corporate or similar
institution, distinguished from other &%Agents. The &%members of an
&%Organization typically have a common purpose or function. Note that
parts of &%Organizations should not be included here, unless they are
&%subOrganizations of an &%Organization.")

(instance OrganizationFn UnaryFunction)
(domain OrganizationFn 1 OrganizationUnit)
(range OrganizationFn Organization)
(documentation OrganizationFn "A &%UnaryFunction that maps an &%OrganizationUnit,
the notion of an organization which is independent of its members, locations,
and facilities, to the corresponding &%Organization, i.e. the &%Group of &%Humans
who are &%members of the &%Organization.  Note that this is a partial function,
since there are many cases of organizations which are legal entities but which
lack any members.")

(=>
   (and
      (equal (OrganizationFn ?UNIT) ?ORG)
      (instance ?ATTR NormativeAttribute))
   (<=>
      (modalAttribute ?UNIT ?ATTR)
      (modalAttribute ?ORG ?ATTR)))

(instance employs BinaryPredicate)
(domain employs 1 Organization)
(domain employs 2 CognitiveAgent)
(documentation employs "(&%employs ?ORG ?PERSON) means that ?ORG has
hired ?PERSON and currently retains ?PERSON, on a salaried or
contractual basis, to provide services in exchange for monetary
compensation.")

(=>
   (employs ?ORG ?PERSON)
   (member ?PERSON ?ORG))

(subclass Corporation Organization)
(documentation Corporation "An &%Organization that provides products and/or
services for a fee with the aim of making a profit.")

(subclass PoliticalOrganization Organization)
(documentation PoliticalOrganization "An &%Organization that is a &%Government,
a &%subOrganizations of a &%Government, or an &%Organization that is attempting
to bring about some sort of political change.")

(=>
   (instance ?POL PoliticalOrganization)
   (exists (?PROC)
      (and
         (instance ?PROC PoliticalProcess)
         (agent ?PROC ?POL))))

(subclass Government PoliticalOrganization)
(documentation Government "The ruling body of a &%Nation or one of the
&%subOrganizations of the ruling body of a &%Nation.")

(subclass EducationalOrganization Organization)
(documentation EducationalOrganization "A &%EducationalOrganization is
an institution of learning. Some examples are public and private K-12
schools, and colleges and universities.")

(subclass ReligiousOrganization Organization)
(subclass ReligiousOrganization BeliefGroup)
(documentation ReligiousOrganization "An &%Organization whose members
share a set of religious beliefs.")

(subrelation subOrganizations subCollection)
(instance subOrganizations IrreflexiveRelation)
(instance subOrganizations TransitiveRelation)
(domain subOrganizations 1 Organization)
(domain subOrganizations 2 Organization)
(documentation subOrganizations "(&%subOrganizations ?ORG1 ?ORG2) means
that ?ORG1 is an &%Organization which is a proper part of the
&%Organization ?ORG2.")

(instance citizen BinaryPredicate)
(instance citizen AsymmetricRelation)
(domain citizen 1 Human)
(domain citizen 2 Nation)
(documentation citizen "(&%citizen ?PERSON ?NATION) means that the
&%Human ?PERSON is a citizen of &%Nation ?NATION.")

;; END FILE

;; BEGIN FILE


;;;;;;;;;;;;;;;;;;;
;;   QUALITIES   ;;
;;;;;;;;;;;;;;;;;;;

;; INCLUDES 'MEREOTOPOLOGY'
;; INCLUDES 'PROCESSES'
;; INCLUDES 'OBJECTS'

(subclass FieldOfStudy Proposition)
(documentation FieldOfStudy "An academic or applied discipline with
recognized experts and with a core of accepted theory or practice.  Note
that &%FieldOfStudy is a &%subclass of &%Proposition, because a
&%FieldOfStudy is understood to be a body of abstract, informational
content, with varying degrees of certainty attached to each element of
this content.")

(subclass Procedure Proposition)
(documentation Procedure "A sequence-dependent specification.  Some
examples are &%ComputerPrograms, finite-state machines, cooking recipes,
musical scores, conference schedules, driving directions, and the scripts
of plays and movies.")

(subclass ComputerProgram Procedure)
(documentation ComputerProgram "A set of instructions in a computer
programming language that can be executed by a computer.")

(subclass Plan Procedure)
(documentation Plan "A specification of a sequence of &%Processes which
is intended to satisfy a specified purpose at some future time.")

(=>
    (and
       (instance ?PLAN Plan)
       (instance ?OBJ ContentBearingObject)
       (containsInformation ?OBJ ?PLAN))
    (exists (?PLANNING)
       (and
          (instance ?PLANNING Planning)
          (result ?PLANNING ?OBJ))))

(=>
    (instance ?PLAN Plan)
    (exists (?PURP)
        (hasPurpose ?PLAN ?PURP)))

(instance orientation SpatialRelation)
(instance orientation TernaryPredicate)
(domain orientation 1 Object)
(domain orientation 2 Object)
(domain orientation 3 PositionalAttribute)
(documentation orientation "A general &%Predicate for indicating how two
&%Objects are oriented with respect to one another.  For example,
(orientation ?OBJ1 ?OBJ2 North) means that ?OBJ1 is north of ?OBJ2, and
(orientation ?OBJ1 ?OBJ2 Vertical) means that ?OBJ1 is positioned
vertically with respect to ?OBJ2.")

(<=>
  (between ?OBJ1 ?OBJ2 ?OBJ3)
  (and
    (orientation ?OBJ2 ?OBJ1 Left)
    (orientation ?OBJ1 ?OBJ3 Left)))

(=>
   (and
      (orientation ?OBJ1 ?OBJ2 ?ATTR1)
      (contraryAttribute @ROW)
      (inList ?ATTR1 (ListFn @ROW))
      (inList ?ATTR2 (ListFn @ROW))
      (not (equal ?ATTR1 ?ATTR2)))
   (not
      (orientation ?OBJ1 ?OBJ2 ?ATTR2)))

(instance direction CaseRole)
(domain direction 1 Process)
(domain direction 2 DirectionalAttribute)
(documentation direction "(&%direction ?PROC ?ATTR) means that the
&%Process ?PROC is moving in the direction ?ATTR.  For example, one
would use this &%Predicate to represent the fact that Max is moving
&%North.")

(=>
   (holdsDuring ?TIME (direction ?PROC ?ATTR1))
   (forall (?ATTR2)
      (=>
         (holdsDuring ?TIME (direction ?PROC ?ATTR2))
         (equal ?ATTR2 ?ATTR1))))

(instance faces BinaryPredicate)
(domain faces 1 Object)
(domain faces 2 DirectionalAttribute)
(documentation faces "(&%faces ?OBJ ?DIRECTION) means that the front of
?OBJ (see &%FrontFn) is positioned towards the compass direction ?DIRECTION.
More precisely, it means that if a line were extended from the center of
?DIRECTION, the line would intersect with the front of ?OBJ before it
intersected with its back (see &%BackFn).")

(=>
   (holdsDuring ?TIME (faces ?PROC ?ATTR1))
   (forall (?ATTR2)
      (=>
         (holdsDuring ?TIME (faces ?PROC ?ATTR2))
         (equal ?ATTR2 ?ATTR1))))

(subclass TruthValue RelationalAttribute)
(documentation TruthValue "The &%Class of truth values, e.g. &%True and
&%False.  These are &%Attributes of &%Sentences and &%Propositions.")

(=>
   (and
      (property ?ITEM ?VALUE)
      (instance ?VALUE TruthValue))
   (or
      (instance ?ITEM Sentence)
      (instance ?ITEM Proposition)))

(instance True TruthValue)
(documentation True "The &%TruthValue of being true.")

(instance False TruthValue)
(contraryAttribute False True)
(documentation False "The &%TruthValue of being false.")

(instance Likely TruthValue)
(contraryAttribute Likely Unlikely)
(documentation Likely "The &%TruthValue of being probable, i.e. more likely than
not to be &%True.")

(=>
   (property ?FORMULA Likely)
   (greaterThan (ProbabilityFn (true ?FORMULA True)) (ProbabilityFn (true ?FORMULA False))))

(instance Unlikely TruthValue)
(documentation Unlikely "The &%TruthValue of being improbable, i.e. more likely
than not to be &%False.")

(=>
   (property ?FORMULA Unlikely)
   (greaterThan (ProbabilityFn (true ?FORMULA False)) (ProbabilityFn (true ?FORMULA True))))

(subrelation true property)
(domain true 1 (UnionFn Sentence Proposition))
(domain true 2 TruthValue)
(documentation true "The &%BinaryPredicate that relates a &%Sentence
to its &%TruthValue.")

(subclass PositionalAttribute RelationalAttribute)
(documentation PositionalAttribute "&%Attributes characterizing the
orientation of an &%Object, e.g. &%Vertical versus &%Horizontal, &%Left
versus &%Right etc.")

(subclass DirectionalAttribute PositionalAttribute)
(documentation DirectionalAttribute "The subclass of &%PositionalAttributes
that concern compass directions.")

(=>
   (and
      (orientation ?OBJ1 ?OBJ2 ?ATTR1)
      (instance ?ATTR1 DirectionalAttribute)
      (instance ?ATTR2 DirectionalAttribute)
      (not
         (equal ?ATTR1 ?ATTR2)))
   (not
      (orientation ?OBJ1 ?OBJ2 ?ATTR2)))

(instance North DirectionalAttribute)
(contraryAttribute North South East West)
(documentation North "The compass direction of &%North.")

(instance South DirectionalAttribute)
(documentation South "The compass direction of &%South.")

(<=>
   (orientation ?OBJ1 ?OBJ2 North)
   (orientation ?OBJ2 ?OBJ1 South))

(instance East DirectionalAttribute)
(documentation East "The compass direction of &%East.")

(instance West DirectionalAttribute)
(documentation West "The compass direction of &%West.")

(<=>
   (orientation ?OBJ1 ?OBJ2 East)
   (orientation ?OBJ2 ?OBJ1 West))

(instance Vertical PositionalAttribute)
(documentation Vertical "Attribute used to indicate that an &%Object
is positioned height-wise with respect to another &%Object.")

(instance Horizontal PositionalAttribute)
(contraryAttribute Horizontal Vertical)
(documentation Horizontal "Attribute used to indicate that an &%Object
is positioned width-wise with respect to another &%Object.")

(<=>
   (orientation ?OBJ1 ?OBJ2 Vertical)
   (orientation ?OBJ2 ?OBJ1 Horizontal))

(instance Above PositionalAttribute)
(contraryAttribute Above Below)
(documentation Above "This is a &%PositionalAttribute derived from the
up/down schema and not involving contact.  Note that this means directly
above, i.e., if one object is &%Above another object, then the projections
of the two objects overlap.")

(<=>
   (orientation ?OBJ1 ?OBJ2 Above)
   (orientation ?OBJ2 ?OBJ1 Below))

(=>
   (orientation ?OBJ1 ?OBJ2 Above)
   (not
      (connected ?OBJ1 ?OBJ2)))

(instance Below PositionalAttribute)
(documentation Below "This &%PositionalAttribute is derived from the
up/down schema and may or may not involve contact.  Note that this means
directly below, i.e., if one object is &%Below another object, then the
projections of the two objects overlap.")

(=>
   (orientation ?OBJ1 ?OBJ2 Below)
   (or
      (orientation ?OBJ2 ?OBJ1 On)
      (orientation ?OBJ2 ?OBJ1 Above)))

(instance Adjacent PositionalAttribute)
(documentation Adjacent "Used to assert that an object ?OBJ1 is close
to, near or abutting ?OBJ2.  This &%PositionalAttribute covers the
following common sense notions:  adjoins, abuts, is contiguous to,
is juxtaposed, and is close to.")

(=>
   (orientation ?OBJ1 ?OBJ2 Adjacent)
   (or
      (orientation ?OBJ1 ?OBJ2 Near)
      (connected ?OBJ1 ?OBJ2)))

(instance Left PositionalAttribute)
(documentation Left "This &%PositionalAttribute is derived from the
left/right schema.  Note that this means directly to the left, so that,
if one object is to the left of another, then the projections of the
two objects overlap.")

(instance Right PositionalAttribute)
(contraryAttribute Right Left)
(documentation Right "This &%PositionalAttribute is derived from the
left/right schema.  Note that this means directly to the right, so that,
if one object is to the right of another, then the projections of the
two objects overlap.")

(<=>
   (orientation ?OBJ1 ?OBJ2 Right)
   (orientation ?OBJ2 ?OBJ1 Left))

(instance Near PositionalAttribute)
(documentation Near "The relation of common sense adjacency.  Note that, if
an object is &%Near another object, then the objects are not &%connected.")

(=>
   (orientation ?OBJ1 ?OBJ2 Near)
   (not
      (connected ?OBJ1 ?OBJ2)))

(=>
   (orientation ?OBJ1 ?OBJ2 Near)
   (orientation ?OBJ2 ?OBJ1 Near))

(instance On PositionalAttribute)
(documentation On "This is used to assert that an object is on top of
another object, and it is derived from the up/down schema and involves
contact.")

(=>
   (orientation ?OBJ1 ?OBJ2 On)
   (connected ?OBJ1 ?OBJ2))

(=>
   (orientation ?OBJ1 ?OBJ2 On)
   (located ?OBJ1 ?OBJ2))

(=>
   (orientation ?OBJ1 ?OBJ2 On)
   (not
      (orientation ?OBJ2 ?OBJ1 On)))

(subclass TimeZone RelationalAttribute)
(documentation TimeZone "An &%Attribute which is used to specify coordinates
in which time measures are uniform, i.e. all time devices are synchronized to
the same &%TimePositions.")

(instance CoordinatedUniversalTimeZone TimeZone)
(documentation CoordinatedUniversalTimeZone "A &%TimeZone which functions
as the standard time zone.  It is also known as Zulu time (in the military),
Greenwich Mean Time, and the Western European time zone.  Note that whenever
a &%TimeZone is not specified, the &%TimePosition is understood to be with
respect to the &%CoordinatedUniversalTimeZone.")

(instance PacificTimeZone TimeZone)
(documentation PacificTimeZone "A &%TimeZone that covers much of the
western part of the United States.")

(=>
   (equal (RelativeTimeFn ?TIME1 PacificTimeZone) ?TIME2)
   (equal ?TIME2 (AdditionFn ?TIME1 8)))

(instance MountainTimeZone TimeZone)
(documentation MountainTimeZone "A &%TimeZone that covers much of the
Rocky Mountain region of the United States.")

(=>
   (equal (RelativeTimeFn ?TIME1 MountainTimeZone) ?TIME2)
   (equal ?TIME2 (AdditionFn ?TIME1 7)))

(instance CentralTimeZone TimeZone)
(documentation CentralTimeZone "A &%TimeZone that covers much of the
midwestern United States.")

(=>
   (equal (RelativeTimeFn ?TIME1 CentralTimeZone) ?TIME2)
   (equal ?TIME2 (AdditionFn ?TIME1 6)))

(instance EasternTimeZone TimeZone)
(documentation EasternTimeZone "A &%TimeZone that covers much of the
eastern United States.")

(=>
   (equal (RelativeTimeFn ?TIME1 EasternTimeZone) ?TIME2)
   (equal ?TIME2 (AdditionFn ?TIME1 5)))

(instance RelativeTimeFn BinaryFunction)
(instance RelativeTimeFn TemporalRelation)
(domain RelativeTimeFn 1 TimePosition)
(domain RelativeTimeFn 2 TimeZone)
(range RelativeTimeFn TimePosition)
(documentation RelativeTimeFn "A means of converting &%TimePositions
between different &%TimeZones.  (&%RelativeTimeFn ?TIME ?ZONE)
denotes the &%TimePosition in &%CoordinatedUniversalTime that is
contemporaneous with the &%TimePosition ?TIME in &%TimeZone ?ZONE.
For example, (&%RelativeTimeFn (&%MeasureFn 14 &%Hour) &%EasternTimeZone)
would return the value (&%MeasureFn 19 &%Hour).")

(subclass SocialRole RelationalAttribute)
(documentation SocialRole "The &%Class of all &%Attributes that
specify the position or status of a &%CognitiveAgent within an
&%Organization or other &%Group.")

(=>
   (and
      (attribute ?PERSON ?ATTRIBUTE)
      (instance ?ATTRIBUTE SocialRole))
   (instance ?PERSON Human))

(subclass OccupationalRole SocialRole)
(documentation OccupationalRole "The &%Class of all &%Attributes that
specify an occupational role of a &%CognitiveAgent.")

(instance Unemployed OccupationalRole)
(documentation Unemployed "The &%Attribute of a &%CognitiveAgent when
he/she is unemployed.")

(<=>
   (forall (?ORG)
      (and
         (not (employs ?ORG ?PERSON))
         (instance ?PERSON Human)))
   (attribute ?PERSON Unemployed))

(subclass Position OccupationalRole)
(documentation Position "A formal position of reponsibility within an
&%Organization. Examples of &%Positions include president, laboratory
director, senior researcher, sales representative, etc.")

(instance occupiesPosition TernaryPredicate)
(domain occupiesPosition 1 Human)
(domain occupiesPosition 2 Position)
(domain occupiesPosition 3 Organization)
(documentation occupiesPosition "(&%occupiesPosition ?PERSON ?POSITION ?ORG)
means that ?PERSON holds the &%Position ?POSITION at &%Organization ?ORG.
For example, (&%occupiesPosition &%TomSmith &%ResearchDirector
&%AcmeLaboratory) means that &%TomSmith is a research director at Acme Labs.")

(=>
   (employs ?ORG ?PERSON)
   (exists (?POSITION)
      (occupiesPosition ?PERSON ?POSITION ?ORG)))

(subclass NormativeAttribute RelationalAttribute)
(documentation NormativeAttribute "A &%Class containing all of the
&%Attributes that are specific to judgements about morality, legality,
aesthetics, etiquette, etc.  In general, these judgements express that
something ought to be the case.")

(instance modalAttribute BinaryPredicate)
(instance modalAttribute AsymmetricRelation)
(instance modalAttribute IrreflexiveRelation)
(subrelation modalAttribute property)
(domain modalAttribute 1 Formula)
(domain modalAttribute 2 NormativeAttribute)
(documentation modalAttribute "A &%BinaryRelation that is used to state the
normative force of a &%Proposition.  (&%modalAttribute ?FORMULA ?PROP) means
that the &%Proposition expressed by ?FORMULA has the &%NormativeAttribute
?PROP.  For example, (&%modalAttribute (&%exists (?ACT ?OBJ) (&%and
(&%instance ?ACT &%Giving) (&%agent ?ACT John) (&%patient ?ACT ?OBJ)
(&%destination ?ACT Tom))) &%Obligation) means that John is obligated to give
Tom something.")

(=>
   (and
      (modalAttribute ?FORMULA1 ?PROP)
      (entails ?FORMULA1 ?FORMULA2))
   (modalAttribute ?FORMULA2 ?PROP))

(=>
   (holdsObligation ?PROCESS ?AGENT)
   (modalAttribute (exists (?INSTANCE)
                     (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT))) Obligation))

(=>
   (holdsRight ?PROCESS ?AGENT)
   (modalAttribute (exists (?INSTANCE)
                     (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT))) Permission))

(subclass SubjectiveAssessmentAttribute NormativeAttribute)
(disjoint SubjectiveAssessmentAttribute ObjectiveNorm)
(documentation SubjectiveAssessmentAttribute "The &%Class of &%NormativeAttributes
which lack an objective criterion for their attribution, i.e. the attribution of
these &%Attributes varies from subject to subject and even with respect to the
same subject over time.  This &%Class is, generally speaking, only used when
mapping external knowledge sources to the SUMO.  If a term from such a knowledge
source seems to lack objective criteria for its attribution, it is assigned to
this &%Class.")

(subclass ObjectiveNorm NormativeAttribute)
(documentation ObjectiveNorm "The &%Class of &%NormativeAttributes that are
associated with an objective criterion for their attribution, i.e. there is
broad consensus about the cases where these attributes are applicable.")

(subclass ContestAttribute ObjectiveNorm)
(documentation ContestAttribute "A &%Class containing all of the
&%Attributes that are specific to participants in a &%Contest.  Some
of these &%Attributes are winning, losing, won, lost, etc.")

(=>
   (and
      (attribute ?OBJ ?ATTR)
      (instance ?ATTR ContestAttribute))
   (exists (?CONTEST)
      (and
         (instance ?CONTEST Contest)
         (or
            (agent ?CONTEST ?OBJ)
            (patient ?CONTEST ?OBJ)))))

(subclass AlethicAttribute ObjectiveNorm)
(documentation AlethicAttribute "A &%Class containing all of the &%Attributes
relating to the notions of possibility and necessity.")

(instance Possibility AlethicAttribute)
(documentation Possibility "Attribute that applies to &%Propositions that are
possible, i.e. true in at least one possible world.")

(instance Necessity AlethicAttribute)
(documentation Necessity "Attribute that applies to &%Propositions that are
necessary, i.e. true in every possible world.")

(<=>
   (modalAttribute ?FORMULA Necessity)
   (not (modalAttribute (not ?FORMULA) Possibility)))

(=>
   (modalAttribute ?FORMULA Necessity)
   (modalAttribute ?FORMULA Possibility))

(subclass DeonticAttribute ObjectiveNorm)
(documentation DeonticAttribute "A &%Class containing all of the &%Attributes
relating to the notions of permission, obligation, and prohibition.")

(instance Permission DeonticAttribute)
(documentation Permission "&%Attribute that applies to &%Propositions that an
&%Agent is permitted, by some authority, to make true.")

(instance Obligation DeonticAttribute)
(documentation Obligation "&%Attribute that applies to &%Propositions that an
&%Agent is required, by some authority, to make true.")

(<=>
   (modalAttribute ?FORMULA Obligation)
   (not (modalAttribute (not ?FORMULA) Permission)))

(=>
   (modalAttribute ?FORMULA Obligation)
   (modalAttribute ?FORMULA Permission))

(subAttribute Law Obligation)
(documentation Law "&%Attribute that applies to &%Propositions that are
required by a government or a branch of the government and that are enforced
with penalties for noncompliance.  These &%Propositions may be codified as
legislation or they may be more informal, as in the case of government policy.")

(subAttribute Promise Obligation)
(documentation Promise "&%Attribute that applies to &%Propositions that
an &%Agent promises to make true.  &%Promises may be implicit or explicit.
They may be expressed in a written or verbal or gestural manner.")

(=>
   (property ?ENTITY Promise)
      (or
         (property ?ENTITY Contract)
         (property ?ENTITY NakedPromise)))

(subAttribute Contract Promise)
(documentation Contract "&%Attribute that applies to &%Propositions where
something is promised in return, i.e. a reciprocal promise.")

(subAttribute PurchaseContract Contract)
(documentation PurchaseContract "A &%Contract between two &%Agents in
which one &%Agent agrees to render the other some good or service in
exchange for currency.")

(subAttribute ServiceContract Contract)
(documentation ServiceContract "A &%Contract where an &%Agent agrees to
perform a service for another &%Agent (usually for a price).")

(subAttribute Warranty ServiceContract)
(documentation Warranty "A &%Contract that states the cirumstances
under which defects in the product will be corrected for no charge.
A &%Warranty is usually limited to a length of time that is specified
in the &%Warranty itself.  A &%Warranty also includes information about
what is not covered and actions that invalidate the &%Warranty.")

(subAttribute NakedPromise Promise)
(contraryAttribute NakedPromise Contract)
(documentation NakedPromise "A &%Promise where nothing is promised in return,
i.e. a nudum pactum.")

(subclass PhysicalState InternalAttribute)
(contraryAttribute Solid Liquid Gas)
(exhaustiveAttribute PhysicalState Solid Liquid Gas)
(documentation PhysicalState "The physical state of an &%Object.  There
are three instances of this &%Class:  &%Solid, &%Liquid, and &%Gas.
Physical changes are not characterized by the transformation of one
substance into another, but rather by the change of the form (physical
states) of a given substance. The bending of a piece of copper wire fails
to change the copper into another substance; crushing a block of ice leaves
only crushed ice; melting an iron nail yields a substance still called
iron: these are all accepted as physical changes.")

(instance Solid PhysicalState)
(documentation Solid "An &%Object has the &%Attribute of &%Solid if it
has a fixed shape and a fixed volume.")

(instance Liquid PhysicalState)
(documentation Liquid "An &%Object has the &%Attribute of &%Liquid if
it has a fixed volume but not a fixed shape.")

(=>
   (instance ?OBJ Solution)
   (attribute ?OBJ Liquid))

(instance Gas PhysicalState)
(documentation Gas "An &%Object has the &%Attribute of &%Gas if it has
neither a fixed volume nor a fixed shape.")

(<=>
   (instance ?OBJ Substance)
   (exists (?ATTR)
      (and
         (instance ?ATTR PhysicalState)
         (attribute ?OBJ ?ATTR))))

(subclass PerceptualAttribute InternalAttribute)
(documentation PerceptualAttribute "Any &%Attribute whose presence is detected
by an act of &%Perception.")

(=>
   (and
      (instance ?PERCEPTION Perception)
      (patient ?PERCEPTION ?OBJ))
   (exists (?PROP)
      (and
         (instance ?PROP PerceptualAttribute)
         (attribute ?OBJ ?PROP))))

(subclass TasteAttribute PerceptualAttribute)
(documentation TasteAttribute "The &%Class of &%Attributes relating to
the taste of &%Objects.")

(=>
   (instance ?OBJ Food)
   (exists (?ATTR)
      (and
         (instance ?ATTR TasteAttribute)
         (attribute ?OBJ ?ATTR))))

(subclass OlfactoryAttribute PerceptualAttribute)
(documentation OlfactoryAttribute "The &%Class of properties that are
detectable by smell.")

(subclass VisualAttribute PerceptualAttribute)
(documentation VisualAttribute "The &%Class of visually discernible
properties.")

(instance Illuminated VisualAttribute)
(documentation Illuminated "The &%Attribute of &%Regions that are
illuminated to some degree, i.e. in which some shapes are visually
discernable.")

(instance Unilluminated VisualAttribute)
(contraryAttribute Unilluminated Illuminated)
(documentation Unilluminated "The &%Attribute of &%Regions that are
unilluminated, i.e in which no shapes are visually discernable.")

(subclass ColorAttribute VisualAttribute)
(documentation ColorAttribute "The &%Class of &%VisualAttributes
relating to the color of &%Objects.")

(subclass PrimaryColor ColorAttribute)
(documentation PrimaryColor "Colors which can be blended to form any
color and which cannot be derived from any other colors.")

(instance Red PrimaryColor)
(documentation Red "The &%Attribute of redness.")

(instance Blue PrimaryColor)
(documentation Blue "The &%Attribute of being blue in color.")

(instance Yellow PrimaryColor)
(documentation Yellow "The &%Attribute of being yellow in color.")

(instance White PrimaryColor)
(documentation White "The &%Attribute of being white in color.")

(instance Black PrimaryColor)
(documentation Black "The &%Attribute of being black in color.")

(instance Monochromatic ColorAttribute)
(documentation Monochromatic "An &%Object with this &%Attribute has
the same color on every part of its surface.")

(=>
   (and
      (attribute ?OBJ Monochromatic)
      (superficialPart ?PART ?OBJ)
      (attribute ?PART ?COLOR)
      (instance ?COLOR PrimaryColor))
   (forall (?ELEMENT)
      (=>
         (superficialPart ?ELEMENT ?OBJ)
         (attribute ?ELEMENT ?COLOR))))

(=>
   (instance ?OBJ Object)
   (or
      (attribute ?OBJ Monochromatic)
      (attribute ?OBJ Polychromatic)))

(instance Polychromatic ColorAttribute)
(contraryAttribute Polychromatic Monochromatic)
(documentation Polychromatic "An &%Object with this &%Attribute has
different colors on different parts of its surface.")

(=>
   (attribute ?OBJ Polychromatic)
   (exists (?PART1 ?PART2 ?COLOR1 ?COLOR2)
      (and
         (superficialPart ?PART1 ?OBJ)
         (superficialPart ?PART2 ?OBJ)
         (attribute ?PART1 ?COLOR1)
         (attribute ?PART2 ?COLOR2)
         (instance ?COLOR1 ColorAttribute)
         (instance ?COLOR2 ColorAttribute)
         (not (equal ?COLOR1 ?COLOR2)))))

(subclass ShapeAttribute InternalAttribute)
(documentation ShapeAttribute "Any &%Attribute that relates to the
shape of an &%Object.")

(instance Pliable ShapeAttribute)
(documentation Pliable "The shape of an &%Object with this &%Attribute
can be altered.")

(=>
   (exists (?CHANGE)
      (and
         (instance ?CHANGE ShapeChange)
         (patient ?CHANGE ?OBJ)))
   (attribute ?OBJ Pliable))

(instance Rigid ShapeAttribute)
(contraryAttribute Rigid Pliable)
(documentation Rigid "The shape of an &%Object with this &%Attribute
cannot be altered.")

(=>
   (instance ?OBJ SelfConnectedObject)
   (or
      (attribute ?OBJ Pliable)
      (attribute ?OBJ Rigid)))

(subclass TextureAttribute PerceptualAttribute)
(documentation TextureAttribute "Any &%Attribute that characterizes the
texture of an &%Object.")

(=>
   (and
      (instance ?ATTRIBUTE TextureAttribute)
      (attribute ?OBJ ?ATTRIBUTE)
      (surface ?SURFACE ?OBJ))
   (attribute ?SURFACE ?ATTRIBUTE))

(subclass SoundAttribute PerceptualAttribute)
(documentation SoundAttribute "Any &%Attribute that characterizes the
sound made by an &%Object.")

(subclass SaturationAttribute InternalAttribute)
(documentation SaturationAttribute "A &%Class of &%Attributes that specify, in
a qualitative manner, the extent of the presence of one kind of &%Object in
another kind of &%Object.")

(instance Dry SaturationAttribute)
(contraryAttribute Dry Damp)
(documentation Dry "An &%Attribute which indicates that the associated
&%Object contains no &%Liquid.")

(=>
   (attribute ?OBJ Dry)
   (not
      (exists (?SUBOBJ)
         (and
            (part ?SUBOBJ ?OBJ)
            (attribute ?SUBOBJ Liquid)))))

(instance Damp SaturationAttribute)
(documentation Damp "An &%Attribute which indicates that the associated
&%Object contains some &%Liquid.")

(instance Wet SaturationAttribute)
(subAttribute Wet Damp)
(documentation Wet "An &%Attribute which indicates that the
associated &%Object is fully saturated with a &%Liquid, i.e.
every part of the &%Object has a subpart which is a &%Liquid.")

(=>
   (attribute ?OBJ Wet)
   (forall (?PART)
      (=>
         (part ?PART ?OBJ)
         (exists (?SUBPART)
            (and
               (part ?SUBPART ?PART)
               (attribute ?SUBPART Liquid))))))

(subclass BreakabilityAttribute InternalAttribute)
(documentation BreakabilityAttribute "A &%subclass of &%Attributes for
characterizing the breakability of &%CorpuscularObjects.")

(instance Fragile BreakabilityAttribute)
(documentation Fragile "An &%Attribute which indicates that the
associated &%Object is very breakable.")

(instance Unbreakable BreakabilityAttribute)
(contraryAttribute Unbreakable Fragile)
(documentation Unbreakable "An &%Attribute which indicates that the
associated &%Object cannot be broken.")

(=>
   (attribute ?OBJ Unbreakable)
   (not (exists (?DAMAGE)
      (and
         (instance ?DAMAGE Damaging)
         (patient ?DAMAGE ?OBJ)))))

(subclass BiologicalAttribute InternalAttribute)
(documentation BiologicalAttribute "&%Attributes that apply specifically
to instances of &%Organism.")

(=>
    (and
        (attribute ?ORG ?ATT)
        (instance ?ATT BiologicalAttribute))
    (instance ?ORG Organism))

(subclass AnimacyAttribute BiologicalAttribute)
(exhaustiveAttribute AnimacyAttribute Living Dead)
(documentation AnimacyAttribute "&%Attributes that indicate whether an
&%Organism is alive or not.")

(instance Living AnimacyAttribute)
(documentation Living "This &%Attribute applies to &%Organisms that are
alive.")

(=>
   (and
      (instance ?ORGANISM Organism)
      (agent ?PROCESS ?ORGANISM))
   (holdsDuring (WhenFn ?PROCESS) (attribute ?ORGANISM Living)))

(instance Dead AnimacyAttribute)
(contraryAttribute Dead Living)
(documentation Dead "This &%Attribute applies to &%Organisms that are
not alive.")

(=>
   (instance ?ORG Organism)
   (exists (?ATTR)
      (and
         (instance ?ATTR AnimacyAttribute)
         (attribute ?ORG ?ATTR))))

(subclass SexAttribute BiologicalAttribute)
(exhaustiveAttribute SexAttribute Female Male)
(documentation SexAttribute "&%Attributes that indicate the sex of an
&%Organism.")

(instance Female SexAttribute)
(documentation Female "An &%Attribute indicating that an &%Organism is
female in nature.")

(=>
   (and
      (instance ?BODY ReproductiveBody)
      (part ?BODY ?ORG)
      (instance ?ORG Organism))
(attribute ?ORG Female))

(instance Male SexAttribute)
(contraryAttribute Male Female)
(documentation Male "An &%Attribute indicating that an &%Organism is
male in nature.")

(=>
   (instance ?ANIMAL Animal)
   (exists (?ATTR)
      (and
         (instance ?ATTR SexAttribute)
         (attribute ?ANIMAL ?ATTR))))

(subclass DevelopmentalAttribute BiologicalAttribute)
(exhaustiveAttribute DevelopmentalAttribute FullyFormed NonFullyFormed)
(documentation DevelopmentalAttribute "&%Attributes that indicate the
stage of development of an &%Organism.")

(instance FullyFormed DevelopmentalAttribute)
(documentation FullyFormed "The stage of an &%Organism when it has reached
the end of its growth phase.")

(=>
   (attribute ?OBJ FullyFormed)
   (exists (?GROWTH)
      (and
         (instance ?GROWTH Growth)
         (experiencer ?GROWTH ?OBJ)
         (holdsDuring (BeginFn (WhenFn ?OBJ)) (attribute ?OBJ NonFullyFormed)))))

(instance NonFullyFormed DevelopmentalAttribute)
(contraryAttribute NonFullyFormed FullyFormed)
(successorAttribute NonFullyFormed FullyFormed)
(documentation NonFullyFormed "The stage of an &%Organism before it is
&%FullyFormed.")

(=>
   (instance ?ORG Organism)
   (exists (?ATTR)
      (and
         (instance ?ATTR DevelopmentalAttribute)
         (attribute ?ORG ?ATTR))))

(instance Larval DevelopmentalAttribute)
(subAttribute Larval NonFullyFormed)
(documentation Larval "Form of most &%Invertebrates, &%Amphibians, and
&%Fish immediately after they hatch.  This form is fundamentally unlike
the adult form, and metamorphosis is required to reach the latter form.")

(=>
   (holdsDuring ?TIME (attribute ?ORG Larval))
   (holdsDuring (PastFn ?TIME) (exists (?BIRTH) (and (instance ?BIRTH Birth) (experiencer ?BIRTH ?ORG)))))

(instance Embryonic DevelopmentalAttribute)
(subAttribute Embryonic NonFullyFormed)
(contraryAttribute Embryonic Larval)
(documentation Embryonic "The stage of an &%Organism or an
&%AnatomicalStructure that exists only before the &%Organism is born.
&%Mammals, for example, have this &%Attribute only prior to
their birth.")

(=>
   (attribute ?ORG Embryonic)
   (exists (?BODY)
      (and
         (instance ?BODY ReproductiveBody)
         (located ?ORG ?BODY))))

(=>
   (holdsDuring ?TIME (attribute ?ORG Embryonic))
   (holdsDuring ?TIME (not (exists (?BIRTH) (and (instance ?BIRTH Birth) (experiencer ?BIRTH ?ORG))))))

(subclass DiseaseOrSyndrome BiologicalAttribute)
(documentation DiseaseOrSyndrome "A &%BiologicalAttribute which qualifies
something that alters or interferes with a normal process, state or activity
of an &%Organism.  It is usually characterized by the abnormal functioning of
one or more of the host's systems, parts, or &%Organs.")

(subclass PsychologicalAttribute BiologicalAttribute)
(partition PsychologicalAttribute StateOfMind TraitAttribute)
(documentation PsychologicalAttribute "&%Attributes that characterize the mental
or behavioral life of an &%Organism.")

(=>
   (instance ?ATTR PsychologicalAttribute)
   (=>
      (holdsDuring ?TIME (attribute ?ORGANISM ?ATTR))
      (holdsDuring ?TIME (attribute ?ORGANISM Living))))

(=>
   (and
      (instance ?ATTR PsychologicalAttribute)
      (attribute ?AGENT ?ATTR))
   (instance ?AGENT SentientAgent))

(subclass StateOfMind PsychologicalAttribute)
(documentation StateOfMind  "The class &%StateOfMind is distinguished from
its complement &%TraitAttribute by the fact that instances of the former are
transient while instances of the latter are persistent features of a creature's behavioral/psychological make-up.")

(subclass EmotionalState StateOfMind)
(documentation EmotionalState "The &%Class of &%Attributes that denote emotional
states of &%Organisms.")

(subclass ConsciousnessAttribute StateOfMind)
(documentation ConsciousnessAttribute "&%Attributes that indicate whether
an &%Organism is conscious or the qualitative degree of consciousness of
an &%Organism.")

(<=>
   (and
      (instance ?AGENT SentientAgent)
      (attribute ?AGENT Living))
   (exists (?ATTR)
      (and
         (instance ?ATTR ConsciousnessAttribute)
         (attribute ?AGENT ?ATTR))))

(subclass Asleep ConsciousnessAttribute)
(contraryAttribute Asleep Unconscious Awake)
(documentation Asleep "This &%Attribute applies to &%Organisms that are
sleeping.")

(subclass Unconscious ConsciousnessAttribute)
(contraryAttribute Unconscious Awake)
(documentation Unconscious "This &%Attribute applies to &%Organisms that
are unconscious because of a non-natural process, e.g. a blow to the head,
a drug, etc.  Note that the &%Attribute &%Asleep is used to describe the
&%ConsciousnessAttribute of an &%Organism that is asleep.")

(subclass Awake ConsciousnessAttribute)
(documentation Awake "This &%Attribute applies to &%Organisms that are
neither &%Unconscious nor &%Asleep.")

(subclass TraitAttribute PsychologicalAttribute)
(documentation TraitAttribute "&%Attributes that indicate the the
behavior/personality traits of an &%Organism.")

(subclass PsychologicalDysfunction PsychologicalAttribute)
(subclass PsychologicalDysfunction DiseaseOrSyndrome)
(documentation PsychologicalDysfunction "A clinically significant
dysfunction whose major manifestation is behavioral or psychological.
These dysfunctions may have identified or presumed biological etiologies
or manifestations.")


;;  END FILE

;; ================================================
;; QoS DOMAIN ONTOLOGY rev. 2002-08-14
;; ================================================

;; definition of Product


(subclass Product Entity)
(documentation Product "Something produced by human or mechanical effort.")

(=>
	(and
		(instance ?Product Product)
		(instance ?Product CorpuscularObject))
	(instance ?Product Artifact))

(=>
	(and
		(instance ?Product Product)
		(instance ?Product Proposition))
	(exists (?Object ?Process)
		(and
			(instance ?Object ContentBearingObject)
			(containsInformation ?Object ?Product)
			(instance ?Process IntentionalProcess)
			(result ?Process ?Object))))

;; definition of productModel

(instance productModel AsymmetricRelation)
(subrelation productModel represents)
(domain productModel 1 SymbolicString)
(domainSubclass productModel 2 Product)
(documentation productModel "(productModel ?Model ?Product) means that
?Model represents the type of the Product ?Product")

;; definition of ComputationalSystem

(subclass ComputationalSystem Product)
(documentation ComputationalSystem "Instances of &%ComputationalSystems
include instances of &%SoftwareSystems, &%HardwareSystems, and
&%ComputerNetworks.")

;; definition of Computer

(subclass Computer Device)
(documentation Computer "A general-purpose machine that processes
data according to a set of instructions that are stored internally
either temporarily or permanently.")

;; definition of ComputerNetwork

(subclass ComputerNetwork ComputationalSystem)
(documentation ComputerNetwork "The network includes the network
operating system in the client and server machines, the cables
connecting them and all supporting hardware in between such as
bridges, routers and switches.")

;; definition of LAN

(subclass LAN ComputerNetwork)
(disjointDecomposition LAN BusNetwork StarNetwork RingNetwork)
(documentation LAN "A computer network that spans a relatively small
area. Most LANs are confined to a single building or group of buildings.
However, one LAN can be connected to other LANs over any distance via
telephone lines and radio waves.")

;; definition of BusNetwork

(subclass BusNetwork LAN)
(documentation BusNetwork "A network in which all nodes are connected
to a single wire (the bus) that has two endpoints. Ethernet 10Base-2
and 10Base-5 networks, for example, are bus networks. Other common
network types include &%StarNetworks and &%RingNetworks.")

;; definition of StarNetwork

(subclass StarNetwork LAN)
(documentation StarNetwork "A local-area network (LAN) that uses a star
topology in which all nodes are connected to a central computer.")

;; definition of RingNetwork

(subclass RingNetwork LAN)
(documentation LAN "A local-area network (LAN) whose topology is a ring.
That is, all of the nodes are connected in a closed loop.  Messages
travel around the ring, with each node reading those messages addressed
to it.")

;; definition of ComputerHardware

(subclass ComputerHardware EngineeringComponent)
(documentation ComputerHardware "The hardware is the physical part of
a computer system; the machinery and equipment.")

(<=>
	(instance ?Hardware ComputerHardware)
	(exists (?Computer)
		(and
			(instance ?Computer Computer)
			(component ?Hardware ?Computer))))

;; definition of ComputerMemory

(subclass ComputerMemory ComputerHardware)
(documentation ComputerMemory	"The computer's workspace (physically,
a collection of RAM chips). It is an important resource, since it
determines the size and number of programs that can be run at the
same time, as well as the amount of data that can be processed
instantly.")

;; definition of HardDiskDrive

(subclass HardDiskDrive ComputerHardware)
(documentation HardDiskDrive "The primary computer storage medium, which
is made of one or more aluminum or glass platters, coated with a
ferromagnetic material. Most hard disks are fixed disks, which are
permanently sealed in the drive.")

;; definition of CPU

(subclass CPU ComputerHardware)
(documentation CPU "CPU (Central Processing Unit) is the computing part
of the computer.")

;; definition of DataTransfer

(subclass DataTransfer ComputerProcess)
(documentation DataTransfer "A subclass of &%ComputerProcesses which
send data over a computer channel or bus.")

(=>
	(instance ?Transfer DataTransfer)
	(exists (?Origin ?Destination ?System ?Data)
		(and
			(origin ?Transfer ?Origin)
			(destination ?Transfer ?Destination)
			(instrument ?Transfer ?System)
			(patient ?Transfer ?Data)
			(instance ?Data ComputerData)
			(instance ?System HardwareSystem)
			(instance ?Origin HardwareSystem)
			(instance ?Destination ComputationalSystem))))

;;definition of ComputerProcess

(subclass ComputerProcess InternalChange)
(documentation ComputerProcess "An instance of &%ComputerProcess is a
process which manipulates data in the computer.")

(=>
     (instance ?Process ComputerProcess)
     (exists (?Computer ?Program)
	     (and
	             (instance ?Computer Computer)
		     (computerRunning ?Process ?Computer)
		     (instance ?Program ComputerProgram)
		     (programRunning ?Process ?Program))))

(=>
	(programRunning ?Process ?Program)
	(exists (?Computer)
		(runningOn ?Program ?Computer)))

;; definition of ComputerFile

(subclass ComputerFile ComputerData)
(documentation ComputerFile "A collection of bytes stored as an
individual entity. All data on disk is stored as a file with an
assigned file name that is unique within the folder (directory)
it resides in.")

;;  definition of ComputerDirectory

(subclass ComputerDirectory ComputerFile)
(documentation ComputerDirectory "This is the class of catalogs that
identify and locate instances of &%ComputerFiles.  The catalog's entries
consist of at least &%ComputerFile names and a physical address on a memory
device of the &%ComputerFile or an index (e.g., file descriptor) into a
table of &%ComputerFile physical addresses.  &%ComputerDirectories are thus
collections of data elements and must be named and stored on memory devices;
hence, &%ComputerDirectory is a subset of &%ComputerFile.")

;; definition of runningOn

(instance runningOn BinaryRelation)
(domain runningOn 1 ComputerProgram)
(domain runningOn 2 Computer)
(documentation runningOn "(runningOn ?Program ?Computer) holds if the
&%ComputerProgram ?Program is being executed on ?Computer.")

(=>
	(runningOn ?Program ?Computer)
	(exists (?Process)
		(and
			(programRunning ?Process ?Program)
			(computerRunning ?Process ?Computer))))

;; definition of computerRunning

(subrelation computerRunning instrument)
(domain computerRunning 1 ComputerProcess)
(domain computerRunning 2 Computer)
(documentation computerRunning "(&%computerRunning ?Process ?Computer)
means that the ComputerProcess ?Process is running on ?Computer.")

;; definition of programRunning

(domain programRunning 1 ComputerProcess)
(domain programRunning 2 ComputerProgram)
(documentation programRunning "(&%programRunning ?Process ?Program)
means that the &%ComputerProcess ?Process is executing the
&%ComputerProgram ?Program.")

;;  definition of directoryOf

(instance directoryOf BinaryPredicate)
(domain directoryOf 1 ComputerFile)
(domain directoryOf 2 ComputerDirectory)
(documentation directoryOf "(&%directoryOf ?FILE ?DIRECTORY) means that
the &%ComputerFile ?FILE is in the &%ComputerDirectory ?DIRECTORY.")

;;  definition of PhysicalAddress.

(subclass PhysicalAddress SymbolicString)
(documentation PhysicalAddress "The collection of all addresses which
identify a location of a &%ComputerFile.")

;;  definition of AddressFn .

(instance AddressFn UnaryFunction)
(domain AddressFn 1 ComputerFile)
(range AddressFn PhysicalAddress)
(documentation AddressFn "(&%AddressFn ?FILE) returns as its value the
physical address of the &%ComputerFile ?FILE.")

; "ComputerDirectories contain information about the physical addresses
; of ComputerFiles which are listed in these directories" .

(=>
	(and
		(instance ?Directory ComputerDirectory)
		(instance ?File ComputerFile)
		(directoryOf ?File ?Directory))
	(refers (AddressFn ?File) ?Directory))

;; definition of BitsPerSecond

(subclass BitsPerSecond TimeDependentQuantity)
(instance BitsPerSecond UnitOfMeasure)
(documentation BitsPerSecond "The measurement of the speed of data
transfer in a communications system.")

;;  definition of PacketsPerSecond

(subclass PacketsPerSecond TimeDependentQuantity)
(instance PacketsPerSecond UnitOfMeasure)
(documentation PacketsPerSecond "The rate or speed of &%Packet-Networks
transferred in a second.")

;;  definition of Packet

(subclass Packet ComputerData)
(documentation Packet "A block of data used for transmission in packet
switched systems.")

;; The following constants are specific to the Quite project

;;  definition of SoftwareSystem

(subclass SoftwareSystem ComputationalSystem)
(documentation SoftwareSystem "This is the class of mutually supportive
groups of instances of &%ComputerProgram for a single general purpose.
For example, a database management system is a collection of many instances
of &%ComputerProgram that work together to store, retrieve, modify, and
delete data.")

; "A software system is a group of computer programs for a single
; general purpose" .

(=>
	(instance ?System SoftwareSystem)
	(forall (?Program ?Process)
		(=>
			(and
				(part ?Program ?System)
				(programRunning ?Process ?Program))
			(exists (?Purpose)
				(hasPurpose ?Process ?Purpose)))))

;;  definition of HardwareSystem

(subclass HardwareSystem ComputerHardware)
(subclass HardwareSystem ComputationalSystem)
(documentation HardwareSystem "The class of hardware systems is the
connection of three types of physical modules: instances of
&%ComputerProcessor(s), &%ComputerMemory, and &%ComputerNetwork.
&%ComputerProcessors execute instructions from &%ComputerPrograms,
which usually include instructions to read and write data from
memory, and send data via instances of &%ComputerNetworks.")

; "A software system requires a hardware system to execute" .

(=>
	(and
		(instance ?Software SoftwareSystem)
		(instance ?Process ComputerProcess)
		(programRunning ?Process ?Software))
	(exists (?Hardware)
		(and
			(instance ?Hardware HardwareSystem)
			(computerRunning ?Process ?Hardware))))

; "A hardware system consists of three physical modules: processors,
; memory, and networks" .

(=>
	(instance ?System HardwareSystem)
	(exists (?Processor ?Memory ?Network)
		(and
			(instance ?Processor ComputerProcessor)
			(component ?System ?Processor)
			(instance ?Memory ComputerMemory)
			(component ?System ?Memory)
			(instance ?Network ComputerNetwork)
			(component ?System ?Network))))

; "When the data is sent from HardwareSystems, it is send via
; ComputerNetworks" .

(=>
	(and
		(instance ?System ?HardwareSystem)
		(component ?Network ?System)
		(instance ?Event DataTransfer)
		(origin ?Event ?System))
	(exists (?Network)
		(and
			(instance ?Network ComputerNetwork)
			(instrument ?Event ?Network))))

;; definition of runsOn

(instance runsOn BinaryPredicate)
(instance runsOn AsymmetricRelation)
(domain runsOn 1 ComputerProgram)
(domain runsOn 2 Computer)
(documentation runsOn "(runsOn ?Program ?Computer) means that ?Program
is capable of running on ?Computer.")

(=>
	(exists (?Process)
		(and
			(programRunning ?Process ?Program)
			(computerRunning ?Process ?Computer)))
	(runsOn ?Program ?Computer))

;;  definition of StartupBlock .

(subclass StartupBlock ComputerProgram)
(documentation StartupBlock "A typically small instance of &%ComputerProgram
(a sequence of instructions that will run on a computer) whose function is
to load and initialize a typically larger instance of &%ComputerProgram
and start it running.")

;;  definition of startupOf

(instance startupOf BinaryPredicate)
(domain startupOf 1 StartupBlock)
(domain startupOf 2 ComputerProgram)
(documentation startupOf "(&%startupOf ?STARTUP ?PROGRAM) holds just in
case an instance of &%StartupBlock ?STARTUP specifies a set of instructions
to start the ?PROGRAM.")

; "Each StartupBlock is a startup of some program" .

(=>
	(instance ?Startup StartupBlock)
	(exists (?Application)
		(startupOf ?Startup ?Application)))

; "The startupBlock of an application starts the application" .

(=>
	(and
		(startupOf ?Startup ?Application)
		(instance ?Process1 ComputerProcess)
		(programRunning ?Process1 ?Startup)
		(equal (WhenFn ?Process1) ?Time1))
	(exists (?Process2 ?Time2)
		(and
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Application)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time1 ?Time2))))

;;  definition of StartupFn

(instance StartupFn UnaryFunction)
(domain StartupFn 1 ComputerProgram)
(range StartupFn StartupBlock)
(documentation StartupFn "(&%StartupFn ?Program) returns an instance of
&%StartupBlock which contains the instructions to start the ?Program.")

;;  definition of ShutdownBlock .

(subclass ShutdownBlock ComputerProgram)
(documentation ShutdownBlock "A typically small instance of
&%ComputerProgram whose function is to end a typically larger
instance of &%ComputerProgram.")

;;  definition of shutdownOf .

(instance shutdownOf BinaryPredicate)
(domain shutdownOf 1 ShutdownBlock)
(domain shutdownOf 2 ComputerProgram)
(documentation shutdownOf "(&%shutdownOf ?SHUTDOWN ?PROGRAM) holds just
in case an instance of &%ShutdownBlock ?SHUTDOWN specifies a set of
instructions to end ?PROGRAM.")

; "ShutdownBlock is a shutdown of an application"

(=>
	(instance ?Shutdown ShutdownBlock)
	(exists (?Application)
		(shutdownOf ?Shutdown ?Application)))

; "ShutdownBlock of an application ends the running version of the application"

(=>
	(and
		(shutdownOf ?Shutdown ?Application)
		(instance ?Process1 ComputerProcess)
		(programRunning ?Process1 ?Shutdown)
		(equal (WhenFn ?Process1) ?Time1))
	(exists (?Process2 ?Time2)
		(and
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Application)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time2 ?Time1))))

;;  definition of ShutdownFn

(instance ShutdownFn UnaryFunction)
(domain ShutdownFn 1 ComputerProgram)
(range ShutdownFn ShutdownBlock)
(documentation ShutdownFn "(&%ShutdownFn ?Program) returns an instance of
&%ShutdownBlock which contains the instructions to end ?PROGRAM.")

;;  definition of EnvironmentSoftwareAttribute .

(subclass EnvironmentSoftwareAttribute Attribute)
(documentation EnvironmentSoftwareAttribute "The class of attributes which
correspond to environment variables.  Environment variables are defined
outside of a &%ComputerProgram, unlike ordinary variables that are
defined in the source code of the &%ComputerProgram. Typically, the
environment variable stores some value that many if not all
&%ComputerProgams will need when they execute. An example is the
environment variable PATH under Unix-like operating systems that stores
the &%ComputerDirectories where executable &%ComputerPrograms can be found.
Another example is the environment variable CLASSPATH for Java programs,
which stores the directory where Java class files can be found that will be
needed by any &%ComputerProgram written in Java.")

;;  definition of environmentAttributes .

(subrelation environmentAttributes property)
(domain environmentAttributes 1 ComputerProgram)
(domain environmentAttributes 2 EnvironmentSoftwareAttribute)
(documentation environmentAttributes "(&%environmentAttributes ?Program
?Attribute) holds if ?Attribute is an &%EnvironmentSoftwareAttribute
which describes the &%ComputerProgram ?Program.")

;; definition of ComputerInputDevice

(subclass ComputerInputDevice ComputerHardware)
(documentation ComputerInputDevice "A peripheral device that generates
input for the computer such as a keyboard, scanner, or mouse.")

;; definition of ComputerOutputDevice

(subclass ComputerOutputDevice ComputerHardware)
(subclass ComputerOutputDevice Terminal)
(documentation ComputerOutputDevice "Any peripheral that presents
output from the computer, such as a screen or printer.")

;; definition of standardInputDevice

(subrelation standardInputDevice instrument)
(domain standardInputDevice 1 ComputerProcess)
(domain standardInputDevice 2 ComputerInputDevice)
(documentation  standardInputDevice "(&%standardInputDevice ?PROCESS
?DEVICE) holds just in case the DEVICE is the predefined input channel
with which the running version of the program PROCESS is initialised.")

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardInputDevice ?Process ?Device)))

;;  definition of standardOutputDevice .

(subrelation standardOutputDevice instrument)
(domain standardOutputDevice 1 ComputerProcess)
(domain standardOutputDevice 2 ComputerOutputDevice)
(documentation standardOutputDevice "(&%standardOutputDevice ?PROGRAM
?DEVICE) holds just in case the DEVICE is the predefined output channel
with which the running version of this program is initialised.")

; "The program of the process contains information about the standard
; output device of the process"

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardOutputDevice ?Process ?Device)))

;;  definition of standardErrorDevice .

(subrelation standardErrorDevice instrument)
(domain standardErrorDevice 1 ComputerProcess)
(domain standardErrorDevice 2 ComputerOutputDevice)
(documentation standardErrorDevice "(&%standardErrorDevice ?PROGRAM
?DEVICE) holds just in case the DEVICE is the predefined error channel
with which the running version of this program is initialised.")

; "The program of the process contains information about the standard
; error device of the process"

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardErrorDevice ?Process ?Device)))

;;  definition of hostOf


(instance hostOf BinaryPredicate)
(domain hostOf 1 ComputationalSystem)
(domain hostOf 2 Computer)
(documentation hostOf "(hostOf ?SYSTEM ?COMPUTER) means that ?COMPUTER
is the host of the computational system ?SYSTEM.")

;;  definition of ProcessState

(subclass ProcessState ContentBearingObject)
(documentation ProcessState "The class of all the information required
for a &%ComputerProgram to run on a processor. It is a vector that
contains a pointer to the next program instruction to be executed as well
as the values of all intermediate and defined variables, the state of the
processor executing the program, and the allocated address space among
other data.")

(=>
	(instance ?State ProcessState)
	(exists (?Program)
		(and
			(instance ?Program ComputerProgram)
			(forall (?Process)
				(=>
					(programRunning ?Process ?Program)
					(represents ?State ?Process))))))

;;  definition of stateOfProcess

(instance stateOfProcess BinaryRelation)
(domain  stateOfProcess 1 ComputerProcess)
(domain  stateOfProcess 2 ProcessState)
(documentation  stateOfProcess "(&%stateOfProcess ?PROCESS ?STATE) says
that ?STATE is a state of the &%ComputerProcess ?PROCESS.")

;;  definition of AutomaticApplication .

(subclass AutomaticApplication ComputerProgram)
(documentation AutomaticApplication "A program which is started
automatically, as opposed to an application started in response to
some condition becoming true.")

; "If an application is an automatic application, it is started when
; the software system is started".

(=>
	(and
		(instance ?Application AutomaticApplication)
		(instance ?System SoftwareSystem)
		(part ?Application ?System))
	(part (StartupFn ?Application) (StartupFn ?System)))

;;  definition of RM_StartApplication

(subclass RM_StartApplication ComputerProgram)
(documentation RM_StartApplication  "A program started by a Resource
Management program, which determines if and where to start the
application.")

(=>
	(instance ?RM RM_StartApplication)
	(exists (?Application ?Process ?RMCopy)
		(and
			(instance ?Application ComputerProgram)
			(programCopy ?RMCopy ?RM)
			(programRunning ?Process (StartupFn ?Application))
			(agent ?Process ?RMCopy))))

;;  definition of ConsoleApplication .

(instance ConsoleApplication ComputerProgram)
(documentation ConsoleApplication "A Program which is started inside
an Xterm or other console.")

;;  definition of RMProgram .

(subclass ResourceManagementProgram ComputerProgram)
(documentation ResourceManagementProgram "The class of resource
management programs.")

;;  definition of rMProgram-of .

(instance rMProgram-of BinaryPredicate)
(domain rMProgram-of 1 ResourceManagementProgram)
(domain rMProgram-of 2 SoftwareSystem)
(documentation rMProgram-of "(&%rMProgram-of ?RM ?SYSTEM) means that
?RM is the resource management program of &%the SoftwareSystem ?SYSTEM.")

; "The resource management program of a software system controls
; applications in this system" .

(=>
	(rMProgram-of ?RM ?System)
	(exists (?Application ?Process ?RMCopy)
		(and
			(part ?Application ?System)
			(programCopy ?RMCopy ?RM)
			(programRunning ?Process ?Application)
			(agent ?Process ?RMCopy))))

;; definition of programCopy

(instance programCopy AsymmetricRelation)
(subrelation programCopy containsInformation)
(domain programCopy 1 ComputerFile)
(domain programCopy 2 ComputerProgram)
(documentation programCopy "(&%programCopy ?File ?Program) means that
the &%ComputerFile ?File is one of the copies of the &%ComputerProgram
?Program.")

;;  definition of criticalityLevel.

(instance criticalityLevel BinaryPredicate)
(domain criticalityLevel 1 ComputerProgram)
(domain criticalityLevel 2 Integer)
(documentation criticalityLevel "(&%criticalityLevel ?PROGRAM ?INTEGER)
holds just in case ?INTEGER indicates the relative priority of ?PROGRAM
with respect to other applications within the &%SoftwareSystem.")

;;  definition of startupTimeDelay

(instance startupTimeDelay BinaryRelation)
(domain startupTimeDelay 1 ComputerProgram)
(domain startupTimeDelay 2 TimeDuration)
(documentation startupTimeDelay "(&%startupTimeDelay ?PROGRAM ?TIME)
says that ?TIME is the time to delay after the previous application
was started before starting the application ?PROGRAM.")

; "If an application has a startupTimeDelay of n seconds, then
; any process which runs after this application has a starting point
; n seconds later than the startup of this application."

(=>
	(exists (?Time1 ?Time2 ?Time)
		(and
			(startupTimeDelay ?Application ?Delay)
			(instance ?Process1 ComputerProcess)
			(programRunning ?Process1 ?Application)
			(equal (WhenFn ?Process1) ?Time1)
			(instance ?Process2 ComputerProcess)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time1 ?Time)
			(meetsTemporally ?Time ?Time2)))
	(measure ?Time ?Delay))

;;  definition of Feedback

(subclass Feedback ContentBearingObject)
(documentation Feedback "The class of all messages to a resource
management program from one of its processes.")

(<=>
	(instance ?Feedback Feedback)
	(exists (?RM ?Process ?Program)
		(and
			(rMProgram-of ?RM ?Program)
			(programRunning ?Process ?Program)
			(instance ?Send DataTransfer)
			(patient ?Send ?Feedback)
			(destination ?Send ?RM))))

;;  definition of processList

(instance processList Predicate)
(instance processList VariableArityRelation)
(documentation processList "The arguments of this relation are data
structures, each of which contains the information necessary for the
process already loaded by the operating system to execute on a processor.")

; "The processes in the list are ordered by the start time" .

(=>
	(and
		(processList @ROW)
                (inList ?Process1 (ListFn @ROW))
                (inList ?Process2 (ListFn @ROW))
                (equal (ListOrderFn (ListFn @ROW) ?Number1) ?Process1)
                (equal (ListOrderFn (ListFn @ROW) ?Number2) ?Process2)
                (lessThan ?Number1 ?Number2))
	(earlier (WhenFn ?Process1) (WhenFn ?Process2)))

;;  definition of settlingTime

(instance settlingTime BinaryPredicate)
(domain settlingTime 1 ComputerProgram)
(domain settlingTime 2 TimeDuration)
(documentation settlingTime "(&%settlingTime ?PROGRAM ?TIME) says that
?TIME represents seconds to delay after an action was taken with respect
to QoS.")

;;  definition of minimumReplications

(instance  minimumReplications BinaryPredicate)
(domain minimumReplications  1 ComputerProgram)
(domain minimumReplications  2 PositiveInteger)
(documentation minimumReplications "(&%minimumReplications ?PROGRAM
?INTEGER) means that ?INTEGER represents the minimum copies of the
application ?PROGRAM required to be survivable, where a program is
survivable if the failure of one or more resources does not result
in the failure of the program.  Either long MTTF for the system as a
whole or short MTTR when failure occurs would improve the survivability
of a program.")

; "MinimumReplications is the mininum number of copies of the application
; involved in a running process".

(=>
	(minimumReplications ?Application ?MinCopies)
	(greaterThanOrEqualTo
		(CardinalityFn
		        (KappaFn ?Copy
			        (programRunning ?Copy ?Application))) ?MinCopies))

;;  definition of maximumReplications

(instance maximumReplications BinaryPredicate)
(domain maximumReplications 1 ComputerProgram)
(domain maximumReplications 2 PositiveInteger)
(documentation maximumReplications "(&%maximumReplications ?PROGRAM ?INTEGER) means that
?INTEGER represents the maximum number of copies of this application which can be run
during a process.")

; "MaximumReplications is the maximum number of copies of the application
; allowed to run during a process".

(=>
	(maximumReplications ?Application ?MaxCopies)
	(greaterThanOrEqualTo ?MaxCopies
			      (CardinalityFn
					     (KappaFn ?Copy
						      (programRunning ?Copy ?Application)))))


;; definition of IPAddress

(subclass IPAddress PhysicalAddress)
(documentation IPAddress "The Internet Protocol address; a numeric address such as 123.231.32.2 that
the domain name server translates into a domain name.")

;;  definition of ipAddressOf

(instance ipAddressOf BinaryPredicate)
(domain ipAddressOf 1 Computer)
(domain ipAddressOf 2 IPAddress)
(documentation ipAddressOf "(&%ipAddressOf ?HOST ?ADDRESS) holds if ?ADDRESS is the &%IPAddress of
the computer ?HOST.")

;;  definition of portNumber

(instance portNumber BinaryPredicate)
(domain portNumber 1 ComputerProgram)
(domain portNumber 2 PositiveInteger)
(documentation portNumber "(&%portNumber ?PROGRAM ?NUMBER) holds if ?NUMBER identifies a protocol
port, i.e. a TCP-IP software abstraction used to distinguish different applications providing
services within a single destination computer. The different ports on a host are identified by a
positive 16-bit number.")

;;  definition of processID .

(instance processID BinaryPredicate)
(domain processID 1 ComputerProcess)
(domain processID 2 PositiveInteger)
(documentation processID "(&%processID ?PROCESS ?NUMBER) holds if ?NUMBER is a unique number
generated by the operating system and used to refer to the &%ComputerProcess ?PROCESS.  There
is usually no significance to the numbers as they are reused as old processes die and new processes
are created.")

;;  definition of ProcessStatus .

(subclass ProcessStatus Attribute)
(documentation ProcessStatus "A class of attributes. Each instance of &%ProcessStatus describes a
status of a &%Process, such as &%ProcessFailure, &%ProcessSuccess, etc.")

;;  definition of ProcessFailure .

(instance ProcessFailure ProcessStatus)
(documentation ProcessFailure "An attribute that denotes the failure of the &%Process to achieve
its goal.")

;;  definition of ProcessSuccess .

(instance ProcessSuccess ProcessStatus)
(contraryAttribute ProcessSuccess ProcessFailure)
(documentation ProcessSuccess "An attribute that denotes the success of the &%Process to achieve
its goal.")

;;  definition of status .

(subrelation status property)
(domain status 1 ComputerProcess)
(domain status 2 ProcessStatus)
(documentation status "(&%status ?PROCESS ?STATUS) holds if ?STATUS is the current status of ?PROCESS.")

(=>
	(and
		(status ?Process ProcessFailure)
		(hasPurpose ?Process ?Purpose))
	(not (holdsDuring (ImmediatePastFn (WhenFn ?Process)) ?Purpose)))

;;  definition of ComputerComponent

(subclass ComputerComponent ComputerHardware)
(documentation ComputerComponent "An instance of &%ComputerComponent is a
piece of computer hardware that has measurable performance characteristics
in terms of different units. Components include hard drives, the performance
of which can be measured in terms of BitsPerSecond required to transfer data
to and from the drive, network adapters, the performance of which can be
measured by &%PacketsPerSecond units of data transfered to and from the adapter,
and other common components like &%ComputerMemory and &%CentralProcessingUnit.")

(subclass ComputerMemory ComputerComponent)

(subclass HardDiskDrive ComputerComponent)

(subclass CentralProcessingUnit ComputerComponent)

(=>
	(instance ?Component ComputerComponent)
	(exists (?Unit)
		(unitMeasuringPerformance ?Component ?Unit)))

;;  definition of NetworkAdapter

(subclass NetworkAdapter ComputerComponent)
(documentation NetworkAdapter "A network adapter, also known as a Network
Interface Card or NIC, is a physical device installed in a computer on its
system bus. Its purpose is to connect to a specific type of network,
usually an ethernet or a token ring network.")

(=>
	(instance ?NA NetworkAdapter)
	(exists (?Net)
		(and
			(instance ?Net ComputerNetwork)
			(connected ?NA ?Net))))

;;  definition of unitMeasuringPerformance .

(instance unitMeasuringPerformance  BinaryPredicate)
(domain unitMeasuringPerformance  1 ComputerComponent)
(domain unitMeasuringPerformance  2 UnitOfMeasure)
(documentation unitMeasuringPerformance "(&%unitMeasuringPerformance ?COMPONENT
?UNIT) holds in case ?UNIT is an instance of &%UnitOfMeasure which is used to
measure the performance of ?COMPONENT.")

; "The performance of Hard Drives is measured in BitsPerSecond" .

(=>
	(instance ?HardDrive HardDiskDrive)
	(unitMeasuringPerformance ?HardDrive BitsPerSecond))

; "The performance of network adapters is measured by packets/second" .

(=>
	(instance ?NA NetworkAdapter)
	(unitMeasuringPerformance ?NA PacketsPerSecond))

;;  definition of MonitoringProgram .

(subclass MonitoringProgram ComputerProgram)
(documentation  MonitoringProgram "A program which monitors performance
of an application, a component, etc.")

(=>
	(instance ?Monitor MonitoringProgram)
	(exists (?System ?Event ?MonitorCopy)
		(and
			(systemMeasured ?Event ?System)
			(programCopy ?MonitorCopy ?Monitor)
			(agent ?Event ?MonitorCopy))))

;; definition of systemMeasured

(instance systemMeasured BinaryPredicate)
(instance systemMeasured AsymmetricRelation)
(domain systemMeasured 1 MeasuringPerformance)
(domain systemMeasured 2 ComputationalSystem)
(documentation systemMeasured "(&%systemMeasured ?Event ?System) means that
?Event is an event of measuring the performance of the &%ComputationalSystem
?System.")

;;  definition of dataID .

(instance dataID BinaryPredicate)
(domain dataID 1 MonitoringProgram)
(domain dataID 2 SymbolicString)
(documentation dataID "(&%dataID ?PROGRAM ?NUMBER) holds if ?NUMBER is a small
number associated with an instance of &%MonitoringProgram.")

;;  definition of MeasuringPerformance .

(subclass MeasuringPerformance ComputerProcess)
(documentation MeasuringPerformance "Each element of &%MeasuringPerformance
is an event of measuring the performance of an instance of &%ComputerComponent,
performed by a &%MonitoringProgram.")

(=>
	(instance ?Event MeasuringPerformance)
	(exists (?Program ?Copy)
		(and
			(instance ?Program MonitoringProgram)
			(programCopy ?Copy ?Program)
			(agent ?Event ?Copy))))

;;  definition of componentDataID .

(instance componentDataID QuintaryPredicate)
(domain componentDataID 1 TimePosition)
(domainSubclass componentDataID 2 ComputerComponent)
(domain componentDataID 3 ComputerComponent)
(domain componentDataID 4 UnitOfMeasure)
(domain componentDataID 5 SymbolicString)
(documentation componentDataID "(&%componentDataID ?TIME ?COMPONENT ?INSTANCE
?UNIT ?NUMBER) holds if ?INSTANCE is an instance of ?COMPONENT, identified by
&%IDNumber ?NUMBER, and whose performance is measured by a &%UnitOfMeasure-ComputerPerformance ?UNIT. The timestamp ?TIME identifies the time when this
information was created.")

(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(instance ?Instance ?Component))


(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(unitMeasuringPerformance ?Instance ?Unit))


(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(refers ?Number ?Instance))

;;  definition of heartBeatRate .

(subrelation heartBeatRate frequency)
;; DWF: harmonized with parent to resolve conflict
;; (domain heartBeatRate 1 ComputerProgram)
(domain heartBeatRate 1 Process)
(domain heartBeatRate 2 TimeDuration)
(documentation heartBeatRate "(&%heartBeatRate ?Program ?Period) holds if
?Period is the period at which the ComputerProgram ?Program sends its heartbeat
to a monitoring process.")

;;  definition of MonitorConnectivityCmd .

(subclass MonitorConnectivityCmd MonitoringProgram)
(documentation  MonitorConnectivityCmd "This is the command to get a list
of applications periodically.")

;;  definition of MonitorApplicationCmd

(subclass MonitorApplicationCmd MonitoringProgram)
(documentation MonitorApplicationCmd "This command is to change the monitoring
for any component for which a &%componentDataID was sent on initial connection.")

;;  definition of MonitorComponentCmd

(subclass MonitorComponentCmd MonitoringProgram)
(documentation MonitorComponentCmd "This is the command to monitor any of the
generic components - hard drive, network, cpu, memory, etc." )

;;  definition of performanceResult.

(instance  performanceResult TernaryPredicate)
(domain  performanceResult 1 MeasuringPerformance)
(domain  performanceResult 2 ComputerComponent)
(domain  performanceResult 3 RealNumber)
(documentation  performanceResult "(&%performanceResult ?EVENT ?COMPONENT
?NUMBER) holds if the performance of ?COMPONENT has a value ?NUMBER,
measured by ?EVENT, an instance of &%MeasuringPerformance.")

;;  definition of monitorComponentData .

(instance monitorComponentData TernaryPredicate)
(domain monitorComponentData 1 TimePosition)
(domain monitorComponentData 2 SymbolicString)
(domain monitorComponentData 3 RealNumber)
(documentation monitorComponentData "(&%monitorComponentData ?TIME ?ID
?NUMBER) holds if at time ?TIME, a component with the &%IDNumber ?ID
has a performance of a value ?NUMBER.")

(=>
	(and
		(monitorComponentData ?Time1 ?ID ?Number)
		(componentDataID ?Time2 ?Component ?Instance ?Unit ?ID))
	(exists (?Event)
		(and
			(instance ?Event MeasuringPerformance)
			(unitMeasuringPerformance ?Instance ?Unit)
			(time ?Event ?Time1)
			(performanceResult ?Event ?Instance ?Number))))

;;  definition of monitorConnectivityData .

(instance monitorConnectivityData BinaryRelation)
(domain  monitorConnectivityData 1 TimePosition)
(domain  monitorConnectivityData 2 IPAddress)
(documentation  monitorConnectivityData "(&%monitorConnectivityData ?TIME
?IPADDRESS) is a relation between a timestamp ?TIME and an ?IP address.")

;;  definition of monitorApplicationData .

(instance monitorApplicationData BinaryPredicate)
(domain monitorApplicationData  1 TimePosition)
(domain monitorApplicationData  2 ComputerProgram)
(documentation monitorApplicationData "(&%monitorApplicationData ?TIME
?APPLICATION) holds if the time stamp ?TIME specifies the time at which
?APPLICATION is running.")

(=>
	(monitorApplicationData ?Time ?Application)
	(exists (?Process)
		(and
			(programRunning ?Process ?Application)
			(time ?Process ?Time))))

;; definition of Executable

(instance Executable Attribute)
(documentation Executable "Able to be run in its current format.")

(<=>
	(exists (?Process)
		(programRunning ?Process ?Program))
	(property ?Program Executable))

;; definition of OperatingSystem

(subclass OperatingSystem SoftwareSystem)
(documentation OperatingSystem "The master control program that runs the
computer. It is the first program loaded when the computer is turned on,
and its main part, called the kernel, resides in memory at all times. It
may be developed by the vendor of the computer it's running in or by a
third party.")

;;  definition of settlingTime

(instance settlingTime BinaryPredicate)
(domain	settlingTime 1	ComputerProgram)
(domain	settlingTime 2 TimeDuration)
(documentation settlingTime "(&%settlingTime ?PROGRAM ?TIME) says that
?TIME represents seconds to delay after an action was taken with respect
to QoS.")

;; definition of defaultNetwork.

(instance defaultNetwork BinaryPredicate)
(domain defaultNetwork 1 HardwareSystem)
(domain defaultNetwork 2 ComputerNetwork)
(documentation defaultNetwork "(&%defaultNetwork ?SYSTEM ?NET) holds if
?NET is the default network of the &%HardwareSystem ?SYSTEM.")

;; definition of Solaris.

(subclass Solaris OperatingSystem)
(documentation Solaris "The class of all instances of Solaris , a
unix-based operating system for Sun SPARC computers. It includes the
Open Look and Motif graphical user interfaces, OpenWindows (the Sun
version of X Windows), DOS and Windows Emulation, and ONC networking.")

;; definition of numberOfCPUs.

(instance numberOfCPUs BinaryPredicate)
(domain numberOfCPUs 1 Computer)
(domain  numberOfCPUs 2 PositiveInteger)
(documentation numberOfCPUs "(&%numberOfCPUs ?COMPUTER ?INTEGER) means
that the number of CPUs for the host ?COMPUTER is equal to INTEGER.")

;; definition of hardwareType.

(subrelation hardwareType represents)
(domain  hardwareType 1 SymbolicString)
(domain  hardwareType 2 Computer)
(documentation hardwareType "(&%hardwareType ?TYPE ?COMPUTER) means that
TYPE represents the computer vendor model name, as well as the version
of the product.")

(=>
	(and
		(hardwareType ?Type ?Computer)
		(productModel ?Model ?Computer))
	(subsumesContentInstance ?Type ?Model))

;; productVersion appears in this implication but is never defined.
;; (=>
;; 	(and
;; 		(hardwareType ?Type ?Computer)
;; 		(productVersion ?Version ?Computer))
;; 	(subsumesContentInstance ?Type ?Version))

;; definition of thresholdOf.

(instance thresholdOf BinaryPredicate)
(domain thresholdOf 1 Computer)
(domain thresholdOf 2 PositiveRealNumber)

;; definition of benchmarkPerformance.

(instance benchmarkPerformance TernaryPredicate)
(domain benchmarkPerformance 1 ComputationalSystem)
(domain benchmarkPerformance 2 MonitoringProgram)
(domain benchmarkPerformance 3 Quantity)
(documentation benchmarkPerformance "(&%benchmarkPerformance ?SYSTEM
?TEST ?NUMBER) holds if ?NUMBER is a benchmark for measuring the performance
of an instance of a &%ComputationalSystem.")

(=>
	(benchmarkPerformance ?System ?Test ?Number)
	(exists (?Event)
		(and
			(instance ?Event MeasuringPerformance)
			(performanceResult ?Event ?System ?Number))))

;; definition of bandwidthOf.

(instance bandwidthOf BinaryPredicate)
(domain bandwidthOf 1 ComputerNetwork)
(domain bandwidthOf 2 Bandwidth)
(documentation bandwidthOf "(&%bandwidthOf ?NET ?BANDWIDTH) holds if
?BANDWIDTH is the amount of data which can be sent through an instance
of a &%ComputerNetwork ?NET, measured in bits per second.")

;; definition of priority.

(instance priority  BinaryPredicate)
(domain priority 1 ComputationalSystem)
(domain priority 2 PriorityAttribute)
(documentation priority "(&%priority ?SYSTEM ?QUANTITY) means that the
priority of the ?SYSTEM is characterized by a &%PriorityAttribute, such
as &%HighPriority or &%LowPriority.")

;; definition of PriorityAttribute

(subclass PriorityAttribute Attribute)
(documentation PriorityAttribute "A class of attributes which describe
priorities of &%ComputationalSystems.")

(instance HighPriority PriorityAttribute)
(documentation HighPriority "Used to indicate that a &%ComputationalSystem
has a high priority.")

(instance LowPriority PriorityAttribute)
(documentation LowPriority "Used to indicate that a &%ComputationalSystem
has a low priority.")

;; definition of ComputerPath.

(subclass ComputerPath ComputerData)
(documentation ComputerPath "An instance of &%ComputerPath is a series
of programs that connects input devices, typically sensors, to output
devices, typically actuators.")

;; definition of softwarePath.

(instance softwarePath BinaryPredicate)
(domain softwarePath 1 SoftwareSystem)
(domain softwarePath 2 ComputerPath)
(documentation softwarePath "(&%softwarePath ?SYSTEM ?PATH) means that
?PATH is a computer path for the instance of &%SoftwareSystem ?SYSTEM.")

;; definition of SoftwareAttribute

(subclass SoftwareAttribute Attribute)
(documentation SoftwareAttribute "The class of all attributes that are
specific to &%SoftwareSystems.")

(=>
	(instance ?Attribute ComputerPathAttribute)
	(exists (?Path)
		(and
			(instance ?Path ComputerPath)
			(property ?Path ?Attribute))))

;; definition of ComputerPathAttribute.

(subclass ComputerPathAttribute SoftwareAttribute)
(documentation ComputerPathAttribute "The class of all attributes that are
specific to &%ComputerPaths.")

(=>
	(instance ?Attribute ComputerPathAttribute)
	(exists (?Path)
		(and
			(instance ?Path ComputerPath)
			(property ?Path ?Attribute))))

;; definition of PathImportanceFunction.

(instance PathImportanceFunction ComputerPathAttribute)
(documentation PathImportanceFunction  "The attribute which denotes that
the path importance is defined by the dynamic library procedure
&%pathImportanceFunction. This functions passes arguments for priority
and current time and returns an integer that represents importance.")

;; definition of Scalable.

(subclass Scalable ComputerPathAttribute)
(documentation Scalable "The attribute which denotes that the path is
scalable, i.e. the applications in the path can be replicated to meet
realtime QoS requirements.")

;; definition of DynamicDataStream.

(subclass DynamicDataStream ComputerPathAttribute)
(documentation DynamicDataStream "The attribute which denotes that the
path data stream type is dynamic, i.e. the time changes but the data
stream follows a pattern.")

;; definition of StochasticDataStream.

(subclass StochasticDataStream ComputerPathAttribute)
(documentation  StochasticDataStream "The attribute which denotes that
the time between data or groups of data changes according to no
discernible pattern.")

;; definition of DeterministicDataStream.

(subclass DeterministicDataStream ComputerPathAttribute)
(documentation DeterministicDataStream "The attribute which denotes that
the data stream is conceived as a stream of one datum after another, and
each datum or identifiable group of data is separated by a constant of
time.")

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path DynamicDataStream))
	(not (property ?Path StochasticDataStream)))

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path DynamicDataStream))
	(not (property ?Path DeterministicDataStream)))

;; definition of ContinuousPath

(subclass ContinuousPath ComputerPathAttribute)
(documentation  ContinuousPath "The attribute which denotes that the
path type is continuous, as opposed to transient or quasiconstinuous
paths. A continuous path handles a stream of data arriving at a comment
of rate.")

;; definition of TransientPath.

(subclass TransientPath ComputerPathAttribute)
(documentation TransientPath "An attribute which applies to computer
paths which handle random events.")

;; definition of QuasicontinuousPath.

(subclass QuasicontinuousPath ComputerPathAttribute)
(documentation  QuasicontinuousPath "An attribute which applies to
computer paths which handle random events, which initiate a bounded
stream of data arriving at a comment of rate, which the path must
process.")

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path ContinuousPath))
	(not (property ?Path TransientPath)))

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path ContinuousPath))
	(not (property ?Path QuasicontinuousPath)))

;; definition of simpleDeadline.

(instance simpleDeadline BinaryPredicate)
(domain simpleDeadline 1 ComputerPath)
(domain simpleDeadline 2 TimeDuration)
(documentation  simpleDeadline "(&%simpleDeadline ?PATH ?TIME)holds if
?TIME is the maximum end-to-end path latency during a cycle of a
continuous or quasicontinuous path or during the activation of a transient
path.")

;; definition of batchLatency.

(instance batchLatency BinaryPredicate)
(domain batchLatency 1 ComputerPath)
(domain batchLatency 2 TimeDuration)
(documentation batchLatency "(&%batchLatency ?PATH ?TIME)holds if ?TIME
is the maximum allowed latency for all cycles of a quasicontinuous path.")

;; definition of batchInterArrival.

(instance batchInterArrival BinaryPredicate)
(domain batchInterArrival 1 ComputerPath)
(domain batchInterArrival 2 TimeDuration)
(documentation batchInterArrival "(&%batchInterArrival ?PATH ?TIME)
holds if ?TIME is the maximum allowable time between processing of a
particular element of a continuous or quasicontinuous path's data
stream in successive cycles.")

;; definition of qoSSlack.

(instance qoSSlack TernaryRelation)
(domain qoSSlack 1 ComputerPath)
(domain qoSSlack 2 ConstantQuantity)
(domain qoSSlack 3 ConstantQuantity)
(documentation qoSSlack "(&%qoSSlack ?PATH ?MIN ?MAX) holds if ?PATH
has a realtime QoS maximum slack percentage of ?MAX and minimum of
?MIN.")

;; definition of slidingWindowSize.

(instance slidingWindowSize BinaryPredicate)
(domain slidingWindowSize 1 ComputerPath)
(domain slidingWindowSize 2 PositiveInteger)
(documentation slidingWindowSize "(&%slidingWindowSize ?PATH ?N) holds
if PATH has a realtime QoS sliding window size of ?N measured samples.")

;; definition of dataStreamSlack.

(instance dataStreamSlack BinaryPredicate)
(domain dataStreamSlack 1 ComputerPath)
(domain dataStreamSlack 2 PositiveInteger)
(documentation dataStreamSlack "(&%dataStreamSlack ?PATH ?N) means that
a continuous or quasicontinuous path ?PATH should be able to process ?N
additional data items at any time.")

(=>
	(dataStreamSlack ?Path ?Number)
	(or
		(property ?Path  ContinuousPath)
		(property ?Path QuasicontinuousPath)))

;; definition of dependencyType.

(instance dependencyType BinaryPredicate)
(domain dependencyType 1 ComputerProgram)
(domainSubclass dependencyType 1 ComputerProgram)
(documentation dependencyType "(&%dependencyType ?PROGRAM ?TYPE) means
that ?PROGRAM has a dependency type ?TYPE, where ?TYPE can be either
&%StartupBlock or &%ShutdownBlock.")

(=>
	(dependencyType ?Program ?Type)
	(or
		(equal ?Type StartupBlock)
		(equal ?Type ShutdownBlock)))

;; definition of Restartable.

(instance Restartable SoftwareAttribute)
(documentation Restartable "The attribute which denotes that a program
can be restarted.")

;; definition of hasDependency.

(instance hasDependency BinaryPredicate)
(domain hasDependency 1 ComputerProgram)
(domain hasDependency 2 ComputerProgram)
(documentation hasDependency "(&%hasDependency ?PROGRAM1 ?PROGRAM2)
holds if ?PROGRAM1 is dependent on the application ?PROGRAM2.")

;; definition of dependencyDelay.

(instance dependencyDelay BinaryPredicate)
(domain dependencyDelay 1 ComputerProgram)
(domain dependencyDelay 2 TimeDuration)
(documentation dependencyDelay "if the dependency type is &%StartupBlock,
then (&%dependencyDelay ?PROGRAM ?TIME) means that the application
?PROGRAM can only be started after a dependency delay of ?TIME after the
startup of the application. If the dependency type is &%ShutdownBlock, then
(&%dependencyDelay ?PROGRAM ?TIME) means that the application ?PROGRAM can
only be stopped after a dependency delay of ?TIME after the application
is stopped.")

;; Logic error -- ?Time variable roams free in consequent.
;;(=>
;;	(exists (?Time1 ?Time2 ?Time)
;;		(and
;;			(dependencyDelay ?Program1 ?Delay)
;;			(dependencyType ?Program1 StartupBlock)
;;			(hasDependency ?Program1 ?Program2)
;;			(instance ?Process1 ComputerProcess)
;;			(programRunning ?Process1 ?Program1)
;;			(instance ?Process2 ComputerProcess)
;;			(programRunning ?Process2 ?Program2)
;;			(equal (WhenFn ?Process2) ?Time2)
;;			(starts ?Time2 ?Time)
;;			(equal (WhenFn ?Process1) ?Time1)
;;			(equal (EndFn ?Time) (BeginFn ?Time1))))
;;	(duration ?Time ?Delay))
;;
;;(=>
;;	(exists (?Time1 ?Time2 ?Time)
;;		(and
;;			(dependencyDelay ?Program1 ?Delay)
;;			(dependencyType ?Program1 ShutdownBlock)
;;			(hasDependency ?Program1 ?Program2)
;;			(instance ?Process1 ComputerProcess)
;;			(programRunning ?Process1 ?Program1)
;;			(instance ?Process2 ComputerProcess)
;;			(programRunning ?Process2 ?Program2)
;;			(equal (WhenFn ?Process2) ?Time2)
;;			(finishes ?Time ?Time1)
;;			(equal (WhenFn ?Process2) ?Time2)
;;			(equal (BeginFn ?Time) (EndFn ?Time2))))
;;	(duration ?Time ?Delay))

;; definition of ReplicationsOnSameHostOK.

(instance ReplicationsOnSameHostOK SoftwareAttribute)
(documentation ReplicationsOnSameHostOK "The attribute which denotes that
a program can be restarted on the same host.")

(=>
	(property ?Program ReplicationsOnSameHostOK)
	(property ?Program Restartable))

;; definition of commandLineArguments.

(instance commandLineArguments BinaryPredicate)
(domain commandLineArguments 1 ComputerProgram)
(domain commandLineArguments 2 List)
(documentation commandLineArguments "(&%commandLineArguments ?PROGRAM
?LIST) means that the application ?PROGRAM requires command line
arguments, as specified in ?LIST.")

;; definition of ScalabilityCombining.

(instance ScalabilityCombining SoftwareAttribute)
(documentation ScalabilityCombining "The attribute which denotes that
an application can combine its input stream from different preceding
applications or devices for greater scalability.")

;; definition of ScalabilitySplitting.

(instance ScalabilitySplitting SoftwareAttribute)
(documentation ScalabilitySplitting "The attribute which denotes that
a program can split its output stream to different succeeding
applications or devices for greater scalability.")

;; definition of InitialProfileFn.

(instance InitialProfileFn UnaryFunction)
(domain InitialProfileFn 1 ComputerProgram)
(documentation InitialProfileFn "The function which returns as its value
the initial profile of the program, i.e. a report of its execution
characteristics.")

;; definition of CPUUtilizationFn.

(subrelation CPUUtilizationFn UnaryFunction)
(domain CPUUtilizationFn 1 ComputerProgram)
(domain CPUUtilizationFn 2 ConstantQuantity)
(documentation  CPUUtilizationFn "(&%CPUUtilizationFn ?PROGRAM) refers to
the percentage of time the CPU is used by an application ?PROGRAM.")

; definition of RealtimeSystem

(subclass RealtimeSystem ComputationalSystem)
(documentation RealtimeSystem "An  computer-controlled system, the
correct operation of which depends on meeting specified timing
constraints.")

(subclass SoftwareSystem RealtimeSystem)

(subclass HardwareSystem RealtimeSystem)

(subclass ComputerNetwork  RealtimeSystem)

; definition of RealtimeSystemAttribute

(subclass RealtimeSystemAttribute Attribute)
(documentation RealtimeSystemAttribute "The class of &%Attributes which
describe instances of the class &%RealtimeSystem.")

; definition of SystemBehaviorAttribute

(subclass SystemBehaviorAttribute RealtimeSystemAttribute)
(documentation SystemBehaviorAttribute "A subclass of
&%RealtimeSystemAttribute, which includes the following &%Attributes:
&%Periodic-SystemBehavior, &%Transient-SystemBehavior, and
&%Hybrid-SystemBehavior.")

; definition of systemBehavior

(subrelation systemBehavior property)
(domain systemBehavior 1 RealtimeSystem)
(domain systemBehavior 2 SystemBehaviorAttribute)
(documentation systemBehavior "(&%systemBehavior ?System ?Attribute)
holds if ?Attribute is a SystemBehaviorAttribute which describes the
&%RealtimeSystem ?System.")

; definition of Periodic-SystemBehavior

(subclass Periodic-SystemBehavior SystemBehaviorAttribute)
(documentation Periodic-SystemBehavior "An instance of the class
&%RealtimeSystem is described as a system with &%Periodic-SystemBehavior
when it is activated at regular intervals.")

; definition of Transient-SystemBehavior

(subclass Transient-SystemBehavior SystemBehaviorAttribute)
(documentation Transient-SystemBehavior "An instance of the class
&%RealtimeSystem shows &%Transient-SystemBehavior when it is
activated by sporadic events.")

; definition of Hybrid-SystemBehavior

(subclass Hybrid-SystemBehavior SystemBehaviorAttribute)
(subAttribute Hybrid-SystemBehavior Transient-SystemBehavior)
(subAttribute Hybrid-SystemBehavior Periodic-SystemBehavior)
(documentation Hybrid-SystemBehavior "An instance of the class
&%RealtimeSystem shows &%Hybrid-SystemBehavior if it is
activated by transient events, i.e. it is executed at regular
intervals when activated, and is deactivated by action completion.")

; definition of DesignPatternAttribute

(subclass DesignPatternAttribute RealtimeSystemAttribute)
(documentation DesignPatternAttribute "This is a subclass of
&%RealtimeSystemAttribute, which includes &%Guidance-DesignPattern,
&%Initiation-DesignPattern, and &%Assessment-DesignPattern.")

; definition of designPattern

(subrelation designPattern property)
(domain designPattern 1 RealtimeSystem)
(domain designPattern 2 DesignPatternAttribute)
(documentation designPattern "(&%designPattern ?System ?Attribute) holds
if ?Attribute is a &%DesignPatternAttribute which describes the
&%RealtimeSystem ?System.")

; definition of Guidance-DesignPattern

(subclass Guidance-DesignPattern DesignPatternAttribute)
(documentation Guidance-DesignPattern "Instances of &%RealtimeSystems
are described as systems with &%Guidance-DesignPattern if they consist
of sensors connected to a software module that filters data from the
sensors and sends the filtered data to a software module that evaluates
the filtered data and sends instructions to a software module that
commands actuators.  The design pattern is an event source that produces
events and a data source that produces data, both executing in parallel
and handled by a single event-driven periodic data handler.  The two
separate input streams have fundamentally different characteristics.
The event stream is necessarily asychronous, or transient.  Once an
event is sensed, the handler accepts data from the data stream, which
has an invariant cycle time.  There are two deadlines for a real-time
guidance system.  The period deadline is the time to process all elements
in the data stream once and generate an actuator command.  The action
completion deadline is the time to guide the actuator to completion of
the action.")

(=>
	(designPattern ?System Guidance-DesignPattern)
	(systemBehavior ?System Transient-SystemBehavior))

; definition of Initiation-DesignPattern

(subclass Initiation-DesignPattern DesignPatternAttribute)
(documentation Initiation-DesignPattern "An instance of the class
&%RealtimeSystem has &%Initiation-DesignPattern if it consists of
one software module and the actuators it commands.  The design pattern
is an event source which produces events for an event handler.  The
event source is typically an evaluate-and-decide software module.
The event stream is necessarily asychronous, or transient.  The arrival
rate of events may vary and is unbounded.  Events may be either
homogeneous or heterogeneous.  The workload per event for homogeneous
events is constant.  The workload per event for heterogeneous events
is a function of each event type.  There is one deadline for real-time
action initiation systems.  It is the upper bound on the time to
generate a command for the actuator.")

(=>
	(designPattern ?System Initiation-DesignPattern)
	(systemBehavior ?System Transient-SystemBehavior))

; definition of Assessment-DesignPattern

(subclass Assessment-DesignPattern  DesignPatternAttribute)
(documentation Assessment-DesignPattern "An instance of the class
&%RealtimeSystem has &%Initiation-DesignPattern if it consists of
sensors connected to a software module that filters data from the
sensors and sends the filtered data to another software module that
evaluates the filtered data and sends decisions to a subsystem.
The design pattern is a data source that produces a data stream for
a data handler.  The data source is typically a periodically sampled
collection of sensors.  The data stream's size may vary and is
unbounded.  Data may be either homogeneous or heterogeneous.  The
workload per data element for homogeneous data is constant.  The
workload per data element for heterogeneous data is a function of
each element type.  There is one deadline for real-time situation
assessment systems.  It is the upper bound on the time to process
all elements in the data stream once.")

; definition of TaskRelationAttribute

(subclass TaskRelationAttribute Attribute)
(documentation TaskRelationAttribute "This is a subclass of
&%RealtimeSystemAttribute, which includes &%Independent-TaskRelation
and &%Dependent-TaskRelation.")

; definition of taskRelation

(subrelation taskRelation property)
(domain taskRelation 1 RealtimeSystem)
(domain taskRelation 2 TaskRelationAttribute)
(documentation taskRelation "(&%taskRelation ?System ?Attribute) holds
if ?Attribute is a &%TaskRelationAttribute which describes the
&%RealtimeSystem ?System.")

; definition of Independent-TaskRelation

(subclass Independent-TaskRelation  TaskRelationAttribute)
(documentation Independent-TaskRelation "An instance of &%RealtimeSystem
is described as &%Independent-TaskRelation if its correct execution
does not depend on the inputs from any other function, the execution state
of any other function, or the acceptance of its outputs by any other
function.")

; definition of Dependent-TaskRelation

(instance Dependent-TaskRelation TaskRelationAttribute)
(documentation Dependent-TaskRelation "An instance of &%RealtimeSystem
is described as &%Dependent-TaskRelation if it depends on at least one
other function in the system; that is, its correct execution depends on
the input from another function, the execution state of another function,
or the acceptance of its outputs by another function.")

; definition of FormOfAdaptationAttribute

(subclass FormOfAdaptationAttribute Attribute)
(documentation FormOfAdaptationAttribute "A subclass of
&%RealtimeSystemAttribute, which includes &%Precision-FormOfAdaptation,
&%Slack-FormOfAdaptation, &%Concurrency-FormOfAdaptation, and
&%ResourceAllocation-FormOfAdaptation.")

; definition of formOfAdaptation

(subrelation formOfAdaptation property)
(domain formOfAdaptation 1 RealtimeSystem)
(domain formOfAdaptation 2 FormOfAdaptationAttribute )
(documentation formOfAdaptation "(&%formOfAdaptation ?System ?Attribute)
holds if ?Attribute is a &%FormOfAdaptationAttribute which describes the
&%RealtimeSystem ?System.")

; definition of Precision-FormOfAdaptation


(subclass Precision-FormOfAdaptation FormOfAdaptationAttribute)

; definition of Slack-FormOfAdaptation

(subclass Slack-FormOfAdaptation FormOfAdaptationAttribute)
(documentation Slack-FormOfAdaptation "The attribute &%Slack-FormOfAdaptation
applies to real-time systems that are designed and implemented with enough
resource overhead that the system can always adapt by utilizing the overhead
without complicated decision making.")

; definition of Concurrency-FormOfAdaptation

(subclass Concurrency-FormOfAdaptation FormOfAdaptationAttribute)
(documentation Concurrency-FormOfAdaptation "This attribute applies to
real-time systems that are designed and implemented so that the system
can adapt by replicating the system components and executing them
concurrently.")

; definition of ResourceAllocation-FormOfAdaptation

(subclass ResourceAllocation-FormOfAdaptation FormOfAdaptationAttribute)
(documentation ResourceAllocation-FormOfAdaptation "This attribute applies
to real-time systems that are designed and implemented so that the system
can adapt under the control of a resource allocation manager like Desiderata.")

; definition of TimingRequirementAttribute

(subclass TimingRequirementAttribute RealtimeSystemAttribute)
(documentation TimingRequirementAttribute "A subclass of
&%RealtimeSystemAttribute which includes &%ComplexityAttribute,
&%StrictnessAttribute, and &%AbstractionLevelAttribute.")

; definition of granularity

(instance granularity BinaryPredicate)
(domain granularity 1 RealtimeSystem)
(domain granularity 2 TimeDuration)
(documentation granularity  "Granularity is a sub-property of the
timing requirements property of real-time systems.  Granularity is
defined by how a timing requirement is specified in units of time.")

; definition of ComplexityAttribute

(subclass ComplexityAttribute TimingRequirementAttribute)
(documentation ComplexityAttribute "A subclass of
&%TimingRequirementAttribute, which includes
&%MultipleRequirement-Complexity and &%SingleRequirement-Complexity.")

; definition of complexity

(subrelation complexity property)
(domain complexity 1 RealtimeSystem)
(domain complexity 2 TimingRequirementAttribute)
(documentation complexity "(&%complexity ?System ?Attribute) holds if
?Attribute is a &%TimingRequirementAttribute which describes the
&%RealtimeSystem ?System.")

; definition of SingleRequirement-Complexity

(subclass SingleRequirement-Complexity  ComplexityAttribute)
(documentation SingleRequirement-Complexity  "An attribute that  describes
instances of &%RealtimeSystems which require a single timing requirement,
either a bound for completion time for systems with
&%Transient-SystemBehavior or cycle deadline for systems with
&%Periodic-SystemBehavior.")

(=>
	(systemBehavior ?System Transient-SystemBehavior)
	(complexity ?System SingleRequirement-Complexity))

(=>
	(systemBehavior ?System Periodic-SystemBehavior)
	(complexity ?System SingleRequirement-Complexity))

; definition of MultipleRequirement-Complexity

(subclass MultipleRequirement-Complexity ComplexityAttribute)
(documentation MultipleRequirement-Complexity "An attribute that describes
instances of &%RealtimeSystems which require multiple timing requirements,
both a bound for completion time for its transient behavior and a cycle
deadline for its periodic behavior.")

(=>
	(systemBehavior ?System Hybrid-SystemBehavior)
	(complexity ?System MultipleRequirement-Complexity))

; definition of StrictnessAttribute

(subclass StrictnessAttribute TimingRequirementAttribute)
(documentation StrictnessAttribute "This is a subclass of
&%TimingRequirementAttribute, which includes &%Hard-Strictness,
&%Firm-Strictness, &%Soft-Strictness, &%Importance-Strictness,
&%Utility-Strictness, and &%Hybrid-Strictness")

; definition of strictness

(subrelation strictness property)
(domain strictness 1 RealtimeSystem)
(domain strictness 2 StrictnessAttribute)
(documentation strictness "(&%strictness ?System ?Attribute) holds if
the &%StrictnessAttribute ?Attribute describes the &%RealtimeSystem
?System.")

; definition of Hard-Strictness

(subclass Hard-Strictness StrictnessAttribute)
(documentation Hard-Strictness "An attribute that applies to a
&%RealtimeSystem just in case all deadlines are met.")

; definition of Firm-Strictness

(subclass Firm-Strictness StrictnessAttribute)
(documentation Firm-Strictness "An attribute that applies to a
&%RealtimeSystem just in case a fixed percentage of requirements
is met.")

; definition of Soft-Strictness

(subclass Soft-Strictness StrictnessAttribute)
(documentation Soft-Strictness "An attribute that applies to a
&%RealtimeSystem just in case it  maximizes the number of timing
requirements like deadlines that are met but does not guarantee that
all such requirements will be met or any fixed percentage of
requirements will be met.")

; definition of Importance-Strictness

(subclass Importance-Strictness StrictnessAttribute)
(documentation Importance-Strictness "An attribute that applies to a
&%RealtimeSystem just in case it is designed and implemented to meet
the more important requirements first.")

; definition of Utility-Strictness

(subclass Utility-Strictness StrictnessAttribute)
(documentation Utility-Strictness "An attribute that applies to a
&%RealtimeSystem just in case it is designed and implemented to use
a utility-computing function, which is applied to competing timing
requirements to determine which should be met because meeting the
requirement produces higher utility as defined by the function.")

; definition of Hybrid-Strictness

(subclass Hybrid-Strictness StrictnessAttribute)
(documentation Hybrid-Strictness "An attribute that applies to a
&%RealtimeSystem just in case the strictness of the system is a
combination of &%Hard/Firm/Soft-Strictness with &%Importance-Strictness
or a combination of &%Utility-Strictness with &%Importance-Strictness.")

(=>
	(strictness ?System Hybrid-Strictness)
	(or
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Utility-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Hard-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Firm-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Soft-Strictness))))

; definition of AbstractionLevelAttribute

(subclass AbstractionLevelAttribute TimingRequirementAttribute)
(documentation AbstractionLevelAttribute "This is a subclass of
&%TimingRequirementAttribute, which includes &%Instrument-AbstractionLevel,
&%Method-AbstractionLevel, &%Object-AbstractionLevel, &%Task-AbstractionLevel,
and &%TaskGroup-AbstractionLevel.")

; definition of abstractionLevel

(subrelation abstractionLevel property)
(domain abstractionLevel 1 RealtimeSystem)
(domain abstractionLevel 2 AbstractionLevelAttribute)

; definition of Instrument-AbstractionLevel

(subclass Instrument-AbstractionLevel AbstractionLevelAttribute)
(documentation Instrument-AbstractionLevel "The attribute
&%Instrument-AbstractionLevel is the lowest level of abstraction,
which can be used to describe a real-time system or subsystem.")

; definition of Method-AbstractionLevel

(subclass Method-AbstractionLevel AbstractionLevelAttribute)
(documentation Method-AbstractionLevel  "The attribute
&%Method-AbstractionLevel is the next to the lowest level of
abstraction that can be used to describe a real-time system or
subsystem.  This is at the level of describing every callable
function (or method in an object-oriented language) implemented
in software.")

; definition of Object-AbstractionLevel

(subclass Object-AbstractionLevel AbstractionLevelAttribute)
(documentation Object-AbstractionLevel "The attribute
&%Object-AbstractionLevel is immediately above the attribute
&%Method-AbstractionLevel and can be used to describe a real-time
system or subsystem.  This is at the level of describing every software
object that can be created from a class together with its data structures
and methods (which define the interface for manipulating the object).")

; definition of Task-AbstractionLevel

(subclass Task-AbstractionLevel AbstractionLevelAttribute)
(documentation Task-AbstractionLevel "The attribute
&%Task-AbstractionLevel is immediately above the attribute
&%Object-AbstractionLevel and can be used to describe a real-time
system or subsystem.  This is at the level of describing the major
tasks that are carried out by the real-time systems and are typically
executable as individual processes.  The description of a task would
consist of listing all the software objects used to perform the task.")

; definition of TaskGroup-AbstractionLevel

(subclass TaskGroup-AbstractionLevel AbstractionLevelAttribute)
(documentation TaskGroup-AbstractionLevel "The attribute
&%TaskGroup-AbstractionLevel is immediately above the attribute
&%Task-AbstractionLevel and can be used to describe a real-time
system or subsystem This is at the level of describing groups of
tasks which are related or connected by the real-time systems and
are typically part of a concurrently executing path.")

;; definition of memorySize

(subrelation memorySize measure)
(domain memorySize 1 ComputationalSystem)
(domain memorySize 2 ConstantQuantity)
(documentation memorySize "(&%memorySize ?System ?Size) holds if
?Size is the required memory size for the &%ComputationalSystem
?System.")

;; definition of Sensor

(subclass Sensor ComputerHardware)
(documentation Sensor "&%Sensors include software that measures any
attribute of executing computer programs or collections of executing
programs, such as CPU utilization, aka load, memory utilization, I/O,
overall task performance, network load and latency, etc.")

;; definition of UniformResourceIdentifier

(subclass UniformResourceIdentifier ContentBearingObject)
(exhaustiveDecomposition UniformResourceIdentifier UniformResourceLocator UniformResourceName)
(documentation UniformResourceIdentifier  "A &%UniformResourceIdentifier
(URI) is a compact string of characters for identifying an abstract or
physical resource. A URI can be further classified as a locator, a name,
or both (source: http://www.ietf.org/rfc/rfc2396.txt).")

(=>
	(instance ?URI UniformResourceIdentifier)
	(exists (?Resource)
		(and
			(instance ?Resource Resource)
			(refers ?URI ?Resource))))

;; definition of UniformResourceLocator

(subclass UniformResourceLocator UniformResourceIdentifier)
(documentation UniformResourceLocator  "The term &%UniformResourceLocator
(URL) refers to the subset of URI that identify resources via a
representation of their primary access mechanism (e.g., their network
location), rather than identifying the resource by name or by some other
attribute(s) of that resource (source: http://www.ietf.org/rfc/rfc2396.txt).")

(=>
	(instance ?URL UniformResourceLocator)
	(exists (?Address)
		(and
			(instance ?Address IPAddress)
			(represents ?URL ?Address))))

;; definition of UniformResourceName

(subclass UniformResourceName UniformResourceIdentifier)
(documentation UniformResourceName "The term UniformResourceName (URN)
refers to the subset of URI that are required to remain globally unique
and persistent even when the resource ceases to exist or becomes
unavailable (source: http://www.ietf.org/rfc/rfc2396.txt).")

;; definition of DataSink

(subclass DataSink ComputerInputDevice)
(documentation ComputerHardware "A device or part of the computer that
receives data.")

(=>
	(instance ?Sink DataSink)
	(exists (?Transfer)
		(and
			(instance ?Transfer DataTransfer)
			(destination ?Transfer ?Sink))))

;; definition of ComputerUser

(subclass ComputerUser CognitiveAgent)
(documentation ComputerUser "Any individual who interacts with a
computer.")

(=>
	(instance ?User ComputerUser)
	(exists (?Computer)
		(and
			(instance ?Computer Computer)
			(uses ?User ?Computer))))

;; definition of UserRequest

(subclass UserRequest ComputerProcess)
(documentation UserRequest "A request made by a &%ComputerUser, such as
looking up a customer record.")

(=>
	(instance ?Request UserRequest)
	(exists (?User)
		(and
			(instance ?User ComputerUser)
			(agent ?Request ?User))))

;; definition of ComputerResponse

(subclass ComputerResponse ComputerProcess)
(documentation ComputerResponse "A &%ComputerProcess which attempts to
comply with a user's request.")

;; definition of responseTo

(instance responseTo BinaryPredicate)
(domain responseTo 1 ComputerResponse)
(domain responseTo 2 UserRequest)
(documentation responseTo "(&%responseTo ?Response ?Request) means that
?Response is a &%ComputerResponse to the &%UserRequest ?Request.")

;;definition of responseTime

(instance responseTime BinaryPredicate)
(domain responseTime 1 UserRequest)
(domain responseTime 2 TimeDuration)
(documentation responseTime "The time it takes for the computer to comply
with a user's request, such as looking up a customer record.")

(=>
	(and
		(responseTime ?Request ?Time)
		(responseTo ?Response ?Request))
	(duration (WhenFn ?Response) ?Time))

;; definition of responseRate

(subrelation responseRate frequency)
(domain responseRate 1 ComputerResponse)
(domain responseRate 2 TimeDuration)
(documentation responseRate "(&%responseRate ?Response ?Period) means
that ?Period is the period at which the computer sends its ?Response.")

;; definition of requestRate

(subrelation requestRate frequency)
(domain requestRate 1 UserRequest)
(domain requestRate 2 TimeDuration)
(documentation requestRate "(&%requestRate ?Request ?Period) means that
?Period is the period at which the user sends its ?Request.")

;; definition of Multitasking

(subclass Multitasking ComputerProcess)
(documentation Multitasking "The running of two or more programs in one
computer at the same time. The number of programs that can be effectively
multitasked depends on the type of multitasking performed (preemptive vs
cooperative), CPU speed and memory and disk capacity.")

(=>
	(instance ?Process Multitasking)
	(exists (?Program1 ?Program2)
		(and
			(programRunning ?Process ?Program1)
			(programRunning ?Process ?Program2)
			(not (equal ?Program1 ?Program2)))))

;; definition of ComputerTask

(subclass ComputerTask ComputerProcess)
(documentation ComputerTask "In a multitasking environment, an
independently running program or subprogram. Each task is assigned
a task number.")

(=>
	(instance ?Task ComputerTask)
	(exists (?Program ?Process)
		(and
			(part ?Task ?Process)
			(instance ?Process Multitasking)
			(programRunning ?Task ?Program))))

;; definition of ComputerResource

(subclass ComputerResource ComputationalSystem)
(documentation ComputerResource "One element of hardware, software or data
that is part of a larger system.  For example, network resources are the
available servers and printers in the network. Software resources can be
programs, utilities or even smaller elements within a program. Data
resources are the files and databases that can be accessed.")

(=>


	(instance ?Resource ComputerResource)
	(exists (?System)
		(and
			(instance ?System ComputationalSystem)
			(part ?Resource ?System))))

;; definition of NetworkResource

(subclass NetworkResource ComputerResource)
(documentation NetworkResource "Network resources are the available
servers and printers in the network.")

(=>
	(instance ?Resource NetworkResource)
	(or
		(instance ?Resource Server)
		(instance ?Resource Printer)))

;; definition of Printer

(subclass Printer ComputerOutputDevice)
(documentation Printer "A device that converts computer output into
printed images.")

;; definition of Server

(subclass Server ComputationalSystem)
(documentation Server "A computer in a network shared by multiple users.
The term may refer to both the hardware and software or just the software
that performs the service.")

;; definition of load

(subrelation load measure)
(domain load 1 ComputerComponent)
(domain load 2 ConstantQuantity)
(documentation load "In performance measurement, the current use of a
system as a percentage of total capacity.")

(=>
	(load ?System ?Load)
	(exists (?Event)
		(performanceResult ?Event ?System ?Load)))

;; definition of ComputerData

(subclass ComputerData ContentBearingObject)
(documentation ComputerData "The term &%ComputerData refers to files
and databases, text documents, and images.")

(=>
	(instance ?Data ComputerData)
	(exists (?Hardware)
		(and
			(instance ?Hardware ComputerHardware)
			(located ?Data ?Hardware))))

;; definition of Image

(subclass Image ComputerData)
(documentation Image "A picture (graphic).")

;; definition of Database

(subclass Database ComputerData)
(documentation Database "A set of related files that is created and
managed by a database management system (DBMS).")

;; definition of dataProcessed

(subrelation dataProcessed patient)
(domain dataProcessed 1 ComputerProcess)
(domain dataProcessed 2 ComputerData)
(documentation dataProcessed "The data being processed during a
&%ComputerProcess.")

;; definition of Abort

(subclass Abort ComputerProcess)
(documentation Abort "To exit a function or application without saving
any data that has been changed.")

;; definition of processAborted

(instance processAborted BinaryPredicate)
(instance processAborted AsymmetricRelation)
(domain processAborted 1 Abort)
(domain processAborted 2 ComputerProcess)
(documentation processAborted "(&%processAborted ?Abort ?Process) means
that the &%ComputerProcess ?Process is aborted as the result of ?Abort.")

(=>
	(and
		(processAborted ?Abort ?Process)
		(dataProcessed ?Process ?Data))
	(not (exists (?Save)
	     (and
		(instance ?Save DataSaving)
		(dataProcessed ?Save ?Data)))))

;; definition of DataSaving

(subclass DataSaving ComputerProcess)
(documentation DataSaving "A process of copying the document, record or
image being worked on onto a storage medium. Saving updates the file by
writing the data that currently resides in memory (RAM) onto disk or tape.
Most applications prompt the user to save data upon exiting.")

(=>
	(instance ?Save DataSaving)
	(exists (?Data)
		(dataProcessed ?Save ?Data)))

;; definition of DataCompression

(subclass DataCompression ComputerProcess)
(documentation DataCompression "Encoding data to take up less storage
space.")

(=>
	(and
		(instance ?Compression DataCompression)
		(dataProcessed ?Compression ?Data)
		(holdsDuring (ImmediatePastFn (WhenFn ?Compression))
			     (memorySize ?Data (MeasureFn ?Memory ?Measure)))
		(holdsDuring (ImmediateFutureFn (WhenFn ?Compression))
			     (memorySize ?Data (MeasureFn ?NewMemory ?Measure))))

	(lessThan ?NewMemory ?Memory))

;; definition of ProcessTask

(subclass ProcessTask Abstract)
(documentation ProcessTask "A function to be performed.")

(=>
	(instance ?Task ProcessTask)
	(exists (?Process)
		(task ?Process ?Task)))

;; definition of task

(instance task BinaryPredicate)
(instance task AsymmetricRelation)
(domain task 1 ComputerProcess)
(domain task 2 ProcessTask)
(documentation task "(&%task ?Process ?Task) means that ?Task is a function to
be performed by the &%ComputerProcess ?Process.")

;; definition of UsingAResource

(subclass UsingAResource ComputerProcess)
(documentation UsingAResource "A &%ComputerProcess which requires access to a
&%ComputerResource.")

(=>
	(instance ?Using UsingAResource)
	(exists (?Resource)
		(resourceUsed ?Using ?Resource)))


(=>
	(and
		(instance ?Using UsingAResource)
		(resourceUsed ?Using ?Resource)
		(agent ?Using ?Agent))
	(uses ?Agent ?Resource))

;; definition of ReusingAResource

(subclass ReusingAResource ComputerProcess)
(documentation ReusingAResource "To use the same resource again.")

(=>
	(instance ?Using ReusingAResource)
	(exists (?Resource)
		(resourceUsed ?Using ?Resource)))

(=>
	(and
		(instance ?Reusing ReusingAResource)
		(resourceUsed ?Reusing ?Resource))
	(exists (?Using)
		(and
			(instance ?Using UsingAResource)
			(resourceUsed ?Using ?Resource)
			(earlier (WhenFn ?Using) (WhenFn ?Reusing)))))

;; definition of resourceUsed

(subrelation resourceUsed patient)
(domain resourceUsed 1 ComputerProcess)
(domain resourceUsed 2 ComputerResource)
(documentation resourceUsed "(&%resourceUsed ?Process ?Resource) means that the
&%ComputerProcess ?Process has access to the &%ComputerResource ?Resource.")

;; definition of imageResolution

(instance imagenResolution BinaryPredicate)
(domain imageResolution 1 ComputerImage)
(domain imageResolution 2 PhysicalQuantity)
(documentation imageResolution "The degree of sharpness of a displayed or printed
image.")

;; Optimization

(subclass Optimization ProcessTask)
(disjoint Optimization SatisfyingRequirements)
(documentation Optimization "Optimization means finding the best solution according
to a set of criteria. For a computer program, an optimal solution would be the
fastest program (according to some benchmark) or the smallest program.")

;; definition of  SatisfyingRequirements

(subclass SatisfyingRequirements ProcessTask)
(documentation SatisfyingRequirements "&%SatisfyingRequirements covers cases of
finding a solution that satisfies necessary conditions.")

;; Utility

(subclass Utility ComputerProgram)
(documentation Utility "A program that performs a specific task related to the
management of computer functions, resources, or files. Utility programs range
from the simple to the sophisticated, and many programmers specialize in producing
and distributing them as shareware.  There are utilities that perform file and
directory management, data compression, disk defragmentation and repair, system
diagnostics, graphics viewing, and system security, for example. Many utilities
are written as memory-resident programs meant to serve as adjuncts to operating
systems. Many operating systems incorporate such popular utility functions as
undeleting, password protection, memory management, virus protection, and file
compression.")

;; UserAccount

(subclass UserAccount ContentBearingObject)
(documentation UserAccount "An established relationship between a user and a
computer, network or information service. User accounts require a username and
password, and new user accounts are given a default set of permissions.")

(=>
	(instance ?Account UserAccount)
	(exists (?User)
		(hasAccount ?User ?Account)))

;; UserName

(subclass UserName SymbolicString)
(documentation UserName "The name a person uses to identify himself or herself
when logging onto a computer system or online service.")

(=>
	(hasAccount ?User ?Account)
	(exists (?Name)
		(userName ?User ?Name)))

;; userName

(subrelation userName name)
(instance userName AsymmetricRelation)
(domain userName 1 ComputerUser)
(domain userName 2 UserName)
(documentation userName "(&%userName ?Name ?User) means that ?Name is the name
the &%ComputerUser uses to identify himself or herself when logging onto a
computer system.")

;; hasAccount

(subrelation hasAccount possesses)
(instance hasAccount AsymmetricRelation)
(domain hasAccount 1 ComputerUser)
(domain hasAccount 2 UserAccount)
(documentation hasAccount "(&%hasAccount ?User ?Account) holds if ?User is
assigned the &%UserAccount ?Account.")

;; ComputerPassword

(subclass ComputerPassword SymbolicString)
(documentation ComputerPassword "A word or code used to serve as a security
measure against unauthorized access to data. It is normally managed by the
operating system or DBMS.")

(=>
	(hasAccount ?User ?Account)
	(exists (?Password)
		(password ?Password ?User)))

;; password

(subrelation password name)
(instance password AsymmetricRelation)
(domain password 2 ComputerUser)
(domain password 1 ComputerPassword)
(documentation password "(&%password ?Password ?User) means that ?Password is
the password the &%ComputerUser uses while logging onto a computer system.")

;; definition of Report

(subclass Report ComputerData)
(documentation Report "A collection of data, presented in a preformatted
manner.")

;; definition of hostStatus

(subrelation hostStatus attribute)
(domain hostStatus 1 Computer)
(domain hostStatus 2 ComputerStatus)
(documentation hostStatus "(&%hostStatus ?Computer ?Status) means that ?Status
describes the status of the Computer, such as &%HostDown, &%HostReady.")

;; definition of ComputerStatus

(subclass ComputerStatus Attribute)
(documentation ComputerStatus "An attribute which describes status of the
&%Computer, such as &%HostDown, &%HostReady.")

;; definition of HostDown

(instance HostDown ComputerStatus)
(documentation HostDown "An attribute which applies to a computer that ceases to
operate due to hardware or software failure.")

;; definition of HostReady

(instance HostReady ComputerStatus)
(documentation HostReady "An attribute which applies to a computer that is
functional, operating properly, and ready to receive work requests.")

;; definition of hostJitter

(instance hostJitter BinaryPredicate)
(domain hostJitter 1 Computer)
(domain hostJitter 2 RealNumber)
(documentation hostJitter "Interference on an analog line caused by a variation
of a signal from its reference timing slots. Jitter can cause problems in the receipt
of data and any subsequent processing of that data.")

;; definition of Epoch

(subclass Epoch TimePoint)
(documentation Epoch "An instant in time that is arbitrarily selected as a point
of reference.")


;; definition of UnixEpoch

(instance UnixEpoch Epoch)
(documentation UnixEpoch "The Unix epoch or point of reference is 00:00:00 UTC,
January 1, 1970.")

(equal UnixEpoch (SecondFn 0 (MinuteFn 0 (HourFn 0 (DayFn 1 (MonthFn 1 (YearFn 1970)))))))

;;  definition of collectRate

(subrelation collectRate frequency)
;; DWF: harmonized with parent to resolve conflict
;; (domain collectRate 1 ComputationalSystem)
(domain collectRate 1 Process)
(domain collectRate 2 TimeDuration)
(documentation collectRate "(&%collectRate ?System ?Period) holds if ?Period is
the period at which &%ComputationalSystem ?System collects data.")

;;  definition of sendRate

(subrelation sendRate frequency)
;; DWF: harmonized with parent to resolve conflict
;; (domain sendRate 1 ComputationalSystem)
(domain sendRate 1 Process)
(domain sendRate 2 TimeDuration)
(documentation sendRate "(&%sendRate ?Program ?Period) holds if ?Period is the
period at which the &%ComputationalSystem ?System sends data reports.")

;; definition of BerkeleySoftwareDistribution

(subclass BerkeleySoftwareDistribution OperatingSystem)
(documentation BerkeleySoftwareDistribution  "Berkeley Software Distribution (UNIX),
a version of Unix distributed by the University of California at Berkeley. Widely
used as a standard for early versions of Unix and Unix software libraries.")

;; ================================================
;; FINANCIAL DOMAIN ONTOLOGY rev. 2002-08-08
;; ================================================


;; =======================
;; Financial Organizations
;; =======================





;; definition of FinancialOrganization

(subclass FinancialOrganization Organization)
(documentation FinancialOrganization "The class &%FinancialOrganization includes,
as subclasses, &%Bank-FinancialOrganization, &%CreditUnion and &%SavingsAnLoans.")


;; definition of Bank-FinancialOrganization

(subclass Bank-FinancialOrganization FinancialOrganization)
(documentation Bank-FinancialOrganization "An organization, chartered by a state or
federal government, which does most or all of the following: receives &%Deposits,
honors &%FinancialInstruments drawn on them, and pays &%Interest on them; discounts
&%Notes, makes &%Loans,  and invests in &%SecuredLoans; collects &%Checks, &%Drafts
and &%Notes, certifies depositor's checks; and issues drafts and Cashier's checks.")


;; definition of CreditUnion

(subclass CreditUnion FinancialOrganization)
(documentation CreditUnion "Credit unions are non-profit, member-owned, financial
cooperatives. They are operated entirely by and for their members. When you deposit
money in a credit union, you become a member of the union because your deposit is
considered partial ownership in the credit union. Many large organizations have
established credit unions for their employees.")


;; definition of SavingsAndLoans

(subclass SavingsAndLoans FinancialOrganization)
(documentation SavingsAndLoans "A federally or state chartered &%FinancialOrganization
that takes &%Deposits from individuals, funds &%Mortgages, and pays &%Dividends.")


;;   Financial Accounts and instruments


;; definition of FinancialAsset

(instance FinancialAsset Physical)
(documentation FinancialAsset "Any item of economic value owned by an individual or
corporation, especially that which could be converted to cash.  Examples are cash,
securities, accounts receivable, inventory, office equipment, a house, a car, and
other property.")

(=>
	(instance ?Asset FinancialAsset)
	(exists (?Value)
		(monetaryValue ?Asset ?Value)))


;; definition of FinancialContract

(subAttribute FinancialContract Contract)
(documentation FinancialContract "A financial agreement between two or more parties")


;; definition of FinancialAccount

(subclass FinancialAccount FinancialTransaction)
(documentation FinancialAccount "A formal banking, brokerage, or business relationship
established to provide for regular services, dealings, and other financial
transactions.")

(=>
    (instance ?Account FinancialAccount)
    (and
         (property ?Account FinancialContract)
         (property ?Account ServiceContract)))

(=>
    (property ?Account FinancialAccount)
    (exists (?Organization)
	    (and
		(instance ?Organization FinancialOrganization)
		(accountAt ?Account ?Organization))))

(=>
	(and
		(property ?Account FinancialAccount)
		(accountAt ?Account ?Bank))
	(exists (?Activity)
		(and
			(instance ?Activity ControllingAnAccount)
			(patient ?Activity ?Account)
			(agent ?Activity ?Bank))))


;; definition of FinancialInstrument

(subclass FinancialInstrument Certificate)
(documentation FinancialInstrument "A document having monetary value or recording
a monetary transaction")


;; definition of Note

(subclass Note FinancialInstrument)
(documentation Note "A legal document that obligates a borrower to repay a loan
at a specified interestRate during a specified period of time or on demand")


;; definition of Check

(subclass Check FinancialInstrument)
(documentation Check "A &%FinancialInstrument drawn against deposited funds,
to pay a specified amount of money to a specific person upon demand.")

(=>
	(instance ?Check Check)
	(exists (?Value)
		(monetaryValue ?Check ?Value)))

(=>
	(instance ?Check Check)
	(exists (?Account)
		(checkAccount ?Check ?Account)))

(=>
	(and
		(monetaryValue ?Check ?Amount)
		(checkAccount ?Check ?Account)
		(instance ?Processing ProcessingACheck)
		(patient ?Processing ?Check)
		(equal (WhenFn ?Processing) ?ProcessingTime))
	(exists (?Withdrawal)
		(and
			(instance ?Withdrawal Withdrawal)
			(instrument ?Withdrawal ?Check)
			(equal (WhenFn ?Withdrawal) ?WithdrawalTime)
			(meetsTemporally ?ProcessingTime ?WithdrawalTime)
			(transactionAmount ?Withdrawal ?Amount)
			(origin ?Withdrawal ?Account))))

(=>
	(and
		(monetaryValue ?Check ?Amount)
		(instance ?Processing ProcessingACheck)
		(patient ?Processing ?Check)
		(destination ?Processing (CurrencyFn ?Account))
		(instance ?Account FinancialAccount)
		(equal (WhenFn ?Processing) ?ProcessingTime))
	(exists (?Deposit)
		(and
			(instance ?Deposit Deposit)
			(instrument ?Deposit ?Check)
			(equal (WhenFn ?Deposit) ?DepositTime)
			(meetsTemporally ?ProcessingTime ?DepositTime)
			(transactionAmount ?Deposit ?Amount)
			(destination ?Deposit (CurrencyFn ?Account)))))

(=>
	(and
		(instance ?Check Check)
		(instance ?Processing ProcessingACheck)
		(patient ?Processing ?Check))
	(exists (?Depositing)
		(and
			(instance ?Depositing DepositingACheck)
			(patient ?Depositing ?Check)
			(time ?Depositing (ImmediatePastFn (WhenFn ?Processing))))))

(=>
	(and
		(instance ?Depositing DepositingACheck)
		(instance ?Check Check)
		(agent ?Depositing ?Agent))
	(signedBy ?Check ?Agent))

(=>
	(and
		(instance ?Drawing DrawingACheck)
		(patient ?Drawing ?Check)
		(instance ?Processing ProcessingACheck)
		(patient ?Processing ?Check)
		(equal (WhenFn ?Drawing) ?DrawingTime)
		(equal (WhenFn ?Procesing) ?ProcessingTime)
		(meetsTemporally ?DrawingTime ?Time)
		(meetsTemporally ?Time ?ProcessingTime)
                (duration ?Time ?Duration))
	(lessThan ?Duration (MeasureFn 6 MonthDuration)))


;; Definition of PayCheck.

(subclass PayCheck Check)
(documentation PayCheck "A check issued to an employee in payment of salary or wages")

;; Logic error -- ?Agent variable roams free in consequent.
;;(=>
;;	(and
;;		(instance ?Check Paycheck)
;;		(issuedBy ?Check ?Organization))
;;	(employs ?Agent ?Organization))


;; definition of BankCard

(subclass BankCard FinancialInstrument)
(documentation BankCard "A &%CreditCard or a &%DebitCard issued by a
&%FinancialOrganization.")

(=>
	(instance ?Card BankCard)
	(exists (?Organization)
		(issuedBy ?Card ?Organization)))

(=>
	(and
		(instance ?Card BankCard)
		(issuedBy ?Card ?Bank))
	(exists (?Account)
		(and
			(instance ?Account FinancialAccount)
			(cardAccount ?Card ?Account)
			(accountAt ?Account ?Bank))))


;; definition of DebitCard

(subclass DebitCard BankCard)
(documentation DebitCard "A card which allows customers to access their funds
immediately, electronically. Unlike a credit card, a debit card does not have
any float.")

(=>
	(and
		(instance ?Card DebitCard)
		(possesses ?Agent ?Card))
	(exists (?Account)
		(and
			(instance ?Account DepositAccount)
			(cardAccount ?Card ?Account)
			(accountHolder ?Account ?Agent))))


;; definition of CreditCard

(subclass CreditCard BankCard)
(documentation CreditCard "Any card that may be used repeatedly to borrow money
or buy products and services on credit.  Issued by banks, savings and loans, retail
stores, and other businesses.")

(=>
	(and
		(instance ?Card CreditCard)
		(possesses ?Agent ?Card))
	(exists (?Account)
		(and
			(instance ?Account CreditCardAccount)
			(cardAccount ?Card ?Account)
			(accountHolder ?Account ?Agent))))


;; definition of accountAt

(subrelation accountAt agreementMember)
(domain accountAt 1 FinancialAccount)
(domain accountAt 2 FinancialOrganization)
(documentation accountAt "(&%accountAt ?Account ?Bank) means that ?Account is a
&%FinancialAccount opened in the &%FinancialOrganization ?Bank.")


;; definition of cardAccount

(instance cardAccount BinaryPredicate)
(domain cardAccount 1 BankCard)
(domain cardAccount 2 FinancialAccount)
(documentation cardAccount "(&%cardAccount ?Card ?Account) means that ?Account is
the &%FinancialAccount linked to a BankCard ?Card.")


;; definition of checkAccount

(instance checkAccount BinaryPredicate)
(domain checkAccount 1 Check)
(domain checkAccount 2 FinancialAccount)
(documentation checkAccount "(&%checkAccount ?Check ?Account) means that ?Account
is the &%FinancialAccount from which the amount specifed on the check is paid.")


;; definition of accountHolder

(subrelation accountHolder agreementMember)
(domain accountHolder 1 FinancialAccount)
(domain accountHolder 2 CognitiveAgent)
(documentation accountHolder "(&%accountHolder ?Account ?Agent) means that ?Agent
is the account holder of the &%FinancialAccount ?Account.")


;; definition of issuedBy

(instance issuedBy BinaryPredicate)
(domain issuedBy 1 FinancialInstrument)
(domain issuedBy 2 CognitiveAgent)
(documentation issuedBy "(&%issuedBy ?Instrument ?Agent) means that a
&%FinancialInstrument ?Instrument is produced and offered by ?Agent.")


;; definition of signedBy

(instance signedBy BinaryPredicate)
(domain signedBy 1 FinancialInstrument)
(domain signedBy 2 CognitiveAgent)
(documentation signedBy "(&%signedBy ?Instrument ?Agent) means that ?Instrument
has been signed by ?Agent.")


;; definition of agreementMember

(instance agreementMember BinaryPredicate)
(domain agreementMember 1 Contract)
(domain agreementMember 2 CognitiveAgent)
(documentation agreementMember "(&%agreementMember ?Agreement ?Agent) means that
?Agent is one of the participants of the Agreement.")


;; definition of CurrencyFn

(instance CurrencyFn UnaryFunction)
(domain CurrencyFn 1 FinancialAccount)
(range CurrencyFn FinancialInstrument)
(documentation CurrencyFn "A unary function that maps a &%FinancialAccount to the
currency linked to the account.")


;;   Financial Activities


;; Definition of OpeningAnAccount.


(subclass OpeningAnAccount FinancialTransaction)
(documentation OpeningAnAccount "An activity of opening a financial account")

(=>
	(and
		(instance ?Opening OpeningAnAccount)
		(located ?Opening ?Bank)
		(instance ?Bank FinancialOrganization)
		(agent ?Opening ?Agent)
		(equal (WhenFn ?Opening) ?OpeningTime))
	(exists (?Account ?AccountPeriod)
		(and
			(agreementPeriod ?Account ?AccountPeriod)
			(meetsTemporally ?OpeningTime ?AccountPeriod)
			(instance ?Account FinancialAccount)
			(accountAt ?Account ?Bank)
			(accountHolder ?Account ?Agent))))


;; Definition of UsingAnAccount.


(subclass UsingAnAccount FinancialTransaction)
(documentation UsingAnAccount "An activity of using a financial account")


(=>
	(and
		(instance ?Using UsingAnAccount)
		(patient ?Using ?Account)
		(accountHolder ?Account ?Agent))
	(agent ?Using ?Agent))


;; definition of DrawingACheck

(subclass DrawingACheck UsingAnAccount)
(documentation DrawingACheck "An activity of paying by a check.")

(=>
	(and
		(instance ?Drawing DrawingACheck)
		(patient ?Drawing ?Check)
		(agent ?Drawing ?Agent)
		(checkAccount ?Check ?Account))
	(accountHolder ?Account ?Agent))


;; definition of DepositingACheck

(subclass DepositingACheck UsingAnAccount)
(documentation DepositingACheck "An activity of depositing a check into a
&%FinancialOrganization.")

(=>
	(instance ?Depositing DepositingACheck)
	(exists (?Check)
		(and
			(instance ?Check Check)
			(patient ?Depositing ?Check))))

(=>
	(and
		(instance ?Depositing DepositingACheck)
		(patient ?Depositing ?Check)
		(instance ?Check Check)
		(checkAccount ?Check ?Account)
		(monetaryValue ?Check ?Amount))
	(exists (?Deposit)
		(and
			(instance ?Deposit Deposit)
			(destination ?Deposit (CurrencyFn ?Account))
			(transactionAmount ?Deposit ?Amount))))


;; definition of ControllingAnAccount

(subclass ControllingAnAccount	FinancialTransaction)
(documentation ControllingAnAccount "An activity of controlling a financial account")

(=>
	(and
		(instance ?Controlling ControllingAnAccount)
		(patient ?Controlling ?Account)
		(accountAt ?Account ?Bank))
	(agent ?Controlling ?Bank))


;; definition of ProcessingACheck

(subclass ProcessingACheck ControllingAnAccount)
(documentation ProcessingACheck "An activity of paying the amount specified on the
check from funds on deposit.")

(=>
	(instance ?Processing ProcessingACheck)
	(exists (?Check)
		(and
			(instance ?Check Check)
			(patient ?Procesing ?Check))))

(=>
	(instance ?Processing ProcessingACheck)
	(exists (?Authorization)
		(and
			(instance ?Authorization AuthorizationOfTransaction)
			(subProcess ?Authorization ?Processing))))


;; definition of AuthorizationOfTransaction

(subclass AuthorizationOfTransaction ControllingAnAccount)
(subclass AuthorizationOfTransaction RegulatoryProcess)
(documentation AuthorizationOfTransaction "An activity which approves or
disapproves a transaction.")


;; definition of ClosingAnAccount

(subclass ClosingAnAccount FinancialTransaction)
(documentation ClosingAnAccount "An activity of closing a financial account")

(=>
	(and
		(instance ?Closing ClosingAnAccount)
		(patient ?Closing ?Account))
        (and
                (holdsDuring (ImmediatePastFn (WhenFn ?Closing)) (instance ?Account FinancialAccount))
		(holdsDuring (ImmediateFutureFn (WhenFn ?Closing)) (not (instance ?Account FinancialAccount)))))


;; definition of Payment

(subclass Payment FinancialTransaction)
(documentation Payment "The partial or complete discharge of an obligation by
its settlement in the form of the transfer of funds, assets, or services equal
to the monetary value of part or all of the debtor's obligation.")

(=>
	(and
		(instance ?Payment Payment)
		(origin ?Payment (CurrencyFn ?Account))
		(instance ?Account FinancialAccount)
		(transactionAmount ?Payment ?Amount)
		(currentAccountBalance ?Account (ImmediatePastFn (WhenFn ?Payment)) ?Balance1)
		(equal ?Balance2 (SubtractionFn ?Balance1 ?Amount)))
	(currentAccountBalance ?Account (ImmediateFutureFn (WhenFn ?Payment)) ?Balance2))


;; definition of Deposit

(subclass Deposit FinancialTransaction)
(disjoint Deposit Withdrawal)
(documentation Deposit "An Activity of money being transferred into a customer's
account at a financial institution.")

(=>
	(instance ?Deposit Deposit)
	(exists (?Account)
		(destination ?Deposit (CurrencyFn ?Account))))


(=>
	(and
		(instance ?Deposit Deposit)
		(time ?Deposit ?TimeOfDeposit)
		(instance ?Account FinancialAccount)
		(destination ?Deposit (CurrencyFn ?Account))
		(transactionAmount ?Deposit ?Amount)
		(currentAccountBalance ?Account (ImmediatePastFn (WhenFn ?Deposit)) ?Balance1)
		(equal ?Balance2 (AdditionFn ?Balance1 ?Amount)))
	(currentAccountBalance ?Account (ImmediateFutureFn (FutureFn ?Deposit)) ?Balance2))


;; definition of Withdrawal

(subclass Withdrawal FinancialTransaction)
(documentation Withdrawal "An activity of money being transferred from a customer's
account at a financial institution.")

(=>
	(instance ?Withdrawal Withdrawal)
	(exists (?Account)
		(and
			(instance ?Account FinancialAccount)
			(origin ?Withdrawal (CurrencyFn ?Account)))))


;; definition of Investing

(subclass Investing FinancialTransaction)
(documentation Investing "An activity of commiting money or capital in order to
gain a financial return.")

(=>
	(and
		(agent ?Purchase ?Buyer)
		(origin ?Purchase ?Seller)
		(patient ?Purchase ?Object)
		(monetaryValue ?Object ?Money))
	(exists (?Payment)
		(and
			(subProcess ?Payment ?Purchase)
			(instance ?Payment Payment)
			(transactionAmount ?Payment ?Money)
			(destination ?Payment ?Seller))))


;; Definition of AutomaticTransaction.

(subclass AutomaticTransaction FinancialTransaction)
(documentation AutomaticTransaction "&%Transactions which occur through computer
networks and which do not require direct management.")


;; Interest and Interest Rates


;; Definition of Interest.

(subclass Interest CurrencyMeasure)
(documentation Interest "Money paid for the use of money.")

;; definition of InterestRate

(subclass InterestRate ConstantQuantity)
(subclass InterestRate EconomicIndicator)
(documentation InterestRate "The usual way of calculating Interest, as a
percentage of the sum borrowed.")

;; definition of interestEarned

(instance interestEarned TernaryPredicate)
(domain  interestEarned 1 FinancialAccount)
(domain  interestEarned 2 Interest)
(domain  interestEarned 3 TimeInterval)
(documentation interestEarned "(&%interestEarned ?Account ?Interest ?Period) means
that ?Interest is the amount earned on the &%FinancialAccount ?Account, for the
duration ?Period.")

;; Definition of simpleInterest.

(instance simpleInterest TernaryPredicate)
(subrelation simpleInterest interestEarned)
(domain  simpleInterest 1 FinancialAccount)
(domain  simpleInterest 2 Interest)
(domain  simpleInterest 3 TimeInterval)
(documentation simpleInterest "(&%simpleInterest ?Account ?Amount ?Time) means
that ?Amount is the interest calculated on a principal sum, not compounded on
earned interest, for the duration ?Time.")


;; MultiplicationFn is a BinaryFunction, so this is invalid:
;; (equal ?Amount (MultiplicationFn (MagnitudeFn ?Period) ?Balance ?Rate-Decimal))
(=>
	(and
		(principalAmount ?Account ?Balance)
		(fixedInterestRate ?Account ?Rate)
		(simpleInterest ?Account ?Amount ?Period)
		(equal ?Rate-Decimal (DivisionFn (MagnitudeFn ?Rate) 100)))
	(equal ?Amount (MultiplicationFn (MultiplicationFn (MagnitudeFn ?Period) ?Balance) ?Rate-Decimal)))

;; Definition of compoundInterest.

(instance compoundInterest TernaryPredicate)
(subrelation compoundInterest interestEarned)
(domain compoundInterest 1 FinancialAccount)
(domain compoundInterest 2 Interest)
(domain compoundInterest 3 TimeInterval)
(documentation compoundInterest "(&%compoundInterest ?Account ?Amount ?Time) means
that ?Amount is the interest which is calculated not only on the initial principal
but also the accumulated interest of prior periods. Compound interest can be
calculated annually, semi-annually, quartely, monthly, or daily.")

(=>
	(and
		(principalAmount ?Account ?Balance)
		(fixedInterestRate ?Account ?Rate)
		(compoundInterest ?Account ?Interest ?Period)
		(equal ?Rate-Decimal (DivisionFn ?Rate 100))
		(equal ?Add (AdditionFn 1 ?Rate-Decimal))
		(equal ?Exponent (ExponentiationFn ?Add  (MagnitudeFn ?Period)))
		(equal ?Multiply (MultiplicationFn ?Exponent ?Balance)))
	(equal ?Interest (SubtractionFn ?Multiply ?Balance)))

;; Definition of interestRatePerPeriod.

(instance interestRatePerPeriod TernaryPredicate)
(domain interestRatePerPeriod 1  FinancialAccount)
(domain interestRatePerPeriod 2 InterestRate)
(domain interestRatePerPeriod 3 TimeInterval)
(documentation interestRatePerPeriod
"(interestRatePerPeriod ?ACCOUNT ?RATE ?TIME) means that ?RATE is the interest
per the period TIME divided by principal amount, expressed as a percentage")

(=>
	(and
		(simpleInterest ?Account ?Interest ?Period)
		(principalAmount ?Account ?Principal)
		(equal ?Rate-Decimal (DivisionFn ?Interest ?Principal))
		(equal ?Rate (MultiplicationFn ?Rate-Decimal 100)))
	(interestRatePerPeriod ?Account ?Rate ?Period))

;; Definition of primeInterestRate.

(instance primeInterestRate BinaryPredicate)
(domain primeInterestRate  1 Day)
(domain primeInterestRate  2 InterestRate)
(documentation primeInterestRate "The interest rate that commercial banks charge
their most creditworthy borrowers, such as large corporations.  The prime rate is
a lagging indicator.")

(=>
	(and
		(instance ?Account PersonalAccount)
		(currentInterestRate ?Account ?Date ?Rate)
		(primeInterestRate ?Date ?PrimeRate))
	(greaterThan ?Rate ?PrimeRate))

;; Definition of currentInterestRate.

(instance currentInterestRate TernaryPredicate)
(domain currentInterestRate 1 FinancialAccount)
(domain currentInterestRate 2 Day)
(domain currentInterestRate 3 InterestRate)
(documentation currentInterestRate "(&%currentInterestRate ?Account ?Day ?Rate)
means that ?Rate is the interest rate of the Account on a specific day ?Day.")

;; Definition of fixedInterestRate.

(instance fixedInterestRate BinaryPredicate)
(domain fixedInterestRate 1 FinancialAccount)
(domain fixedInterestRate 2 InterestRate)
(documentation fixedInterestRate "(&%fixedInterestRate ?Account ?Rate) holds if
?Rate is the interest rate that does not change during the entire term of the
account.")

;; dates

;; definition of agreementActive

(instance agreementActive BinaryPredicate)
(domain agreementActive 1 Contract)
(domain agreementActive 2 TimePosition)
(documentation agreementActive "(&%agreementActive ?Agreement ?Date) holds if
?Agreement is in force at the time specified by ?Date.")

(<=>
	(and
		(agreementPeriod ?Agreement ?Period)
		(overlapsTemporally ?Date ?Period))
	(agreementActive ?Agreement ?Date))

;; Definition of maturityDate.

(instance maturityDate BinaryPredicate)
(subrelation maturityDate expirationDate)
(domain maturityDate 1 FinancialAccount)
(domain  maturityDate  2 Day)
(documentation maturityDate "The date on which the principal amount of the account
becomes due and payable.")

(=>
	(and
		(maturityDate ?Account ?Date)
		(principalAmount ?Account ?Principal))
	(amountDue ?Account ?Principal ?Date))

(<=>
	(and
		(agreementPeriod ?Account ?Period)
		(finishes ?End ?Period))
	(maturityDate ?Account ?End))

;; Definition of amountDue.

(instance amountDue TernaryPredicate)
(domain amountDue  1 FinancialAccount)
(domain amountDue 2 CurrencyMeasure)
(domain amountDue 3 TimePosition)
(documentation amountDue "(&%amountDue ?ACCOUNT ?AMOUNT ?DATE) means ?DATE is the
date on which the amount of Money ?AMOUNT of a particular ?ACCOUNT is due and payable")

(=>
	(and
		(amountDue ?Account ?Amount ?DueDate)
		(accountHolder ?Account ?Agent))
	(holdsObligation (KappaFn ?Payment
				  (and
					(instance ?Payment Payment)
					(transactionAmount ?Payment ?Amount)
					(or
						(destination ?Payment (CurrencyFn ?Account))
						(origin ?Payment (CurrencyFn ?Account)))
					(date ?Payment ?Date)
					(beforeEq (EndFn ?Date) (BeginFn ?DueDate)))) ?Agent))

;; definition of agreementPeriod

(instance agreementPeriod BinaryPredicate)
(domain agreementPeriod 1 Contract)
(domain agreementPeriod  2 TimeInterval)
(documentation agreementPeriod "(&%agreementPeriod ?Agreement ?Period) holds if
?Period specifies a Time interval during which ?Agreement is in force.")


;; Balances and payments


;; definition of transactionAmount


(instance transactionAmount BinaryPredicate)
(domain transactionAmount 1 FinancialTransaction)
(domain transactionAmount 2 CurrencyMeasure)
(documentation transactionAmount "(&%transactionAmount ?Transaction ?Amount) means
that ?Amount is an instance of &%CurrencyMeasure being exhanged in a
&%FinancialTransaction ?Transaction.")

;; definition of currentAccountBalance

(instance currentAccountBalance TernaryPredicate)
(domain currentAccountBalance 1 FinancialAccount)
(domain currentAccountBalance 2 Day)
(domain currentAccountBalance 3 CurrencyMeasure)
(documentation currentAccountBalance "(&%currentAccountBalance ?Account ?Date ?Amount) means that ?Amount is the balance of the FinancialAccount ?Account as of the date
?Date.")

;; Definition of minimumBalance.


(instance minimumBalance TernaryPredicate)
(domain  minimumBalance 1 FinancialAccount)
(domainSubclass  minimumBalance 2 FinancialTransaction)
(domain minimumBalance 3 CurrencyMeasure)
(documentation minimumBalance "(&%minimumBalance ?Account ?ActivityType ?Amount)
means that ?Amount is the mimimum amount required by the type of
&%FinancialTransaction ?ActivityType.")

(=>
	(and
		(instance ?Account ?FinancialAccount)
		(minimumBalance ?Account OpeningAnAccount ?Balance))
	(exists (?Payment)
		(and
			(destination ?Payment (CurrencyFn ?Account))
			(transactionAmount ?Payment ?Amount)
			(greaterThanOrEqualTo ?Amount ?Balance)
			(effectiveDate ?Account ?Date)
			(date ?Payment ?Date))))

(=>
	(exists (?Date)
		(and
			(instance ?Account ?FinancialAccount)
			(minimumBalance ?Account UsingAnAccount ?Balance)
			(currentAccountBalance ?Account ?Date ?Amount)
			(lessThan ?Amount ?Balance)))
	(exists (?Penalty)
		(and
			(instance ?Penalty Penalty)
			(date ?Penalty ?Date)
			(destination ?Penalty (CurrencyFn ?Account)))))

;; Definition of originalBalance.

(instance originalBalance BinaryPredicate)
(domain originalBalance 1 FinancialAccount)
(domain originalBalance 2 CurrencyMeasure)
(documentation originalBalance "(&%originalBalance ?ACCOUNT ?BALANCE) means that
?BALANCE is the balance of the account at the time the account is opened.")

(=>
	(and
		(effectiveDate  ?Account ?Date)
		(currentAccountBalance ?Account ?Date ?Balance))
	(originalBalance ?Account ?Balance))

;; Definition of principalAmount.

(instance principalAmount BinaryPredicate)
(domain principalAmount 1 FinancialAccount)
(domain principalAmount 2 CurrencyMeasure)
(documentation principalAmount "(&%principalAmount ?ACCOUNT ?BALANCE) means
that ?BALANCE is the amount borrowed, or the part of the amount borrowed
which remains unpaid (excluding interest).")

;; Definition of periodicPayment.

(instance periodicPayment TernaryPredicate)
(domain periodicPayment 1 FinancialAccount)
(domain periodicPayment 2 CurrencyMeasure)
(domain periodicPayment 3 TimeDuration)
(documentation periodicPayment "(&%periodicPayment ?Pay ?Amount ?Period) holds if
?Pay is one of the periodic payments for the amount ?Amount.")

(=>
	(periodicPayment ?Account ?Amount ?Period)
	(exists (?Payment)
		(and
			(instance ?Payment Payment)
			(origin ?Payment (CurrencyFn ?Account))
			(transactionAmount ?Payment ?Amount)
			(frequency ?Payment ?Period))))

;; Definition of minimumPayment.

(instance minimumPayment TernaryPredicate)
(domain minimumPayment 1 LiabilityAccount)
(domain minimumPayment 2 CurrencyMeasure)
(domain minimumPayment 3 TimeDuration)
(documentation minimumPayment "The smallest amount which can be paid on a revolving
charge account to avoid a penalty.")

(=>
	(and
		(instance ?Account LiabilityAccount)
		(minimumPayment ?Account ?MinPayment MonthDuration)
		(exists (?Payment ?Month)
			(and
				(instance ?Month Month)
				(destination ?Payment (CurrencyFn ?Account))
				(paymentsPerPeriod ?Account ?Amount ?Month)
				(lessThan ?Amount ?MinPayment))))
	(exists (?Penalty)
		(and
			(instance ?Penalty Penalty)
			(destination ?Penalty (CurrencyFn ?Account)))))

;; definition of overdraft

(instance overdraft TernaryPredicate)
(domain overdraft 1 FinancialAccount)
(domain overdraft 2 CurrencyMeasure)
(domain overdraft 3 Day)
(documentation overdraft "The amount by which withdrawals exceed deposits.")

(=>
	(and
		(currentAccountBalance ?Account ?Date (MeasureFn ?Balance DollarUnitedStates))
		(lessThan ?Balance 0)
		(equal ?Overdraft (SubtractionFn 0 ?Balance)))
	(overdraft ?Account (MeasureFn ?Overdraft DollarUnitedStates) ?Date))

;; Definition of creditLimit.

(instance creditLimit BinaryPredicate)
(domain creditLimit 1 CreditAccount)
(domain creditLimit 2 CurrencyMeasure)
(documentation creditLimit "(&%creditLimit ?ACCOUNT ?AMNT) holds if ?AMNT is the
maximum amount of credit that a bank or other lender will extend to a customer.")

;; definition of floorLoan

(instance floorLoan BinaryPredicate)
(domain floorLoan 1 Loan)
(domain floorLoan 2 CurrencyMeasure)
(documentation floorLoan "A minimum amount that a lender is willing to loan")

;; Definition of downPayment.

(instance downPayment BinaryPredicate)
(domain downPayment 1 Loan)
(domain downPayment 2 CurrencyMeasure)
(documentation downPayment "The part of the purchase price paid in cash up front,
reducing the amount of the loan or mortgage.")

(=>
	(and
		(downPayment ?Loan ?Amount)
		(effectiveDate ?Loan ?Date))
	(exists (?Payment)
		(and
			(transactionAmount ?Payment ?Amount)
			(date ?Payment ?Date)
			(destination ?Payment (CurrencyFn ?Loan)))))

(=>
	(and
		(downPayment ?Loan ?Amount)
		(loanForPurchase ?Loan ?Purchase)
		(monetaryValue ?Purchase ?Value)
		(equal ?Balance (SubtractionFn ?Value ?Amount)))
	(originalBalance ?Loan ?Balance))

;; definition of Prepayment

(subclass Prepayment Payment)
(documentation Prepayment "Prepayment is the payment of all or part of a debt
prior to its due date.")

(=>
	(and
		(transactionAmount ?Payment ?Amount)
		(date ?Payment ?Date)
		(instance ?Account FinancialAccount)
		(destination ?Payment (CurrencyFn ?Account))
		(amountDue ?Account ?AmountDue ?DueDate)
		(before (EndFn ?Date) (BeginFn ?DueDate)))
	(instance ?Payment Prepayment))

;; definition of accountsBalance

;(instance accountsBalance TernaryPredicate)
;(domainSubclass accountsBalance 1 FinancialAccount)
;(domain accountsBalance 2 CurrencyMeasure)
;(domain accountsBalance 3 Day)

;; [Unbalanced commented-out expression deleted]

;; definition of netWorth


(instance netWorth TernaryPredicate)
(instance netWorth SingleValuedRelation)
(domain netWorth 1 CognitiveAgent)
(domain netWorth 2 CurrencyMeasure)
(domain netWorth 3 Day)
(documentation netWorth "Total assets minus total liabilities of an individual or company.")

(=>
	(netWorth ?Agent ?Amount ?Date)
	(holdsDuring ?Date (equal ?Amount (WealthFn ?Agent))))

;; [Unbalanced commented-out expression deleted]


;;	fees


;; definition of ChargingAFee

(subclass ChargingAFee FinancialTransaction)
(documentation ChargingAFee "An activity of a fee being charged")

;; Definition of serviceFee.

(instance serviceFee TernaryPredicate)
(domain serviceFee 1 FinancialOrganization)
(domain serviceFee 2 FinancialTransaction)
(domain serviceFee 3 CurrencyMeasure)
(documentation serviceFee "A charge to the customer levied by a &%FinancialOrganization
for a &%FinancialTransaction, such as &%OpeningAnAccount or &%UsingAnAccount.")

(=>
	(serviceFee ?Bank ?Action ?Amount)
	(exists (?Fee)
		(and
			(instance ?Fee ChargingAFee)
			(agent ?Fee ?Bank)
			(causes ?Action ?fee)
			(amountCharged ?Fee ?Amount))))

;; definition of amountCharged

(subrelation amountCharged transactionAmount)
(domain  amountCharged 1 ChargingAFee)
(domain amountCharged 2 CurrencyMeasure)
(documentation amountCharged "(&%amountCharged ?Fee ?Amount) means that ?Amount is the amount of
the fee charged.")

;; definition of Penalty

(subclass Penalty ChargingAFee)
(documentation Penalty "A fee charged as a penalty.")

;; definition of Tax

(subclass Tax ChargingAFee)
(documentation Tax "A fee charged by a government on a product, income, or activity.")

(=>
	(instance ?Tax Tax)
	(exists (?Org)
		(and
			(instance ?Org Government)
			(agent ?Tax ?Org))))


;;	Types of Accounts


;; Definition of InterestBearingAccount.

(subclass InterestBearingAccount FinancialAccount)
(documentation InterestBearingAccount "FinancialAccounts that have a fixed or adjustable interest rate.")

(=>
	(instance ?Account InterestBearingAccount)
	(exists (?Rate ?Period)
		(interestRate ?Account ?Rate ?Period)))

;; Definition of FixedRateAccount.

(subclass FixedRateAccount InterestBearingAccount)
(disjoint FixedRateAccount AdjustableRateAccount)
(documentation FixedRateAccount "An &%InterestBearingAccount in which the interest rate does not
change during the entire term of the loan.")


(<=>
       (exists (?Rate)
	       (fixedInterestRate ?Account ?Rate))
       (instance ?Account FixedRateAccount))

;; Definition of AdjustableRateAccount.

(subclass AdjustableRateAccount InterestBearingAccount)
(documentation AdjustableRateAccount "An &%InterestBearingAccount in which
the interest rate is adjusted periodically, usually based on a standard
market rate outside the control of the bank or savings institution, such
as that prevailing on &%TreasuryBill or the &%primeInterestRate.")

;; Definition of PersonalAccount.

(subclass PersonalAccount FinancialAccount)
(documentation PersonalAccount "This is the class of personal accounts, as opposed to
&%CorporateAccounts.")

(<=>
	(and
		(accountHolder ?Account ?Agent)
		(instance ?Agent Human))
	(instance ?Account PersonalAccount))

;; Definition of JointAccount.

(subclass JointAccount PersonalAccount)
(documentation JointAccount "An account owned by two or more people, usually sharing a household
and expenses. Each co-owner has equal access to the account. Most types of accounts, whether it's
basic checking, savings or money market, allow for joint use")

(<=>
	(and
		(instance ?Account PersonalAccount)
		(greaterThan (CardinalityFn (KappaFn ?Agent (accountHolder ?Account ?Agent))) 1))
	(instance ?Account JointAccount))

;; Definition of CorporateAccount.

(subclass CorporateAccount FinancialAccount)
(disjoint CorporateAccount PersonalAccount)
(documentation CorporateAccount "This is the class of accounts held by corporations.  This class
is disjoint with &%PersonalAccounts.")

(<=>
	(and
		(accountHolder ?Account ?Agent)
		(instance ?Agent Corporation))
	(instance ?Account CorporateAccount))

;; definition of DepositAccount

(subclass DepositAccount FinancialAccount)
(documentation DepositAccount "An account where money is deposited for checking, savings or
brokerage use.")

;; Definition of SavingsAccount.


(subclass SavingsAccount InterestBearingAccount)
(subclass SavingsAccount DepositAccount)
(documentation SavingsAccount "An account in a bank on which interest is usually paid and from
which withdrawals can be made usually only by presentation of a passbook or by written authorization
on a prescribed form.")

(=>
	(and
		(instance ?Account SavingsAccount)
		(instance ?Transaction FinancialTransaction)
		(origin ?Transaction (CurrencyFn ?Account)))
	(exists (?Authorization)
		(and
			(instance ?Authorization AuthorizationOfTransaction)
			(subProcess ?Authorization ?Transaction))))

(=>
	(and
		(instance ?Account SavingsAccount)
		(accountHolder ?Account ?Agent)
		(interestEarned ?Account ?Interest ?Period))
	(exists (?Payment)
		(and
			(destination ?Payment (CurrencyFn ?Account))
			(transactionAmount ?Payment ?Interest)
			(destination ?Payment ?Agent))))

;; Definition of MoneyMarket.

(subclass MoneyMarket SavingsAccount)
(documentation MoneyMarket "&%MoneyMarket is for borrowing and lending money for three years
or less. The securities in a money market can be U.S. government bonds, TreasuryBills and commercial
paper from banks and companies.")

(=>
	(instance ?Account MoneyMarket)
	(liquidity ?Account HighLiquidity))

(=>
	(instance ?Account MoneyMarket)
	(riskLevel ?Account LowRisk))

;; Definition of TreasuryBill.

(subclass TreasuryBill SavingsAccount)
(documentation TreasuryBill "A negotiable debt obligation issued by the U.S. government and backed
by its full faith and credit, having a maturity of one year or less. Exempt from state and local taxes")

(=>
	(instance ?Account TreasuryBill)
	(riskLevel ?Account LowRisk))

;; Definition of  CertificateOfDeposit.

(subclass CertificateOfDeposit SavingsAccount)
(documentation CertificateOfDeposit "CDs (certificates of deposit) are bank, credit union or savings
and loan instruments that allow the depositor to lock in an interest rate for a specific period of
time (e.g. six months, one year, five years).  If the money is withdrawn from the CD before the CD
matures, there is likely to be an early-withdrawal penalty -- often three month's interest. Generally,
the longer the time period of the CD, the higher the interest paid.")

(=>
	(instance ?CD CertificateOfDeposit)
	(exists (?Date)
		(maturityDate ?CD ?Date)))

(=>
	(and
		(instance ?CD CertificateOfDeposit)
		(maturityDate ?CD ?MaturityDate)
		(instance ?Withdrawal Withdrawal)
		(origin ?Withdrawal (CurrencyFn ?CD))
		(date ?Withdrawal ?DateOfWithdrawal)
		(before (EndFn ?DateOfWithdrawal) (BeginFn ?MaturityDate)))
	(exists (?Penalty)
		(and
			(instance ?Penalty Penalty)
			(destination ?Penalty (CurrencyFn ?CD))
			(causes ?Withdrawal ?Penalty))))

;; Definition of  TraditionalSavingsAccount.

(subclass TraditionalSavingsAccount SavingsAccount)
(documentation TraditionalSavingsAccount "Accounts that pay interest, usually at below-market
interest rates, that do not have a specific maturity, and that usually can be withdrawn upon demand")

(=>
	(instance ?Account TraditionalSavingsAccount)
	(liquidity ?Account HighLiquidity))

(=>
	(instance ?Account TraditionalSavingsAccount)
	(not
		(exists (?Date)
			(maturityDate ?Account ?Date))))

(=>
	(and
		(instance ?Account TraditionalSavingsAccount)
		(instance ?Withdrawal Withdrawal)
		(origin ?Withdrawal (CurrencyFn ?Account)))
	(not (exists (?Penalty)
	     (and
		(instance ?Penalty Penalty)
		(destination ?Penalty (CurrencyFn ?Account))
		(causes ?Withdrawal ?Penalty)))))

;; Definition of CheckingAccount

(subclass CheckingAccount DepositAccount)
(documentation CheckingAccount "A bank account against which the depositor can draw checks")

(=>
	(and
		(instance ?Account CheckingAccount)
		(instance ?Transaction FinancialTransaction)
		(origin ?Transaction (CurrencyFn ?Account)))
	(or
		(exists (?Check)
			(and
				(instance ?Check Check)
				(instrument ?Transaction ?Check)))

		(exists (?DebitCard)
			(and
				(instance ?DebitCard BankDebitCard)
				(instrument ?Transaction ?DebitCard)))))

;; definition of InvestmentAccount

(subclass InvestmentAccount DepositAccount)
(documentation InvestmentAccount "An account acquired for future financial return or benefit")

;; definition of MutualFundAccount

(subclass MutualFundAccount InvestmentAccount)
(documentation MutualFundAccount "An open-ended fund operated by an investment company which
raises money from shareholders and invests in a group of assets, in accordance with a stated
set of objectives. Benefits include diversification and professional money management. Shares
are issued and redeemed on demand, based on the fund's net asset value which is determined at
the end of each trading session.")

;; definition of Liability

(subclass Liability FinancialContract)
(documentation Liability "A financial obligation, debt, claim, or potential loss")

;; definition of LiabilityAccount

(subclass LiabilityAccount FinancialAccount)
(documentation LiabilityAccount "An account for which a person is liable")

(=>
	(and
		(instance ?Account LiabilityAccount)
		(accountHolder ?Account ?Agent)
		(accountAt ?Account ?Bank))
	(exists (?Debt)
		(and
			(instance ?Debt Liability)
			(agreementMember ?Debt ?Agent)
			(agreementMember ?Debt ?Bank))))

;; Definition of CreditAccount.

(subclass CreditAccount LiabilityAccount)
(documentation CreditAccount "Credit extended by a business to a customer")

(=>
	(and
		(instance ?Account CreditAccount)
		(accountAt ?Account ?Organization)
		(accountHolder ?Account ?Agent)
		(interestEarned ?Account ?Interest ?Period))
	(exists (?Payment)
		(and
			(origin ?Payment ?Agent)
			(transactionAmount ?Payment ?Interest)
			(destination ?Payment ?Organization))))

(=>
	(and
		(instance ?Account CreditAccount)
		(accountHolder ?Account ?Agent)
		(principalAmount ?Account ?Principal)
		(agreementPeriod ?Account ?Period)
		(interestEarned ?Account ?Interest ?Period)
		(equal ?Total (AdditionFn ?Principal ?Interest)))
	(holdsObligation (KappaFn  ?Payment
				   (transactionAmount ?Payment ?Total)) ?Agent))

;; Definition of CreditCardAccount.

(subclass CreditCardAccount CreditAccount)
(documentation CreditCardAccount "A type of &%CreditAccount which uses a &%CreditCard for
&%FinancialTransactions.")

(=>
	(and
		(instance ?Account CreditCardAccount)
		(instance ?Transaction FinancialTransaction)
		(origin ?Transaction (CurrencyFn ?Account)))
	(exists (?Card)
		(and
			(instance ?Card CreditCard)
			(instrument ?Transaction ?Card))))

;; definition of Loan

(subclass Loan LiabilityAccount)
(documentation Loan "An arrangement in which a lender gives money or property to a borrower,
and the borrower agrees to return the property or repay the money, usually along with interest,
at some future point(s) in time.")

(=>
	(and
		(borrower ?Loan ?Borrower)
		(lender ?Loan ?Agent)
		(agreementPeriod ?Loan ?Period)
		(interestEarned ?Loan ?Interest ?Period))
	(exists (?Payment)
		(and
			(origin ?Payment ?Borrower)
			(transactionAmount ?Payment ?Interest)
			(destination ?Payment ?Lender))))

(=>
	(and
		(instance ?Account Loan)
		(borrower ?Account ?Agent)
		(principalAmount ?Account ?Principal)
		(agreementPeriod ?Account ?Period)
		(interestEarned ?Account ?Interest ?Period)
		(equal ?Total (AdditionFn ?Principal ?Interest)))
	(holdsObligation (KappaFn ?Payment
			 (transactionAmount ?Payment ?Total)) ?Agent))

;; definition of lender

(subrelation lender agreementMember)
(domain lender 1 Loan)
(domain lender 2 CognitiveAgent)
(documentation lender "(&%lender ?Loan ?Agent) means that ?Agent is a private, public or
institutional entity that put up the funds for the ?Loan.")

;; definition of borrower

(subrelation borrower agreementMember)
(domain borrower 1 Loan)
(domain borrower 2 CognitiveAgent)
(documentation borrower "(&%borrower ?Loan ?Agent) means that ?Agent is a borrower of the ?Loan")

;; Definition of loanForPurchase.

(instance loanForPurchase BinaryPredicate)
(domain loanForPurchase 1 Loan)
(domain loanForPurchase 2 Object)
(documentation loanForPurchase "(&%loanForPurchase ?ACCOUNT ?PRODUCT) means that ?ACCOUNT is a
loan to finance the purchase of ?PRODUCT.")

;; definition of Collateral

(subclass Collateral FinancialAsset)
(documentation Collateral "Assets pledged by a borrower to secure a loan or other credit, and
subject to seizure in the event of &%FinancialDefault.")

(<=>
	(instance ?Collateral Collateral)
	(exists (?Loan)
		(and
			(instance ?Loan SecuredLoan)
			(securedBy ?Loan ?Collateral))))

;; definition of securedBy

(instance securedBy BinaryPredicate)
(domain securedBy 1 FinancialAccount)
(domain securedBy 2 Collateral)

(=>
	(and
		(instance ?Loan Loan)
		(securedBy ?Loan ?Security)
		(lender ?Loan ?Bank)
		(exists (?Default)
			(and
				(instance ?Default FinancialDefault)
				(patient ?Default ?Loan))))
	(holdsDuring (ImmediateFutureFn (WhenFn ?Default)) (possesses ?Bank ?Security)))

;; definition of SecuredLoan

(subclass SecuredLoan Loan)
(disjoint SecuredLoan UnsecuredLoan)

(<=>
	(instance ?Loan SecuredLoan)
	(exists (?Security)
		(securedBy ?Loan ?Security)))

;; definition of UnsecuredLoan

(subclass UnsecuredLoan Loan)

;; definition of RealEstate

(subclass RealEstate Region)
(subclass RealEstate FinancialAsset)
(documentation RealEstate "Land, including all the natural resources and permanent buildings on it.")

;; Definition of Mortgage.

(subclass Mortgage SecuredLoan)
(documentation Mortgage "A loan to finance the purchase of real estate, usually with specified payment
periods and interest rates.")

(=>
	(instance ?Loan Mortgage)
	(exists (?Estate)
		(and
			(instance ?Estate RealEstate)
			(loanForPurchase ?Loan ?Estate))))

(=>
	(and
		(instance ?Loan Mortgage)
		(loanForPurchase ?Loan ?RealEstate))
	(securedBy ?Loan ?RealEstate))

;; definition of BalloonLoan

(subclass BalloonLoan Loan)
(documentation BalloonLoan "A long-term loan, often a mortgage, that has
one large payment (the balloon payment) due upon maturity.  Often done
when refinancing or a major cash flow event is anticipated")

(=>
	(and
		(instance ?Loan BalloonLoan)
		(maturityDate ?Loan ?Date)
		(totalBalance ?Loan ?Amount)
		(borrower ?Loan ?Agent))
	(holdsObligation (KappaFn ?Payment
			 (and
				(date ?Payment ?Date)
				(transactionAmount ?Payment ?Amount)
				(destination ?Payment (CurrencyFn ?Loan)))) ?Agent))

;; definition of Call

(subclass Call FinancialTransaction)

;; definition of CallableLoan

(subclass CallableLoan Loan)
(documentation CallableLoan "A loan that must repaid upon the lender's demand")

(=>
	(and
		(instance ?Loan CallableLoan)
		(lender ?Loan ?Lender)
		(borrower ?Loan ?Borrower)
		(totalBalance ?Loan ?Amount)
		(exists (?Call)
			(and
				(instance ?Call Call)
				(agent ?Call ?Lender)
				(time ?Call ?Time)
				(patient ?Call ?Loan))))
	(holdsObligation (KappaFn ?Payment
			 (and
				(destination ?Payment ?Lender)
				(time ?Payment (ImmediateFutureFn (WhenFn ?Call)))
				(transactionAmount ?Payment ?Amount))) ?Borrower))

;; definition of Refinancing

(subclass Refinancing FinancialTransaction)
(documentation Refinancing "Paying off an existing loan with the proceeds from a new loan, using
the same property as collateral.")

(=>
	(and
		(instance ?Refinancing Refinancing)
		(time ?Refinancing ?Time)
		(instance ?Loan Loan)
		(securedBy ?Loan ?Collateral)
		(borrower ?Loan ?Borrower)
		(currentAccountBalance ?Loan ?Date ?Amount)
		(patient ?Refinancing ?Loan))
	(exists (?NewLoan ?Payment)
		(and
			(instance ?NewLoan Loan)
			(borrower ?NewLoan ?Borrower)
			(securedBy ?Loan ?Collateral)
			(destination ?Payment (CurrencyFn ?Loan))
			(time ?Payment ?Time)
			(origin ?Payment (CurrencyFn ?NewLoan))
			(transactionAmount ?Payment ?Amount))))

;; definition of LoanCommitment

(subclass LoanCommitment Contract)
(documentation LoanCommitment "A formal offer by a lender making explicit
the terms under which it agrees to lend money to a borrower over a certain
period of time.")

(=>
	(instance ?Commitment LoanCommitment)
	(exists (?Loan ?Lender ?Borrower)
		(and
			(instance ?Loan Loan)
			(lender ?Loan ?Lender)
			(borrower ?Loan ?Borrower)
			(agreementMember ?Commitment ?Lender)
			(agreementMember ?Commitment ?Borrower))))

;; definition of appraisedValue

(subrelation appraisedValue monetaryValue)
(domain appraisedValue 1 Collateral)
(domain appraisedValue 2 CurrencyMeasure)

;; definition of BankTermLoan

(subclass BankTermLoan Loan)
(documentation BankTermLoan "A bank loan terminating in one year or more.")

(=>
	(and
		(instance ?Loan BankTermLoan)
		(lender ?Loan ?Lender))
	(instance ?Lender Bank-FinancialOrganization))

(=>
	(and
		(instance ?Loan BankTermLoan)
		(agreementPeriod ?Loan ?Period)
		(duration ?Period (MeasureFn ?Duration YearDuration)))
	(greaterThanOrEqualTo ?Duration 1))

;; definition of BridgeLoan

(subclass BridgeLoan Loan)
(documentation BridgeLoan "Short-term financing which is expected to be paid back relatively
quickly, such as by a subsequent longer-term loan.")

;; definition of BrokerLoan

(subclass BrokerLoan Loan)
(documentation BrokerLoan "Money lent to brokers by banks, for financing
the underwriting of new issues, financing customer margin accounts, and
other purposes.")

(=>
	(and
		(instance ?Loan BrokerLoan)
		(borrower ?Loan ?Borrower))
	(instance ?Borrower Broker))

;; definition of ConsolidationLoan

(subclass ConsolidationLoan Loan)
(documentation ConsolidationLoan "The replacement of multiple loans with a single loan, often
with a lower monthly payment and a longer repayment period.")

(=>
	(instance ?Loan ConsolidationLoan)
	(exists (?Loan1 ?Loan2 ?Payment1 ?Payment2)
		(and
			(instance ?Loan1 Loan)
			(instance ?Loan2 Loan)
			(destination ?Payment1 (CurrenyFn ?Loan1))
			(destination ?Payment2 (CurrencyFn ?Loan2))
			(origin ?Payment1 (CurrencyFn ?Loan))
			(origin ?Payment2 (CurrencyFn ?Loan)))))

;; definition of FHALoan

(subclass FHALoan Mortgage)
(disjoint FHALoan ConventionalMortgage)
(documentation FHALoan  "A government mortgage that is insured by the Federal Housing
Administration (FHA).")

(=>
	(instance ?Loan FHALoan)
	(insured ?Loan FederalHousingAdministration))

;; definition of insured

(instance insured BinaryPredicate)
(instance insured AsymmetricRelation)
(domain insured 1 Contract)
(domain insured 2 Organization)
(documentation insured "(insured ?Contract ?Org) means that ?Contract is insured
by the ?Organization.")

;; definition of FederalHousingAdministration

(subclass FederalHousingAdministration Government)

;; definition of ConventionalMortgage

(subclass ConventionalMortgage Mortgage)
(documentation ConventionalMortgage "A mortgage that is not insured or guaranteed
by the government.")

;; definition of DayLoan

(subclass DayLoan Loan)
(documentation DayLoan "A bank loan to a broker for the purchase of securities pending delivery
through clearing later the same day.")

(=>
	(and
		(instance ?Loan DayLoan)
		(lender ?Loan ?Lender))
	(instance ?Lender Bank-FinancialOrganization))

(=>
	(and
		(instance ?Loan DayLoan)
		(borrower ?Loan ?Borrower))
	(instance ?Borrower Broker))

(=>
	(instance ?Loan DayLoan)
	(and
		(agreementPeriod ?Loan ?Period)
		(duration ?Period (MeasureFn 1 Day-Duration))))

;; definition of PiggybankLoan

(subclass PiggybankLoan Loan)
(documentation PiggybankLoan "Two lenders participating in the same loan.")

(=>
	(instance ?Loan PiggybankLoan)
	(equal (CardinalityFn (KappaFn ?Lender (lender ?Loan ?Lender))) 2))

;; definition of SinglePaymentLoan

(subclass SinglePaymentLoan Loan)
(documentation SinglePaymentLoan "A loan whose principal is due in total with a single
payment at maturity.")

(=>
	(and
		(instance ?Loan SinglePaymentLoan)
		(principalAmount ?Loan ?Principal)
		(maturityDate ?Loan ?Maturity))
	(amountDue ?Loan ?Principal ?Maturity))

;; definition EvergreenLoan

(subclass EvergreenLoan Loan)
(documentation EvergreenLoan "A short-term loan which is continually renewed rather than repaid.")

;; definition of IndexedLoan

(subclass IndexedLoan Loan)
(documentation IndexedLoan "A loan in which payments change in response to
changes in an index such as the Consumer Price Index.")

;; definition of InterestOnlyLoan

(subclass InterestOnlyLoan Loan)
(documentation InterestOnlyLoan "A non-amortized loan in which interest is
due at regular intervals until maturity, when the full principal on the
loan is due.")

(=>
	(and
		(instance ?Loan InterestOnlyLoan)
		(agreementPeriod ?Loan ?Period)
		(principalAmount ?Loan ?Principal)
		(interestEarned ?Loan ?Interest ?Period))
	(and
		(amountDue ?Loan ?Principal (EndFn ?Period))
		(amountDue ?Loan ?Interest ?Date)
		(before (EndFn ?Date) (EndFn ?Period))))


;;   indexes


;; definition of Index

(subclass Index PerformanceMeasure)
(documentation Index "A benchmark against which financial or economic performance is measured,
such as the S&P 500 or the Consumer Price Index.")

(=>
	(instance ?Index Index)
	(exists (?Performance)
		(and
			(benchmark ?Performance ?Index)
			(instance ?Performance EconomicIndicator))))

;; definition of EconomicIndicator

(subclass EconomicIndicator Proposition)
(documentation EconomicIndicator "Data which provide information about or
predict the overall health of the economy or the financial markets;
examples are inflation, interest rates, employment, etc.")

;; definition of PerformanceMeasure

(subclass PerformanceMeasure PhysicalQuantity)

;; definition of benchmark

(instance benchmark BinaryPredicate)
(domain benchmark 1 Abstract)
(domain benchmark 2 PerformanceMeasure)
(documentation benchmark "A standard by which something can be measured or judged.")

;; definition of Inflation

(subclass Inflation EconomicIndicator)
(documentation Inflation "The overall general upward price movement of
goods and services in an economy, usually as measured by the Consumer
Price Index and the Producer Price Index.")

(=>
	(instance ?Inflation Inflation)
	(or
		(and
			(benchmark ?Inflation ?CPI)
			(instance ?CPI ConsumerPriceIndex))
		(and
			(benchmark ?Inflation ?PPI)
			(instance ?PPI ProducerPriceIndex))))

;; definition of InflationIndex

(subclass InflationIndex Index)

(<=>
	(instance ?Index InflationIndex)
	(exists (?Inflation)
		(and
			(instance ?Inflation Inflation)
			(benchmark ?Inflation ?Index))))

;; definition of inflationRate

(instance inflationRate BinaryPredicate)
(domain inflationRate 1 Inflation)
(domain inflationRate 2 RealNumber)
(documentation inflationRate "The percentage increase in the price of goods and services,
usually annually.")

;; definition of ConsumerPriceIndex

(subclass ConsumerPriceIndex InflationIndex)
(documentation ConsumerPriceIndex "An inflationary indicator that measures
the change in the cost of a fixed basket of products and services,
including housing, electricity, food, and transportation.  The CPI is
published monthly.")

;; definition of ProducerPriceIndex
(subclass ProducerPriceIndex InflationIndex)
(documentation ProducerPriceIndex "An inflationary indicator published by the U.S. Bureau
of Labor Statistics to evaluate wholesale price levels in the economy.")

;; definition of StockIndex

(subclass StockIndex Index)

(<=>
	(instance ?Index StockIndex)
	(exists (?Stock)
		(and
			(instance ?Stock Stock)
			(benchmark ?Index ?Stock))))

;; definition of listedOn

(instance listedOn AsymmetricRelation)
(domain listedOn 1 Stock)
(domain listedOn 2 Organization)

;; definition of NASDAQCompositeIndex

(subclass NASDAQCompositeIndex Index)
(documentation NASDAQCompositeIndex "A market-value weighted index of all common stocks
listed on NASDAQ.")

(=>
	(and
		(instance ?Index  NASDAQCompositeIndex)
		(benchmark ?Index ?Stock))
	(listedOn ?Stock NASDAQ))

;; definition of NASDAQ

(instance NASDAQ Organization)
(documentation NASDAQ "National Association of Securities Dealers Automated Quotations
system.")

;; definition of MarketShareWeightedIndex

(subclass MarketShareWeightedIndex Index)
(documentation MarketShareWeightedIndex "A stock index in which each stock affects the
index in proportion to its number of shares outstanding.")

;; definition of MarketValueWeightedIndex

(subclass MarketValueWeightedIndex Index)
(documentation MarketValueWeightedIndex "A stock index in which each stock
affects the index in proportion to its market value.  Examples include
NASDAQ Composite Index, S&P 500, Wilshire 5000 Equity Index, Hang Seng
Index, and EAFE Index.")

;; definition of StockMarket

(subclass StockMarket Organization)
(documentation StockMarket "General term for the organized trading of stocks through
exchanges and over-the-counter.")

;; definition of PriceWeightedIndex

(subclass PriceWeightedIndex Index)
(documentation PriceWeightedIndex "A stock index in which each stock affects the index
in proportion to its price per share.")

;; definition of NikkeiIndex

(subclass NikkeiIndex Index)
(documentation NikkeiIndex "Index of 225 leading stocks traded on the Tokyo Stock
Exchange.")


;;	Investment management


;; definition of Investment

(subclass Investment FinancialAsset)
(documentation Investment "An item of value purchased for income or capital appreciation.")

(=>
	(instance ?Investment Investment)
	(exists (?Investing ?Agent)
		(and
			(agent ?Investing ?Agent)
			(possesses ?Agent ?Investment))))

;; definition of Investor

(subclass Investor CognitiveAgent)
(documentation Investor "A person who purchases income-producing assets.")

;; Commented out because too many free variables
;;(<=>
;;	(instance ?Agent Investor)
;;	(exists (?Investing)
;;		(agent ?Investing ?Investor)))

(<=>
	(instance ?Agent Investor)
	(exists (?Investment)
		(and
			(instance ?Investment Investment)
			(possesses ?Agent ?Investment))))

;; definition of profit

(instance profit AsymmetricRelation)
(domain profit 1 FinancialTransaction)
(domain profit 2 CurrencyMeasure)
(documentation profit "The positive gain from an investment or business operation after
subtracting for all expenses.")

(=>
	(instance ?Investing Investing)
	(hasPurpose ?Investing
		    (exists (?Profit)
			    (profit ?Investing ?Profit))))

;; definition of AsssetAllocation

(subclass AssetAllocation FinancialTransaction)
(documentation AssetAllocation "The process of dividing investments among different kinds of
assets, such as Stocks, Bonds, RealEstate and cash, to optimize the risk/reward tradeoff based
on an individual's or institution's specific situation and goals.")

;; instance InvestmentAttribute

(subclass InvestmentAttribute Attribute)

(=>
	(instance ?Attribute InvestmentAttribute)
	(exists (?Account)
		(and
			(attribute ?Account ?Attribute)
			(instance ?Account InvestmentAccount))))

;; definition of liquidity

(instance liquidity AsymmetricRelation)
(domain liquidity 1 FinancialAccount)
(domain liquidity 2 LiquidtityAttribute)
(documentation liquidity "Degree to which accounts can be easily converted to cash.")

(<=>
	(and
		(instance ?Withdrawal Withdrawal)
		(instance ?Account FinancialAccount)
		(origin ?Withdrawal (CurrencyFn ?Account))
		(not (exists (?Penalty)
		     (and
			   (instance ?Penalty Penalty)
			   (destination ?Penalty (CurrencyFn ?Account))
			   (causes ?Withdrawal ?Penalty)))))
	(liquidity ?Account HighLiquidity))

;; definition of LiquidityAttribute

(subclass LiquidityAttribute Attribute)
(documentation LiquidityAttribute "A class of attributes which describe the degree to
which accounts can be easily converted to cash.")

(instance HighLiquidity LiquidityAttribute)
(contraryAttribute HighLiquidity LowLiquidity)

(instance LowLiquidity LiquidityAttribute)

;; definition of riskLevel

(instance riskLevel AsymmetricRelation)
(domain riskLevel 1 Investment)
(domain riskLevel 2 RiskAttribute)

;; definition of RiskAttribute

(subclass RiskAttribute Attribute)
(documentation RiskAttribute "A class of attributes which describe the degree of risk
of a particular investment.")

(instance HighRisk RiskAttribute)
(contraryAttribute HighRisk LowRisk)

(instance LowRisk RiskAttribute)

;; definition of yieldLevel

(instance yieldLevel AsymmetricRelation)
(domain yieldLevel 1 FinancialAccount)
(domain yieldLevel 2 YieldAttribute)
(documentation yieldLevel "A profit obtained from an investment.")

;; definition of YieldAttribute

(subclass YieldAttribute Attribute)
(documentation YieldAttribute "A class of attributes which describe the degree to which
accounts are profitable.")

(instance HighYield YieldAttribute)
(contraryAttribute HighYield LowYield)

(instance LowYield YieldAttribute)

;; definition of potentialLoss

(instance potentialLoss TernaryPredicate)
(domain potentialLoss 1 CognitiveAgent)
(domain potentialLoss 2 Investment)
(domain potentialLoss 3 CurrencyMeasure)
(documentation potentialLoss "The maximum amount of money the Agent can lose by choosing
this type of Investment.")

;; definition of price

(instance price TernaryPredicate)
(domain price 1 Physical)
(domain price 2 CurrencyMeasure)
(domain price 3 TimePosition)

;; definition of bidPrice

(subrelation bidPrice price)
(domain bidPrice 1 Object)
(domain bidPrice 2 CurrencyMeasure)
(domain bidPrice 3 TimePosition)

;; definition of askPrice

(subrelation askPrice price)
(domain askPrice 1 Object)
(domain askPrice 2 CurrencyMeasure)
(domain askPrice 3 TimePosition)

;; definition of Order

(subclass Order ServiceContract)
(documentation Order "A request from a client to a broker to buy (buy order) or sell
(sell order) a specified amount of a particular security or commodity at a specific
price or at the market price.")

;; definition of PlacingAnOrder

(subclass PlacingAnOrder FinancialTransaction)

(=>
     (and
		(instance ?Place PlacingAnOrder)
		(equal (WhenFn ?Place) ?Time))
     (exists (?Order ?Period)
	        (and
			(equal (WhenFn ?Order) ?Period)
			(meetsTemporally ?Time ?Period))))

;; definition of MarketOrder

(subclass MarketOrder Order)
(documentation MarketOrder "An order to buy or sell security at the best prices available.")

;; definition of orderFor

(instance orderFor TernaryPredicate)
(domain orderFor 1 FinancialTransaction)
(domainSubclass orderFor 2 FinancialTransaction)
(domain orderFor 3 Security)

(=>
	(and
		(instance ?Order PlacingAnOrder)
		(orderFor ?Order ?TransactionType ?Shares))
	(hasPurpose ?Order
		    (exists (?Transaction)
			    (and
				(instance ?Transaction ?TransactionType)
				(patient ?Transaction ?Shares)))))

(=>
	(and
		(instance ?Order MarketOrder)
		(instance ?Broker Broker)
		(agreementMember ?Order ?Broker)
		(orderFor ?Order ?TransactionType ?Shares))
	(holdsObligation (KappaFn ?Transaction
			 (and
				(instance ?Transaction ?TransactionType)
				(patient ?Transaction ?Shares))) ?Broker))

;; definition of LimitOrder

(subclass limitOrder Order)
(documentation LimitOrder "LimitOrder is an order to a Broker  to buy a specified quantity
of a Security at or below a specified price, or to sell it at or above a specified limitPrice.")

;; definition of limitPrice

(instance limitPrice BinaryPredicate)
(instance limitPrice AsymmetricRelation)
(domain limitPrice 1 LimitOrder)
(domain limitPrice 2 CurrencyMeasure)

(=>
	(instance ?Order LimitOrder)
	(exists (?Price)
		(limitPrice ?Order ?Price)))

(=>
	(and
		(instance ?Order LimitOrder)
		(agreementMember ?Order ?Broker)
		(instance ?Broker Broker)
		(orderFor ?Order Buying ?Object)
		(measure ?Object ?Quantity)
		(limitPrice ?Order ?LimitPrice)
		(exists (?Time)
			(and
				(askPrice ?Object ?Price ?Time)
				(lessThanOrEqualTo ?Price ?LimitPrice))))
		(holdsObligation (KappaFn ?Buy
				 (and
					(instance ?Buy Buying)
					(patient ?Buy ?Object)
					(measure ?Object ?Quantity)
					(equal (WhenFn ?Buy) ?BuyingTime)
					(overlapsTemporally ?Time ?BuyingTime))) ?Broker))

(=>
	(and
		(instance ?Order LimitOrder)
		(agreementMember ?Order ?Broker)
		(instance ?Broker Broker)
		(orderFor ?Order Selling ?Object)
		(measure ?Object ?Quantity)
		(limitPrice ?Order ?LimitPrice)
		(exists (?Time)
			(and
				(bidPrice ?Object ?Price ?Time)
				(greaterThanOrEqualTo ?Price ?LimitPrice))))
	(holdsObligation (KappaFn ?Sell
			 (and
				(instance ?Sell Selling)
				(patient ?Sell ?Object)
				(measure ?Object ?Quantity)
				(equal (WhenFn ?Sell) ?SellingTime)
				(overlapsTemporally ?SellingTime ?Time))) ?Broker))

;; definition of Broker

(subclass Broker CognitiveAgent)
(documentation broker "An individual or firm which acts as an intermediary between
a buyer and seller, usually charging a commisssion.")

(=>
	(instance ?Broker Broker)
	(exists (?Contract)
		(and
			(instance ?Contract ServiceContract)
			(agreementMember ?Contract ?Broker))))

;; definition of StopOrder

(subclass StopOrder Order)
(documentation StopOrder "A market order to buy or sell a certain quantity of
a certain security if a specified price (the stopPrice) is reached or passed.")

;; definition of Liquidation

(subclass Liquidation FinancialTransaction)
(documentation Liquidation "The class of events of selling all of a company's assets,
paying outstanding debts, and distribution of the remainder to shareholders, and them
going out of business.")

;; definition of Dividend

(subclass Dividend Payment)
(documentation Dividend "A taxable payment declared by a company's board of directors
and given to its &%shareHolders out of the company's current or retained earnings.
Usually quarterly. Usually given as cash, but it can also take the form of &%Stock or
other property.")

;; definition of Security

(subclass Security FinancialInstrument)
(documentation Security "An investment instrument, other than an insurance policy or
&%FixedAnnuity insurance policy or fixed annuity issued by a corporation, government,
or other organization which offers evidence of debt or equity.")

;; definition of Annuity

(subclass Annuity FinancialContract)
(documentation Annuity "A contract sold by an insurance company designed to provide
payments to the holder at specified intervals, usually after retirement. &%FixedAnnuities
guarantee a certain payment amount, while &%VariableAnnuities do not, but do have the
potential for greater returns; but both are relatively safe, low-yielding investments.")

;; definition of FixedAnnuity

(subclass FixedAnnuity Annuity)
(documentation FixedAnnuity "An investment vehicle offered by an insurance company, that
guarantees a stream of fixed payments over the life of the annuity. The insurer, not the
insured, takes the investment risk.")

;; definition of Share

(subclass Share Security)
(documentation Share "Certificate, representing one unit of ownership in a corporation,
&%MutualFund, or limited partnership.")

;; definition of shareOf

(subrelation shareOf BinaryPredicate)
(domain shareOf 1 Share)
(domain shareOf 2 Organization)

;; definition of shareHolder

(instance shareHolder BinaryPredicate)
(domain shareHolder 1 Share)
(domain shareHolder 2 CognitiveAgent)
(documentation shareHolder "(&%shareHolder ?Stock ?Agent) means that ?Agent possesses
shares of &%Stock in a corporation or mutual fund.")

;; definition of TaxFreeInvestment

(subclass TaxFreeInvestment Investment)

(=>
	(instance ?Investment TaxFreeInvestment)
	(not
		(exists (?Tax)
			(and
				(instance ?Tax Tax)
				(origin ?Tax ?Investment)))))

;; definition of TaxableInvestment

(subclass TaxableInvestment Investment)

(=>
	(instance ?Investment TaxableInvestment)
	(exists (?Tax)
		(and
			(instance ?Tax Tax)
			(origin ?Tax ?Investment))))

;; definition of FinancialDefault

(subclass FinancialDefault FinancialTransaction)
(documentation FinancialDefault "Failure to make required debt payments on a timely basis
or to comply with other conditions of an obligation or agreement.")


;;  Types of Stocks


;; definition of Stock

(subclass Stock FinancialInstrument)
(subclass Stock Investment)
(documentation Stock "An instrument that signifies an ownership position,
or equity, in a &%Corporation, and represents a claim on its proportionate
share in the corporation's assets and profits.")

;; definition of CommonStock

(subclass CommonStock Stock)
(documentation CommonStock "Securities representing equity, ownership in a
Corporation, providing voting rights, and entitling the holder to a share
of the company's success through dividends and/or capital appreciation.
In the event of liquidation, common stock holders have rights to a
company's assets only after bondholders, other debt holders, and
&%PrefereedStock holders have been satisfied.")

;; definition of PreferredStock

(subclass PreferredStock Stock)
(documentation PreferredStock "&%CapitalStock which provides a specific &%Dividend
that is paid before any dividends are paid to common stock holders, and which takes
precedence over common stock in the event of a liquidation.  Usually does not carry
voting rights.")

(=>
	(instance ?Stock PreferredStock)
	(exists (?Dividend ?Amount)
		(and
			(instance ?Dividend Dividend)
			(transactionAmount ?Dividend ?Amount))))

;; definition of BlueChipStock

(subclass BlueChipStock Stock)
(documentation BlueChipStock "&%Stock with a solid and stable earnings record from a
company that either leads or dominates or is a major player in a specific industry.")

;; definition of GrowthStock

(subclass GrowthStock Stock)
(documentation GrowthStock "Investment term that is applied to a &%Stock that is expected
to appreciate in value at a high rate, pay big dividends or split.")

;; definition of ValueStock

(subclass ValueStock Stock)
(documentation ValueStock "When the shares in a company are considered attractive because
the company is undervalue, usually because it has a low P/E ratio.")

;; definition of DefensiveStock

(subclass DefensiveStock Stock)
(documentation DefensiveStock "&%DefensiveStocks are stocks of food companies, drug
manufacturers and utility companies.")

;; definition of RestrictedStock

(subclass RestrictedStock Stock)
(documentation RestrictedStock "&%Securities, usually issued in private placements, that
have limited transferability.")

;; definition of PennyStock

(subclass PennyStock Stock)
(documentation PennyStock "Extremely speculative, high-risk &%Stock, usually
with a price of less than 5 dollars per share.  In the U.S., nearly all
are traded on the over-the-counter bulletin board.")

(=>
	(instance ?Stock PennyStock)
	(riskLevel ?Stock HighRisk))

(=>
	(and
		(instance ?Stock PennyStock)
		(askPrice ?Stock (MeasureFn ?Price UnitedStatesDollar) ?Date))
	(lessThan ?Price 5))

;; definition of StockSplit

(subclass StockSplit FinancialTransaction)
(documentation StockSplit "Exchange of the number of shares of stock outstanding
for a larger number.")

;; definition of splitFor

(instance splitFor TernaryPredicate)
(domain splitFor 1 StockSplit)
(domain splitFor 2 Integer)
(domain splitFor 3 Integer)

(=>
	(and
		(possesses ?Agent ?Stocks)
		(measure ?Stocks (MeasureFn ?Number Shares))
		(exists (?Event)
			(splitFor ?Event ?N1 ?N2)))
	(and
		(holdsDuring (ImmediateFutureFn (WhenFn ?Event))
			     (and
				  (equal ?N3 (MultiplicationFn ?Number ?N2))
				  (equal ?NewNumber (DivisionFn ?N3 ?N1))
				  (measure ?Stocks (MeasureFn ?NewNumber Shares))))))

(=>
	(and
		(price ?Stocks (MeasureFn ?Number DollarUnitedStates) ?Time)
		(exists (?Event)
			(and
				(splitFor ?Event ?N1 ?N2)
				(equal (WhenFn ?Event) ?TimeOfSplit))))
	(and
		(equal ?N3 (MultiplicationFn ?Number ?N1))
		(equal ?NewNumber (DivisionFn ?N3 ?N2))
		(price ?Stocks (MeasureFn ?NewNumber DollarUnitedStates) ?TimeAfterSplit)
		(meetsTemporally ?Time ?TimeOfSplit)
		(meetsTemporally ?TimeOfSplit ?TimeAfterSplit)))


;;  Bonds


;; Definition of Bond.

(subclass Bond Investment)
(subclass Bond FinancialInstrument)
(documentation Bond "A debt instrument issued for a period of more than one year with
the purpose of raising capital by borrowing. The Federal government, states, cities,
corporations, and many other types of institutions sell bonds. A bond is generally a
promise to repay the principal along with interest on a specified &%maturityDate.")

(=>
	(instance ?Bond Bond)
	(exists (?Date)
		(maturityDate ?Bond ?Date)))


(=>
	(and
		(instance ?Bond Bond)
		(couponInterest ?Bond ?Interest)
		(possesses ?BondHolder ?Bond))
	(exists (?Period ?Payment)
		(and
			(periodicPayment (AccountFn ?Bond) ?Interest ?Period)
			(destination ?Payment ?BondHolder))))

;; definition of yield

(instance yield BinaryPredicate)
(domain yield 1 Investment)
(domain yield 2 FunctionQuantity)
(documentation yield "The annual rate of return on an investment, expressed as a
percentage. For bonds and notes, it is the coupon rate divided by the market price.")

;; Definition of couponInterest.

(instance couponInterest BinaryPredicate)
(domain couponInterest 1 Bond)
(domain couponInterest 2 Interest)
(documentation couponInterest "(&%couponInterest ?BOND ?INTEREST) means that ?INTEREST is
the periodic interest payment made to bondholders during the life of the ?BOND.")

;; Definition of accruedInterest.

(instance accruedInterest BinaryPredicate)
(domain accruedInterest 1 Bond)
(domain accruedInterest 2 Interest)
(documentation accruedInterest "The accumulated coupon interest, paid to the seller of a
bond by the buyer unless the bond is in default.")

;; definition of faceValue

(instance faceValue BinaryPredicate)
(domain faceValue 1 Collateral)
(domain faceValue 2 CurrencyMeasure)
(documentation faceValue "The nominal dollar amount assigned to a security by the issuer.
For an equity security, par is usually a very small amount that bears no relationship to
its market price, except for preferred stock, in which case par is used to calculate dividend
payments. For a debt security, par is the amount repaid to the investor when the bond matures
(usually, corporate bonds have a par value of $1000, municipal bonds $5000, and federal bonds
$10,000).")

;; Definition of CouponBond

(subclass CouponBond Bond)
(documentation CouponBond "An unregistered, negotiable bond on which interest and principal
are payable to the holder, regardless of whom it was originally issued to. The coupons are
attached to the bond, and each coupon represents a single interest payment. The holder submits
a coupon, usually semi-annually, to the issuer or paying agent to receive payment. Coupon bonds
are being phased out in favor of registered bonds.")

;; definition of AccountFn

(instance AccountFn UnaryFunction)
(domain AccountFn 1 FinancialAsset)
(range AccountFn FinancialAccount)
(documentation AccountFn "A unary function that maps a &%FinancialAsset to the &%FinancialAccount
associated with the Asset.")

;; Logic error -- ?Account variable roams free in consequent.
;;(<=>
;;	(exists (?Account)
;;		(and
;;			(instance ?Account FinancialAccount)
;;			(possesses ?Agent ?Asset)
;;			(equal ?Account (AccountFn ?Asset))))
;;	(accountHolder ?Account ?Agent))

;; Definition of ZeroCouponBond.

(subclass ZeroCouponBond Bond)
(documentation ZeroCouponBond "A bond in which no periodic coupon is paid over the
life of the contract. Instead, both the principal and the interest are paid at the
maturity date.")

(=>
	(and
		(instance ?Bond ZeroCouponBond)
		(maturityDate (AccountFn ?Bond) ?Date)
		(possesses ?BondHolder ?Bond)
		(principalAmount (AccountFn ?Bond) ?Principal)
		(agreementPeriod (AccountFn ?Bond) ?Period)
		(interestEarned (AccountFn ?Bond) ?Interest ?Period)
		(equal ?Total (AdditionFn ?Principal ?Interest)))
	(exists (?Payment)
		(and
			(instance ?Payment Payment)
			(destination ?Payment ?BondHolder)
			(origin ?Payment (CurrencyFn ?BondAccount))
			(transactionAmount ?Payment ?Total))))

;; Definition of RegisteredBond

(subclass RegisteredBond Bond)
(documentation RegisteredBond "A bond issued with the name of the owner printed on the
face of the certificate. It can be transferred to another individual only with the
owner's endorsement.")

;; definition of MunicipalBond

(subclass MunicipalBond Bond)
(subclass MunicipalBond TaxFreeInvestment)
(documentation MunicipalBond "Bond issued by a state, city, or local government to
finance operations or special projects; interest on it is often tax-free.")

(=>
	(instance ?Bond MunicipalBond)
	(exists (?Agent)
		(and
			(instance ?Agent Government)
			(issuedBy ?Bond ?Agent))))

;; definition of CorporateBond

(subclass CorporateBond Bond)
(subclass CorporateBond TaxableInvestment)
(documentation CorporateBond "A bond issued by a corporation. Such bonds usually have
a par value of $1,000, are taxable, have a term maturity, are paid for out of a sinking
fund accumulated for that purpose, and are traded on major exchanges.")

(=>
	(instance ?Bond CorporateBond)
	(exists (?Agent)
		(and
			(instance ?Agent Corporation)
			(issuedBy ?Bond ?Agent))))

;; definition of SecuredBond

(subclass SecuredBond Bond)
(documentation SecuredBond "Bond backed by collateral, such as a mortgage
or lien, the title to which would be transferred to the bondholders in the
event of default.")

(=>
	(instance ?Bond SecuredBond)
	(exists (?Security)
		(securedBy ?Bond ?Security)))

(=>
	(and
		(instance ?Bond SecuredBond)
		(securedBy ?Bond ?Security)
		(possesses ?Agent ?Bond)
		(exists (?Default)
			(and
				(instance ?Default FinancialDefault)
				(patient ?Default ?Bond))))
	(holdsDuring (ImmediateFutureFn (WhenFn ?Default))  (possesses ?Agent ?Security)))

;; definition of MortgageBond

(subclass MortgageBond CorporateBond)
(documentation MortgageBond "These are bonds generally bought through a
government agency that deals in the real estate market.  They are bonds
issued by mortgage lenders.")

;; definition of JunkBond

(subclass JunkBond CorporateBond)
(documentation JunkBond "A high-risk, non-investment-grade bond with a low
credit rating, usually BB or lower; as a consequence, it usually has a high
yield.")

(=>
	(instance ?Bond JunkBond)
	(riskLevel ?Bond HighRisk))

(=>
	(instance ?Bond JunkBond)
	(yieldLevel ?Bond HighYield))

(=>
	(instance ?Bond JunkBond)
	(bondRating ?Bond D-Rating))

;; definition of GovernmentBond

(subclass GovernmentBond Bond)
(documentation GovernmentBond "A bond sold by the U.S. government.")

(=>
	(instance ?Bond GovernmentBond)
	(exists (?Agent)
		(and
			(issuedBy ?Bond ?Agent)
			(instance ?Agent Government))))

(=>
	(instance ?Bond GovernmentBond)
	(riskLevel ?Bond LowRisk))

(=>
	(instance ?Bond GovernmentBond)
	(yieldLevel ?Bond LowYield))

(=>
	(instance ?Bond GovernmentBond)
	(bondRating ?Bond AAA-Rating))

;; definition of IndexBond

(subclass IndexBond Bond)
(documentation IndexBond "A bond whose cash flow is inflation-adjusted, by
being linked to the purchasing power of a particular currency.")

;; definition of PerformanceBond

(subclass PerformanceBond Bond)
(documentation PerformanceBond "A bond issued by an insurance company to
guarantee satisfactory completion of a project by a contractor.")

;; definition of TreasuryBond

(subclass TreasuryBond Bond)
(documentation TreasuryBond "A negotiable, coupon-bearing debt obligation
issued by the U.S. government and backed by its full faith and credit, having
a maturity of more than 7 years. Interest is paid semi-annually. Exempt from
state and local taxes.")

;; definition of CallableBond

(subclass CallableBond Bond)
(documentation CallableBond "A bond which the issuer has the right to redeem
prior to its maturity date, under certain conditions.")

;; definition of callDate

(instance callDate BinaryPredicate)
(domain callDate 1 Bond)
(domain callDate 2 Day)
(documentation callDate "Date, prior to maturity, on which a callable bond
may be redeemed.")

(=>
	(and
		(instance ?Bond CallableBond)
		(currentAccountBalance (AccountFn ?Bond) ?Date ?Amount)
		(callDate ?Bond ?Date))
	(amountDue (AccountFn ?Bond) ?Amount ?Date))

;; definition of FinancialRating

(subclass FinancialRating Attribute)
(documentation FinancialRating "The highest rating is usually AAA-Rating,
and the lowest is D-Rating.")

;; definition of creditRating

(instance creditRanking BinaryPredicate)
(subrelation creditRanking attribute)
(domain creditRanking 1 CognitiveAgent)
(domain creditRanking 2 FinancialRating)
(documentation creditRanking "(&%creditRanking ?Agent ?Rating) holds if
?Rating is a &%FinancialRating based on financial analysis by a credit
bureau, of one's financial history, specifically as it relates to one's
ability to meet debt obligations. Lenders use this information to decide
whether to approve a loan.")

;; definition of bondRating

(subrelation bondRating attribute)
(domain bondRating 1 Bond)
(domain bondRating 2 FinancialRating)
(documentation bondRating "A measure of the quality and safety of a bond,
based on the issuer's financial condition.  More specifically, an
evaluation from a rating service indicating the likelihood that a debt
issuer will be able to meet scheduled interest and principal repayments.
Typically, AAA is highest (best), and D is lowest (worst).")

;; definition of AAA-Rating

(instance AAA-Rating FinancialRating)
(documentation AAA-Rating "The highest rating given by bond rating agencies")

(instance B-Rating FinancialRating)

(instance C-Rating FinancialRating)

(instance D-Rating FinancialRating)


;;  Options


;; Definition of Option.

(subclass Option FinancialContract)
(documentation Option "An option is a contract to buy or sell 100 shares
of a stock at a fixed price (the strike price) on or before a fixed date.")

(=>
	(instance ?Option Option)
	(exists (?Type ?Date ?Stocks ?Price)
		(and
			(or
				(equal ?Type CallOption)
				(equal ?Type PutOption))
			(instance ?Option ?Type)
			(expirationDate ?Option ?Date)
			(strikePrice ?Option ?Price)
			(underlier ?Option ?Stocks)
			(measure ?Stocks (MeasureFn 100 Shares)))))

;; definition of ConventionalOption

(subclass ConventionalOption Option)
(documentation ConventionalOption "Short-term option contracts.")

(=>
	(instance ?Option ConventionalOption)
	(exists (?Number)
		(and
			(agreementPeriod ?Option ?Period)
			(duration ?Period (MeasureFn ?Number MonthDuration))
			(lessThan ?Number 9))))

;; definition of LEAPS

(subclass LEAPS Option)
(documentation LEAPS "Calls and puts with an expiration as long as
thirty-nine months. Currently, equity LEAPS have two series at any
time with a January expiration. For example, in October 2000, LEAPS
are available with expirations of January 2002 and January 2003.")

(=>
	(instance ?Option ConventionalOption)
	(exists (?Number)
		(and
			(agreementPeriod ?Option ?Period)
			(duration ?Period (MeasureFn ?Number MonthDuration))
			(lessThan ?Number 39))))

;; optionHolder

(subrelation optionHolder agreementMember)
(domain optionHolder 1 Option)
(domain optionHolder 2 CognitiveAgent)
(documentation optionHolder "(&%optionHolder ?Option ?Agent) means that
?Agent is the holder of the option.")

;; optionSeller

(subrelation optionSeller agreementMember)
(domain optionSeller 1 Option)
(domain optionSeller 2 CognitiveAgent)
(documentation optionSeller "(&%optionSeller ?Option ?Agent) means that
?Agent is the writer of the option.")

;; Definition of strikePrice

(instance strikePrice BinaryPredicate)
(domain strikePrice 1 FinancialInstrument)
(domain strikePrice 2 CurrencyMeasure)
(documentation strikePrice "The specified price on an option contract at
which the contract may be exercised, whereby a call option buyer can buy
the underlier or a put option buyer can sell the underlier.")

;; definition of expirationDate

(subrelation expirationDate date)
(domain expirationDate 1 Contract)
(domain expirationDate 2 Day)
(documentation expirationDate "(&%expirationDate ?Contract ?Date) means that
?Date is the date on which ?Contract expires.")

(=>
	(expirationDate ?Contract ?Date)
	(exists (?Period)
		(and
			(agreementPeriod ?Contract ?Period)
			(finishes ?Date ?Period))))

;; Definition of  CallOption

(subclass CallOption Option)
(documentation CallOption "An option contract that gives the holder the
right to buy a certain quantity (usually 100 shares) of an underlying
security from the writer of the option, at a specified price (the strike
price) up to a specified date (the expiration date).")

(=>
	(and
		(instance ?Option Option)
		(optionHolder ?Option ?Agent)
		(strikePrice ?Option ?Price)
		(expirationDate ?Option ?ExpDate)
		(underlier ?Option ?Stocks)
		(price ?Stocks ?Price ?Time)
		(instance ?Time TimeInterval)
		(before (EndFn ?Time) (BeginFn ?ExpDate)))
	(holdsAuthority (KappaFn ?Buy
		(and
			(instance ?Buy Buying)
			(patient ?Buy ?Stocks)
			(time ?Buy ?Time)
			(measure ?Stocks (MeasureFn 100 Shares))
			(agent ?Buy ?Agent))) ?Agent))

(=>
	(and
		(instance ?Option Option)
		(optionSeller ?Option ?Seller)
		(strikePrice ?Option ?Price)
		(expirationDate ?Option ?ExpDate)
		(underlier ?Option ?Stocks)
		(price ?Stocks ?Price ?Time)
		(instance ?Time TimeInterval)
		(before (EndFn ?Time) (BeginFn ?ExpDate)))
	(holdsObligation (KappaFn ?Sell
		(and
			(instance ?Sell Selling)
			(patient ?Sell ?Stocks)
			(time ?Sell ?Time)
			(measure ?Stocks (MeasureFn 100 Shares))
			(agent ?Sell ?Agent))) ?Seller))

;; Definition of PutOption

(subclass PutOption Option)
(documentation PutOption "An option contract that gives the holder the
right to sell a certain quantity of an underlying security to the writer
of the option, at a specified price (strike price) up to a specified date
(expiration date).")

(=>
	(and
		(instance ?Option Option)
		(optionHolder ?Option ?Agent)
		(strikePrice ?Option ?Price)
		(expirationDate ?Option ?ExpDate)
		(price ?Stocks ?Price ?Time)
		(instance ?Time TimeInterval)
		(before (EndFn ?Time) (BeginFn ?ExpDate))
		(underlier ?Option ?Stocks))
	(holdsAuthority (KappaFn ?Sell
		(and
			(instance ?Sell Selling)
			(patient ?Sell ?Stocks)
			(time ?Sell ?Time)
			(measure ?Stocks (MeasureFn 100 Shares))
			(agent ?Sell ?Agent))) ?Agent))

(=>
	(and
		(instance ?Option Option)
		(optionSeller ?Option ?Agent)
		(strikePrice ?Option ?Price)
		(expirationDate ?Option ?ExpDate)
		(price ?Stocks ?Price ?Time)
		(instance ?Time TimeInterval)
		(before (EndFn ?Time) (BeginFn ?ExpDate))
		(underlier ?Option ?Stocks))
	(holdsObligation (KappaFn ?Buy
		(and
			(instance ?Buy Buying)
			(patient ?Buy ?Stocks)
			(time ?Buy ?Time)
			(measure ?Stocks (MeasureFn 100 Shares))
			(agent ?Buy ?Agent))) ?Agent))

;; definition of StockOption

(subclass StockOption Option)
(documentation StockOption "An option in which the underlier is the
common stock of a corporation, giving the holder the right to buy or
sell its stock, at a specified price, by a specific date.")

;; definition of premium

(instance premium BinaryPredicate)
(domain premium 1 Option)
(domain premium 2 CurrencyMeasure)
(documentation premium "Total price of an option.")

(=>
	(and
		(premium ?Option ?Premium)
		(optionHolder ?Option ?Agent))
	(potentialLoss ?Agent ?Option ?Premium))

;; definition of underlier

(instance underlier BinaryPredicate)
(domain underlier 1 Option)
(domain underlier 2 FinancialInstrument)
(documentation underlier "(&%underlier ?Option ?Instrument) means that
?Instrument is a security which is subject to delivery upon exercise of
?Option.")

;; definition of ExerciseAnOption

(instance ExerciseAnOption FinancialTransaction)
(documentation ExerciseAnOption "An activity when the owner of the the &%Option
contract invokes his rights.  In the case of a call, the option owner buys the
underlying stock. In the case of a put, the option owner sells the underlying stock.")

(=>
	(and
		(instance ?Exercise ExerciseAnOption)
		(patient ?Exercise ?Option)
		(instance ?Option CallOption)
		(time ?Exercise ?Time)
		(underlier ?Option ?Stocks))
	(exists (?Buy)
		(and
			(instance ?Buy Buying)
			(patient ?Buy ?Stocks)
			(time ?Buy ?Time)
			(measure ?Stocks (MeasureFn 100 Shares)))))

(=>
	(and
		(instance ?Exercise ExerciseAnOption)
		(patient ?Exercise ?Option)
		(instance ?Option PutOption)
		(time ?Exercise ?Time)
		(underlier ?Option ?Stocks))
	(exists (?Sell)
		(and
			(instance ?Sell Selling)
			(patient ?Sell ?Stocks)
			(time ?Sell ?Time)
			(measure ?Stocks (MeasureFn 100 Shares)))))

;; definition of AmericanStyleOption

(instance AmericanStyleOption Option)
(documentation AmericanStyleOption "An option that can be exercised at any time
prior to its expiration date")

;; definition of EuropeanStyleOption

(instance EuropeanStyleOption Option)
(documentation EuropeanStyleOption "An option that can be exercised only during
a specified period of time just prior to its expiration.")

(=>
	(and
		(instance ?Option EuropeanStyleOption)
		(expirationDate ?Option ?Date))
	(exists (?Period)
		(and
			(instance ?Period TimeInterval)
			(finishes ?Period ?Date)
			(=>
				(exists (?Time)
					(and
						(instance ?Exercise ExerciseAnOption)
						(equal (WhenFn ?Exercise) ?Time)))
				(temporalPart ?Time ?Period)))))

;; definition of EquityOption

(subclass EquityOption Option)
(documentation EquityOption "An option on shares of an individual common stock.")

;;    Types of Orders


;; definition of FillingAnOrder

(subclass FillingAnOrder FinancialTransaction)
(documentation FillingAnOrder "Execute an order or buy or sell a security
or commodity.")

;; definition of CancellingAnOrder

(subclass CancellingAnOrder FinancialTransaction)

(=>
	(and
		(instance ?Kill CancellingAnOrder)
		(patient ?Kill ?Order))
	(not (agreementActive ?Order (ImmediateFutureFn (WhenFn ?Kill)))))

;; definition of IOCOrder

(subclass IOCOrder Order)
(documentation IOCOrder "Immediate or cancel Order is a type of option order
which gives the trading crowd one opportunity to take the other side of the
trade. After being announced, the order will be either partially or totally
filled with any remaining balance immediately cancelled. An IOC order, which
can be considered a type of day order, cannot be used as part of a GTC order
since it will be cancelled shortly after being entered. The difference between
fill-or-kill (FOK) orders and IOC orders is that a IOC order may be partially
executed.")

(=>
	(and
		(instance ?Order IOCOrder)
		(agreementPeriod ?Order ?Period))
	(or
		(exists (?Fill ?Time1)
			(and
				(instance ?Fill FillingAnOrder)
				(patient ?Fill ?Order)
				(equal (WhenFn ?Fill) ?Time1)
				(starts ?Time1 ?Period)))
		(exists (?Kill ?Time2)
			(and
				(instance ?Kill CancellingAnOrder)
				(patient ?Kill ?Order)
				(equal (WhenFn ?Kill) ?Time2)
				(starts ?Time2 ?Period)))))

;; definition of FOKOrder

(subclass FOKOrder Order)
(documentation FOKOrder "Fill-or-kill order is a type of option order
which requires that the order be executed completely or not at all.  A
fill-or-kill order is similar to an all-or-none (AON) order.  The
difference is that if the order cannot be completely executed (i.e.,
filled in its entirety) as soon as it is announced in the trading crowd,
it is to be 'killed' (i.e., cancelled) immediately.  Unlike an AON order,
a FOK order cannot be used as part of a GTC order.")

(=>
	(and
		(instance ?Order FOKOrder)
		(agreementPeriod ?Order ?Period))
	(or
		(exists (?Fill ?Time1)
			(and
				(instance ?Fill FillingAnOrder)
				(patient ?Fill ?Order)
				(equal (WhenFn ?Fill) ?Time1)
				(starts ?Time1 ?Period)))
		(exists (?Kill ?Time2)
			(and
				(instance ?Kill CancellingAnOrder)
				(patient ?Kill ?Order)
				(equal (WhenFn ?Kill) ?Time2)
				(starts ?Time2 ?Period)))))

;; definition of AONOrder

(subclass AONOrder Order)
(documentation AONOrder "All-or-none order (AON) is a type of option order
which requires that the order be executed completely or not at all. An AON
order may be either a day order or a GTC order.")

(=>
	(instance ?Order AONOrder)
	(or
		(instance ?Order DayOrder)
		(instance ?Order GTCOrder)))

;; definition of GTCOrder

(subclass GTCOrder Order)
(documentation GTCOrder "Good-'til-cancelled (GTC) order is a type of limit order
that remains in effect until it is either executed (filled) or cancelled, as opposed
to a day order, which expires if not executed by the end of the trading day. A GTC
option order is an order which if not executed will be automatically cancelled at the
option's expiration")

(=>
	(and
		(instance ?Order GTCOrder)
		(agreementPeriod ?Order ?Period))
	(or
		(exists (?Execute)
			(and
				(instance ?Execute ExecuteAnOrder)
				(patient ?Execute ?Order)
				(equal (WhenFn ?Execute) ?Time)
				(overlapsTemporally ?Time ?Period)))
		(exists (?Cancel)
			(and
				(instance ?Cancel CancellingAnOrder)
				(patient ?Cancel ?Order)
				(equal (WhenFn ?Cancel) ?End)
				(finishes ?End ?Period)))))

;; definition of DayOrder

(subclass DayOrder Order)
(documentation DayOrder "A type of option order which instructs the broker
to cancel any unfilled portion of the order at the close of trading on the
day the order is first entered.")

(=>
	(instance ?Order DayOrder)
	(and
		(agreementPeriod ?Order ?Period)
		(duration ?Period (MeasureFn 1 DayDuration))))

;; definition of MNHOrder

(subclass MNHOrder Order)
(documentation MNHOrder "A Market-not-held order is a type of market order
which allows the investor to give discretion to the floor broker regarding
the price and/or time at which a trade is executed.")

;; definition of MOCOrder

(subclass MOCOrder Order)
(documentation MOCOrder "A Market-on-close order is a type of option order
which requires that an order be executed at or near the close of trading on
the day the order is entered. A MOC order, which can be considered a type of
day order, cannot be used as part of a GTC order")

(=>
	(instance ?Order MOCOrder)
	(instance ?Order DayOrder))

;; definition of NHOrder

(subclass NHOrder Order)
(documentation NHOrder "A not-held order is a type of order which releases
normal obligations implied by the other terms of the order. For example, a
limit order designated as not-held allows discretion to the floor trader in
filling the order when the market trades at the limit price of the order. In
this case, there is no obligation to provide the customer with an execution if
the market trades through the limit price on the order.")

;; definition of OCOOrder

(subclass OCOOrder Order)
(documentation OCOOrder "One-cancels-other order (OCO) is a type of option
order which treats two or more option orders as a package, whereby the execution
of any one of the orders causes all the orders to be reduced by the same amount.
For example, the investor would enter an OCO order if he/she wished to buy
10 May 60 calls or 10 June 60 calls or any combination of the two which when
summed equaled 10 contracts. An OCO order may be either a day order or a GTC order")

(=>
	(instance ?Order OCOOrder)
	(or
		(instance ?Order DayOrder)
		(instance ?Order GTCOrder)))

;; definition of Bullish

(subclass Bullish InvestmentAttribute)
(documentation Bullish "An attribute describing the opinion that a stock, or the
market in general, will rise in price -- a positive or optimistic outlook.")

;; definition of Bearish

(subclass Bearish  InvestmentAttribute)
(documentation Bearish "An adjective describing the opinion that a stock, or
a market in general, will decline in price -- a negative or pessimistic outlook.")

;; definition of IndexOption

(subclass IndexOption Option)
(documentation IndexOption "An option whose underlying interest is an index.
Generally, index options are cash-settled.")

;; definition of inTheMoney

(instance inTheMoney BinaryPredicate)
(domain inTheMoney 1 Option)
(domain inTheMoney 2 TimePosition)
(documentation inTheMoney "A call option is in the money if the stock
price is above the strike price.  A put option is in the money if the
stock price is below the strike price.")

(<=>
	(exists (?Stock ?StockPrice ?StrikePrice)
		(and
			(instance ?Option CallOption)
			(underlier ?Option ?Stock)
			(price ?Stock ?StockPrice ?Time)
			(strikePrice ?Option ?StrikePrice)
			(lessThan ?StrikePrice ?StockPrice)))
	(inTheMoney ?Option ?Time))

(<=>
	(exists (?Stock ?StockPrice ?StrikePrice)
		(and
			(instance ?Option PutOption)
			(underlier ?Option ?Stock)
			(price ?Stock ?StockPrice ?Time)
			(strikePrice ?Option ?StrikePrice)
			(lessThan ?StockPrice ?StrikePrice)))
	(inTheMoney ?Option ?Time))

;; definition of atTheMoney

(instance atTheMoney BinaryPredicate)
(domain atTheMoney 1 Option)
(domain atTheMoney 2 TimePosition)
(documentation atTheMoney "A term that describes an option with a strike
price that is equal to the current market price of the underlying stock.")

(<=>
	(exists (?Stock ?StockPrice ?StrikePrice)
		(and
			(instance ?Option Option)
			(underlier ?Option ?Stock)
			(price ?Stock ?StockPrice ?Time)
			(strikePrice ?Option ?StrikePrice)
			(equal ?StockPrice ?StrikePrice)))
	(atTheMoney ?Option ?Time))

;; definition of outOfTheMoney

(instance outOfTheMoney BinaryPredicate)
(domain outOfTheMoney 1 Option)
(domain outOfTheMoney 2 TimePosition)
(documentation outOfTheMoney "A call option is out of the money if the
stock price is below its strike price. A put option is out of the money
if the stock price is above its strike price.")

(<=>
	(exists (?Stock ?StockPrice ?StrikePrice)
		(and
			(instance ?Option CallOption)
			(underlier ?Option ?Stock)
			(price ?Stock ?StockPrice ?Time)
			(strikePrice ?Option ?StrikePrice)
			(lessThan ?StockPrice ?StrikePrice)))
	(outOfTheMoney ?Option ?Time))

(<=>
	(exists (?Stock ?StockPrice ?StrikePrice)
		(and
			(instance ?Option PutOption)
			(underlier ?Option ?Stock)
			(price ?Stock ?StockPrice ?Time)
			(strikePrice ?Option ?StrikePrice)
			(lessThan ?StrikePrice ?StockPrice)))
	(outOfTheMoney ?Option ?Time))


;; strategies


;; definition of OptionStrategy

(subclass OptionStrategy FinancialTransaction)

;; definition of SingleOption

(subclass SingleOption OptionStrategy)

(documentation SingleOption "A put or call option by itself, as opposed to
multiple options as used in a spread or straddle.")

(=>
	(instance ?Strategy SingleOption)
	(equal (CardinalityFn (KappaFn ?Option (patient ?Strategy ?Option))) 1))

;; definition of SpreadOption

(subclass SpreadOption OptionStrategy)
(documentation SpreadOption "The purchase of one option and the
simultaneous sale of a related option, such as two options of the same
class but different strike prices and/or expiration dates.")

(=>
	(instance ?Spread SpreadOption)
	(exists (?Option1 ?Option2 ?Buy ?Sell ?Time)
		(and
			(instance ?Option1 Option)
			(instance ?Option2 Option)
			(instance ?Buy Buying)
			(instance ?Sell Selling)
			(patient ?Buy ?Option1)
			(patient ?Sell ?Option2)
			(time ?Buy ?Time)
			(time ?Sell ?Time))))

;; definition of ButterflySpread

(subclass ButterflySpread SpreadOption)
(documentation ButterflyOption "A complex option strategy that involves
selling two calls and buying two calls on the same or different markets,
with several maturity dates.  One of the options has a higher exercise
price and the other has a lower exercise price than the other two options.
The payoff diagram resembles the shape of a butterfly.")

(=>
	(instance ?Spread ButterflySpread)
	(exists (?Call1 ?Call2 ?Call3 ?Call4 ?Price1 ?Price2 ?Price3 ?Price4)
		(and
			(instance ?Call1 CallOption)
			(instance ?Call2 CallOption)
			(instance ?Call3 CallOption)
			(instance ?Call4 CallOption)
			(strikePrice ?Call1 ?Price1)
			(strikePrice ?Call2 ?Price2)
			(strikePrice ?Call3 ?Price3)
			(strikePrice ?Call4 ?Price4)
			(lessThan ?Price1 ?Price2)
			(lessThan ?Price1 ?Price3)
			(greaterThan ?Price4 ?Price2)
			(greaterThan ?Price4 ?Price2))))

;; definition of Straddle

(subclass Straddle OptionStrategy)
(documentation Straddle "The purchase or sale of an equal number of puts and
calls, with the same strike price and expiration dates.")

(=>
	(instance ?Straddle Straddle)
	(exists (?Price ?Date ?Number)
		(and
			(equal (CardinalityFn (KappaFn ?Call
			       (and
					(instance ?Call CallOption)
					(part ?Call ?Straddle)))) ?Number)
			(equal (CardinalityFn (KappaFn ?Put
			       (and
					(instance ?Put PutOption)
					(part ?Put ?Straddle)))) ?Number)
			(forall (?Option)
				(=>
					(and
						(instance ?Option Option)
						(part ?Option ?Straddle))

					(and
						(expirationDate ?Option ?Date)
						(stikePrice ?Option ?Price)))))))

;; definition of LongStraddle

(subclass LongStraddle Straddle)
(documentation LongStraddle "A straddle in which a long position is taken in
both a put and a call option")

;; definition of ShortSale

(subclass ShortSale FinancialTransaction)
(documentation ShortSale "Borrowing a security (or commodity futures
contract) from a broker and selling it, with the understanding that it
must later be bought back (hopefully at a lower price) and returned to the
broker.  SEC rules allow investors to sell short only on an uptick or a
zero-plus tick, to prevent 'pool operators' from driving down a stock
price through heavy short-selling, then buying the shares for a large
profit.")

;; definition of BorrowedStock

(subclass BorrowedStock Stock)
(documentation BorrowedStock "Stock in a short sale.")

;; definition of StockMarketTransaction

(subclass StockMarketTransaction FinancialTransaction)

(=>
	(instance ?Transaction StockMarketTransaction)
	(exists (?Market)
		(and
			(instance ?Market StockMarket)
			(located ?Transaction ?Market))))

(=>
	(and
		(instance ?Transaction StockMarketTransaction)
		(patient ?Transaction ?Stock))
	(instance ?Stock Stock))

;; definition of Uptick

(subclass Uptick StockMarketTransaction)
(documentation Uptick "A stock market transaction (or sometimes, a quote)
at a price higher than the preceding one for the same security.")

(=>
	(and
		(instance ?Uptick Uptick)
		(patient ?Uptick ?Stock)
		(equal (WhenFn ?Uptick) ?Time1)
		(price ?Stock ?Price1 ?Time1))
	(exists (?Transaction ?Time2)
		(and
			(instance ?Transaction StockMarketTransaction)
			(patient ?Transaction ?Stock)
			(equal (WhenFn ?Transaction) ?Time2)
			(meetsTemporally ?Time2 ?Time1)
			(price ?Stock ?Price2 ?Time2)
			(lessThan ?Price2 ?Price1))))

;; definition of Downtick

(subclass Downtick StockMarketTransaction)
(documentation Downtick "A stock market transaction (or sometimes, a quote)
at a price lower than the preceding one for the same security.")

(=>
	(and
		(instance ?Downtick Downtick)
		(patient ?Downtick ?Stock)
		(equal (WhenFn ?Downtick) ?Time1)
		(price ?Stock ?Price1 ?Time1))
	(exists (?Transaction ?Time2)
		(and
			(instance ?Transaction StockMarketTransaction)
			(patient ?Transaction ?Stock)
			(equal (WhenFn ?Transaction) ?Time2)
			(meetsTemporally ?Time2 ?Time1)
			(price ?Stock ?Price2 ?Time2)
			(greaterThan ?Price2 ?Price1))))


;; Income, employment, compensations


;; definition of Employment

(subclass Employment ServiceContract)
(subclass Employment FinancialContract)

(<=>
	(employs ?Org ?Agent)
	(exists (?Employment)
		(and
			(instance ?Employment Employment)
			(agreementMember ?Employment ?Org)
			(agreementMember ?Employment ?Agent))))

;; definition of income

(instance income TernaryPredicate)
(domain income 1 Human)
(domain income 2 CurrencyMeasure)
(domain income 3 TimeInterval)
(documentation incomeOf "(&%incomeOf ?Agent ?Money ?Period) means that
?Money is the amount of money or its equivalent received during a period
of time in exchange for labor or services, from the sale of goods or
property, or as profit from financial investments")

;; definition of monthlyIncome

(instance monthlyIncome AsymmetricRelation)
(domain monthlyIncome 1 Human)
(domain monthlyIncome 2 CurrencyMeasure)
(documentation monthlyIncome "(&%monthlyIncome ?Agent ?Money) means that
?Money is the amount of money received during one month period")

;; Error -- income is a TernaryPredicate
;;(<=>
;;	(monthlyIncome ?Agent ?Money)
;;	(exists (?Month)
;;		(and
;;			(instance ?Month Month)
;;			(income ?Agent ?Month))))

;; definition of incomeEarned

(instance incomeEarned TernaryPredicate)
(domain incomeEarned 1 Human)
(domain incomeEarned 2 CurrencyMeasure)
(domain incomeEarned 3 OrganizationalProcess)
(documentation incomeEarned "Money earned as a result of an Activity")

(=>
	(incomeEarned ?Agent ?Money ?Activity)
	(agent ?Activity ?Agent))

;; definition of taxDeferredIncome

(subrelation taxDeferredIncome incomeEarned)
(domain taxDeferredIncome 1 Human)
(domain taxDeferredIncome 2 CurrencyMeasure)
(domain taxDeferredIncome 3 OrganizationalProcess)
(documentation taxDeferredIncome "Income whose taxes can be postponed
until a later date.  Examples include IRA, 401(k), Keogh Plan, annuity,
Savings Bond and Employee Stock Ownership Plan.")

(=>
	(and
		(taxDeferredIncome ?Agent ?Income ?Activity)
		(time ?Activity ?Time))
	(not
	     (exists (?Tax)
		     (and
				(instance ?Tax Tax)
				(causes ?Activity ?Tax)
				(time ?Tax ?Time)))))

;; definition of afterTaxIncome

(subrelation afterTaxIncome incomeEarned)
(domain afterTaxIncome 1 Human)
(domain afterTaxIncome 2 CurrencyMeasure)
(domain afterTaxIncome 3 OrganizationalProcess)
(documentation afterTaxIncome "An amount (usually income) after taxes
have been subtracted.")

(<=>
	(exists (?Agent ?Tax)
		(and
			(incomeEarned ?Agent ?Income ?Activity)
			(amountCharged ?Tax ?TaxAmount)
			(causes ?Activity ?Tax)
			(equal ?ATIncome (SubtractionFn ?Income ?TaxAmount))))
	(afterTaxIncome ?Activity ?ATIncome))

;; definition of beforeTaxIncome

(subrelation beforeTaxIncome incomeEarned)
(domain beforeTaxIncome 1 Human)
(domain beforeTaxIncome 2 CurrencyMeasure)
(domain beforeTaxIncome 3 OrganizationalProcess)
(documentation beforeTaxIncome "Income before taxes are deducted")

;; definition of employeeContribution

(instance employeeContribution TernaryPredicate)
(domain employeeContribution 1 Human)
(domain employeeContribution 2 CurrencyMeasure)
(domain employeeContribution 3 TimeInterval)
(documentation employeeContribution "An individual's contribution to his/her
own retirement plan, often tax-deferred.")

(=>
	(employeeContribution ?Agent ?Money ?Period)
	(exists (?Org ?Plan)
		(and
			(instance ?Plan PensionPlan)
			(employs ?Org ?Agent)
			(agent ?Plan ?Org)
			(destination ?Plan ?Agent))))

;; definition of compensationPackage

(instance compensationPackage TernaryPredicate)
(domain compensationPackage 1 Human)
(domain compensationPackage 2 Income)
(domain compensationPackage 3 TimePosition)
(documentation compensationPackage "The total monetary value an employee
receives during a certain time period.")

(=>
	(compensationPackage ?Agent ?Money ?Period)
	(exists (?Activity)
		(and
			(instance ?Activity OccupationalProcess)
			(agent ?Activity ?Agent)
			(equal ?Period (WhenFn ?Activity))
			(incomeEarned ?Agent ?Money ?Activity))))


;; Retirement plans


;; definition of PensionPlan

(subclass PensionPlan FinancialTransaction)
(subclass PensionPlan Planning)
(documentation PensionPlan "A qualified retirement plan set up by a
corporation, labor union, government, or other organization for its
employees.  Examples include profit-sharing plans, stock bonus and
Employee Stock Ownership Plans, thrift plans, target benefit plans, money
purchase plans, and defined benefit plans.")

(=>
	(and
		(instance ?Plan PensionPlan)
		(destination ?Plan ?Agent)
		(instance ?Agent RetiredPerson)
		(result ?Plan ?Currency))
	(uses ?Agent ?Currency))

(=>
	(and
		(instance ?Plan PensionPlan)
		(destination ?Plan ?Agent)
		(employs ?Org ?Agent))
	(agent ?Plan ?Org))

;;definition of ProfitSharingPlan

(subclass ProfitSharingPlan FinancialTransaction)
(documentation ProfitSharingPlan "An arrangement in which an employer
shares its profits with its employees.  The compensation can be stocks,
bonds, or cash, and can be immediate or deferred until retirement.")

(=>
	(and
		(instance ?Plan ProfitSharingPlan)
		(destination ?Plan ?Agent)
		(employs ?Org ?Agent)
		(profit ?Activity ?Profit)
		(agent ?Activity ?Org))
	(exists (?Compensation ?Payment)
		(and
			(instance ?Payment Payment)
			(transactionAmount ?Payment ?Compensation)
			(lessThan ?Compensation ?Profit)
			(destination ?Payment ?Agent))))

;; definition of IndividualRetirementAccount

(subclass IndividualRetirementAccount SavingsAccount)
(subclass IndividualRetirementAccount PersonalAccount)
(documentation IndividualRetirementAccount "A tax-deferred retirement
account for an individual that permits individuals to set aside up to
$2,000 per year, with earnings tax-deferred until withdrawals begin at age
59 1/2 or later (or earlier, with a 10% penalty).  Only those who do not
participate in a pension plan at work or who do participate and meet
certain income guidelines can make deductible contributions to an IRA.
All others can make contributions to an IRA on a non-deductible basis.
Such contributions qualify as a deduction against income earned in that
year and interest accumulates tax-deferred until the funds are withdrawn.")

;; definition of 401K-Plan

(subclass 401K-Plan DefinedContributionPlan)
(documentation 401K-Plan "A defined contribution plan offered by a
corporation to its employees, which allows employees to set aside
tax-deferred income for retirement purposes.  The name 401(k) comes from
the IRS section describing the program.")

;; definition of DefinedContributionPlan

(subclass DefinedContributionPlan PensionPlan)
(documentation DefinedContributionPlan "A company retirement plan, such as
a 401(k) or 403(b), in which the employee elects to defer some amount of
his/her salary into the plan and bears the investment risk.")

;; definition of 403B-Plan

(subclass 403B-Plan DefinedContributionPlan)
(documentation 403B-Plan "A retirement plan similar to a 401(k) plan, but
one which is offered by non-profit organizations, such as universities and
some charitable organizations, rather than corporations.")

;; definition of SARSEPPlan

(subclass SARSEPPlan DefinedContributionPlan)

;; definition of Rollover

(subclass Rollover FinancialTransaction)
(documentation Rollover  "A tax-free reinvestment of a distribution from a
qualified retirement plan into an IRA or other qualified plan within 60 days.
Also called IRA rollover. Or more generally, a movement of funds from one investment
to another.")

;; definition of DirectRollover

(subclass DirectRollover Rollover)
(documentation DirectRollover "A distribution from qualified pension plan, 401(k)
 plan, or 403(b) plan, that is remitted directly to the trustee, custodian, or
issuer of the receiving IRA and is reported to the IRS as a rollover. This can only
be done once per year, per account.")

;; definition of  408K-Plan

(subclass 408K-Plan PensionPlan)
(documentation 408K-Plan "A simpler alternative to a 401(k) plan available
only to companies with 25 or fewer employees, which gives employees the
opportunity to make contributions to their SEP accounts with pre-tax
dollars and reduce their current year's net income.")

;; definition of  accountNumber

(instance accountNumber BinaryPredicate)
(instance accountNumber AsymmetricRelation)
(domain accountNumber 1 FinancialAccount)
(domain accountNumber 2 PositiveInteger)

;; definition of stockSymbol

(instance stockSymbol BinaryPredicate)
(instance stockSymbol AsymmetricRelation)
(domain stockSymbol 1 Stock)
(domain stockSymbol 2 SymbolicString)
(documentation stockSymbol "A unique symbol assigned to a security. NYSE and
AMEX listed stocks have symbols of three characters or less. NASDAQ-listed
securities have four or five characters.")

;; definition of RothIRAAccount

(subclass RothIRAAccount IndividualRetirementAccount)
(documentation RothIRAAccount "An individual retirement account in which a person
can set aside after-tax income up to a specified amount each year. Earnings on the
account are tax-free, and tax-free withdrawals may be made after age 591/2.")

;; definition of VisaCard

(subclass VisaCard CreditCard)

;; definition of MasterCard

(subclass MasterCard CreditCard)

;; definition of DiscoverCard

(subclass DiscoverCard CreditCard)

;; definition of AmericanExpressCard

(subclass AmericanExpressCard CreditCard)

;; definition of  checkNumber

(instance checkNumber AsymmetricRelation)
(domain checkNumber 1 Check)
(domain checkNumber 2 PositiveInteger)

;; definition of  netAmount

(instance netAmount BinaryPredicate)
(instance netAmount AsymmetricRelation)
(domain netAmount 1 Investment)
(domain netAmount 2 CurrencyMeasure)
(documentation netAmount "The amount due the supplier after commissions
have been deducted.")

;; definition of BrokerageAccount

(instance BrokerageAccount InvestmentAccount)
(documentation BrokerageAccount "A fund that a customer has entrusted to
a securities brokerage.")

;; definition of effectiveDate

(subrelation effectiveDate date)
(domain effectiveDate 1 Contract)
(domain effectiveDate 2 Day)
(documentation effectiveDate "Legal date an agreement or document goes into force.")

(<=>
	(effectiveDate ?Agreement ?StartDate)
	(exists (?Period)
		(and
			(agreementPeriod ?Agreement ?Period)
			(starts ?StartDate ?Period))))

;; definition of closingPrice

(subrelation closingPrice monetaryValue)
(domain closingPrice 1 Stock)
(domain closingPrice 2 CurrencyMeasure)
(documentation closingPrice "Price of the last transaction of a particular stock
completed during a day's trading session on an exchange.")

;; definition of finalPrice

(subrelation finalPrice monetaryValue)
(domain finalPrice 1 Stock)
(domain finalPrice 2 CurrencyMeasure)

;; definition of Cash

(subclass Cash FinancialInstrument)
(subclass Cash FinancialAsset)
(documentation Cash "Circulating paper money")

(=>
	(instance ?Cash Cash)
	(exists (?Value)
		(monetaryValue ?Cash ?Value)))

;; definition of riskTolerance

(instance riskTolerance BinaryPredicate)
(instance riskTolerance AsymmetricRelation)
(domain riskTolerance 1 Investor)
(domain riskTolerance 2 RiskAttribute)

(=>
	(and
		(riskTolerance ?Agent ?Level)
		(instance ?Investment Investment)
		(possesses ?Agent ?Investment))
	(riskLevel ?Investment ?Level))

;; definition of cardCode

(instance cardCode BinaryPredicate)
(subrelation cardCode represents)
(domain cardCode 1 ContentBearingObject)
(domain cardCode 2 BankCard)
(documentation cardCode "(&%cardCode ?Code ?Card) means that ?Code represents
the account number of the BankCard ?Card.")

(=>
	(and
		(cardCode ?Code ?Card)
		(cardAccount ?Card ?Account))
	(exists (?Encoding)
		(and
			(instance ?Encoding Encoding)
			(patient ?Encoding ?Account))))

;; definition of ValidCard

(subclass ValidCard BankCard)
(documentation ValidCard "A class of valid BankCards")

(=>
	(and
		(instance ?Authorization AuthorizationOfTransaction)
		(instance ?Transaction FinancialTransaction)
		(instance ?Card BankCard)
		(instrument ?Transaction ?Card)
		(causes ?Authorization ?Transaction))
	(instance ?Card ValidCard))

;; definition of ExpiredCard

(subclass ExpiredCard BankCard)
(disjoint ExpiredCard ValidCard)
(documentation ExpiredCard "A class of expired BankCards.")

(=>
	(and
		(holdsDuring ?Time (instance ?Card ExpiredCard))
		(cardAccount ?Card ?Account))
	(not (agreementActive ?Card ?Time)))

;; definition of pin

(instance pin BinaryPredicate)
(subrelation pin represents)
(domain pin 1 SymbolicString)
(domain pin 2 BankCard)
(documentation pin "(&%pin ?PIN ?Card) means that ?PIN is a personal identification
number linked to the ?Card.")

(=>
	(and
		(instance ?Card DebitCard)
		(possesses ?Card ?Agent)
		(instance ?Transaction FinancialTransaction)
		(instrument ?Transaction ?Card))
	(exists (?PIN ?Enter)
		(and
			(pin ?PIN ?Card)
			(instance ?Enter EnteringAPin)
			(patient ?Enter ?PIN)
			(agent ?Enter ?Agent))))

;; definition of EnteringAPin

(subclass EnteringAPin AuthorizationOfTransaction)
(subclass EnteringAPing ContentDevelopment)
(documentation EnteringAPin "A subclass of &%AuthorizationOfTransaction where
a customer enters his/her personal identification number.")

(=>
	(instance ?Enter EnteringAPin)
	(exists (?Pin ?Card)
		(and
			(pin ?Pin ?Card)
			(patient ?Enter ?Pin))))

(subclass VerifyingCardCode AuthorizationOfTransaction)
(documentation VerifyingCardCode "A subclass of &%AuthorizationOfTransaction
where an ATM machine checks the code of the BankCard inserted to this machine.")

(=>
	(and
		(instance ?Check VerifyingCardCode)
		(patient ?Check ?Code)
		(codeCard ?Code ?Card))
	(exists (?Decode)
		(and
			(instance ?Decode Decoding)
			(subProcess ?Decode ?Check)
			(patient ?Decode ?Code))))

;; definition of ATMMachine

(subclass ATMMachine StationaryArtifact)
(documentation ATMMachine "(Automatic Teller Machine) A banking terminal that
accepts deposits and dispenses cash. ATMs are activated by inserting a cash or
credit card that contains the user's account number and PIN on a magnetic stripe.
The ATM calls up the bank's computers to verify the balance, dispenses the cash
and then transmits a completed transaction notice.")

(subclass FinancialService CommercialService)
(documentation FinancialService "Services performed by &%FinancialOrganizations")

(=>
	(instance ?Service FinancialService)
	(exists (?Org)
		(and
			(instance ?Org FinancialOrganization)
			(agent ?Service ?Org))))

(subclass OpeningAnAccount FinancialService)

(subclass ClosingAnAccount FinancialService)

(subclass ControllingAnAccount FinancialService)

(subclass CommercialService FinancialTransaction)
(documentation CommercialService "Work done for others as an occupation
or business.")

(=>
	(instance ?Service CommercialService)
	(exists (?Org)
		(and
			(instance ?Org Organization)
			(agent ?Service ?Org))))

(=>
	(and
		(instance ?Service CommercialService)
		(agent ?Service ?Agent)
		(employs ?Org ?Agent)
		(destination ?Service ?Customer))
	(hasPurpose ?Service
		    (exists (?Transaction)
			    (and
				(instance ?Transaction FinancialTransaction)
				(destination ?Transaction ?Org)
				(origin ?Transaction ?Customer)))))

(instance customer IrreflexiveRelation)
(instance customer BinaryPredicate)
(domain customer 1 CognitiveAgent)
(domain customer 2 CognitiveAgent)
(documentation customer "A very general relation that exists whenever there
is a &%FinancialService between the two &%Agents such that the first is
the &%destination of the &%FinancialService and the second is the
&%agent.")

(<=>
	(customer ?Agent1 ?Agent2)
	(exists (?Service)
		(and
			(instance ?Service FinancialService)
			(agent ?Service ?Agent2)
			(destination ?Service ?Agent1))))

(=>
	(and
		(accountHolder ?Account ?Agent)
		(accountAt ?Account ?Bank))
	(customer ?Agent ?Bank))

(instance customerRepresentative TernaryPredicate)
(domain customerRepresentative 1 CognitiveAgent)
(domain customerRepresentative 2 CognitiveAgent)
(domain customerRepresentative 3 Organization)
(documentation customerRepresentative "(&%customerRepresentative
?PERSON1 ?PERSON2 ?ORG) means that ?PERSON1 acts as a representative
of &%Organization ?ORG in a &%SocialInteraction involving ?PERSON2.")

(<=>
	(customerRepresentative ?Person1 ?Person2 ?Org)
	(exists (?Service)
		(and
			(instance ?Service FinancialService)
			(employs ?Org ?Person1)
			(agent ?Service ?Person1)
			(destination ?Service ?Person2))))

(instance Manager Position)
(documentation Manager "One who directs a business or other enterprise.")

(subclass ATMSlot Hole)
(documentation ATMSlot "A narrow opening in an ATM machine where cards are inserted.")

(=>
	(instance ?Slot ATMSlot)
	(exists (?ATM)
		(and
			(instance ?ATM ATMMachine)
			(hole ?Slot ?ATM))))

(=>
	(instance ?Slot ATMSlot)
	(exists (?Insert ?Card)
		(and
			(instance ?Insert Putting)
			(patient ?Insert ?Card)
			(instance ?Card BankCard)
			(destination ?Insert ?Slot))))

(instance address BinaryPredicate)
(subrelation address refers)
(domain address 1 Address)
(domain address 2 Agent)
(documentation address "(address ?Address ?Agent) means that ?Address
describes The location at which ?Agent may be found or reached.")

(=>
	(address ?Address ?Agent)
	(inhabits ?Agent ?Address))

(subrelation postalCode BinaryPredicate)
(domain postalCode 1 SymbolicString)
(domain postalCode 1 Address)

(instance Telephone Device)
(documentation Telephone "An instrument that converts voice and other sound
signals into a form that can be transmitted to remote locations and that
receives and reconverts waves into sound signals.")

(=>
	(and
		(instance ?Phone Telephone)
		(possesses ?Agent ?Phone))
	(exists (?Communication)
		(and
			(instance ?Communication Communication)
			(agent ?Communication ?Agent)
			(instrument ?Communication ?Phone))))

(instance phoneNumber BinaryPredicate)
(subrelation phoneNumber refers)
(domain phoneNumber 1 SymbolicString)
(domain phoneNumber 2 Telephone)
(documentation phoneNumber "(&%phoneNumber ?Phone ?Agent) holds if ?Phone is
a phone number corresponding to the Telephone ?Phone.")

(instance dayPhone BinaryPredicate)
(domain dayPhone 1 SymbolicString)
(domain dayPhone 2 Agent)
(documentation dayPhone "(&%dayPhone ?Phone ?Agent) means that ?Phone is a phone
number corresponding to the location where ?Agent can be reached during the day.")

(=>
	(and
		(dayPhone ?Number ?Agent)
		(instance ?Day Day))
	(exists (?Phone)
		(and
			(phoneNumber ?Number ?Phone)
			(holdsDuring (HourFn ?Number ?Day) (possesses ?Agent ?Phone))
			(lessThan ?Number 18))))

(instance eveningPhone BinaryPredicate)
(domain eveningPhone 1 SymbolicString)
(domain eveningPhone 2 Agent)
(documentation eveningPhone "(&%eveningPhone ?Phone ?Agent) means that ?Phone
is a phone number corresponidng to the location where ?Agent can be reached
during the evening.")

(=>
	(and
		(eveningPhone ?Number ?Agent)
		(instance ?Day Day))
	(exists (?Phone)
		(and
			(phoneNumber ?Number ?Phone)
			(holdsDuring (HourFn ?Number ?Day) (possesses ?Agent ?Phone))
			(greaterThan ?Number 18))))

(instance emailAddress BinaryPredicate)
(subrelation emailAddress refers)
(domain emailAddress 1 SymbolicString)
(domain emailAddress 2 Agent)
(documentation emailAddress "(&%emailAddress ?Address ?Agent) means that ?Address is
an electronic address of the location where ?Agent can be reached.")

(subclass Fax Communication)
(documentation Fax "The communication of a printed page between remote locations.")

(=>
	(instance ?Fax Fax)
	(exists (?FaxMachine)
		(and
			(instance ?FaxMachine FaxMachine)
			(instrument ?Fax ?FaxMachine))))

(subclass FaxMachine Device)
(documentation FaxMachine "Fax machines scan a paper form and transmit a coded
image over the telephone system. The receiving machine prints a facsimile of
the original. A fax machine is made up of a scanner, printer and modem with
fax signaling.")


(subrelation firstName name)
(domain firstName 1 Agent)
(domain firstName 2 SymbolicString)
(documentation firstName "(firstName ?Agent ?Name) holds if ?Name is a given
name or the name that occurs first in a given name.")

(subrelation availableBalance currentAccountBalance)
(domain availableBalance 1 FinancialAccount)
(domain availableBalance 2 Day)
(domain availableBalance 3 CurrencyMeasure)
(documentation availableBalance "(&%availableBalance ?Account ?Day ?Amount) means
that ?Amount is the balance which is available for withdrawal from the &%FinancialAccount
?Account.")

(=>
	(exists (?Transaction)
		(and
			(instance ?Transaction FinancialTransaction)
			(origin ?Transaction (CurrencyFn ?Account))
			(transactionAmount ?Transaction ?Amount)
			(date ?Transaction ?Day)))
        (exists (?Amount2)
		(and
			(availableBalance ?Account ?Day ?Amount2)
			(greaterThanOrEqualTo ?Amount1 ?Amount2))))

(subrelation availableCash availableBalance)
(domain availableCash 1 FinancialAccount)
(domain availableCash 2 Day)
(domain availableCash 3 CurrencyMeasure)
(documentation availableCash "(&%availableCash ?Account ?Day ?Cash) holds if
?Cash is a cash amount available for withdrawal from the &%FinancialAccount
?Account.")

(=>
	(exists (?Transaction)
		(and
			(instance ?Transaction FinancialTransaction)
			(origin ?Transaction (CurrencyFn ?Account))
			(transactionAmount ?Transaction ?Amount)
			(instance ?Cash Cash)
			(instrument ?Transaction ?Cash)
			(date ?Transaction ?Day)))
        (exists (?Amount2)
		(and
			(availableCash ?Account ?Day ?Amount2)
			(greaterThanOrEqualTo ?Amount1 ?Amount2))))

;; paymentsPerPeriod

(instance paymentsPerPeriod TernaryPredicate)
(domain paymentsPerPeriod 1 FinancialAccount)
(domain paymentsPerPeriod 2  CurrencyMeasure)
(domain paymentsPerPeriod 3 TimeInterval)
(documentation paymentsPerPeriod "(&%paymentsPerPeriod ?Account ?Amount ?Period)
holds if ?Amount is the amount paid on the FinancialAccount ?Account during the
time period ?Period.")

(instance purchasesPerPeriod TernaryPredicate)
(domain purchasesPerPeriod 1 FinancialAccount)
(domain purchasesPerPeriod 2 CurrencyMeasure)
(domain purchasesPerPeriod 3 TimeInterval)
(documentation purchasesPerPeriod "(&%purchasesPerPeriod ?Account ?Amount ?Period)
holds if ?Amount is the amount of purchases added to the FinancialAccount ?Account
during the time period ?Period.")

(instance creditsPerPeriod TernaryPredicate)
(domain creditsPerPeriod 1 FinancialAccount)
(domain creditsPerPeriod 2 CurrencyMeasure)
(domain creditsPerPeriod 3 TimeInterval)
(documentation creditsPerPeriod "(&%creditsPerPeriod ?Account ?Amount ?Period)
holds if ?Amount is the amount credited to the FinancialAccount ?Account during
the time period ?Period.")

(instance confirmationNumber BinaryPredicate)
(instance confirmationNumber AsymmetricRelation)
(domain confirmationNumber 1 FinancialTransaction)
(domain confirmationNumber 2 SymbolicString)

(subclass BankStatement Proposition)
(documentation BankStatement "A monthly report sent to a debtor or bank depositor.")

(=>
	(and
		(instance ?Statement BankStatement)
		(statementAccount ?Statement ?Account))
	(exists (?Transaction)
		(and
			(instance ?Transaction FinancialTransaction)
			(or
				(origin ?Transaction (CurrencyFn ?Account))
				(destination ?Transaction (CurrencyFn ?Account)))
			(realization ?Statement ?Transaction))))

(instance lastStatement BinaryPredicate)
(domain lastStatement 1 FinancialAccount)
(domain lastStatement 2 BankStatement)
(documentation lastStatement "(&%lastStatement ?Account ?Statement) means that
?Statement is the most recent monthly report sent to a debtor or bank depositor.")

(=>
	(and
		(lastStatement ?Account ?Statement)
		(instance ?Transaction1 FinancialTransaction)
		(realization ?Statement ?Transaction1)
		(instance ?Transaction2 FinancialTransaction)
		(not (realization ?Statement ?Transaction2)))
	(earlier (WhenFn ?Transaction2) (WhenFn ?Transaction1)))

(instance loanInterest BinaryPredicate)
(domain loanInterest 1 Loan)
(domain loanInterest 2 Amount)

(<=>
	(exists (?Period)
		(and
			(instance ?Loan Loan)
			(agreementPeriod ?Loan ?Period)
			(interestEarned ?Loan ?Amount ?Period)))
	(loanInterest ?Loan ?Amount))

(subclass Title FinancialInstrument)
(documentation Title "The instrument, such as a deed, that constitutes evidence
of a legal right of possession or control.")

(=>
	(instance ?Title Title)
	(exists (?Property ?Agent)
		(containsInformation ?Title (possesses ?Agent ?Property))))

(instance bankAccount BinaryPredicate)
(instance bankAccount AsymmetricRelation)
(domainSubclass bankAccount 1 FinancialAccount)
(domain bankAccount 2 Bank-FinancialOrganization)
(documentation bankAccount "(&%bankAccount ?Type ?Bank) holds if ?Type is a
type of the financial accounts offered by the bank.")

(<=>
	(bankAccount ?AccountType ?Bank)
	(exists (?Account)
		(and
			(instance ?Account ?AccountType)
			(accountAt ?Account ?Bank))))

(subclass ServiceAttribute Attribute)
(documentation ServiceAttribute "The class of attributes which describe
&%CommercialServices, such as &%OpenService and &%ClosedService.")

(instance OpenService ServiceAttribute)
(contraryAttribute OpenService ClosedService)
(documentation OpenService "The attribute which describes services that
are ready to transact business.")

(=>
	(exists (?Transaction)
		(and
			(instance ?Transaction FinancialTransaction)
			(destination ?Transaction ?Agent)))
	(and
		(instance ?Service CommercialService)
		(agent ?Service ?Agent)
		(attribute ?Service OpenService)))

(instance ClosedService ServiceAttribute)
(documentation ClosedService "The attribute which describes services that are
shut or closed.")

(instance Receipt FinancialInstrument)
(documentation Receipt "A written acknowledgment that a specified article,
sum of money, or shipment of merchandise has been received.")

(subclass Request FinancialTransaction)
(documentation Request "The request data being sent.")

;; definition of Response

(subclass Response FinancialTransaction)
(documentation Response "The response data.")

;; definition of responseTo

(instance responseTo BinaryPredicate)
(domain responseTo 1 Response)
(domain responseTo 2 Request)
(documentation responseTo "(&%responseTo ?Response ?Request) means that
?Response is a Response to the Request ?Request.")

(instance dailyLimit TernaryPredicate)
(domain dailyLimit 1 FinancialAccount)
(domainSubclass dailyLimit 2 FinancialTransaction)
(domain dailyLimit 3 CurrencyMeasure)
(documentation dailyLimit "(&%dailyLimit ?Account ?TransactionType ?Amount)
means that ?Amount is the daily limit of the ?Account for the type of
&%FinancialTransactions ?TransactionType.")

(instance accountStatus BinaryPredicate)
(domain accountStatus 1 FinancialAccount)
(domain accountStatus 2 StatusAttribute)
(documentation accountStatus "(&%accountStatus ?Account ?Status) holds if
?Status describes the status of the account, such as &%Active, &%Locked,
&%New or &%Pending.")

(subclass StatusAttribute Attribute)

(instance New StatusAttribute)

(instance Active StatusAttribute)

(instance Locked StatusAttribute)

(instance Pending StatusAttribute)

(instance administrator BinaryPredicate)
(domain administrator 1 FinancialAccount)
(domain administrator 2 Position)

(instance administratorStatus BinaryPredicate)
(domain administratorStatus 1 Position)
(domain administratorStatus 2 StatusAttribute)
(documentation administratorStatus "(&%administratorStatus ?Administrator ?Status)
holds is ?Status describes the status of the administrator.")

(instance dateOfStatement BinaryPredicate)
(domain dateOfStatement 1 BankStatement)
(domain dateOfStatement 2 Day)
(documentation dateOfStatement "(&%dateOfStatement ?Statement ?Date) holds if
?Date is the date when BankStatement was issued.")

(=>
	(dateOfStatement ?Statement ?Date)
	(exists (?Copy)
		(and
			(containsInformation ?Copy ?Statement)
			(date ?Copy ?Date))))

(instance lastStatementBalance BinaryPredicate)
(domain lastStatementBalance 1 FinancialAccount)
(domain lastStatementBalance 2 CurrencyMeasure)
(documentation lastStatementBalance "(&%lastStatementBalance ?Account ?Amount)
holds if ?Amount is the balance shown on the last statement.")

(=>
	(lastStatementBalance ?Account ?Balance)
	(exists (?Statement)
		(and
			(lastStatement ?Account ?Statement)
			(dateOfStatement ?Statement ?Date)
			(currentAccountBalance ?Account ?Date ?Account))))

(instance statementAccount BinaryPredicate)
(domain statementAccount 1 BankStatement)
(domain statementAccount 2 FinancialAccount)
(documentation statementAccount "(&%statementAccount ?Statement ?Account) means
that ?Account is the account of the BankStatement ?Statement.")

(instance statementPeriod BinaryPredicate)
(domain statementPeriod 1 BankStatement)
(domain statementPeriod 2 TimeInterval)
(documentation statementPeriod "(&%statementPeriod ?Statement ?Period) means that
?Period is the time period of the BankStatement ?Statement.")

(=>
	(and
		(statementPeriod ?Statement ?Period)
		(duration ?Period ?Duration))
	(equal ?Duration MonthDuration))

(=>
	(and
		(statementPeriod ?Statement ?Period)
		(dateOfStatement ?Statement ?Date))
	(finishes ?Date ?Period))

(instance statementInterest BinaryPredicate)
(domain statementInterest 1 BankStatement)
(domain statementInterest 2 CurrencyMeasure)
(documentation statementInterest "(&%statementInterest ?Statement ?Amount) holds
if ?Amount is the interest amount as shown on the BankStatement ?Statement.")

;; Logic error -- ?Amount variable roams free in consequent.
;;(=>
;;	(and
;;		(statementInterest ?Statement ?Interest)
;;		(statementPeriod ?Statement ?Period)
;;		(statementAccount ?Statement ?Account))
;;	(interestEarned ?Account ?Amount ?Period))

(subrelation buyingPowerAmount availableBalance)
(documentation buyingPowerAmount "(&%buyingPowerAmount ?Account ?Amount) holds
if ?Amount is the buying power amount of the FinancialAccount ?Account.")

(subrelation marginBalanceAmount availableBalance)
(documentation marginBalanceAmount "(&%marginBalanceAmount ?Account ?Amount)
holds if ?Amount is the margin balance amount of the FinancialAccount ?Account.")

(subrelation shortBalanceAmount availableBalance)
(documentation shortBalanceAmount "(&%shortBalanceAmount ?Account ?Amount) holds
if ?Amount is the short balance amount of the FinancialAccount ?Account.")

(subrelation marketValueAmount availableBalance)
(documentation shortBalanceAmount "(&%marketvalueAmount ?Account ?Amount) holds
if ?Amount is the market value amount of the FinancialAccount ?Account.")

(subclass ExternalTransfer FinancialTransaction)
(documentation ExternalTransfer "A subclass of &%FinancialTransactions from one
&%FinancialOrganization to another.")

(=>
	(and
		(instance ?Transfer ExternalTransfer)
		(origin ?Transfer ?Organization1)
		(instance ?Organization1 FinancialOrganization)
		(destination ?Transfer ?Organization2)
		(instance ?Organization2 FinancialOrganization))
	(not (equal ?Organization1 ?Organization2)))

(subclass InternalTransfer FinancialTransaction)
(disjoint InternalTransfer ExternalTransfer)
(documentation InternalTransfer "A subclass of &%FinancialTransactions within
one &%FinancialOrganization.")

(=>
	(and
		(instance ?Transfer ExternalTransfer)
		(origin ?Transfer ?Organization1)
		(instance ?Organization1 FinancialOrganization)
		(destination ?Transfer ?organization2)
		(instance ?Organization2 FinancialOrganization))
	(equal ?Organization1 ?Organization2))

(subclass Update FinancialTransaction)
(subclass Update ContentDevelopment)
(documentation Update "To change data in a file or database")

(instance loanFeeAmount BinaryPredicate)
(domain loanFeeAmount 1 Loan)
(domain loanFeeAmount 2 CurrencyMeasure)
(documentation loanFeeAmount "(&%loanFeeAmount ?Loan ?Amount) means that
?Amount is the fee amount of the Loan ?Loan.")

(=>
	(and
		(loanFeeAmount ?Loan ?Amount)
		(agreementPeriod ?Loan ?Period))
	(interestEarned ?Loan ?Amount ?Period))

;; ======================================================
;; Services DOMAIN ONTOLOGY rev. ?? downloaded 2002-10-08
;; ======================================================

;;This section is from Olga Babko-Malaya's file: OntologyOfService.txt
;; Upper Ontology of Services

;; definition of WebService
(subclass WebService ComputerProgram)
(documentation WebService "Web sites that do not merely provide static information but allow one to effect some action or change in the world, such as the sale of a product or the control of a physical device.")

(=>
	(instance ?Service WebService)
	(exists (?Resource)
		(providesAService ?Service ?Resource)))

(=>
	(and
		(instance ?Service WebService)
		(instance ?Using UsingAService)
		(patient ?Using ?Service)
		(agent ?Using ?User)
		(providesAService ?Service ?Provider))
	(exists (?Contract)
		(and
			(instance ?Contract ServiceContract)
			(agreementMember ?Contract ?User)
			(agreementMember ?Contract ?Provider))))

; definition of PrimitiveService
(subclass PrimitiveService WebService)
(documentation PrimitiveService "Primitive services are services which invoke only a single Web-accessible computer program, sensor, or  device that does not rely upon another Web service, and there is no ongoing interaction between the user and the service, beyond a simple response. For example, a service that returns a postal code or the longitude and latitude when given an address would be in this category.")

;; definition of ComplexService
(subclass ComplexService WebService)
(documentation ComplexService
"Complex services are composed of multiple primitive services, often requiring an interaction or conversation between the user and the services, so that the user can make choices and provide information conditionally.")


;; definition of UsingAService
(subclass UsingAService ComputerProcess)
(documentation UsingAService "Interaction between the user and the service")


(=>
	(instance ?Using UsingAService)
	(exists (?Service)
		(and
			(instance ?Service WebService)
			(patient ?Using ?Service))))

(=>
	(instance ?Using UsingAService)
	(exists (?User)
		(and
			(instance ?User ServiceUser)
			(agent ?Using ?User))))

(=>
	(and
		(instance ?Using UsingAService)
		(instance ?Service WebService)
		(instance ?User ServiceUser)
		(patient ?Using ?Service)
		(agent ?Using ?User))
	(precondition ?Using (hasAccess ?User ?Service)))


;; definition of ServiceUser
(subclass ServiceUser Agent)
(documentation ServiceUser "An Agent who requests a particular service")


(=>
	(instance ?User ServiceUser)
	(exists (?Process)
		(and
			(instance ?Process ServiceProcess)
			(effector ?Process ?User))))

;; definition of AccessingAService
(subclass AccessingAService ComputerProcess)
(documentation AccessingAService "To enter an online service")


(=>
	(instance ?Access AccessingAService)
	(exists (?Service)
		(and
			(instance ?Service WebService )
			(destination ?Access ?Service))))


(=>
	(and
		(instance ?Access AccessingAService)
		(instance ?Service WebService )
		(destination ?Access ?Service)
		(agent ?Access ?Agent))
	(hasPurposeForAgent ?Access
		(exists (?Using)
			(and
				(instance ?Using UsingAService)
				(patient ?Using ?Service)
				(agent ?Using ?Agent))) ?Agent))

(=>
	(and
		(instance ?Access AccessingAService)
		(instance ?Service WebService )
		(destination ?Access ?Service)
		(agent ?Access ?Agent))
	(holdsDuring (ImmediateFutureFn (WhenFn ?Access)) (hasAccess ?User ?Service)))

;; definition of hasAccess
(instance hasAccess AsymmetricRelation)
(domain hasAccess 1 ServiceUser)
(domain hasAccess 2 WebService )
(documentation hasAccess "(hasAccess ?User ?Service) holds if ?User is authorized to use the WebService ?Service")

(=>
	(hasAccess ?User ?Service)
	(exists (?Using)
		(and
			(subclass ?Using UsingAService)
			(forall (?Use)
				(=>
					(instance ?Use ?Using)
					(patient ?Use ?Service)))
			(holdsAuthority ?Using ?User))))



;; definition of ServiceProfile
(subclass ServiceProfile ContentBearingObject)
(documentation ServiceProfile  "The service profile tells what the service does; that is, it gives the type of information needed by a service-seeking agent to determine whether the service meets its needs (typically such things as input and output types, preconditions and postconditions, and binding patterns).")

(=>
	(instance ?Profile ServiceProfile)
	(exists (?Service)
		(presentsAProfile ?Profile ?Service)))


;; definition of ServiceModel
(subclass ServiceModel ContentBearingObject)
(documentation ServiceModel "The service model tells how the service works; that is, it describes what happens when the service is carried out.")

(=>
	(instance ?Model ServiceModel)
	(exists (?Service)
		(implementsAModel ?Model ?Service)))

(=>
	(and
		(instance ?Model ServiceModel)
		(implementsAModel ?Model ?Service)
		(instance ?Using ?UsingAService)
		(patient ?Using ?Service))
	(represents ?Model ?Using))


;; definition of ServiceGrounding
(subclass ServiceGrounding ContentBearingObject)
(documentation ServiceGrounding " ServiceGrounding specifies the details of how an agent can access a service.  Typically a grounding may specify some well known communications protocol (e.g., RPC, HTTP-FORM, CORBA IDL, SOAP, Java remote calls, OAA, Jini), and service-specific  details such as port numbers used in contacting the service.  In  addition, the grounding must specify, for each abstract type specified  in the ServiceModel, an unambigous way of exchanging data elements of  that type with the service (that is, marshalling / serialization  techniques employed).")

(=>
	(instance ?Grounding ServiceGrounding)
	(exists (?Service)
		(supportsAGrounding ?Grounding ?Service)))

(=>
	(and
		(instance ?Grounding ServiceGrounding)
		(supportsAGrounding ?Grounding ?Service)
		(instance ?Access AccessingAService)
		(destination ?Access ?Service))
	(represents ?Grounding ?Access))



;; definition of presentsAProfile
(instance presentsAProfile AsymmetricRelation)
(subrelation presentsAProfile represents)
(domain presentsAProfile 1 ServiceProfile)
(domain presentsAProfile 2 WebService)
(documentation presentsAProfile
"(presentsAProfile ?Profile ?Service) means that ?Profile represents the type of information needed by a service-seeking agent to determine  whether the service ?Service meets its needs")

;; definition of implementsAModel
(instance implementsAModel AsymmetricRelation)
(subrelation implementsAModel represents)
(domain implementsAModel 1 ServiceModel)
(domain implementsAModel 2 WebService)
(documentation implementsAModel"(implementsAModel ?Model ?Service) holds if ?Model describes what happens when the service ?Service is carried out")

;; definition of supportsAGrounding
(instance supportsAGrounding AsymmetricRelation)
(subrelation supportsAGrounding represents)
(domain supportsAGrounding 1 ServiceGrounding)
(domain supportsAGrounding 2 WebService)
(documentation supportsAGrounding "(supportsAGrounding ?Grounding ?Service) holds if ?Grounding represents the details  of how an agent can access the service ?Service")

;; definition of ServiceProvider
(subclass ServiceProvider Website)
(documentation ServiceProvider "A website which provides a service")

(=>
	(instance ?Resource ServiceProvider)
	(exists (?Service)
		(providesAService ?Resource ?Service)))

;; definition of providesAService
(instance providesAService AsymmetricRelation)
(domain providesAService 1 WebService )
(domain providesAService 2 ServiceProvider)
(documentation providesAService "(providesAService ?Service ?Provider) holds if ?Provider is a website which offers the WebService ?Service")

;; definition of Website
(subclass Website Server)
(documentation Website "A server that contains Web pages and other files which is online to the Internet 24 hours a day.")

;; Ontology of Service Profiles

;; definition of serviceName
(subrelation serviceName represents)
(domain serviceName 1 SymbolicString)
(domain serviceName 2 WebService)
(documentation serviceName "The Service Name refers to the name of the service that is being offered")

(=>
	(and
		(serviceName ?Name ?Service)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Name))


;; definition of intendedPurpose
(instance intendedPurpose AsymmetricRelation)
(domain intendedPurpose 1 WebService)
(domain intendedPurpose 2 Formula)
(documentation intendedPurpose
"(intendedPurpose ?Service ?Purpose) means that ?Purpose provides a brief description of ?Service.  This would typically appear within an advertisement to summarise  what the service offers, or within a  request to describe what is being requested")

(=>
	(and
		(intendedPurpose ?Service ?Purpose)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Purpose))

(=>
	(and
		(intendedPurpose ?Service ?Purpose)
		(programRunning ?Process ?Service))
	(hasPurpose ?Process ?Purpose))

;; definition of requestedBy
(instance requestedBy AsymmetricRelation)
(domain requestedBy 1 WebService)
(domain requestedBy 2 Agent)
(documentation requestedBy "This predicate links the service to an Agent who requests the service.")

(=>
	(requestedBy ?Service ?Agent)
	(exists (?Request)
		(and
			(instance ?Request UserRequest)
			(effector ?Request ?Agent))))

;; definition of domainResource
(instance domainResource AsymmetricRelation)
(domain domainResource 1 WebService)
(domain domainResource 2 Formula)
(documentation domainResource "DomainResource are resources that are necessary for the task to be executed.They may include  computational resources such as bandwidth or disk space as well as more material resources consumed  when the service controls some machinery")

(=>
	(and
		(domainResource ?Service ?Resource)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Resource))


;; definition of serviceInput
(instance serviceInput AsymmetricRelation)
;; DWF: domain and range conflict with parent relation
;; (subrelation serviceInput precondition)
(domain serviceInput 1 WebService)
(domain serviceInput 2 Formula)
(documentation serviceInput
"An input specifies the information that the service requires to proceed with the computation. For  example, a book-selling service could require the credit card number and bibliographical information  of the book  to sell.")

(=>
	(and
		(serviceInput ?Service ?Input)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Input))

;; definition of serviceOutput
(instance serviceOutput AsymmetricRelation)
(domain serviceOutput 1 WebService)
(domain serviceOutput 2 Formula)
(documentation serviceOutput "An output specifies what is the result of the operation of the service.")

(=>
	(and
		(serviceOutput ?Service ?Output)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Output))

(=>
	(and
		(serviceOutput ?Service ?Output)
		(programRunning ?Process ?Service))
	(result ?Process ?Output))

;; definition of conditionalOutput
(instance conditionalOutput AsymmetricRelation)
(subrelation conditionalOutput output)
(domain conditionalOutput 1 WebService)
(domain conditionalOutput 2 Formula)


;; definition of servicePrecondition
(instance servicePrecondition AsymmetricRelation)
;; DWF: domain and range conflict with parent relation
;; (subrelation servicePrecondition precondition)
(domain servicePrecondition 1 WebService)
(domain servicePrecondition 2 Formula)
(documentation servicePrecondition "Preconditions present one or more logical conditions that should be satisfied prior to the service being requested")

(=>
	(and
		(servicePrecondition ?Service ?Formula)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Formula))

;; definition of accessCondition
(instance accessCondition AsymmetricRelation)
(domain accessCondition 1 WebService)
(domain accessCondition 2 Formula)
(documentation accessCondition
"Access conditions are conditions or restrictions that have to be satisfied prior to engaging the service.")

(=>
	(and
		(accessCondition ?Service ?Condition)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Condition))

(=>
	(and
		(accessCondition ?Service ?Condition)
		(instance ?Access AccessingAService)
		(destination ?Access ?Service))
	(precondition ?Access ?Condition))

;; definition of serviceEffect
(instance serviceEffect AsymmetricRelation)
(domain serviceEffect 1 WebService)
(domain serviceEffect 2 ComputerProcess)
(documentation serviceEffect "An effect is an event that is caused by the successful execution of a service.")

(=>
	(serviceEffect ?Service ?Effect)
	(effector ?Effect ?Service))

;; definition of conditionalEffect
(subrelation conditionalEffect serviceEffect)
(domain conditionalEffect 1 WebService)
(domain conditionalEffect 2 ComputerProcess)

;; definition of geographicRadius
(instance geographicRadius AsymmetricRelation)
(domain geographicRadius 1 WebService)
(domain geographicRadius 2 GeographicArea)
(documentation geographicRadius  "The Geographic Radius refers to the geographic scope of the	service.  This may be at the global or national scale (e.g. for ecommerce) or at a local scale (eg pizza delivery)")

;; definition of degreeOfQuality
(instance degreeOfQuality AsymmetricRelation)
;; DWF: domain conflicts with parent relation
;; (subrelation degreeOfQuality attribute)
(domain degreeOfQuality 1 WebService)
(domain degreeOfQuality 2 ServiceAttribute)
(documentation degreeOfQuality "DegreeOfQuality provide qualifications about the service.")

;; definition of ServiceAttribute
(subclass ServiceAttribute Attribute)

;; definition of CheapestService
(instance CheapestService ServiceAttribute)

;; definition of FastestService
(instance FastestService ServiceAttribute)

;; definition of averageResponseTime
;; DELETED -- it was broken.

;; definition of maxResponseTime
;; DELETED -- it was broken.

;; definition of communicationThru
(instance communicationThru AsymmetricRelation)
(domain communicationThru 1 WebService)
(domain communicationThru 2 Formula)
(documentation communicationThru "communicationThru is a property of a Service Profile.	This property provides high level information on how a service may communicate, such as the ACL (eg FIPA, KQML, SOAP etc).  This summarises the descriptions provided by the Service Grounding and are used when matching services; it is not intended to replace the	detail provided by the Service Grounding.")

(=>
	(and
		(communicationThru ?Service ?Formula)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Formula))


;; definition of serviceType
(instance serviceType AsymmetricRelation)
(domain serviceType 1 WebService)
(domainSubclass serviceType 2 WebService)
(documentation serviceType "The Service Type refers to a high level classification of the service, for example B2B, B2C etc")

;; definition of B2BService
(subclass B2BService WebService)

;; definition of B2CService
(subclass B2CService WebService)

;; definition of serviceProduct
(instance serviceProduct AsymmetricRelation)
(domain serviceProduct 1 WebService)
(domain serviceProduct 2 Artifact)

;; definition of qualityGuarantee
(instance qualityGuarantee AsymmetricRelation)
(domain qualityGuarantee 1 WebService)
(domain qualityGuarantee 2 Formula)
(documentation qualityGuarantee "QualityGuarantees are guarantees that the service promises to deliver, such as guaranteeing to provide the lowest possible interest rate, or a response within 3 minutes, etc.")

(=>
	(and
		(qualityGuarantee ?Service ?Promise)
		(presentsAProfile ?Profile ?Service))
	(subsumesContentInstance ?Profile ?Promise))

;; definition of qualityRating
(instance qualityRating AsymmetricRelation)
(domain qualityRating 1 WebService)
(domain qualityRating 2 ServiceRating)
(documentation qualityRating "The quality rating property represents an expandable list of rating RDF properties that may accompany a service profile. These ratings refer to industry accepted ratings, such as the Dun and Bradstreet Rating for businesses, or the Star rating for Hotels.")

;; definition of HotelStarRating
(subclass HotelStarRating ServiceRating)

;; definition of DAndBRating
(subclass DAndBRating ServiceRating)

;; definition of Advertisement
(subclass Advertisement ServiceProfile)
(documentation Advertisement "This class is a subclass of the service profile and represents the class that is used to advertise the service with other entities, such as middle agents")

;; definition of ServiceRequest
(subclass ServiceRequest UserRequest)
(documentation ServiceRequest "This class represents the class that is used to describe service requests")

(=>
	(instance ?Request ServiceRequest)
	(exists (?Service)
		(destination ?Request ?Service)))


;; definition of serviceLocation
(domain serviceLocation 1 WebService)
(domain serviceLocation 2 GeographicArea)
(documentation serviceLocation "This predicate limits the scope or availability of a service to some area")


;; Ontology of Processes


;; definition of ServiceProcess
(subclass ServiceProcess ComputerProcess)
(documentation ServiceProcess "A subclass of ComputerProcess which executes a WebService")

(=>
	(instance ?Process ServiceProcess)
	(exists (?Service)
		(and
			(instance ?Service WebService)
			(programRunning ?Process ?Service))))

;; definition of topLevelProcess
(subrelation topLevelProcess subProcess)
(domain topLevelProcess 1 ComputerProcess)
(domain topLevelProcess 2 ServiceProcess)

;; definition of processPrecondition
;; DWF: range conflicts with parent relation
;; (subrelation processPrecondition precondition)
(domain processPrecondition 1 ComputerProcess)
(domain processPrecondition 2 Formula)
(documentation processPrecondition "Process preconditions may include knowledge preconditions (agent knows credit card number) as well as world Precondition (baud rate > 56Kb)")

;; definition of processEffect
(instance processEffect AsymmetricRelation)
(domain processEffect 1 ComputerProcess)
(domain processEffect 2 Formula)
(documentation processEffect "(processEffect ?Process ?Effect) means that ?Effect describes the effects of the process")

(=>
	(and
		(processEffect ?Process ?EffectDescription)
		(represents ?EffectDescription ?Effect))
	(causes ?Process ?Effect))



;; The following temporal predicates can be replaced by the SUMO temporal predicates, as indicated by the'subrelation' relation or corresponding KIF formulas

;; definition of atTime
(subrelation atTime existant)
(domain atTime 1 ServiceProcess)
(domain atTime 2 TimePoint)
(documentation atTime "Time of an instantaneous Event")

;; definition of startTime
(instance startTime TemporalRelation)
(instance startTime AsymmetricRelation)
(domain startTime 1 ServiceProcess)
(domain startTime 2 TimePoint)
(documentation startTime "Start time for the Event")


(=>
	(startTime ?Process ?Point)
	(equal ?Point (BeginFn (WhenFn ?Process))))

;; definition of endTime
(instance endTime TemporalRelation)
(instance endTime AsymmetricRelation)
(domain endTime 1 ServiceProcess)
(domain endTime 2 TimePoint)
(documentation endTime "End time for the Event")

(=>
	(endTime ?Process ?Point)
	(equal ?Point (EndFn (WhenFn ?Process))))

;; the predicate 'during' can be replaced by SUMO constants 'duration' or 'WhenFn'.


;; Ontology of Composite Events

;; definition of CompositeProcess
(subclass CompositeProcess ServiceProcess)
(documentation CompositeProcess
"CompositeProcesses are complex events that have additional properties with respect to the ordering and conditional execution of individual events")

(=>
	(instance ?Process CompositeEvent)
	(exists (?Component)
		(processComponent ?Component ?Process)))

;; definition of processComponent
(subrelation processComponent subProcess)
(domain processComponent 1 ComputerProcess)
(domain processComponent 2 ServiceProcess)

;; definition of SequenceProcess
(subclass SequenceProcess CompositeProcess)
(documentation SequenceProcess "A list of processes to be done in order")

(=>
	(instance ?Process SequenceProcess)
	(forall (?Component1 ?Component2)
		(=>
			(and
				(processComponent ?Component1 ?Process)
				(processComponent ?Component2 ?Process)
				(equal ?Time1 (WhenFn ?Component1))
				(equal ?Time2 (WhenFn ?Component2)))
			(or
				(before (EndFn ?Time1) (BeginFn ?Time2))
				(before (EndFn ?Time2) (BeginFn ?Time1))))))

;; definition of SplitProcess
(subclass SplitProcess CompositeProcess)
(documentation SplitProcess "The components of a Split process are a bag of subprocesses to be executed concurrently")

(=>
	(instance ?Process SplitProcess)
	(forall (?Component1 ?Component2)
		(=>
			(and
				(processComponent ?Component1 ?Process)
				(processComponent ?Component2 ?Process)
				(equal ?Time1 (WhenFn ?Component1))
				(equal ?Time2 (WhenFn ?Component2)))
			(overlapsTemporally ?Time1 ?Time2))))


;; constants from Financial Ontology

;; definition of agreementMember
(instance agreementMember BinaryRelation)
(domain agreementMember 1 Agreement)
(domain agreementMember 2 Agent)
(documentation agreementMember "(agreementMember ?Agreement ?Agent) means that ?Agent is one of the participants of the Agreement")


;; constants from QoS ontology

;; definition of ComputationalSystem
(subclass ComputationalSystem Artifact)
(documentation ComputationalSystem "Instances of ComputationalSystems include instances of SoftwareSystems, HardwareSystems, and ComputerNetworks")


;; definition of Server
(subclass Server ComputationalSystem)
(documentation Server "A computer in a network shared by multiple users. The term may refer to both the hardware and software or just the software that performs the service.")


;;definition of ComputerProcess
(subclass ComputerProcess Process)
(documentation ComputerProcess "An instance of ComputerProcess is a process which manipulates data in the computer")


;; definition of programRunning
(domain programRunning 1 ComputerProcess)
(domain programRunning 2 ComputerProgram)
(documentation programRunning
"(programRunning ?Process ?Program) means that the ComputerProcess ?Process is executing the ComputerProgram ?Program")


;;definition of responseTime
(instance responseTime BinaryRelation)
(domain responseTime 1 UserRequest)
(domain responseTime 2 TimeInterval)
(documentation responseTime "The time it takes for the computer to comply with a user's request, such as looking up a customer record.")


;; definition of UserRequest
(subclass UserRequest ComputerProcess)
(documentation UserRequest "A request made by a ComputerUser, such as looking up a customer record")

(=>
	(instance ?Request UserRequest)
	(exists (?User)
		(and
			(instance ?User ComputerUser)
			(effector ?Request ?User))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Additional service ontology
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Below are concepts found in the DAML-S specs but which do not occur in SUMO nor in Olga Babko-Malaya's file OntologyOfServices.txt.

(subclass StarRating ServiceRating)

(subclass Identifier SymbolicString)

;;definition of serviceParameter
(documentation serviceParameter "An expandable list of RDF properties that may accompany a profile description.")
(instance serviceParameter AsymmetricRelation)
(domain serviceParameter 1 ServiceProfile)
(domain serviceParameter 2 Entity)

(subrelation maxResponseTime serviceParameter)
(subrelation averageResponseTime serviceParameter)

;;definition of serviceCategory
(documentation serviceCategory "The Service Category refers to an ontology of services that may be on offer. High level services may include: Products, Problem Solving Capabilities, Commercial Services, Information, etc.")
(subrelation serviceCategory AsymmetricRelation)
(domain serviceCategory 1 ServiceProfile)
(domain serviceCategory 2 Entity)

;;definition of serviceName
(documentation serviceName "A  relation between  instances of the class ServiceProvider and the name(s) of a service.")
(instance serviceName AsymmetricRelation)
(domain serviceName 1 ServiceProvider)
(domain serviceName 2 ServiceName)
(subclass ServiceName Identifier)

(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?NAME )
		(name  ?SERVICE ?NAME    )))

;;definition of serviceFax
(documentation serviceFax "A relation between  instances of the class ServiceProvider and the fax number(s) of a service.")
(instance serviceFax AsymmetricRelation)
(domain serviceFax 1 ServiceProvider)
(domain serviceFax 2 ServiceFax)
(subclass ServiceFAX Identifier)
(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?FAX )
		(fax  ?SERVICE ?FAX    )))

;;definition of serviceEmail
(documentation serviceEmail "A  relation between  instances of the class ServiceProvider and the email address(es) of a service.")
(instance serviceEmail AsymmetricRelation)
(domain serviceEmail 1 ServiceProvider)
(domain serviceEmail 2 ServiceEmail)
(subclass ServiceEmail Identifier)

(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?EMAIL )
		(email  ?SERVICE ?EMAIL    )))

;;definition of serviceAddress
(documentation serviceAddress "A  relation between  instances of the class ServiceProvider and the postal address(es) of a service.")
(instance serviceAddress AsymmetricRelation)
(domain serviceAddress 1 ServiceProvider)
(range serviceAddress ServiceAddress)
(subclass ServiceAddress Identifier)

(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?ADDRESS )
		(physicalAddress  ?SERVICE ?ADDRESS    )))

;;definition of servicePhone
(documentation servicePhone "A  relation between  instances of the class ServiceProvider and the phone number(s) of a service.")
(instance servicePhone AsymmetricRelation)
(domain servicePhone 1 ServiceProvider)
(domain servicePhone 2 ServicePhoneNumber)
(subclass ServicePhone Identifier)
(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?PHONE )
		(phone  ?SERVICE ?PHONE    )))

;;definition of serviceWebUrl
(documentation serviceWebUrl "A  relation between  instances of the class ServiceProvider and the webUrl(s) of a service.")
(instance serviceWebUrl AsymmetricRelation)
(domain serviceWebUrl 1 ServiceProvider)
(domain serviceWebUrl 2 ServiceWebUrl)
(subclass ServiceWebURL Identifier)

(=>
	(instance ?SERVICE ServiceProvider)
	(exists (?WEBURL)
		(webURL ?SERVICE ?WEBURL  )))



(documentation ProcessControlStatus "The set of process control statuses.")
(subclass ProcessControlStatus Formula)
(instance OnGoing ProcessControlStatus)
(instance Aborted ProcessControlStatus)
(instance Suspended ProcessControlStatus)
(instance Cancelled ProcessControlStatus)
(instance Completed ProcessControlStatus)

;;definition of controlStatus
;;(documentation controlStatus)
(instance controlStatus AsymmetricRelation)
(domain controlStatus 1 Process)
(domain controlStatus 2 ProcessControlStatus)

(=>
	(instance ?PROCESS Process)
	(exists (?STATUS)
		(currentStatus ?PROCESS ?STATUS  )))

;;From the Merge ontology
  (instance inverse SymmetricRelation)
  (domain inverse 1 BinaryRelation)
  (domain inverse 2 BinaryRelation)
  (documentation inverse "The inverse of a &%BinaryRelation is a relation in which all the tuples of the original relation are reversed. In other words, one &%BinaryRelation is the inverse of another if they are equivalent when their arguments are swapped.")

;;definition of some inverse relations for DAML-S
(inverse describesAModel serviceIsDescribedByModel)
(inverse presentsAProfile profileIsPresentedByService)
(inverse supportsAGrounding groundingSupportsService)
(inverse providesAService isProvidedByService)

;;definition of processParticipant
(documentation processParticipant "A (process) participant is a type of parameter and outputs are properties of events. The top level ontology doesn't restrict them at all. A participant can be any kind of daml object (Thing).  Specific events will specialize this property by restricting the range to types of agents, objects, entities, etc.")
(instance processParticipant AsymmetricRelation)
(subrelation processParticipant processParameter)
(domain processParticipant 1 ComputerProcess)
(domain processParticipant 2 Entity)

;;definition of processInput
(documentation processInput "An input is a type of parameter and are properties of events. The top level ontology doesn't restrict them at all. An input can be any kind of daml object (Thing).  Specific events will specialize this property by restricting the range appropriately; such as required inputs, derivable inputs, etc.")
(instance processInput AsymmetricRelation)
(subrelation processInput processParameter)

(domain processInput 1 ComputerProcess)
(domain processInput 2 Entity)

;;definition of processOutput
(documentation processOutput "An output is a type of parameter and outputs are properties of events. The top level ontology doesn't restrict them at all. An output can be any kind of daml object (Thing).  Specific events will specialize this property by restricting the range.")
(instance processOutput AsymmetricRelation)
(subrelation processOutput processParameter)
(domain processOutput 1 ComputerProcess)
(domain processOutput 2 Entity)

;;definition of processName
(documentation processName "Processes have a name, parameter, precondition, and effect.")
(instance processName AsymmetricRelation)
(domain processName 1 ComputerProcess)
(domain processName 2 Formula)


;;definition of serviceTextDescription
(documentation serviceTextDescription "The relation between a service and a text which describes the service." )
(instance serviceTextDescription AsymmetricRelation)
(domain serviceTextDescription 1 ServiceName)
(domain serviceTextDescription 2 TextDescription)

(=>
	(instance ?SERVICE ServiceName)
	(exists (?TEXT)
		(serviceTextDescription ?SERVICE ?TEXT  )))

;;definition of the class TextDescription
(documentation TextDescription "The TextDescription provides a briefdescription of the service. This would typically appear within an advertisement to summarise what the service offers, or within a request to describe what is being requested.")
(subclass TextDescription Text)

;;definition of role
(documentation role "This property links the service profile to a ServiceActor. The ServiceActor is the entity that provides the service or makes the request.  See the description of ServiceActor. Different roles can be subpropertied from the property role to portray specific roles.")
(instance role AsymmetricRelation)
(domain role 1 ServiceProfile)
(domain role 2 ServiceActor)

(=> (instance ?PROCESS UsingAService)(exists ?ROLE (role ?PROCESS ?ROLE)))

(documentation ServiceActor "The class of service users and service providers.")
(equal ServiceActor (UnionFn ServiceProvider ServiceUser))

;;The definitions which follow pertain to the DAML-S notions of sequence.
;;definition of the class Sequence
(documentation Sequence "The class of functions whose domain is a subclass of the natural numbers")
(subclass Sequence UnaryFunction)

;;Axioms
(<=> (instance ?SEQ Sequence) (and (instance ?SEQ UnaryFunction) (subclass (DomainFn ?SEQ) Integer) (subclass (RangeFn ?SEQ) Entity)))

(=> (instance ?SEQ Sequence) (exists ?REL (and (equal (DomainFn ?REL) (RangeFn ?SEQ)) (forall (?X ?Y ?M ?N) (=> (and (instance ?X (RangeFn ?SEQ)) (instance ?Y (RangeFn ?SEQ)) (instance ?N Integer) (instance ?M Integer) (equal (AssignmentFn ?SEQ ?N) ?X) (equal (AssignmentFn ?SEQ ?M) ?Y) ) (<=> (holds ?REL ?X ?Y) (lessThan ?N ?M) ) ) ) ) ) )

(=> (holds ?REL ?X ?Y) (exists ?SEQ (and(instance ?SEQ Sequence) (equal (IthMemberOfSeq ?SEQ 1) ?X) (equal (IthMemberOfSeq ?SEQ 2) ?Y) (equal (LengthOfSeq ?SEQ) 2))))

(=>(instance ?SEQ Sequence)(exists ?CLASS(<=> (instance ?X ?CLASS)(exists ?INT (equal ?X (ithMemberOfSeq ?SEQ ?INT))))))

;;LengthOfSeqFn
(documentation LengthOfSeqFn "The function which returns the length of an input sequence.")
(instance LengthOfSeqFn UnaryFunction)
(domain LengthOfSeqFn 1 Sequence)
(range LengthOfSeqFn Integer)

;;Axioms
(equal (LengthOfSeqFn NullSeq) 0)
(=> (and (instance ?SEQ Sequence)(not (equal ?SEQ NullSeq))(equal(CardinalityFn (DomainFn ?SEQ)) ?N))(equal(LengthOfSeqFn ?SEQ) ?N))

;;HeadOfSeqFn
(documentation HeadOfSeqFn "A function which returns, for an input sequence S, that sequence which consists of the first member of the sequence S, if it exists, or the NullSet if the sequence is the NullSequence.")
(instance HeadOfSeqFn UnaryFunction)
(domain HeadOfSeqFn 1 Sequence)
(range HeadOfSeqFn Sequence)

;;Axioms
(equal (InitialMemberSeqFn NullSeq) NullSet)
(=> (and (instance ?SEQ Seqence)(equal (CardinalityFn ?SEQ) 1)) (equal (HeadOfSeqFn ?SEQ) ?SEQ))


;;TailOfSeqFn
(documentation TailOfSeqFn "A function which returns, for an input sequence S, that sequence which results from S after removing S's first element, if the length of S is greater than 1. If the length of S is 1 or 0, then this function returns the NullSeq.")
(instance TailOfSeqFn UnaryFunction)
(domain TailOfSeqFn 1 Sequence)
(range TailOfSeqFn Sequence)

;;ReverseSeqFn
(documentation ReverseSeqFn "A function which returns the result of reversing the order of elements of a sequence.")
(instance ReverseSeqFn UnaryFunction)
(domain ReverseSeqFn 1 Sequence)
(range ReverseSeqFn Sequence)


;;IthMemberOfSeqFn
(documentation IthMemberOfSeqFn "This function returns the Ith member of a sequence S, where I is an integer and I is greater than 0 and less than or equal to the length of S. If I is 0 or is greater than the length of S, or if S is the NullSeq, then this function returns the null set.")
(instance IthMemberOfSeqFn BinaryFunction)
(domain IthMemberOfSeqFn 1 Sequence)
(domain IthMemberOfSeqFn 2 Integer)
(range IthMemberOfSeqFn Entity)

;;Axioms
(=> (and (equal (LengthOfSeqFn ?SEQ) ?N)(greaterThan ?M ?N)) (equal (IthMemberOfSeqFn ?M ?SEQ) NullSet))
(=> (equal (LengthOfSeqFn ?SEQ) 0)(equal (IthMemberOfSeqFn ?M ?SEQ) NullSeq))


;;ConcatSeqFn
(documentation ConcatSeqFn "This function, which takes as input two sequences, S1 and S2, in that order, returns the concatenation of the sequences, in the order S1^S2.")
(instance ConcatSeqFn BinaryFunction)
(domain ConcatSeqFn 1 Sequence)
(domain ConcatSeqFn 2 Sequence)
(range ConcatSeqFn Sequence)


;;NullSeq
(documentation NullSeq "The null sequence, which has length 0.")
(instance NullSeq Sequence)
(equal (LengthOfSeqFn NullSeq) 0)

;;OneToOneUnaryFunction
(documentation OneToOneUnaryFunction "The class of functions which are one to one; i.e., a function F is one to one if and only if for all X, Y in the domain of F, if X is not identical to Y, then F(X) is not identical to F(Y).")
(subclass OneToOneUnaryFunction UnaryFunction)

;;Axioms
(<=> (instance ?FUN OneToOneUnaryFunction) (and (instance ?FUN Function) (forall (?X ?Y) (=> (and (instance ?X (DomainFn ?FUN)) (instance ?Y (DomainFn ?FUN)) (not (equal ?X ?Y))) (not (equal ((AssignmentFn ?FUN) ?X) ((AssignmentFn ?FUN) ?Y)))))))


;;homomorphism
(documentation homomorphism "A function, FUN, defines a homomophism between two relations, REL1 and REL2, if and only if, for all X and Y, if REL1(X,Y) then  REL2(FUN(X),FUN(Y)).")
(domain homomorphism 1 Function)
(domain homomorphism 2 Relation)
(domain homomorphism 3 Relation)
(<=>(homomorphism ?FUN ?REL1 ?REL2) (=>(holds ?REL1 ?X ?Y)(holds ?REL2 ((AssignmentFn ?FUN) ?X) ((AssignmentFn ?FUN ?Y)))))

;;isomorphism
(documentation isomorphism "A function, FUN, defines a homomophism between two relations, REL1 and REL2, if and only if, for all X and Y, REL1(X,Y) if and only if REL2(FUN(X),FUN(Y)).")
(domain isomorphism 1 Function)
(domain isomorphism 2 Relation)
(domain isomorphism 3 Relation)
(<=>(isomorphism ?FUN ?REL1 ?REL2) (<=>(holds ?REL1 ?X ?Y)(holds ?REL2 ((AssignmentFn ?FUN) ?X) ((AssignmentFn ?FUN ?Y)))))

;;MaxSeqFn
(documentation MaxSeqFn "This function returns the maximum element of a sequence of integers.")
(instance MaxSeqFn UnaryFunction)
(domain MaxSeqFn 1 Sequence)
(range MaxSeqFn Integer)

;;MinSeqFn
(documentation MinSeqFn "This function returns the minimum value of a sequence of integers.")
(instance MinSeqFn UnaryFunction)
(domain MinSeqFn 1 Sequence)
(range MinimumFn Integer)


;;Pairing axiom
(=>(holds ?REL ?X ?Y)(exists ?CLASS(and (instance ?CLASS Class)(instance ?X Class)(instance ?Y Class) (forall ?Z (<=>(instance ?Z ?CLASS)(or (equal ?Z ?Z)(equal ?Z ?Y)))))))