;;; -*- Mode: LISP; Syntax: Common-Lisp; Package: CYC-SENSUS; Base: 10. -*-


(DEFPACKAGE "CYC-SENSUS" (:NICKNAMES "CYC") (:USE "LOOM" "COMMON-LISP") (:SHADOW "INSTANCE")
            (:SHADOWING-IMPORT-FROM "KBCLASSES" "TRUE" "FALSE" "UNKNOWN")
            (:SHADOWING-IMPORT-FROM "COMMON-LISP" "WHEN" "DO" "APPEND")
            (:SHADOWING-IMPORT-FROM "LOOM" "DEFMETHOD" "COPY-INSTANCE" "FOR" "IN" "ON" "BY" "COLLECT" "ALWAYS"
             "THEREIS" "NEVER" "TRACE" "UNTRACE" "FIND-METHOD" "SUBSET" "PI" "CONSTANT" "SET" "PATTERN" "ROLE")
            (:IMPORT-FROM "COMMON-LISP-USER" "*LOOM-DEFAULT-FEATURES*")
            (:IMPORT-FROM "KBCLASSES" "SHOW" "LIST-OF" "SHOW-ALL"))

(in-package "CYC-SENSUS")

;;;       Context:   CYC-SENSUS
;;; Last Saved On:    01/23/2003 15:16:43
;;;    Written By:    

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)
          #-:CLTL2(LOAD EVAL COMPILE)
 (defparameter savedContext (current-context))
 (defparameter savedCreationPolicy nil))
#+(or :loom3 loom4) (defparameter savedAutoAdvance loom::*automatically-advance-state-p*)
(defparameter savedLoomFeatures (LIST-FEATURES :dont-display-p T))

(SET-FEATURES :allow-duplicate-creates)
(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)
          #-:CLTL2(LOAD EVAL COMPILE)
 (defcontext CYC-SENSUS :THEORY (LOOM::BUILT-IN-THEORY)
    :open-closed-mode :OPEN
   :monotonic-p NIL ))
(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 0
          #-:CLTL2(LOAD EVAL COMPILE)
(change-context 'CYC-SENSUS)
(setf savedCreationPolicy (creation-policy))
(creation-policy :LITE-INSTANCE)


)    ; END EVAL-WHEN 0

;;; Terminological Definitions:

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 1
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 AREA)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 CARDINALITY)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 CAUSAL-RELATION)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 CAUSE-EFFECT)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 CONTAINED)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 DISTANCE)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 ELEMENT)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 ELEMENT-OF)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 GENERALIZED-POSSESSION)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 LESS-THAN-COMPARISON)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 LINEAR-SIZE)|
  :arity 2
  :domain |Thing|
  :range |Distance|
  :annotations ( |Thing|
     |PhysicalAmountSlot|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 LOCATING)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 NOTCONTAINED)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 OWNED-BY)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 SIZE-PROPERTY-ASCRIPTION)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |PhysicalAmountSlot|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 SOURCE-DESTINATION)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 SPATIAL-LOCATING)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 SUBJECT-MATTER)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |(MeaningInSystemFn SENSUS-Information1997 TEMPORAL-NONINCLUSIVE)|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |Thing|
     |BinaryPredicate|)
)
(defrelation |abnormal|
  :arity 2
  :domain |CycSystemList|
  :range |Assertion|
  :annotations ( |BinaryPredicate|
     |DefaultMonotonicPredicate|
     (DOCUMENTATION "Every default rule in our system

  P(x1,...,xn) => Q(x1,...,xn)

is implicitly treated as

  (not(abnormal(x1,...,xn)) and P(x1,...,xn) => Q(x1,...,xn)

This allows rules without exceptions to never have to incur the
overhead of default reasoning.

Exceptions to rules are written like so:

  (#$exceptWhen R(x1,...,xn) Rule001)

and get canonicalized into rules concluding abnormal like so:

  R(x1,...,xn) => (#$abnormal(x1,....,xn) Rule001)

Since a different 'abnormality' predicte is needed for every default
rule in the system, we instead handle this uniqueness requirement by
having a single #$abnormal predicate which takes the rule in question
as an argument.

Also, the variables over which abnormality is computed is given as a
single list.  This allows #$abnormal to be binary rather than
arbitrary arity. "))
)
(defrelation |above-Directly|
  :arity 2
  :is-primitive |above-Generally|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |PhysicalFeatureDescribingPredicate|
     (DOCUMENTATION "(#$above-Directly ABOVE BELOW) means either (1) the volumetric center of ABOVE is directly above some point of BELOW, if ABOVE is smaller than BELOW; or (2) otherwise, it means that some point of ABOVE is directly above the volumetric center of BELOW."))
)
(defrelation |above-Generally|
  :arity 2
  :is-primitive |above-Higher|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |PhysicalFeatureDescribingPredicate|
     (DOCUMENTATION "(#$above-Higher OBJ1 OBJ2)
means that OBJ1 is more or less above OBJ2. To be more 
precise: if OBJ1 would be within a cone-shaped set of 
vectors within about 45 degrees of #$Up-Directly 
pointing up from OBJ2 (see #$Up-Generally), then 
(#$above-Higher OBJ1 OBJ2). This
is a wider predicate than #$above-Directly, but narrower
than #$above-Higher. It probably most closely conforms to
the English word 'above.'"))
)
(defrelation |above-Higher|
  :arity 2
  :is-primitive |cotemporal|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$above-Higher ?OBJ-A ?OBJ-B) means that ?OBJ-A is ``higher up'' than ?OBJ-B.  Since most contexts are terrestrial (see #$TerrestrialFrameOfReferenceMt) ``higher up'' typically means that the #$altitudeAboveGround of ?OBJ-A is greater than that of ?OBJ-B."))
)
(defrelation |above-Overhead|
  :arity 2
  :is-primitive (:and |above-Directly| |above-Generally|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$above-Overhead ABOVE BELOW) means that ABOVE is directly above BELOW, all points of ABOVE are higher than all points of BELOW, and they do NOT touch.  Examples: a bomb falling directly above a bunker; a street lamp shining directly above a person standing below."))
)
(defrelation |above-Touching|
  :arity 2
  :is-primitive (:and |touches| |above-Generally| |above-Directly|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "(#$above-Touching ABOVE BELOW) means that ABOVE is located over BELOW and they are touching.  More precisely, it implies both (#$above-Directly ABOVE BELOW) and that ABOVE #$touches BELOW.  Examples: a person sitting on a chair; coffee in a cup; a boat on water; a hat on a head. (Note that not every point of ABOVE must be higher than every point of BELOW.)"))
)
(defrelation |AbsoluteValueFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$AbsoluteValueFn is the unary mathematical function that returns the absolute value of its argument; e.g., (#$AbsoluteValueFn -2) returns 2, and (#$AbsoluteValueFn 2) returns 2."))
)
(defrelation |accountAdministrator|
  :arity 2
  :domain |Account|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$accountAdministrator identifies the agent who administers a particular account.  (#$accountAdministrator ACCT AGENT) means that the #$Account ACCT is administered by the individual or organization AGENT."))
)
(defrelation |accountBalance|
  :arity 2
  :domain |FinancialAccount|
  :range |Money|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$accountBalance is used to indicate the balance of a particular account.  (#$accountBalance ACCT BAL) means that the #$FinancialAccount ACCT has the balance BAL; BAL is the amount of #$Money either owed by, or available to, the #$accountHolder (depending upon the type of account)."))
)
(defrelation |accountHolder|
  :arity 2
  :domain |Account|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$accountHolder identifies the holder of a particular account.  (#$accountHolder ACCT AGENT) means that the #$Account ACCT is held by the individual or organization AGENT; thus, money (or some other valuable) is owed to or from AGENT, in the amount shown in the account (see #$accountBalance)."))
)
(defrelation |accountStatus|
  :arity 2
  :domain |Account|
  :range |AccountStatusAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$accountStatus indicates whether a particular account is paid up, overdue, delinquent, etc.  (#$accountStatus ACCT STATUS) means that the #$Account ACCT has the attribute STATUS (see also #$AccountStatusAttribute)."))
)
(defrelation |acknowledgedAct|
  :arity 2
  :is-primitive |startsAfterEndingOf|
  :domain |Acknowledging-CommunicationAct|
  :range |CommunicationAct-Single|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$acknowledgedAct ?ACKACT ?COMACT) means that the #$CommunicationAct-Single ?COMACT is acknowledged and replied-to by the responsive #$Acknowledging-CommunicationAct ?ACKACT.   Particular acceptances or rejections of a particular project proposal would involve examples of this predicate, as would a person responding to a wedding invitation, or a court responding to a motion.  See also #$responseTo which refers to the abstarct content of the communication."))
)
(defrelation |acquaintances|
  :arity 3
  :domains (|Person| |Agent|)
  :range |AcquaintanceAttribute|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$acquaintances X Y HOW) means that X is acquainted with Y,  at least in the way (and/or to the degree) specified by HOW.  Note that Y must be an #$Agent, so this is not the predicate to use to express the fact that Fred `is acquainted with' drag racing.  Note that, depending on the value for HOW, there may or may not be some way in which Y is acquainted with X.  E.g., (#$acquaintances #$Lenat Madonna #$TrueFanAcquaintance) but there is no Z such that (#$acquaintances Madonna #$Lenat Z).
Note that X and Y should rarely be instances of #$Entity.  In fact, Doug has only been acqainted with Madonna since 1983, so we should write (#$holdsIn (#$TimeIntervalFromFn (#$YearFn 1983) #$Now) (#$acquaintances #$Lenat Madonna #$TrueFanAcquaintance))."))
)
(defrelation |acquaintedWith|
  :arity 2
  :is-primitive |cotemporal|
  :domain |IndividualAgent|
  :range |IndividualAgent|
  :annotations ( |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$acquaintedWith AGENT1 AGENT2) means the #$IndividualAgent AGENT1 is acquainted with the #$IndividualAgent AGENT2 (in the minimal sense that AGENT1 has come into physical or conversational contact with AGENT2, or that they have somehow knowingly communicated with each other).  This typically means that each #$IndividualAgent is aware of some facts about the other.  In cases where one of the #$IndividualAgents is sentient, this typically includes the ability of this agent to recognize the other by appearance, voice, scent, or some other physical attribute."))
)
(defrelation |actionExpressesFeeling|
  :arity 2
  :domain |Action|
  :range (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$actionExpressesFeeling ACT EMOTYPE) means that the particular action ACT expresses the doer's feeling of EMOTYPE.
Note: additional complications arise in using this in inference, as people can `fake' actions such as laughing, crying, etc., to mislead other people."))
)
(defrelation |actorCapacity|
  :arity 3
  :domains (|SomethingExisting| |Situation|)
  :range |CapacityAttribute|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$actorCapacity is used to indicate the capacity in which some entity participates in a particular event or situation.  (#$actorCapacity ENTITY SIT CAP) means that ENTITY has an (unspecified) role in SIT with the #$CapacityAttribute CAP.  An important use of #$actorCapacity is with the capacity attributes #$MainFunction or #$IntendedFunction to state that a device is serving its #$primaryFunction or intended function (i.e., #$intendedBehaviorCapable) in a certain situation."))
)
(defrelation |actorPartsAffected|
  :arity 2
  :is-primitive (:and |objectActedOn| |nonDeliberateActors|)
  :domain |Event|
  :range (:AND |AnimalBodyPart| |OrganismPart|)
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$actorPartsAffected ACT PART) means that PART is an #$objectActedOn in ACT, and it is one of the #$anatomicalParts of the organism which is #$bodilyActedOn in ACT.  For example, during a man's morning shave, his #$Beard is an #$actorPartsAffected, but the hand with which he shaves is not, because his beard is changed, but his hand is not changed (`acted on') in any significant way."))
)
(defrelation |actorPartsInvolved|
  :arity 2
  :is-primitive (:and |preActors| |nonDeliberateActors|)
  :domain |Event|
  :range |OrganismPart|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$actorPartsInvolved ACT PART) means that PART is one of the #$anatomicalParts of an organism who has an active role in the event ACT, and, moreover, that PART is somehow involved in the action.  Note that the organism to which PART belongs either performs or does ACT; it is not merely an #$objectActedOn.  Some examples of #$actorPartsInvolved  include: the eyes of someone who is sneezing (or crying); the left foot of someone playing in a football game; the right hand of someone who is shaking hands; the claws of a cat who is scratching someone.  As a negative example, consider your hair while you are getting a haircut.  It is not an #$actorPartsInvolved, because you are passive in that event; it is, though, an #$actorPartsAffected in that event."))
)
(defrelation |actors|
  :arity 2
  :is-primitive |temporallyIntersects|
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$actors is the most general instance of #$ActorSlot.  All other actor slots are specializations of this predicate.  Thus, #$actors is a broad concept which includes any entity which is involved in an action.  (#$actors EVENT ACTOR) means that ACTOR is somehow meaningfully (directly or indirectly) involved in EVENT during EVENT.  Mere cotemporality of objects (somewhere in the universe) with a particular event is not enough `involvement' to make those objects #$actors of that event.  Nor is a representation of an event among the #$actors of that event, unless the representation affects the event."))
)
(defrelation |actsInCapacity|
  :arity 4
  :domains (|Agent| |ActorSlot| |ScriptType|)
  :range |CapacityAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "The predicate #$actsInCapacity indicates the capacity in which an agent participates in certain kinds of actions.  (#$actsInCapacity AGENT ROLE SCRIPT-TYPE CAP) means that the agent AGENT plays the role ROLE in instances of SCRIPT-TYPE, and s/he does that role in the capacity CAP.  CAP is a #$CapacityAttribute (q.v.) which describes the AGENT's mode of participation--e.g., as a job, hobby, main function, support function, etc.  Contrast three cases of acts of #$GreetingSomeone, when #$performedBy: (1) instances of #$Receptionist, in their #$JobCapacity and as their #$MainFunction; (2) instances of #$FlightAttendant, in their #$JobCapacity but as a #$SupportFunction; and (3) instances of #$TrainEngineer, in a #$HobbyCapacity (though they do it while working, it's not part of their job)."))
)
(defrelation |addressText|
  :arity 2
  :domain |ContactLocation|
  :range |Address-LocationDesignator|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "The predicate #$addressText maps a particular element of #$ContactLocation to its #$Address-LocationDesignator, ADDRESS.  (#$addressText LOC ADDRESS) means that the #$ContactLocation LOC has the address ADDRESS.  For example, the #$addressText of the Cycorp #$MailingLocation is `Cycorp, 3721 Executive Center Dr., Ste. 100, Austin, TX 78731-1615.'  See also #$ContactLocation."))
)
(defrelation |adjacentPathsAtJunction|
  :arity 2
  :is-primitive (:and |connectedTo| |physicalDecompositions| |cotemporal| |onPath-Generic|)
  :domain |JunctionOfPaths|
  :range |Path-Generic|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(adjacentPathsAtJunction JUNCT PATH) means that the #$JunctionOfPaths JUNCT has PATH as one of the paths joining it. A junction may connect many paths (it must connect more than one), and a path may pass through many junctions, and may end at a junction.  Examples: all the streets meeting at a certain intersection, or the particular trachea and both primary bronchi meeting at  the #$TracheobronchialJunction between a certain person's lungs.  Within a specified #$PathSystem, a node is the end of all the links to that node; this is established with #$linkBetweenInSystem or #$pathBetweenInSystem."))
)
(defrelation |adjacentTo|
  :arity 2
  :is-primitive |touches|
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |InterExistingObjectSlot|
     |SymmetricBinaryPredicate|
     |PhysicalFeatureDescribingPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "arg1 and arg2 are touching such that their region of contact is a line (i.e. not a point).  Also arg1 is neither above nor below arg2."))
)
(defrelation |affiliatedWith|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Agent|
  :range |Agent|
  :annotations ( |CotemporalObjectsSlot|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$affiliatedWith AGENT1 AGENT2) means #$Agents AGENT1 and AGENT2 are somehow affiliated.  This is a broad relation, but it involves at least the voluntary entry into an understood relationship, with rights and obligations, by at least one of the affiliated #$Agents; i.e., they may be business partners, kin, employer/employee, one (say a person) may be a member of the other (say an organization), parent-company/subsidiary, etc."))
)
(defrelation |after|
  :arity 2
  :domain |TimePoint|
  :range |TimePoint|
  :annotations ( |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |PrimitiveTemporalRelation|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$after ?X ?Y) means #$TimePoint ?X is after (occurs later in time than) #$TimePoint ?Y.   
Note:  Individual #$TimePoints are seldom mentioned in axioms; rather, the axiom is likely to use some #$ComplexTemporalRelation, such as #$startsAfterEndingOf, which holds between two #$TemporalThing.   These #$ComplexTemporalRelations are themselves usually defined in terms of #$PrimitiveTemporalRelations, such as #$after and #$simultaneousWith, which relate one #$TimePoint to another."))
)
(defrelation |afterAdding|
  :arity 2
  :domain |Predicate|
  :range |CycSystemSymbol|
  :annotations ( |BinaryPredicate|
     |InferenceRelatedBookkeepingPredicate|
     (DOCUMENTATION "Whenever a source is added to a gaf use of a predicate, each of that predicate's #$afterAdding functions is called on that source."))
)
(defrelation |afterRemoving|
  :arity 2
  :domain |Predicate|
  :range |CycSystemSymbol|
  :annotations ( |BinaryPredicate|
     |InferenceRelatedBookkeepingPredicate|
     (DOCUMENTATION "Whenever a source is removed from a gaf use of a predicate, each of that predicate's #$afterRemoving functions is called on that source."))
)
(defrelation |age|
  :arity 2
  :domain |SomethingExisting|
  :range |Time-Quantity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(age THING TIME) means that the thing THING
has the age TIME, where thing can be a person, a galaxy, or
anything else with temporal extent, e.g., (age MaryShepherd 
       (YearsDuration 40)). The previous assertion is not quite right, however:
notice that one can talk about the #$birthDate of a person quite safely, but whenever one makes a statement about the AGE of a person that statement will only be true `for a while' -- i.e., in some temporal context.  Therefore it would be a mistake to simply assert to Cyc that (#$age #$Lenat (#$YearsDuration 45)), because that would be true in some contexts and false in others.  So what one does is to assert an expression of the form  (#$holdsIn ?X (#$age ?Y ?Z)) to indicate that during time interval ?X, the thing ?Y has age ?Z.  For example, (#$holdsIn (#$QuarterFn 2 (#$YearFn 1996)) (#$age #$Lenat (#$YearsDuration 45)), which means that Doug is a 45-year-old during the entire second quarter of 1996.  It is seldom correct to use #$age outside of some temporal qualification."))
)
(defrelation |agreeingAgents|
  :arity 2
  :domain |Agreement|
  :range |Agent|
  :annotations ( |InterActorSlot|
     (DOCUMENTATION "The predicate #$agreeingAgents relates a particular agreement to the agents who are making the agreement.  (#$agreeingAgents AGR PARTY) means that the #$Agreement AGR has the #$Agent PARTY among its agreeing parties.  #$agreeingAgents may have specialized roles, such as #$agreeingBuyer or #$agreeingSeller, #$insuringAgent or #$policyHolder, #$employedAgent or #$employingAgent.  The #$agreeingAgents will be mentioned in their agreement."))
)
(defrelation |agreementForbids|
  :arity 3
  :domains (|Agreement| |Agent|)
  :range |ScriptType|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$agreementForbids is used to indicate types of actions that a particular agent is forbidden from performing under the terms of a particular agreement.  (#$agreementForbids AGR AGENT ACT-TYPE) means that the #$Agreement AGR forbids the #$Agent AGENT from ACT-TYPE activities.  For example, an instance of #$PeaceAccord #$agreementForbids the governments who signed it from #$WagingWar against one another; or, a business contract may forbid one agent from competing with another after s/he sells rights to a product, design, or practice to the second agent."))
)
(defrelation |agreementPeriod|
  :arity 2
  :domain |Agreement|
  :range |TimeInterval|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$agreementPeriod is used to indicate the period of time during which a particular agreement is in force.  (#$agreementPeriod AGR TIME) means that the #$Agreement AGR holds during the #$TimeInterval TIME; i.e., TIME is the period during which the assertions made in AGR are supposed to be true.  TIME may or may not begin at the moment that AGR is created; e.g., I may sign an employment contract on the very day I begin working or several weeks before, to begin on a specified future date.  Or an #$agreementPeriod could begin before the agreement was made, e.g., when an agent agreed to pay disputed royalties retroactively."))
)
(defrelation |alertnessLevel|
  :arity 2
  :domain |IndividualAgent|
  :range |Alertness|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "Predicate (#$alertnessLevel SENTIENT_BEING LEVEL) indicates how alert SENTIENT_BEING is in the period in which the predicate holds.  The major levels are #$Unconscious and #$Awake, but more specific attributes such as #$Asleep and #$VeryAlert exist as well."))
)
(defrelation |ambientRelativeHumidity|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |GeographicalRegion|
  :range |RelativeHumidity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$ambientRelativeHumidity LOC DEGREE) indicates the DEGREE to which the water vapor content of the air at LOC approaches the total possible saturation (at that temperature)."))
)
(defrelation |ambientTemperature|
  :arity 2
  :domain |PartiallyTangible|
  :range |Temperature|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$ambientTemperature is used to indicate the average temperature in the free space around a particular object.  (#$ambientTemperature OBJ TEMP) means that the space around the tangible object OBJ is at the #$Temperature TEMP.  Used with #$holdsIn (q.v.), #$ambientTemperature expresses the surrounding temperature for a given object at some point in time.  For the temperature of the object itself, use #$temperatureOfObject (q.v.)."))
)
(defrelation |ambientVisibility|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |GeographicalRegion|
  :range |Visibility|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$ambientVisibility LOC DEGREE) indicates how clear the ambient fluid is at the location LOC.  Higher values of DEGREE mean one can see farther (than one could have at lower values)."))
)
(defrelation |amountOfSalesByToDuring|
  :arity 5
  :domains (|Agent| |Agent| |TimeInterval| (:AND |ProductType| (:FILLED-BY SUPERRELATIONS |Product|)))
  :range |Money|
  :annotations ( |QuintaryPredicate|
     |FunctionalPredicate|
     (DOCUMENTATION "The predicate #$amountOfSalesByToDuring is used to indicate how much of a certain product was sold by a particular seller to a particular buyer.  (#$amountOfSalesByToDuring SELLER BUYER TIMEPD PRODTYPE REVENUE) means that, during the #$TimeInterval TIMEPD, SELLER (an #$Agent) sold to BUYER (another #$Agent) some amount of the #$ProductType PRODTYPE, worth the total amount of #$Money REVENUE.  For example, to say that a restaurant, #$Threadgills, sold $3000 worth of their pumpkin pies to a local grocery store in November, we would say: (#$amountOfSalesByToDuring #$Threadgills HEBAt2222 (#$MonthFn #$November (#$YearFn 1996)) #$PumpkinPie (#$Dollar-UnitedStates 3000))."))
)
(defrelation |Ampere|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfCurrent|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     (DOCUMENTATION "The standard unit of measure of electrical current, equivalent to a 1-#$Coulomb flow of current, or 1 #$Volt across a resistance of 1 #$Ohm."))
)
(defrelation |amplitudeOfSignal|
  :arity 2
  :domain |WavePropagation|
  :range |Distance|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$amplitudeOfSignal ?WAVE ?AMP) means the distance from the average to the extremes of the signal ?WAVE is ?AMP."))
)
(defrelation |analogousFeelings|
  :arity 2
  :domain (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :range (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |IntensionalRepresentationPredicate|
     (DOCUMENTATION "(#$analogousFeelings EMOTYPE1 EMOTYPE2) means that a feeling of the type EMOTYPE1 is analogous to a feeling of the type EMOTYPE2.  In part, this means that there is a high probability that an agent having an emotion of one type is also feeling an emotion of the other type.  Often the two feelings differ only in degree, context, etc.  E.g., (#$analogousFeelings #$Irritation #$Anger) and (#$analogousFeelings #$Irritation #$Impatience)."))
)
(defrelation |anatomicallyCapableOf|
  :arity 3
  :domains (|Animal| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$anatomicallyCapableOf indicates that an agent is anatomically able to take a certain role in a certain type of situation or event.  (#$anatomicallyCapableOf AGENT SIT-TYPE ROLE) means that an individual #$Animal AGENT has the anatomical prerequisites (natural or prosthetic) to act in this ROLE in normal instances of SIT-TYPE.  For example, to express that Karen is capable of walking, Cyc would say (#$anatomicallyCapableOf Karen #$BipedWalking #$performedBy).  AGENT may or may not have the skills (or other prerequisites) for actually doing a SIT-TYPE.  #$anatomicallyCapableOf entails that AGENT satisfies the relevant #$anatomicalResourceRequired constraint--e.g., for Karen's #$BipedWalking, that she has two legs (natural or prosthetic).  As a default, Cyc concludes that animals who have the #$anatomicalParts needed for a certain kind of activity are #$anatomicallyCapableOf that activity--for example, that people who have arms and legs are #$anatomicallyCapableOf swimming; those conclusions would be overridden by the additional information that a person was paralyzed."))
)
(defrelation |anatomicalParts|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalParts|)
  :domain |Organism-Whole|
  :range |OrganismPart|
  :annotations ( |CotemporalObjectsSlot|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$anatomicalParts ORGM PART) means that PART is an anatomical part of the (whole) organism ORGM.  
Note that to represent the decomposition of parts of subparts --- for example, to say that a finger is part of a hand --- one should use the predicate #$physicalParts (qv), not #$anatomicalParts."))
)
(defrelation |anatomicalPartTypeAffected|
  :arity 2
  :domain |AnimalActivity|
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|))
  :annotations ( |TypePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$anatomicalPartTypeAffected ACT BODYPARTTYPE) means that body parts of the #$AnimalBodyPartType BODYPARTTYPE are affected by the action ACT.  For example, if BRUSHING is a #$TeethCleaning event, then (#$anatomicalPartTypeAffected BRUSHING #$SetOfTeeth)."))
)
(defrelation |anatomicalResourceRequired|
  :arity 3
  :domains (|AnimalActivity| (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|)))
  :range |NonNegativeInteger|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$anatomicalResourceRequired ACT BODYPARTTYPE NUM) means that the successful doer of ACT must have this many (NUM) of the #$AnimalBodyPartType BODYPARTTYPE.  For example, if VOLANT is an element of #$Flying-FlappingWings, then (#$anatomicalResourceRequired VOLANT #$Wing-AnimalBodyPart 2)."))
)
(defrelation |ancestors|
  :arity 2
  :is-primitive |biologicalRelatives|
  :domain |Animal|
  :range |Animal|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$ancestors YOUNGER OLDER) means OLDER is one of the biological ancestors of YOUNGER.  OLDER could be one of YOUNGER's biological parents, biological grandparents, biological great-grandparents, etc."))
)
(defrelation |and|
  :annotations ( |VariableArityRelation|
     |CommutativeRelation|
     |LogicalConnective|
     (DOCUMENTATION "The predicate #$and is the conjunction relation in Cyc.  #$and is a variable-arity predicate and takes any number of elements of #$CycFormula as its arguments.  (#$and P Q ... Z) is true if all of the formulas P, Q, ..., and Z are true in Cyc."))
)
(defrelation |Angstrom|
  :annotations ( |UnitOfMeasureWithPrefix|
     |MKSUnitOfMeasure|
     |UnitOfDistance|
     (DOCUMENTATION "Extremely small unit of length, used especially for measuring the wavelength of light, derived by dividing a meter by 10,000,000,000.  Abbreviation: A (with a little circle on the top of the `A').  1 A = 1/10,000,000,000 (i.e., 10^-10) meter."))
)
(defrelation |angularAcceleration|
  :arity 2
  :domain |PhysicalEvent|
  :range |AngularAccelerationRate|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "The rate at which the angle to an object is accelerating"))
)
(defrelation |AnteriorRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (AnteriorRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the region consisting of the front half or section, or the anterior main portion, of REGOROBJ.  It applies only when REGOROBJ itself has an intrinsic front/back orientation, or is a (non-backward-facing) part of a larger region or object that has a front/back orientation."))
)
(defrelation |appropriateEmotion|
  :arity 4
  :domains (|Situation| |Role| (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$appropriateEmotion SIT ROLE EMOTYPE DEGREE) means that in the #$Situation SIT, an intelligent agent filling the #$Role ROLE would be expected to feel an emotion of #$FeelingAttributeType EMOTYPE with the intensity DEGREE.  If such an agent did not feel that emotion, s/he would generally be considered rude or strange. E.g., a #$High degree of #$Grief is an #$appropriateEmotion for someone in the audience at a funeral (but not for the workers, the deceased, etc.)"))
)
(defrelation |approximatePay|
  :arity 2
  :domain (:AND |OccupationType| (:FILLED-BY SUPERRELATIONS |Professional|))
  :range |MonetaryFlowRate|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$approximatePay is used to estimate a typical amount of pay offered to workers in a specific occupation.  (#$approximatePay JOBTYPE RATE) means that a person working in the #$OccupationType JOBTYPE makes approximately the #$MonetaryFlowRate RATE, as earned income.  RATE might be expressed in, e.g., #$DollarsPerHour, pounds-per-week, or yen-per-year.  RATE refers to average pay for the occupation JOBTYPE, excluding any unearned pay (such as matching 401K contributions) and the value of other employee benefits."))
)
(defrelation |areaOfObject|
  :arity 2
  :is-primitive |(MeaningInSystemFn SENSUS-Information1997 AREA)|
  :domain |PartiallyTangible|
  :range |Area|
  :annotations ( |PhysicalAmountSlot|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "A general slot to denote the area of some object.  This could be the area of a #$GeographicalRegion, a desk top, or a cross-section of wire."))
)
(defrelation |areaOfRegion|
  :arity 2
  :is-primitive (:and |areaOfObject| |(MeaningInSystemFn SENSUS-Information1997 AREA)|)
  :domain |GeographicalRegion|
  :range |Area|
  :annotations ( |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$areaOfRegion is used to indicate the physical area of a particular region.  (#$areaOfRegion REGION AREA) means that the physical size of the #$GeographicalRegion REGION is the #$Area AREA.  Examples: (#$areaOfRegion #$LakeErie (#$SquareMile 9940)), (#$areaOfRegion #$Elba-Island-Italy (#$SquareMile 86)), (#$areaOfRegion #$VaticanCity (#$SquareMile 0.17)), (#$areaOfRegion #$China-PeoplesRepublic (#$SquareMile 3705390)).  See #$Area for ways of representing areas."))
)
(defrelation |areasOfOrigin|
  :arity 2
  :domain |EthnicGroupType|
  :range |GeographicalRegion|
  :annotations ( |IntensionalRepresentationPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$areasOfOrigin relates an ethnic group to a particular region in which its members originated.  (#$areasOfOrigin GROUP REGION) means that the #$EthnicGroupType GROUP originated in the #$GeographicalRegion REGION.  For example, to indicate that Circassians originated in Asia, we would say (#$areasOfOrigin #$EthnicGroupOfCircassians #$ContinentOfAsia).  Ethnic groups may have originated in several different areas; e.g., the #$EthnicGroupOfHutu is native to #$Rwanda, #$Burundi, #$Tanzania, and #$Uganda."))
)
(defrelation |arg1Format|
  :arity 2
  :domain |Predicate|
  :range |Format|
  :annotations ( |MetaPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$arg1Format PRED FORMAT) means that FORMAT tells how many different first arguments there can be to PRED, given some fixed set of other arguments.  See #$Format for a description of the possible values for FORMAT."))
)
(defrelation |arg1Genl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg1Genl REL COL) means that the predicate or function, REL, accepts only first arguments that have the #$Collection COL among their #$genls."))
)
(defrelation |arg1Isa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |DefaultMonotonicPredicate|
     |FunctionalSlot|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg1Isa REL COL) means that anything given as the first argument to the #$Relationship REL must be an element of the #$Collection COL.  Examples: (#$arg1Isa #$formsBorderBetween #$SpatialThing), (#$arg1Isa #$seriesOrderedBy #$Series), (#$arg1Isa #$uniquePartTypes #$ExistingObjectType)."))
)
(defrelation |arg2Format|
  :arity 2
  :domain |Predicate|
  :range |Format|
  :annotations ( |MetaPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$arg2Format PRED FORMAT) means that FORMAT tells how many different second arguments there can be to PRED, given some fixed set of other arguments.  See #$Format for a description of the possible values for FORMAT."))
)
(defrelation |arg2Genl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg2Genl REL COL) means that the predicate or function, REL, accepts only second arguments that have the #$Collection COL among their #$genls."))
)
(defrelation |arg2Isa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |DefaultMonotonicPredicate|
     |FunctionalSlot|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg2Isa REL COL) means that anything given as the second argument to the #$Relationship REL must be an element of the #$Collection COL.  Examples: (#$arg2Isa #$sheetSurfaceConnected #$PartiallyTangible), (#$arg2Isa #$salutation #$CourtesyTitle), (#$arg2Isa #$mother #$FemaleAnimal)."))
)
(defrelation |arg3Format|
  :arity 2
  :domain |Predicate|
  :range |Format|
  :annotations ( |MetaPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$arg3Format PRED FORMAT) means that FORMAT tells how many different third arguments there can be to PRED, given some fixed set of other arguments.  See #$Format for a description of the possible values for FORMAT."))
)
(defrelation |arg3Genl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg3Genl REL COL) means that the predicate or function, REL, accepts only third arguments that have the #$Collection COL among their #$genls."))
)
(defrelation |arg3Isa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |DefaultMonotonicPredicate|
     |BinaryPredicate|
     |FunctionalSlot|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg3Isa REL COL) means that anything given as the third argument to the #$Relationship REL must be an element of the #$Collection COL."))
)
(defrelation |arg4Format|
  :arity 2
  :domain |Predicate|
  :range |Format|
  :annotations ( |BinaryPredicate|
     |MetaPredicate|
     (DOCUMENTATION "(#$arg4Format PRED FORMAT) means that FORMAT tells how many different fourth arguments there can be to PRED, given some fixed set of other arguments.  See #$Format for a description of the possible values for FORMAT."))
)
(defrelation |arg4Genl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg4Genl REL COL) means that the fourth argument to the #$Relationship (i.e., predicate or function) REL must be a subset of the #$Collection COL."))
)
(defrelation |arg4Isa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |DefaultMonotonicPredicate|
     |BinaryPredicate|
     |FunctionalSlot|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg4Isa REL COL) means that anything given as the fourth argument to the #$Relationship REL must be an element of the #$Collection COL."))
)
(defrelation |arg5Format|
  :arity 2
  :domain |Predicate|
  :range |Format|
  :annotations ( |BinaryPredicate|
     |MetaPredicate|
     (DOCUMENTATION "(#$arg5Format PRED FORMAT) means that FORMAT tells how many different fifth arguments there can be to PRED, given some fixed set of other arguments.  See #$Format for a description of the possible values for FORMAT."))
)
(defrelation |arg5Genl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg5Genl REL COL) means that the fifth argument to the #$Relationship (predicate or function) REL must be a subset of the #$Collection COL."))
)
(defrelation |arg5Isa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |DefaultMonotonicPredicate|
     |FunctionalSlot|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arg5Isa REL COL) means that anything given as the fifth argument to the #$Relationship REL must be an element of the #$Collection COL."))
)
(defrelation |argsGenl|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |MetaRelation|
     (DOCUMENTATION "When a relation REL is an element of #$VariableArityRelation, i.e., it takes a variable number of arguments, then (#$argsGenl REL COL) means that all of those arguments must be subsets of COL."))
)
(defrelation |argsIsa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     |MetaRelation|
     (DOCUMENTATION "The predicate #$argsIsa is used with elements of #$Relationship that take an indefinite number of arguments, in order to specify that the values of all the arguments used with that relation must be of a certain type.  E.g., to specify that all the arguments to Cyc's addition function, #$PlusFn, must be measurable quantities (i.e., elements of #$ScalarInterval), we assert: (#$argsIsa #$PlusFn #$ScalarInterval).  Additional examples: `paths branch only into other paths', i.e., (#$argsIsa #$branchesInto #$Path-Generic); `dinars are measured only in numbers', i.e., (#$argsIsa #$Dinar-Jordan #$CycSystemRealNumber)."))
)
(defrelation |arity|
  :arity 2
  :domain |Relationship|
  :range |Integer|
  :annotations ( |DefaultMonotonicPredicate|
     |BinaryPredicate|
     |FunctionalSlot|
     |RelationshipPredicate|
     |MetaRelation|
     (DOCUMENTATION "(#$arity REL NUMBER) means that the #$Relationship REL takes the number of arguments given by NUMBER.  For example, the #$arity of all instances of #$BinaryPredicate is 2.  In particular, (#$arity #$arity 2) since #$arity takes 2 arguments."))
)
(defrelation |assistingAgent|
  :arity 2
  :is-primitive |deliberateActors|
  :domain |Event|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$assistingAgent ACT AGENT) means that AGENT is one of the agents assisting in the performance of ACT; AGENT itself may or may not also be performing ACT.  AGENT is doing some tasks related to ACT but which are not directly #$subEvents of performing the main or focus action.  Thus, `assisting' here means doing such supporting activities as fetching supplies or tools needed in ACT; helping to manipulate objects involved in ACT; gathering an audience, or booking the performer, if ACT is a public performance, and so forth."))
)
(defrelation |AtomFn|
  :arity 2
  :domain (:AND |ElementStuffTypeByNumberOfProtons| (:FILLED-BY SUPERRELATIONS |ElementStuff|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Atom|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$AtomFn is a Cyc function, specifically a #$CollectionDenotingFunction.  It may be used to denote any subset of #$Atom which contains all the atoms of a particular element type.  #$AtomFn takes an instance of #$ElementStuffTypeByNumberOfProtons as its single argument and returns the collection of all atoms of that element.  Thus, for any E which is an #$ElementStuffTypeByNumberOfProtons, (#$AtomFn E) returns the subset of #$Atom which contains all the atoms of element type E.   Each atom in the collection (#$AtomFn E) has N protons in its atomic nucleus, where N is the #$atomicNumber of the element type E.  For example, (#$AtomFn #$Carbon) is the collection of carbon atoms, each of which has 6 protons in its nucleus."))
)
(defrelation |atomicNumber|
  :arity 2
  :domain (:AND |ElementStuffTypeByNumberOfProtons| (:FILLED-BY SUPERRELATIONS |ElementStuff|))
  :range |PositiveInteger|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$atomicNumber indicates the atomic number of a type of element.  (#$atomicNumber E N) means that E, a collection belonging to #$ElementStuffTypeByNumberOfProtons, has the positive integer N for its atomic number.  This means that any instance of (#$AtomFn E) must have N #$Protons in its #$AtomicNucleus.  For example, (#$atomicNumber #$Carbon 6), and every instance of (#$AtomFn #$Carbon) has six protons in its nucleus."))
)
(defrelation |AttemptingFn|
  :arity 2
  :domain (:AND |TemporalObjectType| |ScriptType| (:FILLED-BY SUPERRELATIONS |Action|))
  :range (:AND |ScriptType| (:FILLED-BY SUPERRELATIONS |PurposefulAction|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "(#$AttemptingFn ACTION-TYPE) maps from the collection ACTION-TYPE (a subset of #$Action) to a collection of attempts to perform ACTION-TYPE.  Thus the result of (#$AttemptingFn #$Speaking) would be the collection of attempts at speaking, both those attempts which are successes (thus resulting in actual #$Speakings), and those which are failures.  #$AttemptingFn operates on the #$Collection level, and is used to talk about kinds of attempts that can occur.  To talk about the specific attempt that brought about an event which actually occurred, use #$SuccessfulAttemptFn."))
)
(defrelation |attitudeTowardsEvent|
  :arity 4
  :domains (|Animal| |Event| (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "#$attitudeTowardsEvent(AGT EVT EMOTYPE DEGREE) means that the #$SentientAnimal AGT has the attitude EMOTYPE (see #$FeelingAttributeType) about the #$Event EVT with DEGREE of intensity.  By `attitude' we mean a feeling which may be latent and/or long-lasting.  To refer to feelings that AGT experiences immediately and consciously towards EVT, use #$feelsTowardsEvent."))
)
(defrelation |attitudeTowardsObject|
  :arity 4
  :domains (|Animal| |Individual| (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |QuaternaryPredicate|
     (DOCUMENTATION "#$attitudeTowardsObject(AGT OBJ EMOTYPE DEGREE) means that the #$SentientAnimal AGT has the attitude EMOTYPE (see #$FeelingAttributeType) about the #$Individual OBJ with DEGREE of intensity.  By `attitude' we mean a possibly latent and/or long-lasting feeling.  To refer to feelings that AGT experiences immediately and consciously towards OBJ, use #$feelsTowardsObject."))
)
(defrelation |AxisFn|
  :arity 4
  :domains (|PartiallyTangible| (:AND |RegionType| (:FILLED-BY SUPERRELATIONS |Side|))
            (:AND |RegionType| (:FILLED-BY SUPERRELATIONS |Side|)))
  :range |IntrinsicAxisOfObject|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(#$AxisFn OBJ REGIONTYP REGIONTYP) is a function that, applied to an individual object OBJ and two types of region of such an object, returns the axis through the object, determined by running the axis through the individual regions (of those types) of the object.  Thus #$AxisFn is an  #$IndividualDenotingFunction that returns a particular axis of an individual object. (#$AxisFn OBJ FROM-SIDE TO-SIDE) denotes a directional axis, pointing from FROM-SIDE to TO-SIDE of OBJ and extending through it. For example, (#$AxisFn `Chair37' #$BackSide #$FrontSide) would denote the back-to-front axis of Chair37. See also #$IntrinsicAxisOfObject."))
)
(defrelation |barometricPressure|
  :arity 2
  :domain |GaseousTangibleThing|
  :range |Pressure|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleSubstancePredicate|
     (DOCUMENTATION "(#$barometricPressure GAS PRESS) means that the instance of #$GaseousTangibleThing GAS has the #$Pressure PRESS.  Typically, GAS is a piece of atmosphere; #$barometricPressure indicates the atmospheric pressure in and around that `object'."))
)
(defrelation |basicPrice|
  :arity 2
  :domain |Individual|
  :range |Money|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$basicPrice indicates the price of a particular item.  (#$basicPrice THING MONEY) means that the object or service, THING, has the basic price MONEY.  (MONEY can be an interval representing a range of prices.)  Note that #$basicPrice refers to the `ticket price' of an item when it is actually bought or offered for sale; #$basicPrice does NOT refer to appraised value (where that differs from an actual selling price).  Since prices are time-sensitive, assertions about #$basicPrice should be suitably qualified.  For example, the price of a fast-food #$HamburgerSandwich in 1996 is a magnitude greater than what it was in 1965.  For the total charge for purchase of an object, including tax, shipping, handling, etc., use #$totalCharge (q.v.)."))
)
(defrelation |behaviorCapable|
  :arity 3
  :domains (|SomethingExisting| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$behaviorCapable is used to describe a type of situation (and the role) in which an object can participate due to its intrinsic properties.  (#$behaviorCapable OBJ SIT-TYPE ROLE) means that the individual, OBJ, is able to act as a ROLE in a situation of type SIT-TYPE.  OBJ may or may not have been designed to function in that way (cf. #$primaryFunction, #$intendedBehaviorCapable).  Also, #$behaviorCapable does not imply that OBJ can unquestionably act in that way in every such situation, since extrinsic factors may prevent it; e.g., the object may be in the wrong location, operated by a person lacking the proper skills, certain legal preconditions may not be satisfied, etc.  Examples: (intended capability) a hammer is #$behaviorCapable of being the #$deviceUsed in instances of #$HammeringANail; (unintended capability) an inner tube is capable of being the #$deviceUsed in instances of people #$FloatingInLiquid."))
)
)    ; END EVAL-WHEN 1

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 2
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |behind-Directly|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$behind-Directly AFT FORE) means that AFT is directly behind FORE.  More precisely, it implies both (#$behind-Generally AFT FORE) and that there is at least one line parallel to the backward pointing axis of FORE that intersects both AFT and FORE.  Note that FORE must have a back face."))
)
(defrelation |behind-Generally|
  :arity 2
  :is-primitive |near|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$behind-Generally AFT FORE) means that AFT is behind FORE.  More precisely, a line originating at the center of FORE projecting away from the front side of FORE and parallel to the intrinsic front-to-back axis of FORE forms an angle of less than 45 degrees with a line intersecting both AFT and FORE."))
)
(defrelation |beliefs|
  :arity 2
  :domain |Agent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$beliefs AGT PROP) means that the #$Agent AGT subscribes to the truth of the proposition PROP (represented by a #$CycFormula).  PROP states something that AGT believes to be true, but of course PROP may or may not actually be true.  Another way to think of this is that PROP is true in the context whose epistemological status is `what AGT believes'.  Naturally, PROP may itself be a proposition about beliefs; one would use nested #$beliefs in this fashion to express a rule such as `most Canadians believe that most Americans believe Canada is a US State.'"))
)
(defrelation |beliefStatements|
  :arity 2
  :domain |BeliefSystem|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$beliefStatements BSYS PROP) indicates that a belief of the belief system BSYS is stated in the proposition PROP (represented by a #$CycFormula).  In other words, each #$BeliefSystems comprises a set of tenets, statements linked to it via this predicate.  
Note: This is NOT the predicate that ties a particular #$Agent to his/her/its beliefs; for that, see #$beliefs and #$hasBeliefSystems."))
)
(defrelation |beneficiary|
  :arity 2
  :domain |Event|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "(#$beneficiary ACT AGT) means that the #$Agent AGT benefits from the performance of the action ACT.  Some desire or interest of AGT is served, enabled, helped, or satisfied by the performance of ACT."))
)
(defrelation |between|
  :arity 3
  :domains (|PartiallyTangible| |PartiallyTangible|)
  :range |PartiallyTangible|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$between THIS THAT MID-OBJ) means that MID-OBJ is spatially directly between THIS and THAT.  Depending on the context, MID-OBJ may lie on a great circle between THIS and THAT, or on a true Euclidian straight line between them.  Note that #$between applies only to physical location.  To describe a relationship involving numbers or #$ScalarIntervals, use #$greaterThan or #$followingValue.  To describe a 'between' relationship along some particular physical path (like: Austin is between Dallas and San Antonio on Highway I-35), or on some trajectory, see #$betweenOnPath."))
)
(defrelation |betweenOnPath|
  :arity 4
  :domains (|Thing| |Thing| |Thing|)
  :range |Path-Simple|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$betweenOnPath X Y Z PATH) means that X, Y and Z are points on the path PATH and X is between Y and Z.  Note that this gives no ordering of Y and Z; it just claims that X is between them.  Note: Given a #$Path-Customary PATH and points or places on PATH, #$betweenOnPath does not in general determine a linear order (#$TotallyOrderedSet) on the set of all points on PATH when PATH is not part of a specified #$PathSystem.  However, in a #$PathSystem SYS, #$betweenOnPath does determine a linear order on the set of all points on PATH in SYS."))
)
(defrelation |biases|
  :arity 2
  :is-primitive |beliefs|
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$biases AGT PROP) means that the #$Agent AGT has the unsubstantiated belief PROP (represented by a #$CycFormula).
Biases generally are so deeply rooted in the agent that the agent may not be consciously aware that PROP is rationally undersupported, and it may be concomittantly harder to change their mind about PROP.
Note:  PROP might or might not turn out to be true (in various contexts); often, PROP is some overgeneralization which is sometimes true but often false, or which once was true but now is usually false, etc."))
)
(defrelation |biologicalFather|
  :arity 2
  :is-primitive (:and |biologicalParents| |father|)
  :domain |Animal|
  :range |MaleAnimal|
  :annotations ( |InterExistingObjectSlot|
     |FunctionalSlot|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$biologicalFather OFFSPRING MALE) means that #$MaleAnimal MALE is the male biological parent of #$Animal OFFSPRING."))
)
(defrelation |biologicalMother|
  :arity 2
  :is-primitive (:and |biologicalParents| |mother|)
  :domain |Animal|
  :range |FemaleAnimal|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |FunctionalSlot|
     |InterExistingObjectSlot|
     |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$biologicalMother OFFSPRING FEMALE) means that #$FemaleAnimal FEMALE is the female biological parent of the #$Animal OFFSPRING."))
)
(defrelation |biologicalParents|
  :arity 2
  :is-primitive |biologicalRelatives|
  :domain |Animal|
  :range |Animal|
  :annotations ( |InterExistingObjectSlot|
     |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$biologicalParents OFFSPRING PARENT) means that PARENT is the biological parent of OFFSPRING."))
)
(defrelation |biologicalRelatives|
  :arity 2
  :is-primitive |relatives|
  :domain |Animal|
  :range |Animal|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$biologicalRelatives ORG1 ORG2) means that ORG1 and ORG2 are biological relatives, related by birth."))
)
(defrelation |birthChild|
  :arity 2
  :is-primitive (:and |bodilyActedOn| |objectOfStateChange|)
  :domain |BirthEvent|
  :range |Animal|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$birthChild BIRTH ANIM) means that ANIM is the #$Animal that is born in the #$BirthEvent BIRTH."))
)
(defrelation |birthDate|
  :arity 2
  :is-primitive |startingDate|
  :domain |Entity|
  :range |Date|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$birthDate ?X ?Y) indicates that the #$Entity ?X came into existance during #$Date ?Y.  For people, this is the date at which they were born, hence the name of this predicate.  The first argument to this predicate must be an #$Entity, and not just any old #$SomethingExisting, because we don't want to talk about the #$birthDate or #$dateOfDeath of a subabstraction like AlbertEinsteinWhileAtPrinceton; in other words, proper subabstractions will have #$startingDates and #$endingDates, but only true #$Entitys will have a #$birthDate or #$dateOfDeath"))
)
(defrelation |birthParent|
  :arity 2
  :is-primitive (:and |bodilyDoer| |objectOfStateChange|)
  :domain |BirthEvent|
  :range |Animal|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$birthParent BIRTH PAR) means that PAR is the parent who is #$bodilyDoer in the #$BirthEvent BIRTH - typically this is also the #$femaleParentActor of the preceding #$BiologicalReproductionEvent."))
)
(defrelation |boardMembers|
  :arity 2
  :is-primitive |hasMembers|
  :domain |Organization|
  :range |Person|
  :annotations ( |ExtensionalRepresentationPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$boardMembers relates a particular organization to the persons who serve on its board of directors.  (#$boardMembers ORG PERSON) means PERSON belongs to that instance of #$BoardOfDirectors which is responsible for oversight of the #$Organization ORG.  A member of the Board of Directors of an organization may or may not be an executive of the organization."))
)
(defrelation |bodilyActedOn|
  :arity 2
  :is-primitive |objectActedOn|
  :domain |Event|
  :range |Organism-Whole|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$bodilyActedOn is used to describe an event in which a living organism is acted on by some external agency.  (#$bodilyActedOn EVENT ORG) means that ORG is a living organism (i.e., an #$Organism-Whole) that is being affected in EVENT.  ORG itself may be intentionally participating in EVENT (e.g., a person voluntarily getting a haircut) or not (e.g., an animal hit by a car).  Either way, the organism ORG is not an active primary `doer' of EVENT.  This predicate is appropriately used to identify actors who undergo (instances of) #$DrugTherapy or #$IncurringAnInjury.
Note an important contrast with #$bodilyDoer (q.v.):  #$bodilyActedOn is for events that merely happen to the body, as opposed to actions the body does.  Because the body of an organism is an active `doer' in its instances of #$PhysiologicalCondition, including any #$InjuryCondition (which is the physical process of a body sustaining an injury and responding by healing or deteriorating), an organism is related to events of those kinds with #$bodilyDoer rather than #$bodilyActedOn.  By contrast, organisms involved in instances of #$DrugTherapy (which refers to the effect of a drug on the patient) or #$IncurringAnInjury (which refers to the event in which an organism gets injured, rather than the process of its being in an injured and hopefully healing state) should be related to events of those types with #$bodilyActedOn."))
)
(defrelation |bodilyDoer|
  :arity 2
  :is-primitive (:and |doneBy| |nonDeliberateActors|)
  :domain |PhysicalEvent|
  :range |Organism-Whole|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$bodilyDoer relates an event to an organism which does it non-deliberately, which in Cyc means without conscious intention or volition.  (#$bodilyDoer EVENT DOER) means that DOER does EVENT (i.e., DOER is not merely subjected to EVENT by external forces), but DOER does EVENT non-deliberately.  Note that for certain kinds of actions, considered as a class, organisms are necessarily merely #$bodilyDoers; for example, physical growth, peristalsis, and reflex actions.  For other actions, such as breathing, flinching, or shouting, an organism commonly (but not necessarily) acts as #$bodilyDoer; some cases of such events may be deliberately #$performedBy the doer.
Note: an organism which dies of natural causes (#$Dying) is the #$bodilyDoer of that event, because of the internal processes the body performs during #$Dying.  Also, in certain #$PhysiologicalConditions, including an #$AilmentCondition (such as #$Diabetes) or a healing process, organisms are considered to be #$bodilyDoers because their own bodily processes are creating or sustaining those conditions.  An organism killed by an external agent, however, is just the #$bodilyActedOn (q.v.) in that event; therefore, instances of #$Killing-Biological should use #$bodilyActedOn to refer to the organism killed."))
)
(defrelation |BodyPartCollectionFn|
  :arity 3
  :domains (|Animal| (:AND |AnimalBodyPartType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|)))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$BodyPartCollectionFn is a #$CollectionDenotingFunction, that is, it is a Cyc function which `returns' (i.e., `has') a collection as its value.  Here is an example of what it does.  The expression (#$BodyPartCollectionFn #$AbrahamLincoln #$Fingernail) returns, as its value, a collection of ten elements, each of which represents one of the fingernails of Abraham Lincoln.  In cases where an animal is likely to only have one part of that type (e.g., head, heart, nose, nervous system), it makes more sense to use the function #$BodyPartFn (qv), rather than using this one, getting a singleton set back, and extracting its lone element."))
)
(defrelation |BodyPartFn|
  :arity 3
  :domains (|Animal|
            (:AND |UniqueAnatomicalPartType| |AnimalBodyPartType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|)))
  :range |AnimalBodyPart|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "#$BodyPartFn is an #$IndividualDenotingFunction, that is, it is a Cyc function which `returns' (i.e., `has') a single individual object as its value.  (#$BodyPartFn DeborahNichols #$Heart) represent's Deborah's one and only heart.  That nonatomic term can be used almost anywhere that the term DeborahNicholsHeart could have been used, but this way we needn't reify that other term, and so on.  Note that the second argument to this function --- i.e., the  #$AnimalBodyPartType --- must be a #$UniqueAnatomicalPartType, that is, a kind of part of which an animal can have only one.  If an animal can have multiple parts of that type, such as #$Finger, then use the function #$BodyPartCollectionFn instead of #$BodyPartFn."))
)
(defrelation |boilingPoint|
  :arity 2
  :domain |PartiallyTangible|
  :range |Temperature|
  :annotations ( |TangibleSubstancePredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$boilingPoint STUFF TEMP) means that TEMP is the temperature at which the substance STUFF changes from having the attribute #$LiquidStateOfMatter to #$GaseousStateOfMatter (when sufficient energy is input to raise STUFF's temperature through that point).  Note that the boiling point of most substances is context-dependent; on a mountaintop in Tibet the boiling point of water is much lower than it is in New York City."))
)
(defrelation |BorderBetweenFn|
  :arity 3
  :domains (|GeographicalRegion| |GeographicalRegion|)
  :range (:AND |Border| |Line|)
  :annotations ( |IndividualDenotingFunction|
     |CommutativeRelation|
     |ReifiableFunction|
     (DOCUMENTATION "(#$BorderBetweenFn REG1 REG2), applied to two individual #$GeographicalRegions REG1 REG2, returns the unique entire #$GeopoliticalBorder that separates them.   To identify arbitrarily large or small segments of borders see #$formsBorderPart.  The border returned by #$BorderBetweenFn may be discontinuous (such the border between France and Spain, interrupted by Andorra), or circular (such as the border between Italy and San Marino), or in abnormal cases it may even have multiple disconnected and nested cyclic fragments (the border between Belgium and Netherlands, due to the Baarle-Nassau and Baarle-Hartog enclaves), or move back and forth periodically (such as at the Isle des Faisans).  Nonetheless, (#$BorderBetweenFn REG1 REG2) must denote exactly one object since #$BorderBetweenFn is a function.  Reference to nonexistant borders such (#$BorderBetweenFn #$Albania #$UnitedStatesOfAmerica) should cause Cyc to realize that they are undefined.  For example, if Cyc concludes that (#$bordersOn #$UnitedStatesOfAmerica #$Albania) is not true, then it should conclude (#$undefined (#$BorderBetweenFn #$Albania #$UnitedStatesOfAmerica)).
 "))
)
(defrelation |bordersOn|
  :arity 2
  :is-primitive (:and |touchesDirectly| |adjacentTo|)
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$bordersOn REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 and the #$GeographicalRegion REGION-2 are physically adjacent to each other.  Examples: (#$bordersOn #$CentralUSATimeZone #$MountainUSATimeZone), (#$bordersOn #$Nepal #$Tibet)."))
)
(defrelation |boss|
  :arity 2
  :is-primitive (:and |acquaintedWith| |cotemporal|)
  :domain |Person|
  :range |Person|
  :annotations ( |CotemporalObjectsSlot|
     |AntiSymmetricBinaryPredicate|
     (DOCUMENTATION "(#$boss PERSON1 PERSON2) means PERSON1 has PERSON2 for his or her immediate boss or supervisor.  
Note:  There can be more than one boss of a person, even cotemporally.
Note: (#$genlPreds #$boss #$acquaintedWith) means that if (#$boss x y), then (#$acquaintedWith x y), which in turn means (#$acquaintances x y #$SimpleContactAcquaintance).  I.e., a person and their direct boss are at least simple contact acquaintances."))
)
(defrelation |businessPartners|
  :arity 2
  :is-primitive |positiveVestedInterest|
  :domain |Agent|
  :range |Agent|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$businessPartners indicates that two agents have jointly undertaken some business project; they are combining resources in some way to further their interests.  (#$businessPartners AGENT1 AGENT2) means AGENT1 is in partnership with AGENT2 to engage in business activities.  The partners are instances of #$Agent and may belong to either #$Person or #$Organization.  The partnership may be formally recognized (e.g., a #$Partnership or some other form of business) or informal."))
)
(defrelation |buyer|
  :arity 2
  :is-primitive |exchangers|
  :domain |CommercialActivity|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$buyer relates an agent to a business activity.  (#$buyer EVENT AGENT) means that the #$Agent AGENT purchases the goods for sale in the #$CommercialActivity EVENT."))
)
(defrelation |buyingAgent|
  :arity 2
  :is-primitive (:and |mediators| |buyingPerformer|)
  :domain |CommercialActivity|
  :range |LegalAgent|
  :annotations ( |FunctionalSlot|
     |ActorSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "A buying agent acts on behalf of a would-be buyer to bring about a buying event involving his/her/its client as the buyer. "))
)
(defrelation |buyingPerformer|
  :arity 2
  :is-primitive (:and |socialParticipants| |performedBy|)
  :domain |CommercialActivity|
  :range |LegalAgent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(buyingPerformer ?COM ?AGENT) means that ?AGENT is the #$Agent who actually pursues and attempts to obtain goods or services in a purchase, by performing an active role in the #$CommercialActivity ?COM.  Frequently this agent is the same as the #$buyer, but occasionally it is a #$buyingAgent representing the #$buyer."))
)
(defrelation |byProducts|
  :arity 2
  :is-primitive |outputs|
  :domain |CreationOrDestructionEvent|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$byProducts EV OBJ) means that OBJ is one of the outputs of EV, but not one of its intended outputs.  For intended outputs, see #$products.  For a particular EV and OBJ, it will not be true that both (#$products EV OBJ) and (#$byProducts EV OBJ)."))
)
(defrelation |CancerFn|
  :arity 2
  :domain (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|))
  :range (:AND |PhysiologicalConditionType| (:FILLED-BY SUPERRELATIONS |Cancer|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$CancerFn is a Cyc function, and in particular a #$CollectionDenotingFunction.  It is used to describe cancers according to the part or region of the animal's body in which they are found.  (#$CancerFn REGION) denotes the collection of all cancers found in the region of the body, REGION.  For example, (#$CancerFn #$Throat) represents the set of all throat cancers, and is a subset of #$Cancer."))
)
(defrelation |canContainShapes|
  :arity 2
  :domain |PartiallyTangible|
  :range |AbstractShape|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$canContainShapes is used to give an approximation of the internal size and shape of particular tangible objects, by relating an object to an abstract region of space described as a geometric shape with definite dimensions.  (#$canContainShapes OBJ SHAPE) gives an upper bound for the size of things that can be contained in the object OBJ, by specifying the dimensions of an abstract shape which OBJ can contain.  #$canContainShapes uses the elements of #$ShapeFunction (q.v.) for reference, especially the basic shapes generated by #$RectangularSolidFn, #$CylinderFn, and #$SphereFn.  For example, the trunk of my Honda Civic #$canContainShapes of (#$RectangularSolidFn (#$Meter 1) (#$Meter 0.5) (#$Meter 0.75)).  Cf. #$fitsIn."))
)
(defrelation |capableOf|
  :arity 3
  :is-primitive (:and |skillCapableOf| |fiscallyCapableOf| |legallyCapableOf| |anatomicallyCapableOf|)
  :domains (|Agent| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$capableOf indicates that an agent is fully able to carry out a certain role in a certain type of situation.  (#$capableOf AGT SIT-TYPE ROLE) means that the #$Agent AGT is able to act as described by ROLE in #$Situations of the type SIT-TYPE.  #$capableOf entails that AGT is qualified in ALL the relevant ways to fill that ROLE; e.g., AGT is #$anatomicallyCapableOf, #$fiscallyCapableOf, #$legallyCapableOf, and #$skillCapableOf playing that ROLE in SIT-TYPE."))
)
(defrelation |capitalCity|
  :arity 2
  :is-primitive (:and |controls| |geographicalSubRegions|)
  :domain |GeopoliticalEntity|
  :range |CapitalCityOfRegion|
  :annotations ( |InterExistingObjectSlot|
     |FunctionalSlot|
     (DOCUMENTATION "The predicate #$capitalCity is used to indicate the capital of a country (only).  (#$capitalCity CNTRY CITY) means that CITY is the capital city of the #$Country CNTRY.  Examples: the #$capitalCity of the #$UnitedStatesOfAmerica is the #$CityOfWashingtonDC; the #$capitalCity of #$Armenia is Yerevan.  Note: for regional capitals, use #$capitalCityOfThisState."))
)
(defrelation |cardinality|
  :arity 2
  :domain |SetOrCollection|
  :range |Integer|
  :annotations ( |FunctionalSlot|
     |IntensionalRepresentationPredicate|
     (DOCUMENTATION "(#$cardinality SETORCOL INTEGER)
means that the #$SetOrCollection SETORCOL has INTEGER number
of members. For instance, #$TheEmptySet has a #$cardinality
of 0."))
)
(defrelation |carriesInfectionType|
  :arity 2
  :domain |TangibleThing|
  :range (:AND |InfectionType| (:FILLED-BY SUPERRELATIONS |Infection|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate (#$carriesInfectionType OBJECT INFECT_TYPE) relates a particular organism or other object to a type of infection that it carries.  (#$carriesInfectionType OBJ INFTYP) means that the individual OBJ is a carrier of the #$InfectionType INFTYP.  For example, (#$carriesInfectionType TyphoidMary #$TyphoidFever) or (#$carriesInfectionType Needle0567 #$AIDS)."))
)
(defrelation |catalyst|
  :arity 2
  :is-primitive |unchangedActors|
  :domain |ChemicalReaction|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$catalyst identifies the particular thing that acts as a catalyst in a particular chemical reaction.  (#$catalyst R X) means that the #$ChemicalReaction R has the particular quantity of substance X as a catalyst.  For example, every instance of #$Photosynthesis has some portion of #$Chlorophyll as a catalyst; an amount of #$Water may be a #$catalyst in some #$OxidationProcess of a #$Metal."))
)
(defrelation |causedBy|
  :arity 2
  :is-primitive (:and |(MeaningInSystemFn SENSUS-Information1997 CAUSE-EFFECT)| |startsAfterStartingOf|)
  :domain |Event|
  :range |Event|
  :annotations ( |InterExistingObjectSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "#$causedBy is the predicate used for 
token-token event causation, i.e., causation between individual
events. (causedBy EVENT1 EVENT2) means that EVENT1 is causedBy
EVENT2."))
)
(defrelation |causes|
  :arity 2
  :is-primitive |(MeaningInSystemFn SENSUS-Information1997 CAUSE-EFFECT)|
  :domain |CycFormula|
  :range |CycFormula|
  :annotations ( |IrreflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$causes p1 p2) means that p1 causes p2.  That is, the state of affairs described by proposition p1 causally leads to the state of affairs described by p2.  This is stronger than material implication; i.e., it must also be the case that (#$implies p1 p2).  Note that #$causes means more than #$implies, of course: there is a temporal ordering involved, there is a presumed mechanism of causation, etc.  Unlike #$implies, #$causes is not reflexive; one would not say that p1 causes p1, even though p1 implies p1.  Another difference between #$implies and #$causes is that #$causes is a predicate, not a logical connective.  Just because (#$causes p1 p2) is true that does NOT entail that (#$causes (#$not p2) (#$not p1)) is true.Note that (#$causes p1 p2) is generally a more accurate way of talking about causation than saying that some event e1 caused event e2 (which one can do in Cyc, using the predicate #$causedBy) since often there are a few key aspects of e1 that caused a few key aspects of e2, and the remaining details of e1 and e2 were, to first order, irrelevant.  Note that, similarly, (#$causes p1 p2) is generally a more accurate way of talking about causation than saying that some agent AGT caused something to be true (which one can do in Cyc, using the predicate #$causesProp) since often there is some specific aspect of the agent, or something they were involved in or did, that is the cause of the proposition's becoming satisfied.  Because this predicate is asymetric and since effect (p2) can not temporally precede cause (p1), #$causes may not be used to express mutual causation, e.g. feedback loops for which it may be said that two events (probably more process-like) cause each other.  We consider mutual causation to be a different form of causation and should be expressed using some as of yet (Dec 96) unreified relationship."))
)
(defrelation |causesProp|
  :arity 2
  :is-primitive |(MeaningInSystemFn SENSUS-Information1997 CAUSE-EFFECT)|
  :domain |TemporalThing|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$causesProp INDIV PROP) means that the #$TemporalThing INDIV causes the proposition PROP to become true.  INDIV may be an #$Agent or an #$Event.  PROP is a #$CycFormula.  
Note:  A much simpler predicate is #$causedBy, in which both arguments are just #$Events."))
)
(defrelation |cavityConnectedAlongPathSide|
  :arity 2
  :is-primitive (:and |hasPortalToRegion| |connectedTo| |connectedTo-Rigidly|)
  :domain |PartiallyTangible|
  :range (:AND |Path-Simple| |PartiallyTangible|)
  :annotations ( |BinaryPredicate|
     |ConnectionPredicate|
     (DOCUMENTATION "(cavityConnectedAlongPathSide PATH CAVITY) means that there is a portal somewhere along the wall of the #$Path-Generic (which must also be #$PartiallyTangible) PATH which leads to the #$CavityOrContainer CAVITY. It does not apply if an end of PATH is the portal, nor to a branching of the path, nor a small hole in an otherwise dead end of the path. The portal is substantially smaller in width than the path, and instead of a smaller path connected there, the portal opens into a neighboring #$CavityOrContainer.  Example: an #$Alveolus attached to a #$RespiratoryBronchiole in the #$Lung is so connected.  Or, a room opening along the side of a hallway."))
)
(defrelation |cavityHasWall|
  :arity 2
  :is-primitive |physicalParts|
  :domain |Cavity|
  :range |SolidTangibleThing|
  :annotations ( |PartPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(cavityHasWall CAV WALL) means that the the #$Cavity CAV has WALL as one of its walls (or part of one of its walls), or partly-enclosing inner surfaces.  #$cavityHasWall is often used for describing the relationship between some space or part of a #$ConstructionArtifact and the substructures that bound or enclose it (e.g., the relationship between a room and its walls, floor(s), and ceiling(s))."))
)
(defrelation |Cent-UnitedStates|
  :annotations ( |UnitOfMeasureWithPrefix|
     |UnitOfMoney|
     (DOCUMENTATION "An element of #$UnitOfMoney.  #$Cent-UnitedStates represents the smallest unit of money used officially in the United States of America; one-hundredth of a #$Dollar-UnitedStates.  See also #$UnitOfMeasure."))
)
(defrelation |Centimeter|
  :annotations ( |CGSUnitOfMeasure|
     |UnitOfMeasureWithPrefix|
     |UnitOfDistance|
     (DOCUMENTATION "The measurement function used in Cyc to represent the centimeter, a unit used within the Metric system to measure length.  See also #$CGSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |CentimetersPerSecond|
  :annotations ( |CGSUnitOfMeasure|
     |UnitOfMeasureWithPrefix|
     |UnitOfSpeed|
     (DOCUMENTATION "(#$CentimetersPerSecond NUMBER) returns a dimensionless rate or speed of NUMBER centimeters per second.  Notice that this result is not presently thought of as incorporating a vector, although it might be modified to do so at some point in the future if this should prove appropriate."))
)
(defrelation |chiefPorts|
  :arity 2
  :is-primitive |geographicalSubRegions|
  :domain |GeopoliticalEntity|
  :range |UrbanArea|
  :annotations ( |InterExistingObjectSlot|
     (DOCUMENTATION "This is a list of the chief ports for a given geographical region."))
)
(defrelation |children|
  :arity 2
  :is-primitive (:and |relatives| |cotemporal|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$children PARENT CHILD) means that CHILD is the biological offspring of PARENT."))
)
(defrelation |circumferenceOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Distance|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "The distance around a circular object"))
)
(defrelation |citizens|
  :arity 2
  :domain |GeopoliticalEntity|
  :range |Person|
  :annotations ( |IntensionalRepresentationPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$citizens indicates that a particular person is a citizen of a particular country/state/... .  (#$citizens GEOPOL PERSON) means that GEOPOL is a #$GeopoliticalEntity in which the #$Person PERSON has full rights of citizenship (whatever those rights might consist of in GEOPOL)."))
)
(defrelation |cityInState|
  :arity 2
  :domain |UrbanArea|
  :range |CountrySubsidiary|
  :annotations ( |FunctionalSlot|
     |NonPhysicalPartPredicate|
     (DOCUMENTATION "(#$cityInState CITY STATE) means that the #$UrbanArea CITY is physically located in the geopolitical sub-region STATE.  Note that STATE may be an element of #$State-Geopolitical (q.v.), or it may be some other kind of #$CountrySubsidiary, such as #$Territory. Examples: the #$CityOfDurhamNC in a #$cityInState of #$NorthCarolina-State; Xiamen (Amoy) is a #$cityInState of Fujian."))
)
(defrelation |cityOfAddress|
  :arity 2
  :is-primitive |objectFoundInLocation|
  :domain |ContactLocation|
  :range |City|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$cityOfAddress LOC CITY) means that the #$ContactLocation LOC is located in the #$City CITY.  For example, #$Cycorp's #$cityOfAddress is the #$CityOfAustinTX.  See also #$ContactLocation."))
)
(defrelation |clients|
  :arity 2
  :is-primitive |positiveVestedInterest|
  :domain |Agent|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$clients represents a relationship between two #$Agents.  (#$clients AGENT1 AGENT2) means that AGENT1 provides goods and/or services to AGENT2.  AGENT2 may or may not pay AGENT1 for the goods/services received.  The predicate #$clients can indicate either a one-time relationship or a more long-term relationship.  See also #$suppliers and #$customers."))
)
(defrelation |cloudinessOfRegion|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |OutdoorLocation|
  :range |Cloudiness|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$cloudinessOfRegion LOC DEGREE) means that the #$OutdoorLocation LOC has this DEGREE of cloud cover."))
)
(defrelation |coExtensional|
  :arity 2
  :domain |Collection|
  :range |Collection|
  :annotations ( |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "the sets v1 which are such that ( x (u instances) (isa x v1))"))
)
(defrelation |cohabitants|
  :arity 2
  :is-primitive (:and |cotemporal| |acquaintedWith|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$cohabitants X Y) means that X and Y live together in the same dwelling structure, nest, etc.  
Note: in some contexts (in the real Cyc knowledge base) the arguments to this predicate are restricted to being #$Persons.
Note: in many parts of the world, esp. in past centuries, people cohabit (have cohabitetd) with domesticated animals that are/were not pets."))
)
(defrelation |cohabitingFamilyMembers|
  :arity 2
  :is-primitive (:and |positiveVestedInterest| |cohabitants| |relatives|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |SymmetricBinaryPredicate|
     |FamilyRelationSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$cohabitingFamilyMembers X Y) means that X and Y are family members (relatives, spouses, in-laws) living with one another.  If the members of a family no longer live together, they are still members of a #$Family-SocialEntity, but they are no longer members of the same #$FamilyCohabitationUnit.
Note: In the #$HumanSocialLifeMt context, X and Y must be #$Persons.  In the #$NaiveBiologicalDescentMt context, they can be any #$Animals at all."))
)
(defrelation |cohesivenessOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Cohesiveness|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$cohesivenessOfObject OBJ DEGREE) indicates how tightly a tangible object OBJ coheres.  A higher value of DEGREE means that it is harder to separate away chunks from the object."))
)
(defrelation |colorOfObject|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |PartiallyTangible|
  :range |Color|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$colorOfObject OBJ COLOR) means that a significant fraction of some visible part of the tangible object OBJ has the #$Color COLOR."))
)
(defrelation |comment|
  :arity 2
  :domain (:AND |CycIndexedTerm| |Thing|)
  :range (:AND |CycSystemString| |CharacterString| |CycSystemAtom|)
  :annotations ( |BinaryPredicate|
     |MetaKnowledgePredicate|
     |FunctionalSlot|
     (DOCUMENTATION "#$comment is a predicate belonging to the Cyc collection #$DocumentationConstant.  #$comment is used to relate Cyc constants to (usually) brief English explanations of their meaning and use, as an aid to humans browsing through the Cyc Knowledge Base.  (#$comment CONST STRING) means that STRING is an instance of #$CycSystemString that contains an explanation of the Cyc constant CONST.  Example: what you are reading now."))
)
(defrelation |commitsForFutureUses|
  :arity 2
  :is-primitive |preActors|
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$commitsForFutureUses EVENT OBJECT) means that as a result of EVENT, OBJECT is subsequently put into a configuration and/or a form where it is serving some ongoing #$Role.  Things which are re-usable in their typical uses: a videocassette, a battery, a brick, an artist's canvas, a canvas tent.  Non-reusable things: paint, glue, mortar.  See also #$inputsCommitted, #$recyclableActors.   Consider a brick in a wall in a building.  It is `committed for future use' in the role of part-of-a-wall in the event of that building existing.  While the building is standing, it can't be part-of-a-wall in another building, though it could serve other roles such as an artistic accent, or to anchor a coat-hook.  After the building is torn down, that brick might still be intact, and could be used as part-of-a-wall in a future building.  Notice that the brick isn't necessarily transformed by being part of a wall.  However, so long as OBJECT serves the use to which it is `assigned' by EVENT, OBJECT is unavailable to be assigned the same #$Role by another event of the same type, at least an event that would temporally intersect with this committed use of OBJECT.  That is what is meant by it being `committed' for a particular future use.  An object may be re-used in a similar event, ONLY IF the #$Role to which it was assigned in EVENT either comes to its natural end or is given up (or thwarted), or in cases where EVENT is composed of discontinous pieces of time --- to illustrate that latter case, consider a tent that's used to shelter a certain group of workers on weekdays, but is used to shelter a different group in a different location on weekends."))
)
(defrelation |communicationTarget|
  :arity 2
  :is-primitive |preActors|
  :domain |CommunicationAct-Single|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$communicationTarget is used to indicate the intended recipient in a communication.  (#$communicationTarget COMM OBJ) means that the agent who originates the #$CommunicationAct-Single COM intends the #$recipientOfInfo to be OBJ.  Normally, OBJ is an instance of #$Agent."))
)
(defrelation |communicationToken|
  :arity 2
  :domain |Communicating|
  :range |InformationBearingThing|
  :annotations ( |Role|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$communicationToken is used to indicate the particular IBT (i.e., element of #$InformationBearingThing) that is instrumental in a particular communication.  (#$communicationToken COM IBT) means that IBT is an #$InformationBearingThing that carries the information transferred in the #$Communicating COM.  A communication event transfers the information content of IBT from one agent to some other(s).  IBT may be a tangible object (e.g., a newspaper), a sound (e.g., a voice), an image (e.g., from a television broadcast), or even a touch (e.g., a staying hand)."))
)
(defrelation |competingAgents|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |Competition|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$competingAgents COMPETITN AGT) means that the #$Agent AGT is a competitor in the contest or competition COMPETITN.  This excludes many participants of such events, such as referees, judges, and spectators."))
)
(defrelation |compressibilityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Compressibility|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "(#$compressibilityOfObject OBJ DEGREE) indicates how readily the tangible object OBJ can be compressed to a smaller volume.  The higher the DEGREE of compressibility, the more easily the object can be compressed to a smaller volume.  A related concept is #$elasticityOfObject."))
)
(defrelation |connectedByPathType|
  :arity 3
  :domains (|Thing| |PartiallyTangible|)
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "(#$connectedByPathType PATHTYPE THING1 THING2) means that there is some path of PATHTYPE links connecting THING1 and THING2, where PATHTYPE is some type of linking object that can link two things, like a road, wire, tie-rod, tube, nerve, rope, etc.  This means that the two are connected somehow by one or more paths consisting of links of type PATHTYPE, and that there is no permanent barrier or gap preventing all forms of access along all of those paths."))
)
(defrelation |connectedTo|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |ReflexiveBinaryPredicate|
     |ConnectionPredicate|
     |SpatialPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$connectedTo OBJ1 OBJ2) means that OBJ1 and OBJ2 are configured in a way that allows only certain types of relative motion between them.  A hinged connection, for example, allows limited rotational motion between OBJ1 and OBJ2.  OBJ2 at least must be in a #$SolidStateOfMatter.  In many cases, being #$connectedTo implicitly involves a third object; e.g., a door frame that is #$connectedTo a door by a separate piece, a door hinge."))
)
(defrelation |connectedTo-Rigidly|
  :arity 2
  :is-primitive (:and |connectedTo| |touchesDirectly|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SymmetricBinaryPredicate|
     |ConnectionPredicate|
     |SpatialPredicate|
     |InterExistingObjectSlot|
     (DOCUMENTATION "(#$connectedTo-Rigidly OBJ1 OBJ2) means that OBJ1 and OBJ2 are joined so that no relative motion between them can occur unless the connection is severed by breakage of some part of the connected objects or by disassembly of the connection.  Both of the connected objects are solid."))
)
(defrelation |connectedTo-SemiRigidly|
  :arity 2
  :is-primitive |connectedTo|
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |InterExistingObjectSlot|
     |ConnectionPredicate|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$connectedTo-SemiRigidly OBJ1 OBJ2) means that there is a physical connection between OBJ1 and OBJ2 such that due to the flexibility of a connector, OBJ1, or OBJ2, limited movement around the point of connection is possible.  Positive exemplars include a book flap hinged to the spine of a book (see #$flapHingedTo), the #$GallBladder's attachment to the #$Liver.  Negative exemplars include a wheel and axle or a door hinged to a door frame because the degrees of freedom of the object arise out of geometrical/mechanical properties of the objects and their connectors, not out of the flexibity of said objects.  Note that all flexible connections have a limit to their relative motion.  An extreme example of such a limit is in the connection between a propeller and the fuselage of a rubber band powered airplane."))
)
(defrelation |connotes|
  :arity 3
  :domains ((:AND |SpatialThing| |Individual|) |Thing|)
  :range |GenericAttribute|
  :annotations ( |TernaryPredicate|
     |CotemporalPredicate|
     (DOCUMENTATION "(#$connotes OBJ-1 OBJ-2 DEGREE) means that as a consequence of perceiving one thing (OBJ-1), a typical sane intelligent perceiving agent would likely think of another thing (OBJ-2) with a strength of association indicated by DEGREE.  E.g., (#$connotes #$GermanNaziParty #$Prejudice #$High), (#$connotes #$Lenat #$Cyc #$High).  This predicate is sometimes symmetric, but often not."))
)
(defrelation |constituents|
  :arity 2
  :is-primitive (:and |physicalDecompositions| |cotemporal|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |CompositionPredicate|
     (DOCUMENTATION "The predicate #$constituents is used to indicate a particular #$PartiallyTangible which makes up another (possibly non-distinct) #$PartiallyTangible thing.  (#$constituents WHL PART) means that the individual object WHL is partially constituted by PART, and PART is more or less uniformly distributed in WHL.  For example, the two teaspoons of chocolate syrup that I put in my milk become #$constituents of my glass of chocolate milk.  Note that #$constituents does not entail any special kind of association or bond among the constituents of a thing; they might be simply mixed, they might be chemically bonded, and they might be part of some complex structure."))
)
(defrelation |constrainingObject|
  :arity 2
  :is-primitive (:and |preActors| |postActors|)
  :domain |MovementEvent|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$constrainingObject MOTION OBJ) means that OBJ physically constrains the motion of some #$objectMoving in the #$MovementEvent MOTION.  The #$constrainingObject necessarily #$touches the #$objectMoving during at least part of MOTION.  Examples of #$constrainingObjects include: an axle constraining a wheel turning, a car or other #$transporter carrying passengers, and a railroad track guiding a train.  As these examples show, a #$constrainingObject may or may not be moving.  A road driven on by a car is a marginally negative example of a #$constrainingObject, because the car can drive off the road, though the road does facilitate its motion."))
)
(defrelation |consumesPortion|
  :arity 2
  :is-primitive |objectActedOn|
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$consumesPortion ?EV ?OBJ) means that a portion of the object ?OBJ is used up (consumed) in the event ?EV.  However, enough of ?OBJ remains at the end of ?EV for it to maintain its identity.  Thus #$consumesPortion would be appropriate for an apple that has a bite taken out of it in an eating event, but not for an apple that has been eaten to its core, since the latter is no longer an apple."))
)
(defrelation |containsCavity|
  :arity 2
  :is-primitive (:and |physicalDecompositions| |cotemporal|)
  :domain |PartiallyTangible|
  :range |Cavity|
  :annotations ( |CotemporalObjectsSlot|
     |PhysicalPartPredicate|
     |FunctionalSlot|
     (DOCUMENTATION "(containsCavity OBJ CAV) means that the object OBJ contains the #$Cavity CAV somewhere in it or on its surface.  The cavity of a container could be, e.g., the interior of a box with its walls."))
)
(defrelation |containsInformation|
  :arity 2
  :domain |InformationBearingThing|
  :range |AbstractInformation|
  :annotations ( |NonPhysicalPartPredicate|
     |InterExistingObjectSlot|
     (DOCUMENTATION "(#$containsInformation ?IBT ?INFO) means that ?INFO is part of the information content of the #$InformationBearingThing, ?IBT."))
)
(defrelation |containsPortals|
  :arity 2
  :is-primitive (:and |containsCavity| |physicalParts| |cotemporal|)
  :domain |PartiallyTangible|
  :range (:AND |PartiallyTangible| |Portal|)
  :annotations ( |PhysicalPartPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The portals of this container."))
)
(defrelation |contiguousAfter|
  :arity 2
  :is-primitive |startsAfterEndingOf|
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ComplexTemporalRelation|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$contiguousAfter AFTER BEFORE) means that AFTER starts immediately following BEFORE.  The two events have no time points in common, but there is no time point between them --- i.e., between the ending of the first one (BEFORE) and the starting of the second one (AFTER).  E.g., one can use this predicate to state an axiom that adolescence is #$contiguousAfter childhood.

Note:  This Cyc temporal relation is similar, but not equivalent to, what James Allen independently dubbed the METBY relation."))
)
(defrelation |continuouslyConnectedTo|
  :arity 2
  :is-primitive |touchesDirectly|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |SymmetricBinaryPredicate|
     |ShapeDescribingPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(continuouslyConnectedTo OBJ1 OBJ2) means that OBJ1 and OBJ2 are #$PartiallyTangibles which are are directly and almost seamlessly connected (e.g. they are formed from the same chunk of material, with no substantial barrier or surface or gap separating them.)."))
)
(defrelation |contraryFeelings|
  :arity 2
  :is-primitive |contrastedFeelings|
  :domain (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :range (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :annotations ( |AntiTransitiveBinaryPredicate|
     |IntensionalRepresentationPredicate|
     |FunctionalSlot|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$contraryFeelings EMOTYPE CONTTYPE) means that a feeling of the type EMOTYPE is contrary to a feeling of the type CONTTYPE.  One feeling is contrary to another if they are opposed in almost all their components.  See also #$contrastedFeelings.  It would be very rare for someone to feel both an EMOTYPE and CONTTYPE at the same time, especially about the same thing/event/situation.  E.g., (#$contraryFeelings #$Gloominess #$Cheerfulness), (#$contraryFeelings #$Respect #$Contempt), (#$contraryFeelings #$Shame #$Pride), and so on."))
)
(defrelation |contrastedFeelings|
  :arity 2
  :domain (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :range (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|))
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |IntensionalRepresentationPredicate|
     (DOCUMENTATION "(#$contrastedFeelings EMOTYPE CONTTYPE) means that a feeling of the type EMOTYPE differs in enough components from a feeling of the type CONTTYPE that it is unlikely (but not virtually impossible, as in the case of #$contraryFeelings) that someone would simultaneously experience feelings of both types EMOTYPE and CONTTYPE, especially with respect to the same object. E.g., (#$contrastedFeelings #$Pride #$Remorse),  (#$contrastedFeelings #$Abhorrence #$Respect), (#$contrastedFeelings #$Entertained-Emotion #$Panic), etc.  That last assertion expresses the rule of thumb that one does not often feel both entertained and panicy at the same time, though those two emotions are clearly not each other's `opposite' by any means."))
)
(defrelation |contrastive-RST|
  :arity 2
  :domain |LinguisticObject|
  :range |LinguisticObject|
  :annotations ( |SymmetricBinaryPredicate|
     |RSTRelation|
     (DOCUMENTATION "The discourse relation that holds between two segments of text when ARG1 and ARG2 are presented as being similar in many ways but contrasting in ways the speaker wants to point out."))
)
(defrelation |controls|
  :arity 2
  :is-primitive (:and |positiveVestedInterest| |cotemporal|)
  :domain |Agent|
  :range |Individual|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$controls X Y) represents that assertion that agent X controls the object Y, in one of the following 2 senses:  X can influence (prohibit, enable or constrain) the behavior of Y; or else X can at least influence (prohibit, enable or constrain) the behavior of other #$Agents in/concerning Y.  For example, Fred may control his horse directly, forcing it to do things, or not do them; and he also could control the horse indirectly, by deciding who else has access to and use of that horse.  Control of one agent over another agent is rarely total, of course, so this predicate is most likely to apply to a Y which is a non-living possession, and/or to apply in a very narrow context.  X's control over Y is usually either actual (de facto) control or legal (de jure) control.  It is usually #$cotemporal, meaning that some time slice of X controls the same temporal time slice of Y."))
)
(defrelation |ConvexHullFn|
  :arity 2
  :domain |SpatialThing|
  :range |Surface-Abstract|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(ConvexHullFn OBJECT) is a function applied to a #$SpatialThing (which may be a single object or a #$Group of several unconnected objects) and returns the surface that is the convex hull of the object or objects.  The convex hull encloses, precisely, all of OBJECT and all space that lies on a straight line between any two points that are parts of OBJECT.  The convex hull is a surface; see also #$ConvexHullSpaceFn."))
)
(defrelation |ConvexHullSpaceFn|
  :arity 2
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(ConvexHullSpaceFn OBJECT) is a function applied to a #$SpatialThing (which may be a single object or a #$Group of several unconnected objects) and returns the spatial region that is enclosed by the convex hull of the object or objects.  The convex hull encloses, precisely, all space that lies on a straight line between any two points that are parts of OBJECT.  The enclosed space is three or two dimensional and is not necessarily the hull surface itself; see also #$ConvexHullFn."))
)
(defrelation |conveyor-Stationary|
  :arity 2
  :is-primitive |instrument-Generic|
  :domain |TransportationEvent|
  :range |TangibleThing|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(conveyor-Stationary ?TRAN ?CONV) means that in the transportation event ?TRAN, ?CONV is a conveyor just like a transporter except it does not move together with the transportee along the path of the transportation.  For example, a river can move aboat from a location to another, and a conveyor belt can move some objects from one place to another, without itself moving with them inthe literal sense, i.e., the river does not change its location(though some pieces of water in the river do) together with the boat, nor does the conveyor belt move with the objects on it from place to place (though some parts of it do)."))
)
(defrelation |cost|
  :arity 2
  :domain |Individual|
  :range |Money|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$cost OBJECT MONEY) means that buying OBJECT costs the amount MONEY, where this amount can be an interval.  The #$cost of something is time- and seller-dependent.  For example, the cost of a particular mansion Grey Gables is US$800,000 in an actual sale, or when offered for sale; #$cost does not refer to appraised value."))
)
(defrelation |costPerQuantity|
  :arity 4
  :domains ((:AND |StuffType| |ProductType| (:FILLED-BY SUPERRELATIONS |Product|)) |PhysicalAmountSlot|
            |ScalarInterval|)
  :range |Money|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "The predicate #$costPerQuantity gives the price for a measured amount of some type of stuff.  (#$costPerQuantity STUFF UNITS QUANTITY PRICE) means that this kind of STUFF costs PRICE for each QUANTITY of UNITS.  For example, #$Milk, as measured by volume (i.e., by the predicate #$volumeOfObject), costs about US $3 per gallon."))
)
(defrelation |cotemporal|
  :arity 2
  :is-primitive (:and |temporalBoundsIdentical| |temporallySubsumes|)
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |TransitiveBinaryPredicate|
     |ComplexTemporalRelation|
     |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     (DOCUMENTATION "(#$cotemporal X Y) means that X and Y have the exact same temporal extent.  This is a much stronger relation than #$temporalBoundsIdentical (q.v.).







Note:  Cyc's #$cotemporal relation is equivalent to what James Allen independently dubbed the EQUALS relation."))
)
(defrelation |cotemporalSubEvents|
  :arity 2
  :is-primitive (:and |subEvents| |cotemporal|)
  :domain |Event|
  :range |Event|
  :annotations ( |SubProcessSlot|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$cotemporalSubEvents is used to relate an event to some sub-portion of the event which has the same duration as the whole event but doesn't include everything that happens.  (#$cotemporalSubEvents WHOLE PART) means that WHOLE and PART are cotemporal events (i.e., they have the same exact duration), and PART is a component of WHOLE.  For example, a particular element of #$RainStorm may have distinguishable #$cotemporalSubEvents for (1) raining and (2) wind blowing.  Or, an instance of swimming #$Backstroke has separable events for (1) kicking and (2) arm motion throughout the swimming.  #$cotemporalSubEvents allows us to identify them and state different things about the distinct processes.  See also #$cotemporal, #$subEvents."))
)
(defrelation |Coulomb|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfCharge|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     (DOCUMENTATION "This is the basic unit of measure for charge in the metric system and in CYC."))
)
(defrelation |countryOfAddress|
  :arity 2
  :is-primitive |objectFoundInLocation|
  :domain |PartiallyTangible|
  :range |Country|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$countryOfAddress LOC COUNTRY) means that the #$ContactLocation LOC is located in the #$Country COUNTRY.  For example, #$Cycorp's #$countryOfAddress is the #$UnitedStatesOfAmerica.  See also #$ContactLocation."))
)
(defrelation |covering|
  :arity 2
  :domain |SetOrCollection|
  :range |SetOrCollection|
  :annotations ( |TaxonomicSlot|
     (DOCUMENTATION "(#$covering SETORCOL COVER) means that the mathematical set or collection COVER is a covering of the mathematical set or collection SETORCOL -- that is, the elements of COVER are themselves mathematical sets or collections, and every element of SETORCOL is an element of at least one of the elements of COVER.  For example, the Linnaean taxonomy of types of living things (Dog, Mammal, Chordate, Fungus, etc.) is a covering of the set of all animals alive today.  Every animal alive today is a member of one or more of the Linnaean categories.  A covering set or collection COVER may contain `extra' elements, which are not members of SETORCOL.  For example, the union of all the Linnaean categories (see #$OrganismClassificationType) is actually much larger than the set of animals alive today, encompassing plants, extinct animal species, etc.  In order to express an assertion about covering, one need not create a new constant from scratch to play the role of COVER if such a constant doesn't already exist.  Instead, one can specify a covering set by enumerating its elements, using the function #$TheCovering.  (This is a special #$ReifiableFunction whose principal reason-for-being is to facilitate the inference heuristics associated with assertions about covering.)"))
)
(defrelation |covers-Baglike|
  :arity 2
  :is-primitive (:and |touches| |surroundsCompletely|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$covers-Baglike WRAP OBJECT) means that WRAP covers OBJECT as a continuous sheet wrapping wholly around object.  WRAP #$touches OBJECT, so there is nothing greater than a sheet thickness separating them.  OBJECT is totally enclosed in WRAP."))
)
(defrelation |covers-Hairlike|
  :arity 2
  :is-primitive |cotemporal|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$covers-Hairlike HAIR OBJECT) means that HAIR consists of a mob of things that are embedded close together in OBJECT and cover some portion of its surface.  See also #$Mob."))
)
(defrelation |covers-Paintlike|
  :arity 2
  :is-primitive (:and |cotemporal| |touches|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(covers-Paintlike COATING OBJECT) means that COATING adheres to and covers OBJECT like a coat of paint. COATING touchesDirectly onto OBJECT. COATING may be either dry (e.g., dried paint) or liquid (e.g., lubricant spread on a surface, like cooking oil on a baking pan). Like paint, COATING isn't more cohesive with itself thanit is with OBJECT, so (if dry) it would tend to peel or flake off in small pieces, rather than as a whole."))
)
(defrelation |covers-Ruglike|
  :arity 2
  :is-primitive |cotemporal|
  :domain |SolidTangibleThing|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$covers-Ruglike MAT OBJECT) means that MAT covers at least part of one surface of OBJECT.  MAT is #$SheetShaped, and MAT lies with its two longer dimensions parallel to OBJECT.  See also #$coversWithConformity."))
)
(defrelation |covers-Skinlike|
  :arity 2
  :is-primitive (:and |cotemporal| |touches|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |FunctionalSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$covers-Skinlike SKIN OBJECT) means that SKIN forms all or part of OBJECT's outer surface, shell, or skin.  The predicate is agnostic as to whether SKIN is a part of OBJECT."))
)
(defrelation |coversWithConformity|
  :arity 3
  :domains (|SolidTangibleThing| |SheetOfSomeStuff|)
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |TernaryPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "(#$coversWithConformity OBJ SHEET LEVEL) means that OBJ is covered by SHEET, and SHEET conforms to the surface features of OBJ to the degree LEVEL.  SHEET may cover OBJ in either the sense of #$covers-Ruglike or #$covers-Baglike.  For example, hosiery covers legs with a #$High degree of conformity; sweat pants have #$Low conformity to legs."))
)
(defrelation |CubicCentimeter|
  :annotations ( |CGSUnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfVolume|
     (DOCUMENTATION "The measurement function used in Cyc to represent the Metric cc, a unit of measure for volume.  See also #$CGSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |customers|
  :arity 2
  :is-primitive (:and |cotemporal| |clients| |doesBusinessWith|)
  :domain |Agent|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$customers represents a relationship between two #$Agents.  (#$customers AGENT1 AGENT2) means AGENT1 sells goods and/or services to AGENT2.  AGENT2 must actually buy something from AGENT1 in order to be one of AGENT1's #$customers.  (Thus, #$customers has a narrower meaning than `customer' in colloquial English, which includes potential buyers.)  See also #$clients.  Cf. #$buyingAgent (in a particular sales event). "))
)
(defrelation |cycleInSystem|
  :arity 2
  :domain |Path-Generic|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$cycleInSystem CYCLE SYS) means that CYCLE is a cycle in the path system SYS.  A cycle in SYS is either a loop in SYS or the concatenation of two different paths PATH1 and PATH2 in SYS satisfying (i) there are two points X and Y in SYS such that (#$pathBetweenInSystem PATH1 X Y SYS) and (#$pathBetweenInSystem PATH2 X Y SYS), and (ii) no point in SYS other than X and Y is on both PATH1 and PATH2."))
)
(defrelation |cyclistNotes|
  :arity 2
  :domain |CycIndexedTerm|
  :range |CycSystemString|
  :annotations ( |BinaryPredicate|
     |DistributingMetaKnowledgePredicate|
     (DOCUMENTATION "(#$cyclistNotes X S) means that S is a string of text that usually conveys a message useful to others involved in building the Cyc KB.  This might include warnings ('don't use this!'), plans for future expansion or changes, etc."))
)
)    ; END EVAL-WHEN 2

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 3
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |CylinderFn|
  :arity 3
  :domains (|Distance| |Distance|)
  :range (:AND |AbstractShape| |ThreeDimensionalShape|)
  :annotations ( |ShapeFunction|
     (DOCUMENTATION "The Cyc function #$CylinderFn is a #$ShapeFunction (q.v.).  (#$CylinderFn L D) that returns an abstract cylinder of length L and diameter D.  For example, a particular beer mug #$canContainShapes (#$CylinderFn (#$Inch 10) (#$Inch 5))."))
)
(defrelation |dailyHighTemperature|
  :arity 2
  :domain |GeographicalRegion|
  :range |Temperature|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$dailyHighTemperature PLACE TEMP) means that the #$Temperature TEMP is the high temperature for a day at the #$GeographicalRegion PLACE.  #$dailyHighTemperature is typically used for a specified period of time (e.g., a particular day or a specific season); it may be used with generic temperature ranges as well as precise temperatures.  Examples: using #$holdsIn, we can say that Austin's temperature for 7/20/96 is 102 degrees Fahrenheit; or we can say that for any #$SummerSeason, Austin's [typical] #$dailyHighTemperature is #$VeryHot."))
)
(defrelation |dailyLowTemperature|
  :arity 2
  :domain |GeographicalRegion|
  :range |Temperature|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$dailyLowTemperature PLACE TEMP) means that the #$Temperature TEMP is the low temperature for a day at the #$GeographicalRegion PLACE.  #$dailyLowTemperature is typically used for a specified period of time (e.g., a particular day or a specific season); it may be used with generic temperature ranges as well as precise temperatures."))
)
(defrelation |damages|
  :arity 2
  :is-primitive (:and |maleficiary| |objectActedOn|)
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(#$damages EV OBJ) means that OBJ is acted on in EV in such a way as to end up damaged.  Destruction is considered an extreme form of damage."))
)
(defrelation |DateAfterFn|
  :arity 3
  :domains (|Date| |Time-Quantity|)
  :range |Date|
  :annotations ( |NonPredicateFunction|
     |EvaluatableFunction|
     (DOCUMENTATION "Like #$PlusFn, but for #$Dates.  (#$DateAfterFn ?DATE ?DUR) returns a #$Date which is ?DUR amount of time after ?DATE.  For example, (#$DateAfterFn (#$YearFn 1950) (#$YearsDuration 10)) returns (#$YearFn 1960).  See also #$DateBeforeFn, #$TimeElapsedFn."))
)
(defrelation |DateBeforeFn|
  :arity 3
  :domains (|Date| |Time-Quantity|)
  :range |Date|
  :annotations ( |NonPredicateFunction|
     |EvaluatableFunction|
     (DOCUMENTATION "Like #$DifferenceFn, but for #$Dates.  (#$DateBeforeFn ?DATE ?DUR) returns a #$Date which is ?DUR amount of time before ?DATE.  For example, (#$DateBeforeFn (#$YearFn 1999) (#$YearsDuration 1)) returns (#$YearFn 1998).   See also #$DateAfterFn, #$TimeElapsedFn."))
)
(defrelation |dateOfDeath|
  :arity 2
  :is-primitive |endingDate|
  :domain |Entity|
  :range |Date|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$dateOfDeath ?X ?Y) indicates that the #$Entity ?X ceased to exist during #$Date ?Y. For people, this is the date at which they died, hence the name of the predicate.  The first argument to this predicate must be an #$Entity, and not just any old #$SomethingExisting, because we don't want to talk about the #$birthDate or #$dateOfDeath of a subabstraction like AlbertEinsteinWhileAtPrinceton; in other words, proper subabstractions will have #$startingDates and #$endingDates, but only true #$Entitys will have a #$birthDate or #$dateOfDeath"))
)
(defrelation |DayFn|
  :arity 3
  :domains (|PositiveInteger| |CalendarMonth|)
  :range |CalendarDay|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$DayFn ?D ?MNTH) denotes a #$CalendarDay -- in particular, the day number ?D of month ?MNTH.  For example, (#$DayFn 14 (#$MonthFn #$February (#$YearFn 1966))) denotes Feb. 14th, 1966"))
)
(defrelation |DaysDuration|
  :annotations ( |UnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfTime|
     (DOCUMENTATION "This is a function that takes one or two numbers and returns, as its value, some amount of #$Time.  An expression of the form (#$DaysDuration ?min ?max) denotes a quantity of #$Time that is at least ?min Days and at most ?max Days.  (#$DaysDuration ?num) denotes a quantity of #$Time that is exactly ?num days."))
)
(defrelation |deadEndInSystem|
  :arity 2
  :is-primitive |pointInSystem|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$deadEndInSystem END SYS) means that END is a dead-end node in the specified #$PathSystem SYS.  A node X in SYS is a dead-end node in SYS if there is exactly one link LINK in SYS that END is on and END is not on any loop in SYS.  One easy way to illustrate a deadend X in SYS is to picture it as a node with only one path (possibly very 'short') in the system through which one can approach or leave X.  Note that no totally isolated node in SYS can be a deadend in SYS, neither can any point in SYS that is on a loop in SYS.  If there is no specified #$PathSystem in which the path ends, but the ending is a dead end of a #$Path-Customary like a road or wire, then use #$pathTerminus instead."))
)
(defrelation |dealerFor|
  :arity 2
  :domain |RetailOrganization|
  :range |ManufacturingOrganization|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$dealerFor relates a retailer to the manufacturer(s) whose products are sold by that retailer.  (#$dealerFor RETAILER MANUF) means that the #$RetailOrganization RETAILER is a dealer for products made by the #$ManufacturingOrganization MANUF.  RETAILER may be only one of many dealers.  RETAIL sells MANUF's products to the final consumers."))
)
(defrelation |defendants|
  :arity 2
  :is-primitive |litigants|
  :domain |Trial|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION " (defendants ARG1 ARG2) means that the agent ARG2 is the accused party in the lawsuit ARG1."))
)
(defrelation |defnIff|
  :arity 2
  :is-primitive |defnSufficient|
  :domain |Collection|
  :range |CycSystemSymbol|
  :annotations ( |FunctionalSlot|
     |InferenceRelatedBookkeepingPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$defnIff COL TEST) means that TEST is the name of a piece of code in the Cyc system substrate, and TEST acts as a necessary and sufficient test for inclusion in the #$Collection COL.  If TEST returns T [True] when applied to a particular item, that item is considered an element of COL; all elements of COL must fulfill TEST's requirements.  Cf. #$defnNecessary, #$defnSufficient."))
)
(defrelation |defnNecessary|
  :arity 2
  :domain |Collection|
  :range |CycSystemSymbol|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$defnNecessary COL TEST) means that TEST is the name of a piece of code in the Cyc system substrate, and TEST acts as a necessary definition for membership in the Cyc #$Collection COL.   Only if TEST returns T [True] when applied to a particular item can that item be considered an element of COL; all elements of COL must fulfill TEST's requirements, although there may be additional requirements for membership in COL as well.  Cf. #$defnIff and #$defnSufficient."))
)
(defrelation |defnSufficient|
  :arity 2
  :domain |Collection|
  :range |CycSystemSymbol|
  :annotations ( |BinaryPredicate|
     |InferenceRelatedBookkeepingPredicate|
     (DOCUMENTATION "(#$defnSufficient COL TEST) means that TEST is the name of a piece of code in the Cyc system substrate, and TEST acts as a sufficient definition for inclusion in the Cyc #$Collection COL.  If TEST returns T [True] when applied to a particular item, that item is considered an element of COL.  Note that TEST isn't necessarily a necessary test for membership in COL; i.e., not all elements of COL must pass the test, unless TEST is also a #$defnNecessary for COL.  Cf. #$defnNecessary, #$defnIff."))
)
(defrelation |Degree-UnitOfAngularMeasure|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfAngularDistance|
     (DOCUMENTATION "The basic unit to measure the size of angles, in the Imperial system of measurement.  360 degrees = 1 complete circle"))
)
(defrelation |DegreeCelsius|
  :annotations ( |UnitOfMeasureNoPrefix|
     |MKSUnitOfMeasure|
     |UnitOfTemperature|
     (DOCUMENTATION "The standard unit of temperature in much of the world and also in CYC."))
)
(defrelation |DegreeFahrenheit|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfTemperature|
     (DOCUMENTATION "The unit of measure on the Fahrenheit scale; mainly used in the USA"))
)
(defrelation |DegreeKelvin|
  :annotations ( |UnitOfMeasureNoPrefix|
     |StandardUnitOfMeasure|
     |UnitOfTemperature|
     (DOCUMENTATION "The unit of measure on the Kelvin or Absolute temperature scale; mainly used in science; note that the size of this unit is equal to the size of a DegreeCentrigrade."))
)
(defrelation |deliberateActors|
  :arity 2
  :is-primitive |preActors|
  :domain |Event|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$deliberateActors ACT ACTR) means that the #$Agent ACTR is conscious, volitional, purposeful in the event ACT.   ACTR is aware of acting in ACT and chooses to play the role he/she/it has in that event; i.e., ACTR has some purpose in mind.
Note:  If you do something deliberately but you fail, you are still a #$deliberateActors.  For instance, you are a near-sighted doer of #$ShowingSupportForSomeone at a fencing match, and it turns out you were cheering for Fred when you thought you were cheering for Joe; nevertheless, you are still one of the #$deliberateActors in the #$ShowingSupportForSomeone event.
Note: Legal responsibility is a separte issue from `deliberateness.'  Doing something in a fit of rage (e.g. a crime of passion) still involves purpose, volition, and consciousness even if considered for only an instant, and even if the laws and courts find you not guilty."))
)
(defrelation |denotation|
  :arity 4
  :domains (|EnglishWord| (:AND |LinguisticObjectType| (:FILLED-BY SUPERRELATIONS |SpeechPart|)) |Integer|)
  :range |Thing|
  :annotations ( |QuaternaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "The predicate #$denotation is used to relate English words to their denotations within the Cyc Knowledge Base.  Some words have multiple denotations associated with different word senses, which may or may not occur in the same parts of speech. (#$denotation WORD PART NUM CONST) means that the denotation of WORD, with part of speech PART and word sense number NUM, is the Cyc constant CONST.  Examples: (1) #$Place-TheWord, an instance of #$EnglishWord, has the denotation #$PuttingSomethingSomewhere when used as a #$Verb with its word sense 0, and the denotation #$Place when used as a #$SimpleNoun with that same word sense; (2) #$Ring-TheWord currently has four #$denotation assertions in the KB: #$EmittingSound (as a #$Verb with its 1st word sense); #$AudibleSound (as a #$SimpleNoun with its 1st word sense); #$RingShape (as a #$SimpleNoun with its 0th word sense); and #$Ring-Jewelry (as a #$SimpleNoun with its 2nd word sense).  Note that #$denotation may reference the results of Cyc functions, as well as Cyc constants; e.g., #$Density-TheWord denotes (#$IntervalMinFn (#$LowAmountFn #$Density)).  See also #$WordSense, #$SpeechPart."))
)
(defrelation |densityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Density|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$densityOfObject OBJ DENS) means that the tangible thing OBJ has the #$Density DENS."))
)
(defrelation |desires|
  :arity 2
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$desires AGT PROP) means that the #$Agent AGT desires that the world be as the proposition PROP (represented by a #$CycFormula) describes it to be.  #$desires is implied by #$goals, but is weaker:  PROP might be some desirable state of affairs that the agent is not actively working, or planning, to make/keep true; e.g., #$WorldPeace.  See also #$goals and #$intends."))
)
(defrelation |destination-RoundTrip|
  :arity 2
  :is-primitive |nonDeliberateActors|
  :domain |Translation-RoundTrip|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$destination-RoundTrip TRIP PLACE) means that PLACE is the destination (i.e., the #$toLocation) of the OUTBOUND leg of the round-trip event TRIP.  PLACE is where the #$objectMoving in TRIP goes and then returns from.  See also #$origin-RoundTrip, #$Translation-RoundTrip, #$outboundLegOfRoundTrip."))
)
(defrelation |developerOfIBTType|
  :arity 2
  :domain |SpecifiedInformationBearingThingType|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "The predicate #$developerOfIBTType relates a specific work to its creator(s).  (#$developerOfIBTType IBTTYPE AGENT) means that AGENT is one of the people, corporations, publishers, etc., responsible for the invention or bringing into being of the #$SpecifiedInformationBearingThingType IBTTYPE, which may be a book, television show, computer program, musical score, etc.  Examples: #$Lenat is a #$developerOfIBTType for the #$CycKB; #$OrsonWelles is a #$developerOfIBTType for #$CitizenKane-TheMovie."))
)
(defrelation |deviceControlledBy|
  :arity 2
  :domain |PhysicalDevice|
  :range |ControlDevice|
  :annotations ( |AsymmetricBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     (DOCUMENTATION "(#$deviceControlledBy DEV CONTROL) means that CONTROL is a #$ControlDevice that controls #$PhysicalDevice DEV.  Most of the time, the controls will be #$physicalParts of the device.  However there are some notable exceptions -- one's TV remote control, for example -- which control a device but are not #$physicalParts of that device."))
)
(defrelation |deviceUsed|
  :arity 2
  :is-primitive |instrument-Generic|
  :domain |Event|
  :range |PhysicalDevice|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$deviceUsed indicates that a particular device is used in a particular event. (#$deviceUsed EVENT OBJECT) means that the #$PhysicalDevice OBJECT plays an instrumental role in the #$Event EVENT.  (See also #$instrument-Generic.) OBJECT is intentionally used in EVENT, and standardly (e.g., in the #$HumanActivitiesMt) OBJECT's role in EVENT is consistent with the object's #$primaryFunction."))
)
(defrelation |DifferenceFn|
  :arity 3
  :domains (|ScalarInterval| |ScalarInterval|)
  :range |ScalarInterval|
  :annotations ( |EvaluatableFunction|
     |NonPredicateFunction|
     |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$DifferenceFn is Cyc's subtraction operator; it is a binary mathematical function.  (#$DifferenceFn MINUEND SUBTRAHEND) yields a new quantity that is the result of subtracting SUBTRAHEND from MINUEND.  Both arguments to #$DifferenceFn must be elements of #$ScalarInterval, as is its result.  Examples: (#$DifferenceFn 88 11) returns 77; (#$DifferenceFn (#$Kilogram 4.2) (#$Kilogram 3)) returns (#$Kilogram 1.2)."))
)
(defrelation |different|
  :annotations ( |CommutativeRelation|
     |VariableArityRelation|
     |EvaluatableFunction|
     |Predicate|
     (DOCUMENTATION "The variable-arity predicate #$different is used to state the non-identity of two or more objects. (#$different X1 X2 ... Xn) means that each Xi given as an argument is not equal to any of the other Xi's.  #$different is an element of #$EvaluatableFunction (q.v.).  See also #$equals.



#$different can be used to simplify formulas when several things need to be tested for mutual inequality."))
)
(defrelation |differentInAttribute|
  :arity 3
  :domains (|Thing| |Thing|)
  :range |AttributeType|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$differentInAttribute THING1 THING2 ATTRIBUTE) means that the two things THING1 and THING2 do not have the same values of the #$AttributeType ATTRIBUTE.  Here 'the same' could mean means complete identity or close resemblance -- what this 'different' means, and what the standard of closeness or identity is, depends on the context, but #$differentInAttribute and #$identicalInAttribute cannot both be correctly asserted of the same two things.  See also #$resemblesInAttribute, and #$differentInAttribute."))
)
(defrelation |directingAgent|
  :arity 2
  :is-primitive |deliberateActors|
  :domain |Event|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$directingAgent ACT AGENT) means that AGENT is one of the agents that is in control of or directing ACT, but not necessarily directly performing it.  If, in the event ACT, an agent other than AGENT has the #$performedBy role, then that performer's actions in ACT are directed by AGENT.  For example, (#$directingAgent PSOBicentennialConcertOfBeethovensNinth #WilliamSteinberg) is true, because Steinberg was the conductor of that concert; he directed the many other musicians who performed in that event.  Another case: (#$directingAgent MassacreAtMyLai LtWilliamCalley).  The type of direction implied by #$directingAgent is the kind that can be accomplished by AGENT communicating its desires to the actual performer(s) of ACT.  So, a person would be the #$directingAgent in a clothes-washing event #$doneBy a washing machine ONLY in those contexts in which we can consider the machine an agent, acting intentionally."))
)
(defrelation |direction-Pointing|
  :arity 2
  :domain |PartiallyTangible|
  :range |UnitVectorInterval|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$direction-Pointing OBJ DIR) means that the intrinsic pointing axis of OBJ points in the direction DIR (which is described using an instance of #$UnitVectorInterval).  Pointing axes may be ascribed to certain objects especially in relation to their function(s); e.g., objects which are intended to indicate direction (e.g., a pointer stick, a compass needle); objects which cause motion in a certain direction (e.g., a gun, a train); objects which are accessed from a certain direction (e.g., cupboards, couches)."))
)
(defrelation |directionBetweenObjects|
  :arity 3
  :domains (|PartiallyTangible| |PartiallyTangible|)
  :range |UnitVectorInterval|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$directionBetweenObjects OBJ1 OBJ2 UVI) means that UVI, an element of #$UnitVectorInterval, is a vector or set of vectors which point(s) from a point (or set of points) in OBJ1 to a point (or set of points) in OBJ2.  See also #$VectorFromToFn which is roughly interchangeable with #$directionBetweenObjects.  #$directionBetweenObjects has the advantage that an arbitrarily precise direction may be specified.  #$VectorFromToFn saves the user from doing the labor involved with reifiing and from having to know the direction between OBJ1 and OBJ2."))
)
(defrelation |directionOfTranslation-Throughout|
  :arity 2
  :domain |Movement-TranslationEvent|
  :range |UnitVectorInterval|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$directionOfTranslation-Throughout MOVEMENT DIR) means that the #$objectMoving in the MOVEMENT #$Event translates in the direction DIR throughout MOVEMENT.  In a #$Translation-MultiPath event, where there are several objects moving and following different pathways, this means that at least one of those objects moves in direction DIR.
Note: It may turn out, in the future, to be worth creating a ternary version of this, which specifies which direction each particular #$objectMoving moves in."))
)
(defrelation |dirtinessOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Dirtiness|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$dirtinessOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$Dirtiness."))
)
(defrelation |disjointWith|
  :arity 2
  :domain |SetOrCollection|
  :range |SetOrCollection|
  :annotations ( |RuleMacroPredicate|
     |TaxonomicSlot|
     |DefaultMonotonicPredicate|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$disjointWith SETORCOL1 SETORCOL2) means that the mathematical set or collection SETORCOL1 is disjoint with the mathematical set or collection SETORCOL2 -- that is, the two have no elements in common."))
)
(defrelation |dislikesObject|
  :arity 2
  :domain |Agent|
  :range |PartiallyTangible|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$dislikesObject AGT OBJ) means that AGT feels an emotion of #$Dislike when interacting with OBJ in some way.  See #$likesObject for elaboration.  A specialization of #$dislikesObject is #$dislikesSensorially (qv). "))
)
(defrelation |dislikesRoleInActivity|
  :arity 3
  :domains (|Agent| |ActorSlot|)
  :range |Event|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$dislikesRoleInActivity AGT ROLE EVT) means that if the #$Agent AGT has the relation ROLE to the #$Event EVT, then AGT is likely to feel #$Dissatisfaction.  This predicate is useful to represent sentences such as `Joe dislikes running' or `Fred disliked receiving the flogging'."))
)
(defrelation |dislikesSensorially|
  :arity 2
  :is-primitive |dislikesObject|
  :domain |PerceptualAgent|
  :range |SensoryAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$dislikesSensorially AGT SENSUM) means that the #$PerceptualAgent AGT feels some physical discomfort from the sensory experience of SENSUM (a taste, an odor, a particular level of pain, etc. --- see #$SensoryAttribute).
Note: this is a stronger statement than (#$not (#$likesSensorially AGT SENSUM)), as there may be many #$SensoryAttributes which one neither particularly likes nor dislikes."))
)
(defrelation |distanceAboveSeaLevel|
  :arity 2
  :domain |GeographicalRegion|
  :range |Distance|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$distanceAboveSeaLevel REG DIST) means that the altitude above sea level of the #$GeographicalRegion REG is the #$Distance DIST.  For elements of #$Mountain, distance is measured from sea level to the peak; for elements of #$Lake, from the surface to sea level; for cities, from the center of town to sea level.  Examples: (#$distanceAboveSeaLevel #$PikesPeak-Mount (#$Foot-UnitOfMeasure 14110)); (#$distanceAboveSeaLevel #$MountEverest (#$Foot-UnitOfMeasure 29028)); (#$distanceAboveSeaLevel #$MountFuji-Volcano (#$Foot-UnitOfMeasure 12389)); (#$distanceAboveSeaLevel #$LakeHuron (#$Foot-UnitOfMeasure 580))."))
)
(defrelation |distanceBetween|
  :arity 3
  :domains (|SpatialThing| |SpatialThing|)
  :range |Distance|
  :annotations ( |FunctionalPredicate|
     |TernaryPredicate|
     |CotemporalPredicate|
     (DOCUMENTATION "(#$distanceBetween THIS THAT DIST) means that the distance between two things, THIS and THAT, is DIST.  DIST is the length of the shortest straight line which extends from a point on THIS to a point on THAT.  For example, (#$distanceBetween #$LaGuardiaAirport #$NewYorkHiltonAtBroadway (#$Kilometer 12)).  The notion of 'straight line' depends on the context; in a Geography-related context it would be a great circle line on the Earth's surface rather than a true Euclidian straight line going through the Earth."))
)
(defrelation |distanceOfRotation|
  :arity 2
  :domain |Movement-Rotation|
  :range (:AND |ScalarInterval| |PhysicalAttribute|)
  :annotations ( |Role|
     |BinaryPredicate|
     (DOCUMENTATION "This predicate indicates, for a particular rotational motion event, the total absolute value of the angular distance travelled by the #$objectMoving in that event.  (#$distanceOfRotation ROT DIST) means that in the event ROT, the #$objectMoving travelled the angular distance DIST.  Note that this is not the same as the net angular displacement of the #$objectMoving, but rather the entire angular distance travelled.  So if you unscrew a jar lid 1/6 of a turn, and later screw it back on, the #$distanceOfRotation is 120 degrees, not zero; and if you spin around ten times, your #$distanceOfRotation is 3600 degrees, not zero.  Angular distance is measured in degrees, radians, etc."))
)
(defrelation |distanceTranslated|
  :arity 2
  :domain |Movement-TranslationEvent|
  :range |Distance|
  :annotations ( |IntervalBasedQuantitySlot|
     |Role|
     (DOCUMENTATION "This predicate relates a translational movement event to the total distance travelled by the #$objectMoving in that event.  (#$distanceTranslated MOVE DIST) means that in the event MOVE, the #$objectMoving covered the distance DIST.  Note that DIST is the actual distance travelled by the object, not merely its net change in position; so if the #$pathway-Complete of MOVE is a round trip a mile each way to the store, the #$distanceTranslated would be 2 miles, not zero."))
)
(defrelation |doesBusinessWith|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Agent|
  :range |Agent|
  :annotations ( |CotemporalObjectsSlot|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$doesBusinessWith relates two agents who do business with each other.  (#$doesBusinessWith AGENT1 AGENT2) means that AGENT1 does some business with AGENT2.  Minimally, that means the two agents at least occasionally negotiate to buy or sell products or services from one other. The two agents may or may not complete the sales/purchase and enter into actual contracts."))
)
(defrelation |Dollar-UnitedStates|
  :annotations ( |StandardUnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfMoney|
     (DOCUMENTATION "An element of #$UnitOfMoney.  #$Dollar-UnitedStates represents the main standard monetary unit of the United States of America.  One #$Dollar-UnitedStates is equivalent to 100 #$Cent-UnitedStates.  See #$UnitOfMeasure for further explanation."))
)
(defrelation |DollarsPerHour|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfMonetaryFlowRate|
     (DOCUMENTATION "An element of #$UnitOfMonetaryFlowRate; the amount of #$Money in dollars earned, spent, or transferred in an hour."))
)
(defrelation |DollarsPerYear|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfMonetaryFlowRate|
     (DOCUMENTATION "An element of #$UnitOfMonetaryFlowRate; the amount of #$Money in dollars earned, spent, or transferred in a year."))
)
(defrelation |domainAssumptions|
  :arity 2
  :domain |Microtheory|
  :range |CycFormula|
  :annotations ( |MicrotheoryPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$domainAssumptions M P) means that the microtheory M has the proposition P as a domain assumption.  See the comment for #$Microtheory for a detailed explanation of what the `assumptions' of a mt are, as opposed to its `content'.  In brief, it means that all the `content' assertions of M assume that P is true.  Another way of thinking of this is that one is `in' context M only if all its domain assumptions are true.  Another way of thinking of this is that the various `content' assertions of M only apply to objects that satisfy all its #$domainAssumptions.  Yes, that means that the `domain of quantifiers' (#$forAll and #$thereExists) is limited to the universe of such objects.  So if it's true in M that (#$forAll ?x Q), and if we lift this axiom to another theory M2 that does not make the domain assumption P, then the axiom becomes (#$forAll ?x (#$implies P Q)).  

Note:  Actually, what becomes true in M2 is slightly more complicated, namely: (#$forAll ?x (#$implies (#$and P1 P2 P3...) Q)), where P1, P2, P3,... are all the domain assumptions of M which are not implied by the domain assumptions of M2.

Note:  Domain assumption propositions --- in this case P --- must have a special format:  P must contain the free variable ?U, and this ?U represents `some term which is talked about in M'.  The idea is that one could have a domain assumption that said `if ?U is a person, ?U must have been born after 1950', or which said `if ?U is the performer of an event, then ?U is a person' etc.  For example:  (#$implies (#$isa ?U #$PhysicalStateChangeEvent) (#$isa ?U #$CreationOrDestructionEvent)) is one of the #$domainAssumptions of the #$NaiveStateChangeMt context.  It says that, in that context, physical state changes of an object (e.g., melting or boiling) are viewed as creations and destructions, in which elements of #$Entity come into or go out of existence, rather than viewing them as events which preserve entityhood."))
)
(defrelation |doneBy|
  :arity 2
  :is-primitive (:and |actors| |preActors|)
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$doneBy relates an event to its `doer'.  (#$doneBy EVENT DOER) means that DOER is the `doer' in the event EVENT.  Some action on the part of the doer causes or carries out the event.  This predicate is agnostic as to whether DOER does EVENT intentionally or not (DOER need not even be animate; e.g., the event in which Mount Vesuvius erupted and buried Pompeii was #$doneBy Mount Vesuvius).  See #$performedBy and #$bodilyDoer for the more specific senses of `doer' when DOER is, respectively, an agent (#$Agent) acting deliberately or a biological organism (#$Organism-Whole)."))
)
(defrelation |doorwayHasCovering|
  :arity 2
  :is-primitive |portalHasCovering|
  :domain |Doorway|
  :range |DoorwayCovering|
  :annotations ( |BinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "Relates a #$Doorway to the physical covering used to seal it.  The user should be aware that #$Doorway, the designated arg1 for this predicate, is currently constrained to be a physical part of some instance of #$ShelterConstruction.  This is because, in normal English parlance, doorways are the portals through which people pass to get in and out of shelter constructions, and from room to room.  Planes, trains, automobiles, and other vehicles are not conventionally said to have #$Doorways, and if the aim is to assert something about the #$PortalCoverings of a vehicle, #$portalHasCovering would be the appropriate predicate to use."))
)
(defrelation |driverActor|
  :arity 2
  :is-primitive (:and |performedBy| |transportees|)
  :domain |TransportationEvent|
  :range |Person|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(#$driverActor DRIVE DRIVER) means that DRIVER controls (see #$ControllingATransporter) the #$transporter in DRIVE.  DRIVER steers the wheel, graps the tiller, controls the throttle, the reins, the brakes etc of the #$transporter, e.g. a boat, train, windsurfer, mule, plane, horse and carriage, spaceship, sled, etc..   DRIVER is not a #$passengers in DRIVE.  Because #$transporter and #$transportees are disjoint and #$driverActor has #$transportees as a #$genlPreds, DRIVER is distinct from the value on #$transporter.  Thus a person walking while carrying a watermelon would not be a #$driverActor in their own walking.  DRIVER is usually in #$SittingPosture during DRIVE.  For any given instant of DRIVE there is exactly one DRIVER.  Until we have more extensive vocabulary, the transportees is the most specific we can be about events in which multiple drivers share driving responsibility throughout the event or if there is a pilot/co-pilot combination."))
)
(defrelation |DrugTherapyUseFn|
  :arity 2
  :domain (:AND |ExistingStuffType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :range (:AND |ScriptType| |TemporalStuffType| (:FILLED-BY SUPERRELATIONS |DrugTherapy|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "The collection of events in which instances of ARG1 are used to achieve a medical purpose.  These events do not include the administration of the drug - they are the scripts which result from that administration."))
)
(defrelation |ductilityOfObject|
  :arity 2
  :domain |SolidTangibleThing|
  :range |Ductility|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$ductilityOfObject OBJ DEGREE) means that the instance of #$SolidTangibleThing OBJ has this DEGREE of #$Ductility (q.v.)."))
)
(defrelation |duration|
  :arity 2
  :domain |TemporalThing|
  :range |Time-Quantity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$duration ?X ?Y) means that ?Y is length of time #$TemporalThing ?X happened/existed.  For a continuous #$TemporalThing, this is the same as its #$measure (the elapsed time from start to end.)  But for a discontinuous #$TemporalThing, the #$duration is strictly less than the #$measure.  For example, the #$duration of `the Mondays during May of 1996' is (#$DaysDuration 4), whereas the #$measure of that same temporal object is (#$DaysDuration 22).
Note:  Unfortunately, in some disciplines, such as Real Analysis, these two terms' definitions are switched!  In such contexts, one could assert to Cyc that the preferred denotation of #$duration was #$Measure-TheWord, and that the preferred denotation of #$measure was #$Duration-TheWord, but notice that the two concepts --- #$measure and #$duration --- are still distinct and useful in that discipline, they just happen to have different names there."))
)
(defrelation |eastOf|
  :arity 2
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$eastOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the east of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference.  Note that REGION-2 is therefore west of REGION-1; thus, no distinct predicate is needed to represent `west of'.  Example: (#$eastOf #$EasternUSATimeZone #$CentralUSATimeZone)."))
)
(defrelation |eatsWillingly|
  :arity 2
  :domain |Animal|
  :range (:AND |TemporalStuffType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$eatsWillingly is used to relate an #$Animal to the type of food
it will willingly eat.  In a normal #$EatingEvent, the food consumed is of a type
that the eater #$eatsWillingly.  As negative examples, no vegetarian or herbivore
#$eatsWillingly meat."))
)
(defrelation |EdiblePartFn|
  :arity 2
  :domain (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |EdibleStuff|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "The Cyc function #$EdiblePartFn is a #$CollectionDenotingFunction.  When applied to a set of tangible objects OBJ-TYPE, (#$EdiblePartFn OBJ-TYPE) represents the collection of all the edible parts of objects of OBJ-TYPE.  This collection includes any #$EdibleStuff (i.e., edible by humans or koalas or whatever the current microtheory is talking about) that is part of instances of OBJ-TYPE.  To represent only parts that humans eat, we may restrict the #$resultGenl to a specialized subset of #$FoodAndDrink defined in #$HumanActivitiesMt or other appropriate microtheory.  Examples: the collection (#$EdiblePartFn #$Apple-TheFruit) includes the skin and flesh of all apples, but not --- in the #$HumanActivitiesMt --- the instances of #$Stem or #$Seed found in them; the collection (#$EdiblePartFn #$Egg-Chickens) includes the yolks and whites of chicken eggs, but does not  --- in the #$HumanActivitiesMt ---  include any instances of #$Eggshell.  Because of cultural or philosophical preferences and prohibitions about food, exactly what parts are edible may differ in different human cultural microtheories; e.g., in a FundamentalistJewish or FundamentalistIslamic cultural #$Microtheory, the function call (#$EdiblePartFn #$Pig) would return NIL; in a vegan #$Microtheory, even (#$EdiblePartFn #$Animal) would return NIL."))
)
(defrelation |EdiblesRichInFn|
  :arity 2
  :domain (:AND |ExistingStuffType| (:FILLED-BY SUPERRELATIONS |Nutrient|))
  :range (:AND |ExistingStuffType| (:FILLED-BY SUPERRELATIONS |EdibleStuff|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "The Cyc function #$EdiblesRichInFn is a #$CollectionDenotingFunction.  It is used to represent foodstuffs which have a high concentration of a certain nutrient.  (#$EdiblesRichInFn NUTRIENT) denotes the collection of edible things that are rich in the type of #$Nutrient NUTRIENT.  For example, (#$EdiblesRichInFn #$EdibleCalcium) denotes the collection of all #$EdibleStuff rich in calcium; that collection will have the collection #$DairyProduct as a subset."))
)
(defrelation |educationLevel|
  :arity 2
  :domain |Person|
  :range |EducationLevelAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$educationLevel PRSN LVL) means #$Person PRSN has had formal schooling up to the highest level #$EducationLevelAttribute LVL at one or more #$EducationalOrganizations.  This will refer to a particular #$subAbstrac of a #$Person, not to the person as a whole lifetime #$Entity."))
)
(defrelation |elasticityOfObject|
  :arity 2
  :domain |SolidTangibleThing|
  :range |Elasticity|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$elasticityOfObject OBJ DEGREE) indicates how readily the solid tangible thing OBJ returns to its original shape after being deformed (but not broken).  The higher the DEGREE of elasticity, the more quickly and completely the object returns to its previous shape.  Billiard balls, for example, are highly elastic in this sense.  A related concept is #$compressibilityOfObject."))
)
(defrelation |elementOf|
  :arity 2
  :domain |Thing|
  :range |SetOrCollection|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$elementOf THNG SETORCOL) means that THNG is an element of the mathematical set or collection SETORCOL.  #$elementOf is a more general relation than the more-heavily-used #$isa, which is used to talk about membership in a natural kind (an element of #$Collection).  #$elementOf can also be used to talk about membership in an arbitrarily-defined mathematical set (an instance of #$Set-Mathematical), such as those denoted by #$TheSet expressions."))
)
(defrelation |EmbryoFn|
  :arity 2
  :domain (:AND |OrganismClassificationType| (:FILLED-BY SUPERRELATIONS |Animal|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Embryo|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$EmbryoFn is an element of #$CollectionDenotingFunction.  (#$EmbryoFn LIFETYPE) returns the collection of organisms which are embryonic instances of LIFETYPE.  Note that this use of the word `embryo' does not correspond exactly with the English word, because the collection returned by #$EmbryoFn includes zygotes, fetuses, etc."))
)
(defrelation |emitter|
  :arity 2
  :is-primitive (:and |doneBy| |fromLocation| |providerOfMotiveForce|)
  :domain |Emission|
  :range |PartiallyTangible|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The Cyc predicate #$emitter is used to identify the source of an emission.  (#$emitter EMIT OBJ) means that OBJ provides the force involved in making the #$objectEmitted move from OBJ to someplace outside of OBJ.  See also #$providerOfMotiveForce, #$fromLocation."))
)
(defrelation |employedAgent|
  :arity 2
  :is-primitive |agreeingAgents|
  :domain |WorkAgreement|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$employedAgent identifies the particular employee who is covered by a particular work agreement.  (#$employedAgent AGREE WORKER) means that AGREE is an instance of #$WorkAgreement covering the employee WORKER."))
)
(defrelation |employees|
  :arity 2
  :is-primitive (:and |cotemporal| |affiliatedWith| |hasWorkers|)
  :domain |Agent|
  :range |Agent|
  :annotations ( |CotemporalObjectsSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "The predicate #$employees relates a particular employer to one of its paid employees.  (#$employees EMPLOYER WORKER) means WORKER regularly performs work for EMPLOYER, and EMPLOYER pays WORKER for that activity (often by paycheck).  EMPLOYER directs the manner in which WORKER performs the work and may provide the workplace, tools, capital, and other assistance for the work.  EMPLOYER is commonly an organization but may be a person. E.g., (#$employees PerryMason PaulDrake); (#$employees #$Cycorp #$Lenat).  This predicate is true during all or any part of the period that the employment continues; e.g., (#$holdsIn (#$YearFn 1995) (#$employees #$CarnegieMellonUniversity #$Derthick))."))
)
(defrelation |employeeStatus|
  :arity 2
  :domain (:AND |Agent| |Person|)
  :range |WorkStatus|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$employeeStatus describes a worker's job as full-time, part-time, salaried, commissioned, paid by the hour, or etc.  More than one may apply.  (#$employeeStatus WORKER STATUS) means that STATUS indicates the #$WorkStatus of WORKER.  For example, the #$employeeStatus of an auto worker at GM probably includes the #$WorkStatus attributes #$FullTime and #$HourlyWork."))
)
(defrelation |employingAgent|
  :arity 2
  :is-primitive |agreeingAgents|
  :domain |WorkAgreement|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$employingAgent identifies the employer in a particular work agreement.  (#$employingAgent AGREE EMPLOYER) means that the #$Agent EMPLOYER has entered into the #$WorkAgreement AGREE with some employee, and AGREE obligates EMPLOYER to compensate that employee for specified work.  See also #$Agreement, #$obligatedAgent."))
)
(defrelation |emptiesInto|
  :arity 2
  :domain |Stream|
  :range |BodyOfWater|
  :annotations ( |FunctionalSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$emptiesInto is used to indicate that a particular flowing body of water disgorges into another body of water.  (#$emptiesInto RIV WAT) means that the #$Stream RIV flows into WAT, an element of #$BodyOfWater.  Examples: (#$emptiesInto #$AmazonRiver #$AtlanticOcean); (#$emptiesInto #$HuangHeRiver #YellowSea)."))
)
(defrelation |EndFn|
  :arity 2
  :domain |TemporalThing|
  :range |TimePoint|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "#$EndFn is a function that takes a #$TemporalThing and returns the #$TimePoint it ends.  Thus: (#$endingPoint ?X (#$EndFn ?X))"))
)
(defrelation |endingDate|
  :arity 2
  :is-primitive |endsDuring|
  :domain |TemporalThing|
  :range |Date|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$endingDate ?X ?Y) indicates that ?Y is a #$Date such that (#$temporallySubsumes ?Y (#$EndFn ?X)). This is NOT the same as #$endingPoint.  Rather, it means that ?X stopped happening (went out of existence, etc.) sometime on that date.
Note:  the date is tied to a time interval on a calendar, but need not be a particular day; it might be a particular calendar month, a particular calendar year, etc."))
)
(defrelation |endingPoint|
  :arity 2
  :domain |TemporalThing|
  :range |TimePoint|
  :annotations ( |TemporalRelation|
     (DOCUMENTATION "(#$endingPoint ?X ?T) indicates that ?T is the #$TimePoint at which ?X ends, the latest moment of its temporal extent."))
)
(defrelation |endsAfterEndingOf|
  :arity 2
  :is-primitive |endsAfterStartingOf|
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ComplexTemporalRelation|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$endsAfterEndingOf LATER EARLY) means that LATER ends after EARLY ends -- in Cyc terms, (#$after (#$EndFn LATER) (#$EndFn EARLY)).  That is, the #$endingPoint of LATER is later than the #$endingPoint of EARLY.   This implies nothing about whether LATER and EARLY overlap, or how much they overlap, except that they can't be fully #$cotemporal.  Examples: rinsing while showering ends after soaping while showering; the process of hiring a contractor ends after the process of collecting bids."))
)
(defrelation |endsAfterStartingOf|
  :arity 2
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |ReflexiveBinaryPredicate|
     |ComplexTemporalRelation|
     (DOCUMENTATION "(#$endsAfterStartingOf ?X ?Y) means (#$after (#$EndFn ?X) (#$StartFn ?Y)).  That is, the #$endingPoint of ?X is later than the #$startingPoint of ?Y.  This implies nothing about whether ?X and ?Y overlap, or how much they overlap."))
)
(defrelation |endsDuring|
  :arity 2
  :is-primitive (:and |temporalBoundsIntersect| |endsAfterStartingOf|)
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |AsymmetricBinaryPredicate|
     |ComplexTemporalRelation|
     (DOCUMENTATION "(#$endsDuring ?X ?Y) means ?Y covers the end of ?X, i.e. the #$endingPoint of ?X is properly contained in (#$temporalBoundsContain) ?Y.  Note that ?X and ?Y don't necessarily intersect, however, if ?Y is continuous, they do."))
)
(defrelation |endsOfPathSegment|
  :arity 2
  :is-primitive (:and |physicalParts| |cotemporal|)
  :domain |Path-Simple|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$endsOfPathSegment PATH LOC) means that LOC is one end of the #$Path-Simple segment PATH; LOC may be either a junction or a genuine terminal-end of the path segment.  This refers to the ends of any kind of simple path."))
)
(defrelation |endToEndConnected|
  :arity 2
  :is-primitive |connectedTo-Rigidly|
  :domain |Path-Simple|
  :range |Path-Simple|
  :annotations ( |SymmetricBinaryPredicate|
     |SpatialPredicate|
     |ConnectionPredicate|
     |InterExistingObjectSlot|
     (DOCUMENTATION "(#$endToEndConnected PATH1 PATH2) means that one end of a #$Path-Simple or a #$SimpleUnloopedSegmentOfPath, PATH1, is connected to one end of another #$Path-Simple or #$SimpleUnloopedSegmentOfPath, PATH2, end-to-end, allowing flow or transport between them.  This kind of connection is not currently included as a #$JunctionOfPaths.  In pipe welding, these connections are called butt welds or circumferential pipe welds."))
)
(defrelation |english|
  :arity 2
  :domain |Thing|
  :range |CycSystemString|
  :annotations ( |BinaryPredicate|)
)
(defrelation |equals|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |DefaultMonotonicPredicate|
     |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$equals is the Cyc version of identity of predicate logic.  (#$equals A B) means A and B denote the same thing."))
)
(defrelation |equiv|
  :arity 2
  :domain |CycFormula|
  :range |CycFormula|
  :annotations ( |CommutativeRelation|
     |ELRelation|
     (DOCUMENTATION "The logical connective #$equiv represents bi-directional implication.
 #$equiv takes two arguments, each of which must be an element of 
 #$CycFormula. (#$equiv FORMULA-1 FORMULA-2) means that formula FORMULA-1 
 is true precisely when formula FORMULA-2 is true; in other words, 
 FORMULA-1 is true if and only if FORMULA-2 is true.  An EL formula that
 mentions #$equiv is translated during canonicalization into an equivalent
 (though less compact) formula that mentions #$implies and does not mention
 #$equiv (see the #$expansion gaf for #$equiv)."))
)
(defrelation |ethnicGroupsHere|
  :arity 2
  :domain |GeopoliticalEntity|
  :range |EthnicGroupType|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The ethnic groups that inhabit a geographical region."))
)
(defrelation |ethnicity|
  :arity 2
  :is-primitive |isa|
  :domain |Person|
  :range (:AND |EthnicGroupType| (:FILLED-BY SUPERRELATIONS |Person|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$ethnicity PERSON GROUPTYPE) means #$Person PERSON belongs to the #$EthnicGroupType GROUPTYPE.   E.g., (#$ethnicity #$JohnWilkesBooth #$CensusGroupOfCaucasians).  One #$Person may belong to more than one #$EthnicGroupType."))
)
(defrelation |evaluate|
  :arity 2
  :domain |CycELVariable|
  :range |Thing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$evaluate VAR EXPRESSION) is satisfied by an HL module which evaluates EXPRESSION and binds VAR to the result.  For example, (#$evaluate ?SUM (#$PlusFn 1 2)) would bind ?SUM to 3."))
)
(defrelation |eventHonors|
  :arity 2
  :domain |SocialOccurrence|
  :range |Agent|
  :annotations ( |AsymmetricBinaryPredicate|
     |Role|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$eventHonors OCCURRENCE AGENT) means that AGENT is honored or commemorated by OCCURRENCE.  If AGENT is a living #$Person, AGENT is probably present at OCCURRENCE.  This is the appropriate predicate for relating a #$Funeral to the deceased person for whom the #$Funeral is in honor."))
)
(defrelation |eventOccursAt|
  :arity 2
  :is-primitive (:and |inRegion| |actors| |temporallyIntersects|)
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$eventOccursAt relates a particular event to the instance of #$PartiallyTangible in which it occurs.  (#$eventOccursAt EVENT PT) means that the spatial extent of EVENT is within PT.  For example, (#$eventOccursAt #$LomaPrietaEarthquake #$SanFranciscoBayArea)."))
)
(defrelation |eventOccursNear|
  :arity 2
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$eventOccursNear is used to give an approximate location for an event.  (#$eventOccursNear EVENT LOC) means that EVENT occurs at a place #$near LOC.  #$eventOccursNear is useful when the more exact #$eventOccursAt is unknown, hard to specify, or not worth reifying.  For example, #$eventOccursNear is useful for describing the location of events in scenarios such as `Bob was cycling by the dam', `We played checkers near the TV', and `He is standing by the horse's hind legs'.  See #$cyclistNotes for ideas on how to formalize this."))
)
(defrelation |eventTypeTemporalLocality|
  :arity 2
  :domain (:AND |ScriptType| (:FILLED-BY SUPERRELATIONS |Event|))
  :range |Time-Quantity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The time period over which the effects of this type of event may be felt. This could be infinite for certain events (such as killing a person), but for most events this is a much shorter period.  E.g., some of the effects of swimming are being wet, being tired, being out of breath, etc. but those effect generally only persist for a period of minutes after the swimming ends."))
)
(defrelation |evokes|
  :arity 3
  :domains (|Individual| (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |TernaryPredicate|
     |CotemporalPredicate|
     (DOCUMENTATION "(#$evokes OBJ EMOTYPE DEGREE) means that as a consequence of perceiving OBJ, a typical sane intelligent perceiving agent would experience a feeling of EMOTYPE with degree of intensity DEGREE.  E.g., in some contexts, (#$evokes #$StatueOfLiberty #$Pride #$High)."))
)
(defrelation |exceptFor|
  :arity 2
  :domain |ReifiableTerm|
  :range |Assertion|
  :annotations ( |Relationship|
     |LogicalConnective|
     (DOCUMENTATION "(#$exceptFor TERM ASSERTION) means that TERM is a thing, about which ASSERTION is not known to hold.  

#$exceptFor is a special case of #$exceptWhen (q.v.), applicable when ASSERTION has only one universally quantified variable.  (#$exceptFor TERM ASSERTION) prevents TERM from binding to that variable, thereby blocking the conclusions about TERM that Cyc might otherwise draw from ASSERTION.  In other words, if ASSERTION is an implication, then whatever proposition(s) -- call that Q -- that Cyc might have concluded about TERM from ASSERTION may or may not be true in Cyc, but (due to the exception) they would no longer be justified, even partially, by ASSERTION.

Note that the exception TERM  should be a particular binding for
the rule, not a collection, all of whose members the rule
does not apply to. Example: I have the rule 
(#$implies (#$isa ?X #$Cyclist) (#$loves ?X #$RichardNixon)).
I could use #$exceptFor to state that this rule does not
apply to some particular cyclist, e.g., #$Foxvog. But if
I wanted to make an exception to this rule for all 
#$MalePersons, I would not use #$exceptFor, but #$exceptWhen."))
)
(defrelation |exceptWhen|
  :arity 2
  :domain |CycFormula|
  :range |Assertion|
  :annotations ( |Relationship|
     |LogicalConnective|
     (DOCUMENTATION "(#$exceptWhen FORMULA ASSERTION) means that FORMULA gives a set of conditions under which ASSERTION is known not to hold (or, more precisely, conditions under which ASSERTION should not be relied upon as the justification for some other inferences).  The universally quantified variables in ASSERTION's formula may be used in FORMULA to refer to the same objects.  A common special case of #$exceptWhen is handled by #$exceptFor (q.v.)"))
)
(defrelation |exchangers|
  :arity 2
  :is-primitive (:and |preActors| |postActors| |performedBy| |socialParticipants|)
  :domain |ExchangeOfUserRights|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$exchangers is used to identify the (typically, two) #$Agents involved in an instance of #$ExchangeOfUserRights.   In such an event, each of the #$exchangers gives up possession of one thing and gains possession of another which was previously possessed by the other agent.  (#$exchangers EXCH AGENT) means that AGENT is one of the parties having such a dual role in the #$ExchangeOfUserRights EXCH.  Every instance of #$ExchangeOfUserRights has two sub-events which are instances of #$TransferringPossession (e.g., a dollar bill goes in one direction and some french fries and a few coins go in the other direction.)  Each of the #$exchangers is both a #$toPossessor (in one of the two #$TransferringPossession sub-events of EXCH) and a #$fromPossessor (in the other sub-event)."))
)
(defrelation |exhibitors|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |SocialGathering|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$exhibitors GATHERING AGENT) means that AGENT actively presents information, markets a product, displays merchandise or artwork to the attendees of GATHERING."))
)
(defrelation |expansion|
  :arity 2
  :domain |Relationship|
  :range |CycSystemList|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The complex functions/relations can be explained in terms of more primitive functions. This slot contains such a primitive expansion."))
)
(defrelation |expansionAxiom|
  :arity 2
  :domain |RuleMacroPredicate|
  :range |Assertion|
  :annotations ( |BinaryPredicate|
     |MetaKnowledgePredicate|
     (DOCUMENTATION "(#$expansionAxiom PRED ASSERT) means that the assertion ASSERT is part of the expansion of PRED."))
)
(defrelation |expects|
  :arity 2
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$expects AGT PROP) means that the agent AGT believes the proposition PROP (represented by a #$CycFormula) will be true sometime in the future.  A use of this predicate is to state rules such as: when someone confirms that they will be participating in a social event, the host(ess) #$expects that they will participate."))
)
(defrelation |ExpFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$ExpFn is the exponential operator, i.e., the unary mathematical function that returns e^x for the x value taken as its argument.  (#$ExpFn 1) returns e.  Its inverse (i.e., #$inverseFunc) is #$LogFn."))
)
(defrelation |exports|
  :arity 2
  :domain |GeopoliticalEntity|
  :range (:AND |ProductType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :annotations ( |BinaryPredicate|
     |ProcessPredicate|
     (DOCUMENTATION "(exports REGION THING) means that the region REGION has substantial regular exports of the commodity THING."))
)
(defrelation |ExteriorRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (ExteriorRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the sub-region consisting of all the outer parts or sections of REGOROBJ, or the exterior main portion of REGOROBJ.  It applies when REGOROBJ itself has an intrinsic inside/outside orientation (unlike, say, a loop of thread), but if REGOROBJ is an enveloping part, surface membrane, ring or layer within or on a larger region or object that has its own inside/outside orientation, the function returns REGOROBJ's outside portion with respect to the inside and outside of the larger region or object."))
)
(defrelation |externalParts|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalParts|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$externalParts OBJ PART) means that OBJ has PART as one of its external #$physicalParts."))
)
(defrelation |eyeColor|
  :arity 2
  :domain |Animal|
  :range |Color|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$eyeColor ANIMAL COLOR) means that the #$Animal ANIMAL has eyes whose #$Color is COLOR  (more precisely, this means that their irises appear to have that color, in sunlight).  E.g., (#$eyeColor AmyIrving #$PurpleColor)."))
)
(defrelation |facesDirection|
  :arity 2
  :domain |PartiallyTangible|
  :range |UnitVectorInterval|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$facesDirection OBJ DIR) means that the intrinsic forward axis of OBJ (i.e., the vector normal to its intrinsic front side) points in the direction DIR.  Note that an object only has an intrinsic forward axis if it has some intrinsic front side by virtue of its design or function.  For example, trains, cars, and bullets have intrinsic front faces by virtue of the direction in which they are intended to travel.  Other objects, such as refrigerators, bookshelves against walls, and televisions, have front faces by virtue of how people usually view the object.  Spheres, being symmetric, do not have an intrinsic forward axis."))
)
)    ; END EVAL-WHEN 3

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 4
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |facesObject|
  :arity 3
  :domains (|PartiallyTangible| |IntrinsicAxisOfObject|)
  :range |PartiallyTangible|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$facesObject is used to represent the orientation of one object to another. (#$facesObject OBJ1 AXIS1 OBJ2) means that an intrinsic axis projected through OBJ1 (i.e., AXIS1) spatially intersects with the second object, OBJ2.  See also #$IntrinsicAxisOfObject, #$AxisFn."))
)
(defrelation |failureForAgents|
  :arity 2
  :is-primitive |performedBy|
  :domain |PurposefulAction|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$failureForAgents is used to indicate that a particular agent fails to achieve (at least one of) its goals in a particular action.  (#$failureForAgents ENDEAVOR AGT) means that the #$Agent AGT had some purpose in performing ENDEAVOR that was not realized.  See also #$purposeInEvent."))
)
(defrelation |fanOutArg|
  :arity 2
  :domain |TransitiveBinaryPredicate|
  :range |PositiveInteger|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$fanOutArg ?PRED ?N) means that transitively-related assertions using ?PRED usually ''fan out'' in the direction of argument position ?N.  For example, (#$fanOutArg #$geographicalSubRegions 2).  This means there are more non-subsumed arg2s for a given arg1 to #$geographicalSubRegions than there would be non-subsumed arg1s for a given arg2."))
)
(defrelation |fastenedTo|
  :arity 2
  :is-primitive |connectedTo-Rigidly|
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$fastenedTo OBJ1 OBJ2) means that there is an assembly consisting of OBJ1, OBJ2, and one or more fasteners configured so that OBJ1 and OBJ2 are rigidly connected.  Many types of fastener are covered by #$fastenedTo; e.g., screws, nails, rivets, nuts and bolts.  The fastener penetrates all the way through OBJ1 and may or may not go all the way through OBJ2.  Examples: a utility shelf screwed into the wall; paper notices stapled to a bulletin board; shingles nailed to the roof of a house."))
)
(defrelation |father|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Animal|
  :range |MaleAnimal|
  :annotations ( |IrreflexiveBinaryPredicate|
     |FamilyRelationSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$father CHILD FATHER) means FATHER is one of the persons who fulfill the role of father for CHILD.  This may or may not include CHILD's biological father, and might include CHILD's step father(s) or foster father(s)."))
)
(defrelation |faxNumberText|
  :arity 2
  :domain |ContactLocation|
  :range |PhoneNumber|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$faxNumberText relates a particular location to the fax number at that location.  (#$faxNumberText LOC NUM) means that NUM is a string denoting (one of) the fax number(s) of the #$ContactLocation LOC."))
)
(defrelation |feelsEmotion|
  :arity 3
  :domains (|IntelligentAgent| (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |TernaryPredicate|
     |CotemporalPredicate|
     (DOCUMENTATION "(#$feelsEmotion AGT EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the type EMOTYPE with the intensity DEGREE.  For example, (#$feelsEmotion #$Lenat #$Pride #$High).  As you might imagine, such statements are generally embedded in a context, or within some other statement (such as #$holdsIn some small time interval).  See also #$feelsTowardsEvent, #$feelsTowardsObject.
Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions."))
)
(defrelation |feelsResponseOnBodyRegion|
  :arity 4
  :domains (|PerceptualAgent| (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyRegion|))
            |SensoryReactionType|)
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |QuaternaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$feelsResponseOnBodyRegion is used to represent localized somatic feelings of a perceptive being. (#$feelsResponseOnBodyRegion AGT BODYPARTTYPE SENS DEGREE) means that the #$PerceptualAgent AGT feels on its body, in the area specified by BODYPARTTYPE, the sensory reaction SENS with an intensity of DEGREE.  For example, Cyc's knowledge base contains an assertion that the very same part of one's body doesn't feel both hot and cold at the same time.  #$feelsResponseOnBodyRegion can also be used to state symptoms, e.g., when you're feverish, your head feels hot.  See also #$SensoryReactionType."))
)
(defrelation |feelsSensation|
  :arity 3
  :domains (|BiologicalLivingObject| (:AND |SensoryReactionType| (:FILLED-BY SUPERRELATIONS |SensoryAttribute|)))
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "(#$feelsSensation BLO SENSTYPE DEGREE) means that the #$BiologicalLivingObject BLO feels a sensation of type SENSTYPE with the intensity DEGREE.  #$feelsSensation may be used to describe an organism's feeling during a particular time period or activity (see #$holdsIn); for example, we might say of a particular person who is doing yoga: (#$holdsIn `TodaysYoga' (#$feelsSensation Prakriti #$LevelOfRelaxationFeeling #$VeryHigh).  Note that the first argument of #$feelsSensation could also be filled by a part of an organism, e.g., `John F. Kennedy's head'; however, by using the more specialized predicate #$feelsResponseOnBodyRegion (q.v.), we can express localized feelings without reifying each such region."))
)
(defrelation |feelsTowardsEvent|
  :arity 4
  :domains ((:AND |IntelligentAgent| |Person|) |Event|
            (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$feelsTowardsEvent AGT EVT EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the #$FeelingAttributeType EMOTYPE towards the #$Event EVT, with intensity DEGREE.
Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions. "))
)
(defrelation |feelsTowardsObject|
  :arity 4
  :domains ((:AND |IntelligentAgent| |Person|) |Individual|
            (:AND |FeelingAttributeType| (:FILLED-BY SUPERRELATIONS |FeelingAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$feelsTowardsObject AGT OBJ EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the #$FeelingAttributeType EMOTYPE towards the #$Individual OBJ, with intensity DEGREE.
Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions."))
)
(defrelation |FemaleFn|
  :arity 2
  :domain (:AND |OrganismClassificationType| (:FILLED-BY SUPERRELATIONS |Animal|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |FemaleAnimal|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$FemaleFn is a Cyc function, in particular, an instance of #$CollectionDenotingFunction.  (#$FemaleFn ORGTYPE) returns that subset of the animal taxonomic collection ORGTYPE which includes all and only the females of ORGTYPE.  For example, (#$FemaleFn #$Person) and #$FemalePerson denote the same collection, while (#$FemaleFn #$Deer) denotes the collection of all female members of #$Deer."))
)
(defrelation |femaleParentActor|
  :arity 2
  :is-primitive |parentActors|
  :domain |BiologicalReproductionEvent|
  :range |BiologicalLivingObject|
  :annotations ( |FunctionalSlot|
     |ActorSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$femaleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the female parent in the #$SexualReproductionEvent ?EVENT."))
)
(defrelation |fieldsOfActivity|
  :arity 2
  :is-primitive |fieldsOfCompetence|
  :domain |Person|
  :range |FieldOfStudy|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$fieldsOfActivity X FLD) means the #$Person X was or is active in the #$FieldOfStudy FLD, and usually is making, has made, or intends to make some contribution to FLD.  E.g., (#$fieldsOfActivity #$Thales #$MilesianSchool) and, to take a more recent example, (#$fieldsOfActivity #$Lenat #$ArtificialIntelligence)."))
)
(defrelation |fieldsOfCompetence|
  :arity 2
  :domain |Person|
  :range |FieldOfStudy|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$fieldsOfCompetence Z FLD) means the #$Person Z has actual competence and knowledgeability in the #$FieldOfStudy FLD, or else at least is recognized by peers and colleagues in the same field as being competent in that field.  E.g., (#$fieldsOfCompetence #$Nichols #$PhilosophyAncient)"))
)
(defrelation |fieldsOfFormalEducation|
  :arity 2
  :is-primitive |fieldsOfCompetence|
  :domain |Person|
  :range |FieldOfStudy|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$fieldsOfFormalEducation Z FLD) means that #$Person Z has had formal academic or tutorial education in the #$FieldOfStudy FLD.  E.g., (#$fieldsOfFormalEducation #$Colvin #$Linguistics).  This is a good example of a predicate whose precise meaning, and associated heuristic rules, vary quite a bit from context to context, such as from culture to culture, from century to century, etc."))
)
(defrelation |firstName|
  :arity 2
  :is-primitive |nameOfAgent|
  :domain |Person|
  :range |HumanGivenNameString|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$firstName X STRNG) means that #$Person X is known by the #$HumanGivenNameString STRNG as his or her first name.  E.g., (#$firstName #$Lenat ``Douglas'').  A person rarely has more than one first name, though they may have many nicknames which acquaintences use almost interchangably with the person's first and/or last names."))
)
(defrelation |firstSubEvents|
  :arity 2
  :is-primitive (:and |subEvents| |temporallyStartedBy|)
  :domain |Event|
  :range |Event|
  :annotations ( |SubProcessSlot|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$firstSubEvents ?X ?Y) implies (#$subEvents ?X ?Y) and (#$temporallyStartedBy ?X ?Y).  For example, if one is #$RelievingPain by taking a pill, then the #$firstSubEvents in that event is an #$Ingesting event.  See also #$lastSubEvents."))
)
(defrelation |fiscallyCapableOf|
  :arity 3
  :domains (|IntelligentAgent| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$fiscallyCapableOf indicates that an agent has the economic prerequisites needed for taking a certain role in a certain type of situation or event.  (#$fiscallyCapableOf AGT SIT-TYPE ROLE) means that a particular #$Agent AGT has the financial resources for acting in this ROLE in normal instances of SIT-TYPE.  For example, we could say that Mary is #$fiscallyCapableOf being the #$buyer in a #$Buying of a Humvee (i.e., (#$BuyingFn Humvee)).  However, #$fiscallyCapableOf is noncommittal as to whether Mary does or will in fact buy a Humvee."))
)
(defrelation |fitsIn|
  :arity 2
  :domain |PartiallyTangible|
  :range |AbstractShape|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$fitsIn is used to give an approximation of the external size and shape of particular tangible objects, by relating an object to an abstract region of space described as a geometric shape with definite dimensions.  (#$fitsIn OBJ SHAPE) gives an upper bound for the size of the object OBJ, by stating what sized shape OBJ will fit inside.  #$fitsIn uses the elements of #$ShapeFunction (q.v.) for reference, especially the basic shapes generated by #$RectangularSolidFn, #$CylinderFn, and #$SphereFn.  (Note: actual instances of AbstractPhysicalShape are NOT used for assertions made with #$fitsIn.)  Examples: (#$fitsIn #$Pittman (#$RectangularSolidFn (#$Meter 2) (#$Meter 0.35) (#$Meter 0.25))) and (#$fitsIn HopeDiamond (#$CylinderFn (#$Centimeter 10) (#$Centimeter 10))).  When #$fitsIn is used in a rule to represent a class of objects with variable sizes, the #$ShapeFunction used should refer to the largest size that such objects normally have.  For example, by default, any sandwich SW (#$fitsIn SW (#$RectangularSolidFn (#$Inch 12) (#$Inch 12) (#$Inch 6)))."))
)
(defrelation |flammabilityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Flammability|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$flammabilityOfObject SUBST DEGREE) means that the tangible SUBST has this DEGREE of #$Flammability.  A higher value of DEGREE describes objects that catch fire and burn more quickly and easily than those with a lower value."))
)
(defrelation |fluidPressure|
  :arity 2
  :domain |FluidTangibleThing|
  :range |Pressure|
  :annotations ( |TangibleSubstancePredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$fluidPressure FLUID PRESS) means that the #$FluidTangibleThing FLUID exerts the #$Pressure PRESS at its surface."))
)
(defrelation |followingIntervalType|
  :arity 2
  :domain |TemporalObjectType|
  :range |TemporalObjectType|
  :annotations ( |TemporalRelation|
     (DOCUMENTATION "(#$followingIntervalType ?X ?Y) indicates that every instance of ?X is followed by some instance of ?Y, and every instance of ?Y is preceded by some instance of ?X.  The instance of ?Y is #$contiguousAfter the instance of ?X.  For example,  (#$followingIntervalType #$Saturday #$Sunday).  Every Saturday is followed by a Sunday, and every Sunday is preceded by a Saturday; the Sunday is #$contiguousAfter the Saturday."))
)
(defrelation |followingValue|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ExtensionalRepresentationPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$followingValue is used to represent an ordering of generic attributes.  (#$followingValue VAL1 VAL2) means that VAL2 is a greater value than VAL1 on a scale that they share.  (#$followingValue VAL1 VAL2) implies (#$greaterThan VAL2 VAL1).  Typically, one uses #$followingValue when the values VAL1 and VAL2 are elements of #$GenericAttribute, and they are not grounded in numerically quantifiable units of measure (see #$NoteAboutGivingGenericValueFunctionsNumericValues).  If VAL1 and VAL2 do have numerical grounding, a #$followingValue formula is unnecessary since #$numericallyEqual, #$greaterThanOrEqualTo, and #$greaterThan, are automatically computable using arithmetic relations holding between the minimum and maximum of val1 and val2.  (See #$minQuantValue, #$maxQuantValue.)  For example, one must use #$followingValue to state that (#$HighAmountFn #$Glamor) is more glamorous than (#$LowAmountFn #$Glamor).  On the other hand, it is unnecessary to assert a #$followingValue relation between (#$MilesPerHour 5) and (#$MilesPerHour 25 60) since #$greaterThan is arithmetically determinable.  See also #$GenericAttribute, #$GenericValueFunction."))
)
(defrelation |foodSourceFor|
  :arity 2
  :domain |Organism-Whole|
  :range (:AND |TemporalStuffType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$foodSourceFor is used to relate a particular organism to the kinds of things it usually eats.  (#$foodSourceFor ORG OBJTYPE) means ORG is an organism that typically eats some instances of OBJTYPE for food.  Note that OBJTYPE refers to a type of food source, not a particular object that ORG eats.  For example, (#$foodSourceFor #$BillJ #$Popcorn) means that #$Popcorn is a #$foodSourceFor Bill, i.e., Bill often eats (instances of) popcorn."))
)
(defrelation |Foot-UnitOfMeasure|
  :annotations ( |UnitOfDistance|
     |FPSUnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     (DOCUMENTATION "The measurement function used in Cyc to represent the basic unit of length within the British (FPS) system.  See also #$FPSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |forAll|
  :arity 2
  :domain |CycELVariable|
  :range |CycFormula|
  :annotations ( |Relationship|
     |Quantifier|
     (DOCUMENTATION "The predicate #$forAll is Cyc's version of the universal quantifier of predicate calculus (i.e., the operator symbolized in one common notation by an upside-down `A').  As its two arguments, #$forAll takes a variable (which is an element of #$CycELVariable) and an element of #$CycFormula, respectively.  (#$forAll VAR FORM) means that FORM is true whenever all the occurrences of the variable VAR in the formula FORM are replaced by any object in the Cyc universe.  For example, to say that every person is a mammal, we could assert: (#$forAll ?X (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal))).  In addition, CycL follows a convention that allows #$forAll to be omitted; that is, when no explicit quantifier is used, seemingly unbound variables inside formulas are assumed to be universally quantified.  With that convention, the sample assertion could be written more compactly as: (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal)).



[Developer-level footnote:  There are many `flavors' of quantification `on the market' these days; here is how the Cyc system currently handles axioms that involve #$forAll:



When processing an FI-ASK about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc determines extensionally whether or not any known VAR (anything in the knowledge base) could make FORM false.



When processing an FI-PROVE about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc tries to construct an intensional proof (at least at a default-true level) that FORM must be true regardless of what VAR is ever inserted therein.



When processing an FI-ASSERT in which a user or program tells Cyc that an assertion of the form (#$forAll VAR FORM) is true, Cyc records it intensionally so that it can later serve as part of an intensional proof, when some future FI-PROVE request is processed.]"))
)
(defrelation |forceActingOnObject|
  :arity 2
  :domain |PartiallyTangible|
  :range (:AND |PhysicalAttribute| |VectorInterval|)
  :annotations ( |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "#$forceActingOnObject is a predicate relating an instance of #$PartiallyTangible to any force which changes its direction of travel or the speed at which it is traveling."))
)
(defrelation |forceCapacity|
  :arity 2
  :domain |BiologicalLivingObject|
  :range |Strength|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The slot describing the capability of an animal to exert force."))
)
(defrelation |formedByConfluenceOf|
  :arity 2
  :domain |River|
  :range |River|
  :annotations ( |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(formedByConfluenceOf WATER1 WATER2) means that WATER1 is formed, or increased in volume, by the confuence of the rivers including RIVER2 which merge to form RIVER1."))
)
(defrelation |formsBorderBetween|
  :arity 3
  :domains (|SpatialThing| |SpatialThing|)
  :range |SpatialThing|
  :annotations ( |TernaryPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "(#$formsBorderBetween BORDER REG1 REG2) means that BORDER comprises at least part of the border between REG1 and REG2.  BORDER may be a surface separating two regions of space, or a curve separating two regions of a surface.  The arguments REG1 and REG2 may be physical objects, geographical regions, or abstract entities.  Note that BORDER need not comprise the entire border between REG1 and REG2.  By contrast, #$BorderBetweenFn returns the entire border between the regions that serve as arguments."))
)
(defrelation |fourWayJunctionInSystem|
  :arity 2
  :is-primitive |junctionInSystem|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$fourWayJunctionInSystem JUNCT SYS) means that JUNCT is a 4-way junction in the specified #$PathSystem SYS.  (See also #$FourWayJunctionOfPaths for the general case.)  Formally, a 4-way junction in SYS is any point (actually, a node) X in SYS such that either there are exactly 4 links and no loops in SYS that X is on, or there are exactly 2 loops and no links in SYS that X is on, or there are exactly 2 links and 1 loop in SYS that X is on.  See #$junctionInSystem."))
)
(defrelation |fragilityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Fragility|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$fragilityOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$Fragility.  The higher the fragility, the more easily the object can be broken."))
)
(defrelation |freezingPoint|
  :arity 2
  :domain |PartiallyTangible|
  :range |Temperature|
  :annotations ( |TangibleSubstancePredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$freezingPoint STUFF TEMP) means that TEMP is the temperature at which the substance STUFF changes from having the attribute #$LiquidStateOfMatter to #$SolidStateOfMatter (when sufficient energy is output to lower STUFF's temperature through this point).  Note that the freezing point of most substances is context-dependent (e.g., based on altitude and other factors.)"))
)
(defrelation |frequencyOfActionType|
  :arity 4
  :domains ((:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)) |Collection| |ActorSlot|)
  :range |Frequency|
  :annotations ( |TypePredicate|
     |FunctionalPredicate|
     |QuaternaryPredicate|
     (DOCUMENTATION "(#$frequencyOfActionType ?X ?Y ?R ?F) indicates that instances of ?Y play the role ?R in a number of instances of ?X, and they occur with the frequency ?F.  One axiom in Cyc that uses this predicate expresses the rule of thumb that each military typically wages war about once a generation: (#$frequencyOfActionType  #$WagingWar #$MilitaryOrganization #$performedBy #$OnceAGeneration).  Another use of it is to express the fact that animals are virtually always breathing:  (#$frequencyOfActionType #$Breathing #$Vertebrate #$bodilyDoer #$Continuously).  Even more interesting examples of this predicate express the the rules of thumb that in a modern Western personal... context a person engages in a toothbrushing event about once a day, while as the recipient of professional service that happens 0.5 - 4 times per year, while as the provider of such a service that happens 4 - 20 times per day.  Those three axioms would be written -- in the appropriate contexts of course -- (#$frequencyOfActionType #$TeethCleaning #$Person #$performedBy (#$TimesPerDay 1)) and (#$frequencyOfActionType #$TeethCleaning #$Person #$recipientOfService (#$TimesPerYear 0.5 4)) and (#$frequencyOfActionType #$TeethCleaning #$Person #$providerOfService (#$TimesPerDay 4 20)).   Two additional notes are in order about this predicate:
Note that ?X must be a set of #$Situations [there is an argument constraint on this predicate that enforces this, namely (#$arg1Genl #$frequencyOfActionType #$Situation)],.
Note that this predicate is functional in its fourth argument position.  That is, given a legal set of values for ?X, ?Y, and ?R, there is one and only one meaningful value for the frequency ?F [this is specified by the Cyc axiom (#$functionalInTheNthArg #$frequencyOfActionType 4)]."))
)
(defrelation |frequencyOfSignal|
  :arity 2
  :domain |WavePropagation|
  :range |Frequency|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$frequencyOfSignal WAVE FREQ) means that the #$WavePropagation event WAVE consists of waves that occur at intervals of FREQ.  FREQ is a measure of #$Frequency generally expressed as cycles per unit of time; frequency of electromagnetic radiation is standardly measured in #$Hertz."))
)
(defrelation |friends|
  :arity 2
  :is-primitive (:and |cotemporal| |likesAsFriend|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |IrreflexiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     |InterPersonalRelationSlot|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$friends X Y) means X and Y are friends; typically they have a close relationship of reciprocal care, concern, respect, enjoyment, and mutual regard based on emotional (and/or ideological and intellectual) compatibility, shared interests, etc.
Note:  In the cases of assertions of two non-human animals being friends, there may be some anthropomorphism going on."))
)
(defrelation |fromLocation|
  :arity 2
  :is-primitive (:and |preActors| |(MeaningInSystemFn SENSUS-Information1997 SOURCE-DESTINATION)|)
  :domain |Translocation|
  :range |PartiallyTangible|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$fromLocation is used to indicate the starting point of a particular movement.  (#$fromLocation MOVE LOC) means that LOC is where the #$objectMoving in the #$Movement-TranslationEvent MOVE is found at the beginning of MOVE and is where it begins this motion.  The #$objectMoving may or may not be #$Stationary at LOC.  If MOVE is a single-pathway translation (see #$Translation-SinglePath), then every #$objectMoving is found at LOC when MOVE starts.  If MOVE has multiple movers and multiple pathways (see #$Translation-MultiPath), then at least some of the #$objectMoving(s) can be found at LOC at the start of MOVE.  If MOVE is a flow (including rivers flowing, winds blowing, tornado, typhoon, clouds moving and even air filling your lungs when you take breath, see #$Translation-Flow), then at least some portion of the fluid #$objectMoving can be found at LOC at the start of MOVE.  See also #$pathway-Complete, #$pathConnects."))
)
(defrelation |fromOrientation|
  :arity 2
  :domain |Movement-Rotation|
  :range |OrientationAttribute|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "This predicate indicates, for the particular rotational motion ROT, the orientation that the #$objectMoving in that event has at the beginning of that motion.  (#$fromOrientation ROT ORIENT) means that when ROT begins, the object that moves in ROT has the position ORIENT, with respect to the current frame of reference.  For example, the object may have a #$HorizontalOrientation, #$VerticalOrientation, #$RightSideUp orientation, etc.  See also #$toOrientation, #$OrientationAttribute."))
)
(defrelation |fromPossessor|
  :arity 2
  :is-primitive |preActors|
  :domain |LosingUserRights|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "This predicate identifies an #$Agent who loses some right to use an object.  (#$fromPossessor LOSS AGENT) means that AGENT enjoys some #$UserRightsAttribute over the #$objectOfPossessionTransfer at the start of the #$LosingUserRights event LOSS, but no longer has that particular #$UserRightsAttribute after the LOSS ends."))
)
(defrelation |fromState|
  :arity 2
  :domain |ChangingDeviceState|
  :range |DeviceState|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "This predicate is used in connection with #$ChangingDeviceState, to identify the #$DeviceState that a device is in before the change.  (#$fromState EVENT DEVICE-STATE) means that immediately prior to EVENT (which is the device state-changing action), the device that is changed in EVENT has the state DEVICE-STATE (and during the EVENT the device changes from that to another state).  For example, prior to any X which is a #$TurningOnAnElectricalSwitch, the switch involved has (#$fromState X #$DeviceOff)."))
)
(defrelation |FruitFn|
  :arity 2
  :domain (:AND |OrganismClassificationType| (:FILLED-BY SUPERRELATIONS |Plant|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Fruit|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$FruitFn is a Cyc function, specifically a #$CollectionDenotingFunction, which is used to denote the various natural kinds of fruit.  #$FruitFn takes a single plant collection as its argument and returns the collection of fruits of that type of plant.  (#$FruitFn PLANTTYPE) denotes the collection of all fruits from the elements of PLANTTYPE.  Examples: (#$FruitFn #$AppleTree) denotes the collection of apples (corresponds to #$Apple-TheFruit); (#$FruitFn #$CashewTree) denotes the fruit of the cashew tree (note this does NOT correspond with #$Cashew-TheNut; the red pulpy fruit is used to make cashew wine)."))
)
(defrelation |GaseousFn|
  :arity 2
  :domain |TangibleStuffCompositionType|
  :range (:AND |TangibleStuffStateType| (:FILLED-BY SUPERRELATIONS |GaseousTangibleThing|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "A #$CollectionDenotingFunction.  #$GaseousFn takes as an argument a collection COL, membership in which is based only on physical and/or chemical composition and not on any other property (see #$TangibleStuffCompositionType).  (#$GaseousFn COL) is the collection of elements of COL that are in the #$GaseousStateOfMatter."))
)
(defrelation |genFormat|
  :arity 3
  :domains (|Relationship| |CycSystemString|)
  :range |CycSystemList|
  :annotations ( |TernaryPredicate|)
)
(defrelation |genlAttributes|
  :arity 2
  :domain |AttributeValue|
  :range |AttributeValue|
  :annotations ( |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |IntangibleObjectPredicate|
     |RuleMacroPredicate|
     (DOCUMENTATION "(#$genlAttributes S-ATT G-ATT) means that G-ATT is a more general attribute than S-ATT.  If we know, for some object, THING, (#$hasAttributes THING S-ATT), the system will be able to derive (#$hasAttributes THING G-ATT).  #$genlAttributes is transitive, so (#$genlAttributes A B) and (#$genlAttributes B C) lets the system derive (#$genlAttributes A C).  For example, if a certain portion of the atmosphere has the attribute #$Hazy, Cyc can conclude through its #$genlAttributes knowledge that there is only moderate #$Visibility there."))
)
(defrelation |genlInverse|
  :arity 2
  :domain |BinaryPredicate|
  :range |BinaryPredicate|
  :annotations ( |BinaryPredicate|
     |RuleMacroPredicate|
     (DOCUMENTATION "(#$genlInverse NARROW BROAD) means that binary predicate BROAD is a more general version of binary predicate NARROW, but with the arguments reversed. Thus  (NARROW ARG1 ARG2) implies (BROAD ARG2 ARG1).   



Note:  Notice that if two predicates are true inverses of each other, such as the pair parents and children, or the pair greater-than and less-than, then each member of the pair will be a #$genlInverse of the other.  Creating two predicates like that is considered poor KEing style, however, because in that case the second predicate in the pair adds no new `expressive power' over what the first already provides.  One might decide to write an end-user interface which acts as though both predicates exist, so that the user doesn't have to remember which is `the real one' in the system, but there is no gain at the representation language level to having both predicates."))
)
(defrelation |genlMt|
  :arity 2
  :domain |Microtheory|
  :range |Microtheory|
  :annotations ( |RuleMacroPredicate|
     |MicrotheoryPredicate|
     |DefaultMonotonicPredicate|
     |AntiSymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$genlMt SMT GMT) means #$Microtheory SMT is a specialization of #$Microtheory GMT.   E.g., (#$genlMt #$ModernMilitaryMt #$OrganizationMt), which means that all the assertions which are true `content' in the general #$OrganizationMt context are also true in the more specialized #$ModernMilitaryMt context.  Another way to think of this is that SMT `has access to' the content of GMT.   Each proposition which is true in GMT is also true in SMT.  The #$genlMt relation is transitive; it induces a partial ordering on the set of all microtheories.   


Each assertion in the knowledge base must be explicitly stated to be true in at least one mt.  It will then (by inference) also be true in all the more specialized contexts.  If something is true in the `life in North America' mt, then it should by default be true in the `life in Canada' mt.  I.e., the microtheories are organized into a generalization/specialization lattice by the predicate #$genlMt, just as collections are organized into such a lattice by #$genls, and just as predicates are organized into such a lattice by #$genlPreds.  Just as a collection may have several incommensurable supersets, so too a microtheory may have several incommensurable #$genlMts.  Just as each and every collection must have some explicitly recorded superset (except for #$Thing), each and every mt must have some (expicitly recorded) more general mt (except for the #$BaseKB, which is the most general context, containing universal, timeless truths).  Just as a Cyc concept may have multiple incommensurable sets of which it is an element (via #$isa), so too a Cyc assertion may be declared to be true in a set of incommensurable mts.  For virtually all intents and purposes, #$genlMt assertions should go in #$BaseKB."))
)
(defrelation |genlPreds|
  :arity 2
  :domain |Predicate|
  :range |Predicate|
  :annotations ( |AntiSymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |RuleMacroPredicate|
     (DOCUMENTATION "(#$genlPreds NARROW BROAD) means that predicate BROAD is a more general version of predicate NARROW; e.g., (#$genlPreds #$biologicalMother #$biologicalParents), (#$genlPreds #$greaterThan #$greaterThanOrEqualTo).   (#$genlPreds NARROW BROAD) is shorthand for the axiom schema (NARROW ARG1 ... ARGN) => (BROAD ARG1 ... ARGN).  See also #$genlInverse, which can handle cases where NARROW and BROAD are both binary but their order of arguments is reversed.  If the #$arity of NARROW differs from the #$arity of BROAD (or their order of arguments differs and they're not binary), then we just assert the whole appropriate axiom into the Cyc knowledge base; of course, such axioms are absent from the public release of the Upper Cyc Ontology."))
)
(defrelation |genls|
  :arity 2
  :is-primitive |subsetOf|
  :domain |Collection|
  :range |Collection|
  :annotations ( |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |DefaultMonotonicPredicate|
     |TaxonomicSlotForCollections|
     |RuleMacroPredicate|
     (DOCUMENTATION "(#$genls COL SUPER) means that SUPER is one of the supersets of COL.  Both arguments must be elements of #$Collection.  Cyc knows that #$genls is transitive; that is, if one asserts (#$genls COL SUPER) and (#$genls SUPER BIGGER), Cyc will infer that (#$genls COL BIGGER). Therefore, in practice one only manually asserts a small fraction of the #$genls assertions --- the vast majority are inferred automatically by Cyc."))
)
(defrelation |GenValueFn|
  :arity 4
  :domains (|IntervalBasedQuantitySlot| |Collection| |GenericAttribute|)
  :range |ScalarInterval|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "#$GenValueFn is a Cyc function, in particular, an element of #$IndividualDenotingFunction.  It is used to denote an amount of a specified attribute that can be considered a generic value (very low, low, medium, high, or etc.) for members of the indicated group.  Thus, (#$GenValueFn PRED COL GEN) denotes the amount which can be considered the GEN value of PRED for members of the #$Collection COL.  Thus (#$GenValueFn #$heightOfObject #$BasketBallPlayer #$High) denotes the amount of distance which is a high height among basketball players.  See also #$GenericAttribute."))
)
(defrelation |geographicalSubRegions|
  :arity 2
  :is-primitive |surfaceParts|
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |ReflexiveBinaryPredicate|
     |SpatialPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$geographicalSubRegions SUPER SUB) means that SUPER and SUB are both elements of #$GeographicalRegion, and the area SUB lies wholly within the region SUPER (see #$inRegion).  SUPER may or may not completely surround SUB (i.e., they may share an outer boundary, as do Texas and the USA).  See also #$surroundsHorizontally, #$bordersOn."))
)
(defrelation |gerund|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$gerund WORD STRING) means that STRING is the gerund form of WORD.  Also known as present participle or progressive. The regular gerund is formed from the infinitive verb form with an `ing' suffix. Verbs in the Cyc lexicon will have a #$gerund entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `singing'. Irregular example: `swimming'."))
)
(defrelation |goals|
  :arity 2
  :is-primitive |desires|
  :domain |Agent|
  :range |Goal|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$goals AGT G) means that the #$Agent AGT has the #$Goal G.  That is, G is one of their goals.  This implies (#$desires AGT G), but #$goals is stronger than #$desires, in that an agent will take action (or at least intend to take action, and plan accordingly) to make their #$goals true, while their #$desires may include things s/he merely wishes were true, but about which s/he has no intention of undertaking action.  Additionally, #$goals are generally about the future, whereas #$desires can be about the present, future, or even the past.  For further information about goals, see #$Goal.  Also see #$intends."))
)
(defrelation |governedByAgreement|
  :arity 2
  :is-primitive |preActors|
  :domain |SocialOccurrence|
  :range |Agreement|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$governedByAgreement relates an event to an agreement which stipulates that certain conditions are to hold during that event.  (#$governedByAgreement EVT AGR) means that some aspects of the #$SocialOccurrence EVT are controlled by the #$Agreement AGR.  For example, a #$BuyingGroup may have #$SalesContracts with its #$suppliers that specify what prices may be charged for goods bought by members of the group during the agreement period."))
)
(defrelation |government|
  :arity 2
  :domain |GeopoliticalEntity|
  :range |RegionalGovernment|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$government identifies the political entity which has governing authority over a particular geopolitical region.  (#$government GEOPOL GOV) means that the #$RegionalGovernment GOV is the government of the #$GeopoliticalEntity GEOPOL.  That is, GOV claims to be the government of GEOPOL, is recognized as such at least informally, and effectively functions as such -- administering the internal and external affairs of GEOPOL --  whether or not GOV has formal diplomatic recognition.  Effectively functioning as a #$government includes having the power to settle disputes, collect revenue, and provide services.  Examples include the #$UnitedStatesFederalGovernment, the #$CityCouncilOfAustin (TX), and all of the entities returned by the Cyc function #$GovernmentFn (q.v.) -- e.g., (#$GovernmentFn #$Taiwan-RepublicOfChina), (#$GovernmentFn #$Russia)."))
)
(defrelation |GovernmentFn|
  :arity 2
  :domain |GeopoliticalEntity|
  :range |RegionalGovernment|
  :annotations ( |ReifiableFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "The Cyc function #$GovernmentFn is an #$IndividualDenotingFunction.  Given an element of #$GeopoliticalEntity as its single argument, #$GovernmentFn forms a non-atomic term (NAT) used to denote the element of #$RegionalGovernment that governs that geopolitical entity.  (#$GovernmentFn REGION) is the NAT used to denote the government of REGION.  For example, what is denoted by #$UnitedStatesFederalGovernment is the same as -- i.e., #$equals -- what is denoted by (#$GovernmentFn #$UnitedStatesOfAmerica).  See also #$government."))
)
(defrelation |governmentType|
  :arity 2
  :domain |GeopoliticalEntity|
  :range |SystemOfGovernment|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "The predicate #$governmentType indicates what kind of system of government a geopolitical entity has.  (#$governmentType REGION GOVSYSTEM) means that the government of the #$GeopoliticalEntity REGION is an element of the #$SystemOfGovernment type denoted by GOVSYSTEM.  For example, the #$governmentType of the #$UnitedStatesOfAmerica is a #$FederalRepublic and a #$RepresentativeDemocracy."))
)
(defrelation |Gram|
  :annotations ( |CGSUnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfMass|
     (DOCUMENTATION "The measurement function used in Cyc to represent the gram used within the Metric system to measure mass.  See also #$CGSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |grandchildren|
  :arity 2
  :is-primitive (:and |positiveVestedInterest| |relatives|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$grandchildren OLDER YOUNGER) means YOUNGER is the grandchild of OLDER."))
)
(defrelation |granuleOfStuff|
  :arity 2
  :domain |ExistingStuffType|
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$granuleOfStuff STUFFTYPE OBJTYPE) means 
that the collection STUFFTYPE has as its spatial granules (or granularity level) the 
collection OBJTYPE. If some collection is spatially stuff-like, that means that 
the instances of that collection can be divided spatially, and the physical portions 
remaining will still be instances of that collection; e.g., a physcial portion of 
some instance of #$SandMob is still sand (cf. #$ExistingStuffType). Such division cannot 
go on indefinitely in this way,
however: eventually, division of something spatially stuff-like will result in the 
object-like 'granules' out of which the stuff-like thing is composed. For instances, 
division of sand would eventually result in individual grains of sand, division of 
water would eventually get down to individual molecules of water, etc. At this level 
of division or below, the remaining physical portions do NOT count as instances of 
the stuff-type from which they were divided. This may seem counter-intuitive: isn't 
an individual molecule of water still water? Perhaps in some sense, but since the 
individual granules of a stuff typically do NOT have most of the properties that 
the groups made of the granules have (including the property of being stuff-like), 
we do not count the individual granules as instances of the collection of which 
they are granules."))
)
(defrelation |granuleOfTime|
  :arity 2
  :domain |TemporalStuffType|
  :range |TemporalObjectType|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$granuleOfTime STUFFTYPE OBJTYPE) means 
that the collection STUFFTYPE has as its temporal granules (or granularity level) the 
collection OBJTYPE. If some collection is temporally stuff-like, that means that 
the instances of that collection can be divided temporally, and the temporal slices 
remaining will still be instances of that collection; e.g., a time slice of 
some instance of #$Person is still a person, and a temporal slice of a walking process
is still a walking process (cf. #$TemporalStuffType). Such division cannot 
always go on indefinitely, however: eventually, division of something temporally 
stuff-like will result in the 
temporally object-like 'granules' out of which the stuff-like thing is composed. 
For instances, 
division of a walking process would eventually result in individual steps. At this level 
of division or below, the remaining temporal slices do NOT count as instances of 
the temporal stuff-type from which they were divided. This may seem counter-intuitive,
but since the 
individual temporal granules of a temporal stuff typically do NOT have most of the 
properties that the groups made of the granules have (including the property of being 
temporally stuff-like),  we do not count the individual granules as instances of the 
collection of which they are granules. See also #$granuleOfStuff."))
)
(defrelation |greaterThan|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |EvaluatableFunction|
     |NumericComparison|
     (DOCUMENTATION "The predicate #$greaterThan is Cyc's representation of the `greater than' ( > ) relation in mathematics, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values.  Formally, there are two conditions under which (#$greaterThan SI-1 SI-2) is true, for two elements of #$ScalarInterval: (1) (#$followingValue SI-1 SI-2) is true, or (2) the minimum of SI-1 is greater than the maximum of SI-2.  Note that `A is less than B' is expressed in CycL as (#$greaterThan B A)."))
)
(defrelation |greaterThanOrEqualTo|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |EvaluatableFunction|
     |NumericComparison|
     (DOCUMENTATION "The predicate #$greaterThanOrEqualTo is Cyc's representation of the `greater than or equal to' ( >= ) relation in mathematics, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values.  (See #$ScalarInterval.) Formally, there are three conditions under which (#$greaterThanOrEqualTo SI-1 SI-2) is true, for two elements of #$ScalarInterval: (1) (#$equals SI-1 SI-2) is true; (2) (#$followingValue SI-1 SI-2) is true; or (3) the minimum of SI-1 is greater than or equal to the maximum of SI-2.  Note that `A is less than or equal to B' is expressed in CycL as (#$greaterThanOrEqualTo B A)."))
)
(defrelation |groundOf|
  :arity 2
  :domain |PartiallyTangible|
  :range |Surface-Physical|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$groundOf OBJ GROUND) means that GROUND is the stationary surface on which OBJ is located and possibly supported."))
)
(defrelation |groupCardinality|
  :arity 2
  :domain |Group|
  :range |NonNegativeInteger|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$groupCardinality is used to indicate the total number of members there are in a particular group.  (#$groupCardinality GROUP INTEGER) means that the number of members in the #$Group GROUP is INTEGER.  For example, the #$groupCardinality of the #$SevenWondersOfTheAncientWorld is 7.  Cyc infers that the #$groupCardinality of any group that is a pair is 2, and that of a dozen is 12."))
)
(defrelation |GroupFn|
  :arity 2
  :domain |ObjectType|
  :range (:AND |ObjectType| (:FILLED-BY SUPERRELATIONS |Group|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$GroupFn is a Cyc #$CollectionDenotingFunction.  #$GroupFn is used for referring to specializations of #$Group; esp. note that applications of #$GroupFn produce COLLECTIONS (of groups), not individual groups.  #$GroupFn takes any element of #$ObjectType as its argument and returns a subset of #$Group, namely the collection containing those groups whose #$groupMembers are elements of that #$ObjectType.  (#$GroupFn OBJ-TYPE) denotes the collection of all groups whose members belong to (#$isa) OBJ-TYPE. For example, (#$GroupFn #$BallisticMissile) represents the collection of all groups of ballistic missiles, e.g., Russia's ballistic missiles, China's ballistic missiles, the U.S.'s ballistic missiles, etc.  Another example: A group of 101 (particular) Dalmatians #$isa (#$GroupFn #$Dog).  Collections of groups of events may also be denoted; e.g., Columbus's voyages to North America constitute a group (of events) which #$isa (#$GroupFn #$Travel-TripEvent)."))
)
(defrelation |groupMembers|
  :arity 2
  :is-primitive (:and |structureMembers| |cotemporal|)
  :domain |Group|
  :range |TemporalThing|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$groupMembers is used to relate a particular group to its individual members.  (#$groupMembers GROUP MEMBER) means that MEMBER is a member of GROUP.  For example,  the #$PyramidOfCheops is a member of the #$SevenWondersOfTheAncientWorld.  Or, to say that President Bill Clinton was a member of the Democratic Party throughout 1996, we would say: (#$holdsIn (#$YearFn 1996) (#$groupMembers #$DemocraticParty #$BillClinton))."))
)
(defrelation |groupMemberType|
  :arity 2
  :domain |Group|
  :range (:AND |ObjectType| (:FILLED-BY SUPERRELATIONS |TemporalThing|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$groupMemberType is used in characterizing the members of a particular group.  (#$groupMemberType GROUP TYPE) means that all of GROUP's members are elements of the collection TYPE.  For example, to state that the #$groupMembers of the Austin City Council are humans, one would write (#$groupMemberType AustinCityCouncil #$Person).  The members of a particular group might be characterized in more than one way; e.g., a Hispanic Business Council may have both the #$groupMemberType #$EthnicGroupOfHispanics and the #$groupMemberType #$BusinessPerson (provided that all of its members are Hispanic business people)."))
)
(defrelation |hairColor|
  :arity 3
  :domains ((:AND |Animal| |Mammal|) (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|)))
  :range |Color|
  :annotations ( |TernaryPredicate|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$hairColor ANIMAL BODYPARTTYPE COLOR) means that the hair which the #$Animal ANIMAL has on its BODYPARTTYPE has the #$Color COLOR.  E.g., (#$hairColor #$SantaClaus #$Chin #$WhiteColor).  This is normally #$Mammal hair, but certain #$Invertebrates also have hair."))
)
(defrelation |hangsAround|
  :arity 2
  :is-primitive (:and |on-Physical| |hangsFrom|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$hangsAround ?loop ?obj) means that ?loop is a semi-flexible loop, looped around a piece of ?obj.  ?loop is supported by gripping friction and/or ?loop's limited ability to elongate as it moves down on ?obj.  See also #$hangsFrom."))
)
(defrelation |hangsFrom|
  :arity 2
  :is-primitive |supportedBy|
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$hangsFrom ?obj1 ?obj2) means that ?obj1 is suspended from ?obj2, either directly touching it (like a weight attached to a line) or through some intermediary object (like a weight suspended from the ceiling).  All of the weight of ?obj1 is #$supportedBy ?obj2.  Most if not all of ?obj1 is below ?obj2. Certainly, the center of ?obj1 is below the connection point.  If pushed, ?obj1 will undergo #$Swinging without necessarily dislodging it."))
)
(defrelation |hardnessOfObject|
  :arity 2
  :domain |SolidTangibleThing|
  :range |Hardness|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$hardnessOfObject OBJ DEGREE) means that the instance of #$SolidTangibleThing OBJ has this DEGREE of #$Hardness."))
)
(defrelation |hasAsTributary|
  :arity 2
  :domain |River|
  :range |River|
  :annotations ( |AsymmetricBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "The predicate #$hasAsTributary is used to indicate the tributaries of a particular river.  (#$hasAsTributary BIGRIV SMALLRIV) means that BIGRIV has SMALLRIV as one of its tributaries.  SMALLRIV flows into BIGRIV.  Examples: the #$MississippiRiver has the #$WisconsinRiver, #$OhioRiver, #$ArkansasRiver, #$RedRiverOfTexas, and others as its tributaries.  Cf. #$formedByConfluenceOf."))
)
(defrelation |hasAttributes|
  :arity 2
  :domain |TemporalThing|
  :range |AttributeValue|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "A very general predicate. (#$hasAttributes THING ATT) means that THING has the attribute ATT.  See also #$AttributeType and #$AttributeValue."))
)
(defrelation |hasBeliefSystems|
  :arity 2
  :domain |IntelligentAgent|
  :range |BeliefSystem|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$hasBeliefSystems AGT BSYS) means that the #$Agent AGT has the belief system BSYS.   E.g., (#$hasBeliefSystems BorisYeltsin #$RussianOrthodoxReligion)."))
)
(defrelation |hasClimateType|
  :arity 2
  :domain |GeographicalRegion|
  :range (:AND |ClimateCycleType| (:FILLED-BY SUPERRELATIONS |AnnualClimateCycle|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$hasClimateType is used to specify the type of climate that occurs in a particular region.  (#$hasClimateType AREA CLIME) means that the climate in the #$GeographicalRegion AREA is of the #$ClimateCycleType CLIME; i.e., any individual annual cycle falls under the type CLIME.  For example, to describe the climate of Houston, we would say: (#$hasClimateType #$CityOfHoustonTX #$HumidSubtropicalClimateCycle).  See also #$ClimateCycleType, #$AnnualClimateCycle."))
)
(defrelation |hasCommConvention|
  :arity 2
  :domain |Agent|
  :range |CommunicationConvention|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$hasCommConvention AGENT CONV) means that the agent AGENT knows the #$CommunicationConvention CONV and can use it to encode or decode information."))
)
(defrelation |hasGender|
  :arity 2
  :domain |BiologicalLivingObject|
  :range |GenderOfLivingThing|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$hasGender BLO SEX) means that the #$BiologicalLivingObject BLO is of the gender SEX."))
)
(defrelation |hasHabitat|
  :arity 2
  :domain |Organism-Whole|
  :range |EcologicalRegion|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "The predicate #$hasHabitat is used to relate an organism to the region where it lives.  (#$hasHabitat ORG REGION) means that the organism ORG lives in the #$EcologicalRegion REGION. Typically, REGION will belong to one of the subsets of #$EcologicalRegion which represent specific biomes (e.g., #$Desert, #$CoralReef)."))
)
(defrelation |hasHeadquartersInCountry|
  :arity 2
  :domain |Organization|
  :range |Country|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$hasHeadquartersInCountry identifies the country in which a particular organization has its headquarters.  (#$hasHeadquartersInCountry ORG COUNTRY) means that the #$Organization ORG has its world-wide headquarters and place of primary central control in the #$Country COUNTRY."))
)
(defrelation |hasLevels|
  :arity 2
  :is-primitive |physicalParts|
  :domain |ConstructionArtifact|
  :range |LevelOfAConstruction|
  :annotations ( |PartPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "Levels which are part of this building"))
)
(defrelation |hasMembers|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Organization|
  :range |Agent|
  :annotations ( |CotemporalObjectsSlot|
     |SubProcessSlot|
     |TaxonomicSlot|
     (DOCUMENTATION "The predicate #$hasMembers relates a particular organization to the agents which are members of that organization.  This predicate indicates `generic' membership, although there may be specialized kinds of membership in the same organization.  (#$hasMembers ORG AGENT) means that AGENT is a member of the #$Organization ORG; typically, membership elegibility is determined by ORG and accepted with AGENT's voluntary affiliation.  For example, (#$hasMembers 'PeanutsBaseballTeam' #$CharlieBrown).   A member may be any #$Agent, including other #$Organizations (such as member countries in the United Nations).  The truth of an assertion made with #$hasMembers may be time-dependent and, if so, should be qualified appropriately.  E.g., (#$holdsIn (#$YearFn 1975) (#$hasMembers #$UnitedNationsOrganization #$Taiwan-RepublicOfChina)) is true, but (#$holdsIn (#$YearFn 1995) (#$hasMembers #$UnitedNationsOrganization #$Taiwan-RepublicOfChina)) is not."))
)
(defrelation |hasOwnershipIn|
  :arity 2
  :domain |Agent|
  :range |SomethingExisting|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$hasOwnershipIn relates a particular agent to some thing of which it has part or whole ownership.  (#$hasOwnershipIn AGENT SOMETHING) means that the #$Agent AGENT owns a part (or possibly the whole) of the thing SOMETHING.  For example, Ted Turner #$hasOwnershipIn Atlanta's Olympic Stadium. There may be other owners.  See also #$legalOwnerOf and #$ownsShare."))
)
(defrelation |hasPatients|
  :arity 2
  :is-primitive |clients|
  :domain |MedicalCareProvider|
  :range |Animal|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$hasPatients represents a relationship between a medical professional and a patient (including nonhuman animals).  (#$hasPatients MEDIC PATIENT) means that the #$MedicalCareProvider MEDIC is treating the recipient-of-care PATIENT.  PATIENT may be a human or a nonhuman animal.  An assertion using #$hasPatients holds only during the time that PATIENT has a condition that is being treated by MEDIC; it does not represent or imply a long term doctor-patient relationship."))
)
(defrelation |hasPhysiologicalAttributes|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |BiologicalLivingObject|
  :range |PhysiologicalAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$hasPhysiologicalAttributes ?BLO  ?ATT) means that the #$BiologicalLivingObject ?BLO has the #$PhysiologicalAttribute ?ATT.  #$PhysiologicalAttributes are concerned with the physiological functions of a living animal, especially with the physical and/or (bio)chemical basis of those functions.  However, #$PhysiologicalAttributes need not be specified in scientific detail.  Many common #$PhysiologicalAttributes permit commonsense inference about further features of an individual having a certain physiological state or condition.  Note that many, perhaps most, assertions made with #$hasPhysiologicalAttributes will be time-dependent; e.g., an individual person is not #$SexuallyMature throughout his or her life, but only during a portion of it.  Thus, it is necessary to make these assertions only about the appropriate temporal #$subAbstrac; one way to do that is by using #$holdsIn; e.g., (#$holdsIn (#$YearFn 1820)  (#$hasPhysiologicalAttributes #$LudwigVanBeethoven #$Deaf))."))
)
(defrelation |hasPortalToRegion|
  :arity 2
  :is-primitive |cotemporal|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "ARG1 is connected to ARG2 through some type of portal (e.g. #$hasPortalToRegion(MyMasterBedroom MyMaterBathroom))"))
)
(defrelation |hasPositionIn|
  :arity 3
  :domains (|Person| |Organization|)
  :range |PositionType|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$hasPositionIn is used to relate a particular person to his or her position in a particular organization.  (#$hasPositionIn PER ORG POS-TYPE) means that the #$Person PER works in the #$Organization ORG, in a position of type POS-TYPE.  POS-TYPE may or may not specifically indicate PER's occupational field or training; that is, one individual occupying a position of #$Manager may be a #$MarketingPerson, while another is an #$ElectricalEngineer.  In addition, POS-TYPE may or may not correspond to an official `Job Title' (cf. #$hasTitle) or be the primary occupation of PER.  Contrast, e.g., (#$hasPositionIn JerryLewis MarchOfDimes #$Spokesman) with (#$hasPositionIn DellaStreet PerryMasonsLawOffice #$Secretary).  Note that assertions using #$hasPositionIn should be properly time-constrained, for example with #$holdsIn."))
)
(defrelation |hasPreparationAttributes|
  :arity 2
  :domain |EdibleStuff|
  :range |PreparationAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$hasPreparationAttributes is used to indicate the way in which a particular food item was prepared.  (#$hasPreparationAttributes EDIBLE PREP) means the #$EdibleStuff EDIBLE has been processed so that it has the food #$PreparationAttribute PREP (e.g., #$Cooked, #$Roasted, #$Chilled -- or #$Raw).  For example, a piece of #$Toast #$hasPreparationAttributes #$Toasted; any quantity of #$Beer that is ready to drink #$hasPreparationAttributes #$Fermented."))
)
(defrelation |hasRooms|
  :arity 2
  :is-primitive (:and |containsCavity| |physicalParts| |internalParts| |cotemporal|)
  :domain |ConstructionArtifact|
  :range |SpaceInAHOC|
  :annotations ( |CotemporalObjectsSlot|
     |PhysicalPartPredicate|
     (DOCUMENTATION "The predicate #$hasRooms allows us to say that a particular space is within a particular building.  (#$hasRooms BUILD ROOM) means that ROOM is a room or demarcated space which is physically contained within BUILD, a #$ConstructionArtifact.  ROOM is not removable from BUILD.  Spaces that can be identified in this way include lobbies, hallways, kitchens, closets, dining rooms, gymnasia, studios, stairwells, bedrooms, etc."))
)
(defrelation |hasSameEntityAs|
  :arity 2
  :domain |SomethingExisting|
  :range |SomethingExisting|
  :annotations ( |InterExistingObjectSlot|
     |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$hasSameEntityAs ?X ?Y) indicates that ?X and ?Y are both subabstractions of the same #$Entity.  The unique #$myEntity of ?X is the same as the unique #$myEntity of ?Y.  For instance, AlbertEinsteinAsAnAdult and AlbertEinsteinWhileAtPrinceton are in this relationship."))
)
(defrelation |hasTitle|
  :arity 3
  :domains (|Person| |Title|)
  :range |Organization|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$hasTitle relates a person to a title that s/he holds in an organization.  (#$hasTitle PER TITLE ORG) means that the #$Person PER has the #$Title TITLE in the #$Organization ORG.  Elements of #$Title are linguistic objects usually related to positions or other qualifications that a person has.  A person generally has a title only while actually holding the related position; e.g., (#$hasTitle #$Lenat #$PrincipalScientist-Title #$CycGroup) tells us Doug Lenat's title at the Cyc Project while under MCC's organizational structure.  A noteworthy class of exceptions is #$CourtesyTitle (q.v.), which include forms of address such as `Mr.' and `Ms.', plus some titles which by courtesy the holders retain for life, such as (in the U.S.) `President' and military rank designations (e.g., officers retired from the armed services).
Note: Elements of #$Title belong to the set #$LinguisticObject, while positions themselves are represented by persons (cf. #$PositionType).  Cf. #$hasPositionIn."))
)
(defrelation |hasWorkers|
  :arity 2
  :is-primitive (:and |worksWith| |cotemporal|)
  :domain |Agent|
  :range |Agent|
  :annotations ( |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$hasWorkers relates an
organization or individual agent to those who work for it in any capacity.  (#$hasWorkers
AGENT1 AGENT2) says that the second agent regularly
 works for the first agent.  This includes employees,
managers, soldiers, sailors, certain prison inmates, volunteers,
apprentices, slaves, servants, sharecroppers, and indentured workers
(as well as other organizations, e.g. subcontractors).  The truth of
an assertion made with #$hasWorkers is time-relative; e.g.,
(#$hasWorkers #$Cycorp #$Dexter) is true when asserted for the period
(or any sub-period) from May 1989 to July 1994.  Note that `workers'
in the sense of #$hasWorkers need not be #$employees (e.g., they could
be volunteers); cf. #$employees."))
)
(defrelation |headquarters|
  :arity 2
  :is-primitive |physicalQuarters|
  :domain |Organization|
  :range |ConstructionArtifact|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$headquarters indicates the building(s) where a particular organization has its headquarters.  (#$headquarters ORG BUILDING) means that BUILDING is the buildings, rooms, offices, etc., which house the main administrative and decision-making functions of the #$Organization ORG."))
)
(defrelation |hears|
  :arity 2
  :is-primitive |perceives|
  :domain |PerceptualAgent|
  :range |TemporalThing|
  :annotations ( |PerceivingSlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$hears AGT OBJ) means that the #$PerceptualAgent AGT percieves sounds emananating from or as the result of OBJ.  Events such as the shooting of a gun and tangible objects such as telephones are things which can emit audible sound and thus be perceived auditorily. "))
)
(defrelation |heightOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Distance|
  :annotations ( |PhysicalAmountSlot|
     (DOCUMENTATION "(#$heightOfObject OBJ HEIGHT) means that the #$Distance from OBJ's top boundary to its bottom boundary is HEIGHT.  Note that top and bottom are determined by an object's default orientation, if it has one (as do, e.g., people, houses, cars, trees); otherwise, by the orientation of the object in its environment."))
)
(defrelation |Hertz|
  :annotations ( |UnitOfMeasureNoPrefix|
     |StandardUnitOfMeasure|
     |UnitOfFrequency|
     (DOCUMENTATION "A Cyc function, specifically an #$IndividualDenotingFunction.  #$Hertz represents the basic unit of measure for elements of #$Frequency (1 Hz=1 cycle per second).  (#$Hertz NUM) denotes the frequency NUM cycles per second."))
)
(defrelation |HighAmountFn|
  :arity 2
  :domain (:AND |PrimitiveAttributeType| (:FILLED-BY SUPERRELATIONS |ScalarInterval|))
  :range |ScalarInterval|
  :annotations ( |GenericValueFunction|
     (DOCUMENTATION "#$HighAmountFn is a Cyc function, in particular, an element of #$IndividualDenotingFunction.  It is one of several functions used to denote so-called generic values for a wide variety of attributes.  When ATT is a type of attribute, (#$HighAmountFn ATT) returns an instance of ATT which is considered `a high amount of' ATT in the current context.  A high amount of ATT is more than (#$MediumAmountFn ATT) but less than (#$VeryHighAmountFn ATT)."))
)
(defrelation |hingedTo|
  :arity 2
  :is-primitive |rotationallyConnectedTo|
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |PhysicalFeatureDescribingPredicate|
     |ExtensionalRepresentationPredicate|
     |SymmetricBinaryPredicate|
     |SpatialPredicate|
     |ConnectionPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$hingedTo OBJ1 OBJ2) means that there is some hinge connecting OBJ1 and OBJ2 which allows limited rotational motion between them.  That is the only relative motion that can occur between them.  The hinged pivoting motion may be repeated.  #$hingedTo is noncommittal about whether the hinge is a distinct object or is part of OBJ1 or OBJ2.  Some edge of OBJ1 adjoins an edge of OBJ2."))
)
(defrelation |holdsIn|
  :arity 2
  :domain |TemporalThing|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$holdsIn ?X ?P) means that the proposition ?P is true during the temporal extent of #$TemporalThing ?X.  To represent `Nick owned Spot in 1992' we could create the appropriate cotemporal subabstractions of each, and assert (#$owns NickIn1992 SpotIn1992).  More tersely, we could use #$holdsIn and simply assert (#$holdsIn (#$YearFn 1992) (#$owns Nick Spot)), since #$holdsIn implicitly treats instances of #$SomethingExisting as their appropriate temporal subabstractions.  Alternatively, we could create a context (a microtheory) one of whose assumptions was a temporal one, limiting all axioms to holding during 1992, and then in that context we could simply assert (#$owns Nick Spot).  But it would be incorrect to assert (#$owns Nick Spot) in the #$BaseKB --- i.e., devoid of context --- since Nick as a baby and Nick as an old man didn't/won't own Spot."))
)
(defrelation |HorsePower|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfPower|
     (DOCUMENTATION "An english unit of power.  The power that, roughly, a single workhorse can continually supply"))
)
)    ; END EVAL-WHEN 4

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 5
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |hostOfEvent|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |SocialGathering|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$hostOfEvent GATHERING AGENT) means that AGENT is a host and sponsor of the #$SocialGathering GATHERING."))
)
(defrelation |HourFn|
  :arity 3
  :domains (|NonNegativeInteger| |CalendarDay|)
  :range |CalendarHour|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$HourFn ?H ?D) denotes a #$CalendarHour -- in particular, hour number ?H (military time) of day ?D.  For example, (#$HourFn 18 (#$DayFn 14 (#$MonthFn #$February (#$YearFn 1966)))) denotes 6pm Feb. 14th, 1966"))
)
(defrelation |HoursDuration|
  :annotations ( |UnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfTime|
     (DOCUMENTATION "This is a function that takes one or two numbers and returns, as its value, some amount of #$Time.  An expression of the form (#$HoursDuration ?min ?max) denotes a quantity of #$Time that is at least ?min hours and at most ?max hours.  (#$HoursDuration ?num) denotes a quantity of #$Time that is exactly ?num hours."))
)
(defrelation |hungerLevelOf|
  :arity 2
  :domain |LevelOfHunger|
  :range |Animal|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "Just what it says"))
)
(defrelation |iboCreated|
  :arity 2
  :is-primitive (:and |outputsCreated| |informationDestination| |ibtGenerated|)
  :domain |IBOCreation|
  :range |InformationBearingObject|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$iboCreated is used to link a particular information bearing object (IBO) to the event in which it is created.  (#$iboCreated CREATION IBO) means that the #$InformationBearingObject IBO is created in the event CREATION.  For example, my copy of today's `Austin American-Statesman' morning paper was created during the previous night's paper-publishing event."))
)
(defrelation |ibtGenerated|
  :arity 2
  :domain |IBTGeneration|
  :range |InformationBearingThing|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "The predicate #$ibtGenerated is used to link a particular information bearing thing (IBT) to the event in which it is created.  (#$ibtGenerated GEN IBT) means that the #$InformationBearingThing IBT comes about, happens, or comes into existence in or as an immediate consequence of the event GEN."))
)
(defrelation |ibtHasInfoAbout|
  :arity 2
  :domain |InformationBearingThing|
  :range |Thing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$ibtHasInfoAbout ?IBT ?THING) means that the #$InformationBearingThing ?IBT is generally 'about' ?THING -- which may be any #$Thing at all.  This is a very general notion of aboutness, which does not require that ?THING be explicitly named in ?IBT, nor that it be the main topic."))
)
(defrelation |identicalInAttribute|
  :arity 3
  :domains (|Thing| |Thing|)
  :range |AttributeType|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$identicalInAttribute THING1 THING2 ATTRIBUTE) means that the two things THING1 and THING2 have the same values of the #$AttributeType ATTRIBUTE.  Here 'the same' means complete identity or very close resemblance -- what this means, and what the standard of closeness or identity is, depends on the context, but #$identicalInAttribute and #$differentInAttribute cannot both be correctly asserted of the same two things.  See also #$resemblesInAttribute, and #$differentInAttribute."))
)
(defrelation |illuminationLevel|
  :arity 2
  :domain |PartiallyTangible|
  :range |LightIntensity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$illuminationLevel LOC DEGREE) indicates how brightly illuminated the location LOC is.  Higher values of DEGREE mean greater light intensity."))
)
(defrelation |implies|
  :arity 2
  :domain |CycFormula|
  :range |CycFormula|
  :annotations ( |Relationship|
     |LogicalConnective|
     (DOCUMENTATION "The predicate #$implies represents the material implication relation in Cyc.  #$implies is a logical connective taking two arguments, each of which must be an element of #$CycFormula.   (#$implies ANTE CONSEQ) means that whenever the formula ANTE is true, the formula CONSEQ must also be true; in other words, it is not the case that ANTE is true while CONSEQ is false.  Cyc assertions that begin with #$implies are used during inference, both in modus ponens and modus tollens."))
)
(defrelation |in-Among|
  :arity 2
  :is-primitive (:and |objectFoundInLocation| |cotemporal|)
  :domain |PartiallyTangible|
  :range |Group|
  :annotations ( |SpatialPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$in-Among OBJ GROUP) means that the tangible thing OBJ is physically located within the spatial cluster GROUP, which is composed of individuals.  OBJ may (but need not) be a member of GROUP.  OBJ is spatially distinct from any (other) member of GROUP; cf. #$spatiallyIntersects.  Examples: a bird in the branches of a tree; a zebra in its herd; a flea in a dog's pelt; a bee in a swarm of bees; a snake in the grass."))
)
(defrelation |in-ContClosed|
  :arity 2
  :is-primitive (:and |in-ContGeneric| |cotemporal|)
  :domain |PartiallyTangible|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$in-ContClosed OBJ CONT) means that OBJ is contained in CONT and cannot leave CONT unless CONT opens or breaks, or OBJ is broken into pieces small enough to escape from CONT.  Examples: water in a bottle; CD in a CD case; food in a plastic zip bag; books in a backpack; spare tire in the trunk.  In order for a relation to count as #$in-ContClosed, the container must have a portal, even though that portal is closed while this relation holds.  So, for example, it is NOT proper to use #$in-ContClosed to say that an egg is in its eggshell, or that a brain is in its skull.  See also #$Portal."))
)
(defrelation |in-ContFullOf|
  :arity 2
  :is-primitive (:and |in-ContGeneric| |touchesDirectly| |cotemporal|)
  :domain |PartiallyTangible|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$in-ContFullOf STUFF CONT) means that STUFF is the substance that fills CONT.  STUFF is unique in that it is the only substance that `fills' CONT, even though other things may be with it in CONT (e.g., as #$in-ContGeneric).  Filling the container means that the inside surface of CONT touches the filling STUFF at virtually all points of CONT's inner surface, rather than touching whatever stuff CONT itself is immersed in and which CONT's outside surface touches (e.g., air).  The only thing which can override this #$touches (i.e., get alongside CONT's inside wall without being STUFF) would be some other object which is also in CONT (e.g., with #$in-ContGeneric).  In order to fill the container, STUFF must be #$Pourable or have a shape which conforms to the shape of CONT's cavity.  Cf. #$in-ContGeneric to cover cases of stuff which is in a container without filling it. "))
)
(defrelation |in-ContGeneric|
  :arity 2
  :is-primitive (:and |cotemporal| |objectFoundInLocation|)
  :domain |PartiallyTangible|
  :range |SolidTangibleThing|
  :annotations ( |CotemporalObjectsSlot|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "(#$in-ContGeneric OBJ CONT) means that OBJ is contained, confined, or held in CONT.  CONT may be open or closed. See also #$in-ContOpen, #$in-ContClosed, #$in-ContFullOf, #$inRegion."))
)
(defrelation |in-ContOpen|
  :arity 2
  :is-primitive (:and |in-ContGeneric| |cotemporal|)
  :domain |PartiallyTangible|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$in-ContOpen OBJ CONT) means that OBJ is contained in CONT -- CONT confines or holds OBJ in -- but OBJ can be removed from CONT without having to open any portals in CONT.  In gravity fields, CONT is right-side-up, and if CONT is turned over, OBJ will fall out.  Cf. #$in-ContClosed."))
)
(defrelation |in-Embedded|
  :arity 2
  :is-primitive (:and |objectFoundInLocation| |cotemporal| |touchesDirectly| |connectedTo|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$in-Embedded OBJ1 OBJ2) means that some portion of OBJ1 is embedded in OBJ2 at least semi-permanently.  OBJ1 is thus #$connectedTo OBJ2.  The remaining portion of OBJ1 is not embedded in OBJ2. In many cases, an #$in-Embedded relationship comes about during the formation of OBJ1 or OBJ2.  Examples: grass in the ground, hair in the scalp, or eyes in sockets."))
)
(defrelation |in-Floating|
  :arity 2
  :is-primitive (:and |above-Touching| |in-ImmersedPartly|)
  :domain |SolidTangibleThing|
  :range |LiquidTangibleThing|
  :annotations ( |SpatialPredicate|
     |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$in-Floating OBJ LIQUID) means that OBJ is floating in LIQUID.  Thus, OBJ is buoyant and is #$in-ImmersedPartly in LIQUID."))
)
(defrelation |in-Held|
  :arity 2
  :is-primitive (:and |touches| |in-ContGeneric| |cotemporal|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |AntiSymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$in-Held OBJ HOLDER) means that OBJ is being held or restrained by HOLDER, which is applying pressure to OBJ.  HOLDER #$touches OBJ.  HOLDER may be either a #$deviceUsed or an #$anatomicalPartTypeAffected in an instance of #$HoldingAnObject; OBJ would be the #$objectActedOn by that holding."))
)
(defrelation |in-ImmersedFully|
  :arity 2
  :is-primitive (:and |cotemporal| |in-ImmersedGeneric| |objectFoundInLocation|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$in-ImmersedFully OBJ FLUID) means that FLUID is the unique fluid in which OBJ is completely immersed.  Thus, as a default inference, every outside surface region of OBJ #$touches FLUID.  E.g., (live) fish are fully immersed in water, and people are usually immersed in air (even though the bottoms of their feet touch the ground and not the air).  Examples like air bubbles in water or mercury globules immersed in air suggest that the #$arg1Isa should be kept general, i.e., #$PartiallyTangible rather than #$SolidTangibleThing."))
)
(defrelation |in-ImmersedGeneric|
  :arity 2
  :is-primitive |touches|
  :domain |PartiallyTangible|
  :range |FluidTangibleThing|
  :annotations ( |SpatialPredicate|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(#$in-ImmersedGeneric OBJ FLUID) means that OBJ is immersed in FLUID.  #$in-ImmersedGeneric is noncomittal as to whether OBJ is completely or partially immersed.  But FLUID #$touches OBJ and conforms to a significant portion of the surface of OBJ.   See also #$in-ImmersedFully, #$in-ImmersedPartly."))
)
(defrelation |in-ImmersedPartly|
  :arity 2
  :is-primitive |in-ImmersedGeneric|
  :domain |PartiallyTangible|
  :range |FluidTangibleThing|
  :annotations ( |SpatialPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$in-ImmersedPartly OBJ FLUID) means that a portion of OBJ is immersed in FLUID, but OBJ is not completely surrounded by FLUID.  In gravitational fields, #$in-ImmersedPartly entails #$surroundsHorizontally, because in that context fluid surfaces are of generally #$HorizontalOrientation."))
)
(defrelation |in-Lodged|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|)
)
(defrelation |in-Permeates|
  :arity 2
  :is-primitive |objectFoundInLocation|
  :domain |LiquidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$in-Permeates LIQUID SOLID)
means that LIQUID permeates SOLID.  LIQUID must be separable from SOLID
by physical, not chemical means.  If LIQUID is not a constituent (see
#$constituents) of SOLID, then SOLID is porous (see #$Porous).
Exemplars include water permeating a wet sponge, oil soaking a sponge,
or water in soil.  Negative exemplars include vapor suspended in air
(see, e.g. #$suspendingFluid or #$solute) .  Other negative exemplars
include liquids which undergoe a chemical change and combine with some
other substance, e.g. water which becomes a chemical part of plant
material in photosynthesis."))
)
(defrelation |in-Snugly|
  :arity 2
  :is-primitive (:and |in-ContGeneric| |touches| |cotemporal|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The #$BinaryPredicate (#$in-Snugly ?INNER ?OUTER) means that ?INNER is #$in-ContGeneric ?OUTER, that ?INNER #$touches ?OUTER, and that a #$FrictionProcess would be necessary for a #$RemovingSomething in which ?INNER is the #$objectMoving and ?OUTER is the #$fromLocation."))
)
(defrelation |in-Spiked|
  :arity 2
  :is-primitive (:and |connectedTo-Rigidly| |in-Embedded| |in-Lodged|)
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$in-Spiked OBJ REG) means that an object, OBJ, is spiked into another object, REG, in the way that nails, push pins, needles, and other pointed objects stick into other objects.  Thus, OBJ must be #$LongAndThin and must be harder than REG.  Typically, the rigid connection between REG and OBJ can support forces substantially greater than the weight of OBJ."))
)
(defrelation |Inch|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfDistance|
     |FPSUnitOfMeasure|
     (DOCUMENTATION "The measurement function used in Cyc to represent the inch used to measure length within the British (FPS) system.  See also #$FPSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |includedItems|
  :arity 2
  :is-primitive |parts|
  :domain |FormalProduct|
  :range |Individual|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |PartPredicate|
     (DOCUMENTATION "The predicate #$includedItems is used to identify the peripheral items that come with a particular packaged product.  (#$includedItems FORM ITEM) means that the #$Individual ITEM is one of the things that are included in the #$FormalProduct FORM, along with its #$mainProduct; but ITEM is not the main product itself.  ITEM can be an accessory, owner's manual, warranty agreement, or included service.  ITEM is something that is a regular part of the package.  ITEM does NOT refer to free samples or extras thrown in--for that, see #$includesWithProductType."))
)
(defrelation |includesWithProductType|
  :arity 3
  :domains (|CommercialOrganization| (:AND |ProductType| (:FILLED-BY SUPERRELATIONS |Product|)))
  :range (:AND |ProductType| (:FILLED-BY SUPERRELATIONS |Product|))
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$includesWithProductType is used to specify `extras' that a particular seller includes with a specific product.  (#$includesWithProductType SELLER MAINTYPE EXTRATYPE) means that the #$CommercialOrganization SELLER provides an item of the #$ProductType EXTRATYPE free of charge to its customers who purchase a product of #$ProductType MAINTYPE.  For example, to say that Ernie's Garage provides towing free with a car repair, we could say (#$includesWithProductType ErniesGarage #$CarRepairing #$TowingAnAutomobile)."))
)
(defrelation |income|
  :arity 2
  :domain |Agent|
  :range |MonetaryFlowRate|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$income is used to state the income of a person or other agent.  (#$income AGT RATE) means that the #$Agent AGT has the income RATE, where RATE is a #$MonetaryFlowRate, e.g., a number of #$DollarsPerHour or #$DollarsPerYear.  See #$MonetaryFlowRate."))
)
(defrelation |infectingOrganism|
  :arity 2
  :is-primitive |preActors|
  :domain |Infection|
  :range |Organism-Whole|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "This predicate relates a particular instance of #$Infection to an organism which causes that infection.  (#$infectingOrganism INFECT ORG) means that the organism ORG is one of the causes of the infection INFECT.  For example, if INFECT is a case of  #$StrepThroat, then ORG is an instance of #$Streptococcus.  I.e., 
(#$forAll ?x
  (#$forAll ?y
     (#$implies 
         (#$and
             (#$isa ?x #$StrepThroat) 
             (#$infectingOrganism ?x ?y))
         (#$isa ?y #$Streptococcus))))
"))
)
(defrelation |InfectionFn|
  :arity 2
  :domain (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AnimalBodyPart|))
  :range (:AND |InfectionType| (:FILLED-BY SUPERRELATIONS |Infection|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$InfectionFn is a Cyc function, and in particular a #$CollectionDenotingFunction.  It is used to decribe ailments according to the region of the animal's body in which they are found.  (#$InfectionFn REGION) denotes the collection of infections of the region of the body, REGION.  For example, (#$InfectionFn #$Throat) is the set of all throat infections, and hence a subset of #$Infection.  When you get a case of strep throat, that is an element of (#$InfectionFn #$Throat).   When you get appendicitis, that is an element of the set represented by (#$InfectionFn #$Appendix-OrganPart)."))
)
(defrelation |infectionHost|
  :arity 2
  :is-primitive |bodilyDoer|
  :domain |Infection|
  :range |Organism-Whole|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "This predicate relates a particular case of #$Infection to the organism it is infecting.  (#$infectionHost INF ORG) means that INF is an #$Infection in which the host organism is ORG."))
)
(defrelation |infinitive|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$infinitive WORD STRING) means that STRING is the infinitive verb form of WORD.  For example, `to hit' is the infinitive form of #$Hit-TheWord."))
)
(defrelation |infoAdded|
  :arity 2
  :is-primitive |infoTransferred|
  :domain |InformationUpdating|
  :range |AbstractInformation|
  :annotations ( |Role|
     |BinaryPredicate|
     (DOCUMENTATION "(#$infoAdded CHANGE INFO) means that in the #$InformationUpdating action, CHANGE, INFO was added to the IBO (#$InformationBearingObject) acted on."))
)
(defrelation |infoContributed|
  :arity 3
  :domains (|MultiDirectionalCommunication| |Agent|)
  :range |PropositionalInformationThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$infoContributed is used to identify which agent said what in a particular complex communication activity.  (#$infoContributed MULTICOM AGENT INFO) means that in the #$MultiDirectionalCommunication event MULTICOM, AGENT does something that expresses INFO.  Note that speaking, writing, or otherwise signalling are all viable methods of `saying'.  The (unspecified) thing that AGENT does in MULTICOM generates the message, and INFO is a propositional item expressing the content of AGENT's message.  See also #$PropositionalInformationThing and #$IBTGeneration."))
)
(defrelation |infoRemoved|
  :arity 2
  :is-primitive |infoTransferred|
  :domain |InformationUpdating|
  :range |AbstractInformation|
  :annotations ( |Role|
     |BinaryPredicate|
     (DOCUMENTATION "(#$infoRemoved CHANGE INFO) means that in the #$InformationUpdating action, CHANGE, INFO was removed from the IBO (#$InformationBearingObject) acted on."))
)
(defrelation |informationDestination|
  :arity 2
  :domain |InformationTransferEvent|
  :range |TemporalThing|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "The predicate #$informationDestination is used to indicate where information is transferred in a particular information transfer event.  (#$informationDestination TRANSFER DEST) means that in the #$InformationTransferEvent TRANSFER, the information being transferred is sent, given to, or impressed upon DEST.  DEST is an IBT (i.e., an element of #$InformationBearingThing) or an agent.  Note that if DEST is an agent, you should probably use the more specific actor slot, #$recipientOfInfo.  Note also that if DEST existed before the transfer, it may have already contained the information."))
)
(defrelation |informationOrigin|
  :arity 2
  :domain |InformationTransferEvent|
  :range |TemporalThing|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "The predicate #$informationOrigin is used to indicate the source of information for a particular communication event.  (#$informationOrigin TRANSFER ORIGIN) means that in the #$InformationTransferEvent TRANSFER, the information being transferred is coming from ORIGIN.  ORIGIN is either an IBT (i.e., element of #$InformationBearingThing) or an agent.  Note that if ORIGIN still exists past the transfer, it presumably still contains the information."))
)
(defrelation |informStatement|
  :arity 2
  :is-primitive |ist-Information|
  :domain |PropositionalInformationThing|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     |MicrotheoryPredicate|
     (DOCUMENTATION "(#$informStatement ?MT ?PROP) means that the #$CycFormula ?PROP is true in the information context ?MT.  (An information context here usually means a particular database application of #$Cyc.  In these applications, ?PROP is communicated to #$Cyc directly as an explicit #$informStatement, and is not inferred to be true.)  Note that (#$informStatement ?mt ?clpe) implies that (#$ist ?mt ?clpe)."))
)
(defrelation |infoTransferred|
  :arity 2
  :domain |InformationTransferEvent|
  :range |AbstractInformation|
  :annotations ( |BinaryPredicate|
     |Role|
     (DOCUMENTATION "The predicate #$infoTransferred is used to indicate the propositional content of a particular transferral of information.  (#$infoTransferred TRANSFER INFO) means that INFO is information that is transferred due to the #$InformationTransferEvent TRANSFER.  INFO originates from some agent or IBT (i.e., element of #$InformationBearingThing).  After TRANSFER, INFO is contained in another IBT or agent; INFO may persist in the source as well.  For example, when I read the front page of the newspaper, some information about current world events is transferred from the newspaper to me.   See also #$informationOrigin, #$informationDestination."))
)
(defrelation |inFrontOf-Directly|
  :arity 2
  :is-primitive |inFrontOf-Generally|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$inFrontOf-Directly FORE AFT) means that FORE is directly in front of AFT.  More precisely, it implies both (#$inFrontOf-Generally FORE AFT) and that there is at least one line parallel to the forward pointing axis of AFT that intersects both FORE and AFT."))
)
(defrelation |inFrontOf-Generally|
  :arity 2
  :is-primitive |near|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$inFrontOf-Generally FORE AFT) means that the tangible object FORE is in front of the tangible object AFT.  More precisely, the intrinsic back-to-front axis of AFT is within 45 degrees of some line intersecting both FORE and AFT."))
)
(defrelation |IngestingFn|
  :arity 2
  :domain (:AND |StuffType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :range (:AND |TemporalObjectType| (:FILLED-BY SUPERRELATIONS |Ingesting|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "The Cyc function #$IngestingFn is a #$CollectionDenotingFunction.  It is used to represent collections of events in which certain types of things are consumed.  (#$IngestingFn STUFFTYPE) denotes the collection of events in which a tangible substance of the type STUFFTYPE is ingested.  For example, lots of instances of (#$IngestingFn #$Popcorn) occur at the movies."))
)
(defrelation |ingredients|
  :arity 2
  :is-primitive (:and |physicalDecompositions| |cotemporal|)
  :domain |Artifact|
  :range |PartiallyTangible|
  :annotations ( |TransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     |CompositionPredicate|
     (DOCUMENTATION "The predicate #$ingredients is used to indicate a particular input used to make a particular artifact.  (#$ingredients ART INGR) means that the #$PartiallyTangible thing INGR was one of the #$inputs to the creation of the #$Artifact ART, and INGR is one of ART's #$physicalDecompositions.  Note that #$ingredients applies only to those inputs which retain their identity in the creation process and which are incorporated into the resulting #$Artifact.  For example, a meatball can be considered an ingredient of a plate of spaghetti, and a portion of ground beef can be considered an ingredient of the meatball.  On the other hand, we would not say that an egg is an ingredient of the meatball, even though it was an input to the creation process, because its identity was not preserved."))
)
(defrelation |inhabitantTypes|
  :arity 2
  :domain |GeographicalRegion|
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Person|))
  :annotations ( |BinaryPredicate|
     |IntensionalRepresentationPredicate|
     (DOCUMENTATION "The predicate #$inhabitantTypes is used to indicate the type(s) of people who live in a region.  (#$inhabitantTypes REGION TYPE) means that TYPE is (one of) the (primary) type(s) of people who live in the #$GeographicalRegion REGION.  For example, to say that Chileans are among the primary groups of inhabitants of Chile, we assert (#$inhabitantTypes #$Chile #$ChileanPerson).  TYPE may be based on ethnicity, nationality, age, economics--in short, any demographic class.  E.g., (#$inhabitantTypes #$UnitedStatesOfAmerica #$AdultMiddleClassAmerican), (#$inhabitantTypes #$UnitedStatesOfAmerica #$WorkingAdultAmericanWoman), (#$inhabitantTypes #$UnitedStatesOfAmerica #$MexicanImmigrantToUSA)."))
)
(defrelation |inPlane|
  :arity 2
  :is-primitive |spatiallyIntersects|
  :domain |SpatialThing|
  :range |Surface-Abstract|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$inPlane OBJ SURFACE) means that OBJ spatially intersects with the #$FlatSurface SURFACE."))
)
(defrelation |inputs|
  :arity 2
  :is-primitive (:and |objectActedOn| |startsAfterStartingOf| |preActors|)
  :domain |CreationOrDestructionEvent|
  :range |SomethingExisting|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$inputs relates a particular event to things which are `inputs', i.e., materials used in that event and somehow altered by it.  (#$inputs EVENT OBJECT) means that OBJECT is an input to the #$CreationOrDestructionEvent EVENT.  During and due to the event, OBJECT is either destroyed or incorporated into a new entity.  For example, the pigments used to paint the Mona Lisa were #$inputs to Leonardo's painting process; however, his brushes were not #$inputs, even though they were changed a little by it.  In general, in instances of #$Manufacturing, materials or objects are inputs if they find their way into the product manufactured, or if they are destroyed -- such as the coke used in manufacturing steel -- as part of that manufacturing process.  
Note: One should use the specialized predicates #$inputsDestroyed or #$inputsCommitted whenever they are appropriate, rather than the more general predicate #$inputs."))
)
(defrelation |inputsCommitted|
  :arity 2
  :is-primitive (:and |postActors| |inputs| |commitsForFutureUses|)
  :domain |CreationEvent|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "The predicate #$inputsCommitted is used when some #$inputs to a particular event is incorporated into some #$outputs of that event, but remains recognizable rather than being destroyed.  (#$inputsCommitted EVENT OBJECT) means that OBJECT exists before EVENT and continues to exist afterwards, and as a result of EVENT, OBJECT becomes incorporated into something created during EVENT.  For example, bricks that are used to build a house continue to exist as bricks once the house has been built.  (See also #$outputsCreated.)
Note: there is a grey area between #$inputsCommitted and #$inputsDestroyed; the less possible it is to take apart the relevant #$outputs of EVENT and get OBJECT back as an independent thing, the more likely it is that the relationship between EVENT and OBJECT should be #$inputsDestroyed, rather than #$inputsCommitted."))
)
(defrelation |inputsDestroyed|
  :arity 2
  :is-primitive (:and |endsAfterEndingOf| |inputs|)
  :domain |DestructionEvent|
  :range |SomethingExisting|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$inputsDestroyed is used to relate a particular event to the items which are destroyed by it.  (#$inputsDestroyed EVENT OBJECT) means that OBJECT exists before EVENT, is affected by EVENT, and due to that involvement, ends its existence as an #$Entity sometime during EVENT.  OBJECT may or may not be a #$deliberateActors in EVENT."))
)
(defrelation |inRegion|
  :arity 2
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |ExtensionalRepresentationPredicate|
     |TransitiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     (DOCUMENTATION "(#$inRegion OBJECT AREA) means that all points in OBJECT are found within the boundaries of AREA, which is another spatial thing (of which OBJECT may or may not be a part).  OBJECT is totally included spatially within the region demarcated by AREA.  







Note, regarding whether OBJECT is a part of AREA: Two subordinate, but contrasting, predicates are #$physicalDecompositions (a #$genlInverse of #$inRegion) and #$objectFoundInLocation (a #$genlPreds of #$inRegion).  (1) OBJECT is a #$physicalDecompositions of AREA if the set of points occupied by OBJECT is a subset of the points actually occupied by AREA; i.e., OBJECT is spatially a part of AREA.  (2) On the other hand, if OBJECT is merely present in AREA, but is not a part of it, then #$objectFoundInLocation applies."))
)
(defrelation |insIsJobOf|
  :arity 2
  :domain |ScriptType|
  :range |Professional|
  :annotations ( |TypePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$insIsJobOf indicates a type of work done by a particular individual.  (#$insIsJobOf SCRIPT-TYPE PER) means that the person PER performs instances of SCRIPT-TYPE as part of his or her job.  E.g., #$KeithRichards performs instances of #$WritingMusic as part of his work; #$Goolsbey performs instances of #$ProgrammingAComputer in his job at Cycorp; a #$SecurityGuard performs instances of #$ProtectingSomething.  Note that assertions using #$insIsJobOf are true for some specific period of time, which may be indicated with #$holdsIn."))
)
(defrelation |instrument-Container|
  :arity 2
  :is-primitive |instrument-Generic|
  :domain |Event|
  :range |SolidTangibleThing|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$instrument-Container ?EVENT ?CONT) means that the #$objectActedOn in ?EVENT is contained in (#$in-ContGeneric) ?CONT during ?EVENT, and that ?CONT facilitates ?EVENT being accomplished."))
)
(defrelation |instrument-Generic|
  :arity 2
  :is-primitive |actors|
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$instrument-Generic is used to link a particular event to any of the objects which play an instrumental role in it.  (#$instrument-Generic EVENT OBJECT) means that OBJECT plays an intermediate causal role in EVENT, facilitating its occurrence and serving some purpose of some #$Agent.  This can happen in at least two ways: a. the `doer' of EVENT acts on OBJECT, which in turn acts on something else (as when someone uses a hammer to pound in a nail) or b. the `doer' of EVENT acts on something, making it possible for OBJECT to act on that thing (as when someone puts wet clothes out in the sun to dry).  Typically, an #$instrument-Generic is not significantly altered by playing that role in an event.  #$deviceUsed is an important specialization predicate of #$instrument-Generic."))
)
(defrelation |intangibleComponent|
  :arity 2
  :is-primitive |parts|
  :domain |CompositeTangibleAndIntangibleObject|
  :range |IntangibleIndividual|
  :annotations ( |TransitiveBinaryPredicate|
     |NonPhysicalPartPredicate|
     (DOCUMENTATION "(#$intangibleComponent WHOLE PART) means that PART is the intangible part of the #$CompositeTangibleAndIntangibleObject WHOLE."))
)
(defrelation |intendedAudience|
  :arity 2
  :domain |InformationBearingThing|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$intendedAudience indicates an individual who is the intended recipient of the information in a particular IBT (i.e., element of #$InformationBearingThing).  (intendedAudience IBT AGT) means that the #$InformationBearingThing IBT has the individual #$Agent AGT as its intended audience--viewer, reader, listener, etc.  AGT (possibly along with other agents) is an individual who is supposed to access the information represented in IBT.  For example, the #$intendedAudience of a personal letter is usually its addressee."))
)
(defrelation |intendedAudienceType|
  :arity 2
  :domain |AbstractInformation|
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Agent|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$intendedAudienceType indicates the type of agents who are the intended recipients of the information in a particular IBT (i.e., element of #$InformationBearingThing).  (#$intendedAudienceType PIT TYPE) means that agents who are elements of TYPE are in the intended audience of the particular #$PropositionalInformationThing PIT.  Examples: the #$intendedAudienceType for the information in a copy of `AMA Journal' is the collection of American physicians; the #$intendedAudienceType of TV commercials for sugary packaged cereals are those members of #$HumanChild living in the broadcast area."))
)
(defrelation |intendedBehaviorCapable|
  :arity 3
  :is-primitive |behaviorCapable|
  :domains (|SomethingExisting| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$intendedBehaviorCapable is used to describe ways in which an object was designed to function.  (#$intendedBehaviorCapable OBJ SITTYPE ROLE) means that the individual, OBJ, was designed to serve as a ROLE in situations or events of type SITTYPE.  For example, a #$LandTransportationDevice such as an automobile is intended to serve the #$vehicle role in instances of (#$TransportViaFn #$LandTransportationDevice); an element of #$Sphygmomanometer is intended to serve as the #$deviceUsed in instances of #$SystolicBloodPressureTest; an element of #$RestArea is intended to be where a #$Resting-Relaxing #$eventOccursAt.  A thing may be able to play the same kind of ROLE in different kinds of situations; e.g., an element of #$StoveTopCookingPot can be the #$instrument-Container in either #$BoilingFood or #$SteamingFood events.  Or something may serve more than one function; e.g., a #$VacuumCleaner serves both as the #$deviceUsed in instances of #$Vacuuming and (in virtue of its #$VacuumDustBag) as the #$instrument-Container."))
)
(defrelation |intendedForUseBy|
  :arity 2
  :domain |Product|
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Organism-Whole|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$intendedForUseBy PROD TYPE) means that the #$Product PROD is intended to be used by individuals of the #$ExistingObjectType TYPE, where TYPE must be a subset of #$Organism-Whole.  E.g., many types of products are only for use by adults, by women, by dogs, etc.
Note:  This is a good example of a predicate which is redundant but useful.  `Redundant' means that any assertion one states using #$intendedForUseBy could be stated, albeit less tersely, using other, more basic predicates in the KB, in this case #$intends and #$usesObject.  Often, a huge number of axioms can be drastically shortened by introducing such a redundant predicate, and writing axioms that define it in terms of the more-basic predicates."))
)
(defrelation |intends|
  :arity 2
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$intends AGT PROP) means that the #$Agent AGT intends the proposition PROP (represented by a #$CycFormula) to become (or remain) true.  This predicate is obviously similar to #$goals (q.v.), but PROP is likely to be more short-lived (at least as far as the agent's intending) and more event-centered (`I did it because I intended that...') and more mechanically satisfied (`I intend to turn off the lamp') than any of the agent's goals.  You may intend to turn off the lamp, but it would be odd to call that one of your goals."))
)
(defrelation |interArgIsa1-2|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |RuleMacroPredicate|
     |MetaRelation|
     |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa1-2 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the first argument to PRED, the second argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa1-3|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa1-3 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the first argument to PRED, the third argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa1-4|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa1-4 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the first argument to PRED, the fourth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa1-5|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa1-5 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the first argument to PRED, the fifth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa2-1|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |RuleMacroPredicate|
     |MetaRelation|
     |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa2-1 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the second argument to PRED, the first argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa2-3|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa2-3 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the second argument to PRED, the third argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa2-4|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa2-4 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the second argument to PRED, the fourth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa2-5|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa2-5 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the second argument to PRED, the fifth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa3-1|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa3-1 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to PRED, the first argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa3-2|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa3-2 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to PRED, the second argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa3-4|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa3-4 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to PRED, the fourth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa3-5|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa3-5 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to PRED, the fifth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa4-1|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa4-1 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fourth argument to PRED, the first argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa4-2|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa4-2 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fourth argument to PRED, the second argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa4-3|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa4-3 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fourth argument to PRED, the third argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa4-5|
  :arity 3
  :domains (|Predicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa4-5 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fourth argument to PRED, the fifth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa5-1|
  :arity 3
  :domains (|QuintaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa5-1 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to PRED, the first argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa5-2|
  :arity 3
  :domains (|QuintaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa5-2 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to PRED, the second argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa5-3|
  :arity 3
  :domains (|QuintaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa5-3 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to PRED, the third argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |interArgIsa5-4|
  :arity 3
  :domains (|QuintaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$interArgIsa5-4 PRED INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) #$BaseKB) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to PRED, the fourth argument in that assertion is constrained to be an instance of DEPENDENT-ARG-COL."))
)
(defrelation |InteriorFn|
  :arity 2
  :domain |TangibleThing|
  :range |Interior|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (InteriorFn OBJ), applied to a #$TangibleThing OBJ, means all the interior space within the #$Cavity or cavites (chambers, passages, pockets, bubbles, etc.) that occur inside of OBJ.  The result is an instance of #$Interior.  An #$Interior, unlike a #$Cavity, does not include the walls of the chamber or passage, just the interior space itself without any of the the enclosing walls, panels or membranes."))
)
(defrelation |InteriorRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (InteriorRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the sub-region consisting of the core or inner parts or sections of REGOROBJ, or the interior main portion of REGOROBJ.  It applies when REGOROBJ itself has an intrinsic inside/outside orientation (unlike, say, a loop of thread), but if REGOROBJ is an enveloping part, surface membrane, ring or layer within or on a larger region or object that has its own inside/outside orientation, the function returns REGOROBJ's inside portion with respect to the inside and outside of the larger region or object."))
)
(defrelation |internalParts|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalParts|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |IrreflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "the internal parts of this tangible object"))
)
(defrelation |internationalOrg-MemberCountry|
  :arity 2
  :domain (:AND |InternationalOrganization| |InternationalOrganizationOfCountries|)
  :range |Country|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "The predicate #$internationalOrg-MemberCountry is used to indicate that a particular country belongs to a particular international organization.  (#$internationalOrg-MemberCountry INTORG NATION) means that the #$Country NATION (as represented by its national government or other legally designated body) is a member of the #$InternationalOrganization INTORG.  For example, #$Bahrain is an #$internationalOrg-MemberCountry of the #$LeagueOfArabStates and of the #$UnitedNationsOrganization; or, #$China-PeoplesRepublic is a #$internationalOrg-MemberCountry of the #$UnitedNationsOrganization -- but #$Taiwan-RepublicOfChina is not.
Note: Cyc requires that members of organizations be #$Agents.  Since geographical regions (such as countries) are not #$Agents, the usual Cyc predicate for indicating membership -- #$hasMembers -- refers to the governments of the countries which are mentioned in assertions made with #$internationalOrg-MemberCountry."))
)
(defrelation |intersectsIntervalType|
  :arity 2
  :domain |TemporalObjectType|
  :range |TemporalObjectType|
  :annotations ( |ReflexiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     |TemporalRelation|
     (DOCUMENTATION "(#$intersectsIntervalType ?X ?Y) indicates that every instance of ?X #$temporallyIntersects some instance ?Y.  For example, in the nontropics, (#$intersectsIntervalType #$SummerSeason #$CalendarSummer).  The `summer season' may not coincide exactly with the time between the summer solstice and autumnal equinox, but there is an (enormous) overlap between those two time periods.  This relation, #$intersectsIntervalType, is commutative but not transitive."))
)
(defrelation |IntervalAfterFn|
  :arity 3
  :domains (|TemporalThing| |Time-Quantity|)
  :range |TimeInterval|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(#$IntervalAfterFn T-OBJ DUR) denotes the #$TimeInterval which immediately follows T-OBJ, lasting for duration DUR."))
)
(defrelation |IntervalBeforeFn|
  :arity 3
  :domains (|TemporalThing| |Time-Quantity|)
  :range |TimeInterval|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(#$IntervalBeforeFn ?X ?D) returns the time interval, of duration ?D, immediately preceding ?X.  So the value is a #$TimeInterval, it has #$duration ?D, and  (#$contiguousAfter  ?X  (#$IntervalBeforeFn ?X ?D))."))
)
(defrelation |IntervalEndedByFn|
  :arity 2
  :domain |TemporalThing|
  :range |TimeInterval|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(#$IntervalEndedByFn TEMP-OBJ) denotes the time interval which ends when TEMP-OBJ starts.  The beginning of this interval coincides with the beginning of all time (#$Always-TimeInterval), if it has a beginning."))
)
(defrelation |IntervalMaxFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "(#$IntervalMaxFn SCALAR) returns an interval of the same type as SCALAR whose maximum value is the maximum value of SCALAR and whose minimum value is #$MinusInfinity.  For example, (#$IntervalMaxFn (#$Mile 3)) is the same as `the interval from negative infinity miles to three miles'. [Technical Note: if that expression were to denote a strictly absolute, as opposed to a relative-or-absolute, distance, then it would mean `the interval from 0 miles to 3 miles'.]   (#$IntervalMaxFn (#$Unity 1)) is the same as `the interval from negative infinity to 1', in other words, `no greater than one'."))
)
(defrelation |IntervalMinFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "(#$IntervalMinFn SCALAR) returns an interval of the same type as SCALAR whose minimum value is the minimum value of SCALAR and whose maximum value is #$PlusInfinity.  For example, (#$IntervalMinFn (#$Mile 3)) is the same as `the interval from three miles to an infinite number of miles', in other words, `at least three miles'."))
)
(defrelation |IntervalStartedByFn|
  :arity 2
  :domain |TemporalThing|
  :range |TimeInterval|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "(#$IntervalStartedByFn TEMP-OBJ) denotes the time interval which begins when TEMP-OBJ ends.  The end of this interval coincides with the end of all time (#$Always-TimeInterval), if time has an end."))
)
(defrelation |interviewee|
  :arity 2
  :is-primitive |socialParticipants|
  :domain (:AND |MultiDirectionalCommunication| |SpokenCommunicating|)
  :range |Person|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$interviewee INTERVIEW AGT) means that the #$Agent AGT is an interviewee in the #$Interviewing event INTERVIEW."))
)
(defrelation |interviewer|
  :arity 2
  :is-primitive (:and |performedBy| |socialParticipants|)
  :domain (:AND |MultiDirectionalCommunication| |SpokenCommunicating|)
  :range |Person|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$interviewer INTERVIEW AGT) means that the #$Agent AGT is an interviewer in the #$Interviewing event INTERVIEW."))
)
(defrelation |inverseFunc|
  :arity 2
  :domain |FunctionFromQuantitiesToQuantities|
  :range |FunctionFromQuantitiesToQuantities|
  :annotations ( |RelationshipPredicate|
     |FunctionalSlot|
     (DOCUMENTATION "The predicate #$inverseFunc relates a mathematical function to a unique inverse.  Both arguments to #$inverseFunc are elements of #$FunctionFromQuantitiesToQuantities.  (#$inverseFunc FN INVFN) relates the function FN to its inverse INVFN; e.g., the #$inverseFunc of the logarithm function (#$LogFn) would be the exponential function (#$ExpFn)."))
)
(defrelation |InverseOfIntervalFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$InverseOfIntervalFn is the unary mathematical function that returns the inverse of the number taken as its argument.  For example, (#$InverseOfIntervalFn 7) returns 1/7."))
)
(defrelation |inverseRelationType|
  :arity 3
  :domains (|BinaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |RuleMacroPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "(#$inverseRelationType SLOT COL1 COL2) means that, for every INS2 which is an instance of COL2, there is some INS1 which is an instance of COL1, such that (SLOT INS1 INS2) holds.  #$inverseRelationType is thus redundant with a huge set of commonly-occurring axioms.  By having this predicate (along with an axiom that defines it, and, eventually, support in code for quick inferencing with it), axioms in that set can be stated more tersely, and collection-level reasoning with it is possible."))
)
(defrelation |inverseRelationTypeCount|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |NonNegativeInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$inverseRelationTypeCount SLOT COL1 COL2 NUM) means that, for every instance of COL2 (INS2) there are exactly NUM instances of COL1 (INS1, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS3 INS2), ..., hold.  Thus (#$inverseRelationTypeCount #$anatomicalParts #$Animal #$Head-AnimalBodyPart 1) would mean `every animal head belongs to exactly one animal'."))
)
(defrelation |inverseRelationTypeMax|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |NonNegativeInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$inverseRelationTypeMax SLOT COL1 COL2 NUM) means that, for every instance of COL2 (INS2) there are at most NUM instances of COL1 (INS1, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS3 INS2), ..., hold.  Thus (#$inverseRelationTypeMax #$physicalParts #$Hand #$Finger 1) means `every finger is part of at most one hand'."))
)
(defrelation |inverseRelationTypeMin|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |NonNegativeInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$inverseRelationTypeMin SLOT COL1 COL2 NUM) means that, for every instance of COL2 (INS2) there are at least NUM instances of COL1 (INS1, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS3 INS2), ..., hold.  Thus (#$inverseRelationTypeMin #$children #$Person #$HumanChild 1) means literally `every child is the child of at least one person' or `every child has at least one parent'."))
)
(defrelation |isa|
  :arity 2
  :is-primitive |elementOf|
  :domain |ReifiableTerm|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |DefaultMonotonicPredicate|
     |TaxonomicSlotForAnyUnit|
     (DOCUMENTATION "(#$isa EL COL) means that EL is an element of the collection COL.   Cyc knows that #$isa distributes over #$genls; that is, if one asserts (#$isa EL COL) and (#$genls COL SUPER), Cyc will infer that (#$isa EL SUPER). Therefore, in practice one only manually asserts a small fraction of the #$isa assertions --- the vast majority are inferred automatically by Cyc."))
)
(defrelation |isolatedNodeInSystem|
  :arity 2
  :is-primitive |pointInSystem|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$isolatedNodeInSystem X SYS) means that the node X in the #$PathSystem SYS is an isolated point in SYS, i.e., X is not on any link or loop in the #$PathSystem SYS.  Note that an isolated point must be a node in SYS."))
)
)    ; END EVAL-WHEN 5

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 6
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |ist|
  :arity 2
  :domain |Microtheory|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     |MicrotheoryPredicate|
     (DOCUMENTATION "(#$ist MICRO PROP) means that the Cyc assertion PROP is true in the Cyc #$Microtheory MICRO.  E.g., one might assert (#$ist Image8093Mt (#$age #$Lenat (#$YearsDuration 5)) to state that in the context of a certain photograph, Doug was 5 years old.  In other microtheories, Doug would have different ages, or not be `known about' at all."))
)
(defrelation |ist-Agreement|
  :arity 2
  :is-primitive |ist|
  :domain |Agreement|
  :range |CycFormula|
  :annotations ( |MicrotheoryPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$ist-Agreement is used to indicate the propositions which have been agreed upon in a particular agreement.  (#$ist-Agreement AGR PROP) means that the proposition PROP is and should be true, according to the #$Agreement AGR.  PROP is expressed as a #$CycFormula and is considered true within the microtheory which represents AGR.  PROP may or may not be true in reality.
Note the distinction between #$ist and #$ist-Agreement:  #$ist relates any particular microtheory to all assertions that happen to be true in that microtheory; but #$ist-Agreement specially indicates those assertions in an #$Agreement microtheory which belong to the agreement itself and are not just something that happens to be true in it (e.g., that one of the #$agreeingAgents is named Joe)."))
)
(defrelation |ist-Information|
  :arity 2
  :is-primitive |ist|
  :domain |PropositionalInformationThing|
  :range |CycFormula|
  :annotations ( |MicrotheoryPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "This is a form of #$ist that applies to the explicit content of a chunk of information.  It is needed so we can distinguish between things that are true in an information context because they were explicitly stated, and things that are true because they can be inferred."))
)
(defrelation |itemWorn|
  :arity 2
  :domain |WearingSomething|
  :range |SomethingToWear|
  :annotations ( |Role|
     |BinaryPredicate|
     (DOCUMENTATION "The predicate #$itemWorn is used to indicate a particular article of clothing (or other wearable item) that is worn in a particular situation.  (#$itemWorn WEARING ITEM) means that ITEM is the #$ClothingItem worn during the situation WEARING, an element of #$WearingSomething (q.v.)."))
)
(defrelation |jobAttributes|
  :arity 2
  :domain |OccupationType|
  :range |JobAttribute|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "The predicate #$jobAttributes describes a type of job as #$BlueCollar, #$WhiteCollar, #$Unionized, etc.  (#$jobAttributes JOBTYPE ATTRIBUTE) means that ATTRIBUTE describes a general property of the #$OccupationType JOBTYPE.  Note that this predicate talks about elements of #$OccupationType (kinds of occupations), not about a particular job held by some individual."))
)
(defrelation |JointTypeBetweenFn|
  :arity 3
  :domains ((:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
            (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|)))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Configuration|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "(#$JointTypeBetweenFn OBJ-TYPE1 OBJ-TYPE2) denotes the class of #$Connections found between objects of type OBJ-TYPE1 and OBJ-TYPE2.  For example, (#$JointTypeBetweenFn #$TelephoneBody #$TelephoneReceiver) is the class of #$Connections between telephone handsets and bodies of telephones.  (#$JointTypeBetweenFn #$Humerus #$Radius-Bone) would be the class of elbows, but we chose to reify that class (#$ElbowJoint).  #$JointTypeBetweenFn is most useful when one needs to refer to a type of connection without creating it and naming it specifically."))
)
(defrelation |judicialAgents|
  :arity 2
  :is-primitive |mediators|
  :domain |SocialOccurrence|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$judicialAgents EV JUDGE) means that the #$Agent JUDGE is acting as a judge in the event EV."))
)
(defrelation |junctionInSystem|
  :arity 2
  :is-primitive |pointInSystem|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$junctionInSystem JUNCTION SYS) means that JUNCTION is a junction in the #$PathSystem SYS, i.e., a node in SYS that is an 'intersection' or 'branching point' of links or loops in SYS.  (For the case when no SYS is specified, see #$JunctionOfPaths.)  Formally, a node X in SYS is a junction in SYS iff either there are three (different) links in SYS such that X is on all of them, or there are two (different) loops in SYS such that X is on both of them, or there is a link in SYS and there is a loop in SYS such that X is on both of them.  For different kinds of junctions in a path system, see #$threeWayJunctionInSystem, #$fourWayJunctionInSystem."))
)
(defrelation |JuvenileFn|
  :arity 2
  :domain (:AND |OrganismClassificationType| (:FILLED-BY SUPERRELATIONS |Animal|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |JuvenileAnimal|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$JuvenileFn is a Cyc function, and in particular a #$CollectionDenotingFunction.  (#$JuvenileFn ORGCLASSTYPE) represents that subset of #$JuvenileAnimal whose elements are the juveniles of the group of animals denoted by ORGCLASSTYPE.  E.g., (#$JuvenileFn #$Deer) denotes the collection of all fawns.  Certain kinds of organisms have no juveniles (e.g., the members of #$Amoeba)."))
)
(defrelation |Kilogram|
  :annotations ( |UnitOfMeasureWithPrefix|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     |UnitOfMass|
     (DOCUMENTATION "The measurement function used in Cyc to represent the basic unit of mass in the Metric system (and in Cyc).  See also #$MKSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |Kilometer|
  :annotations ( |MKSUnitOfMeasure|
     |UnitOfMeasureWithPrefix|
     |UnitOfDistance|
     (DOCUMENTATION "The measurement function used in Cyc to represent the 1000-meter unit used within the Metric system to measure distance.  Modern countries using the metric system measure their roads - and their road races - in kilometers. See also #$MKSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |KilometersPerHour|
  :annotations ( |MKSUnitOfMeasure|
     |UnitOfSpeed|
     (DOCUMENTATION "(#$KilometersPerHour NUMBER) returns a dimensionless rate or speed of NUMBER kilometers per hour."))
)
(defrelation |knows|
  :arity 2
  :is-primitive |beliefs|
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$knows AGT PROP) means that the #$Agent AGT believes the proposition PROP (represented by a #$CycFormula), is sure about the truth of PROP (may or may not have a rational argument for PROP), and furthermore PROP is in fact true at least in the current context (#$Microtheory).
Note: Knowledge is stronger than belief; it implies belief.  So if (#$knows AGT PROP), then (#$beliefs AGT PROP) is true.
Note: Knowledge is stronger than truth; it implies truth (in the current #$Microtheory): if (#$knows AGT PROP), then PROP is true.
Note:  Opinion and knowledge are mutually exclusive: if (#$knows AGT PROP), then it is NOT true that (#$opinions AGT PROP).
Note: Knowledge implies awareness.  Since Abraham Lincoln died a century before we were born, it is impossible for (#$knows #$AbrahamLincoln (#$likesAsFriend #$Lenat #$MaryShepherd)) to hold, except in some fictional context.
"))
)
(defrelation |knowsAbout|
  :arity 2
  :domain |IntelligentAgent|
  :range |Thing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$knowsAbout AGT X) means that the #$IntelligentAgent AGT knows something about X.  This predicate represents more than simple awareness, but exactly what is known -- the content of AGT's knowledge about X -- is not specified.  Examples: (#$knowsAbout #$Lenat #$Cyc),  (#$knowsAbout #$MichaelJordan #$BasketBallGame). 
Note: many commonsense rules can conclude (#$knowsAbout AGT X) -- e.g., those having to do with AGT's occupation, college degrees, city of residence,... in fact, almost any assertion about AGT can lead to presumptions that he/she probably #$knowsAbout something.  #$knowsAbout in turn can serve (weakly) in arguments about whether or not AGT #$knows (qv) specific common assertions involving X, and in arguments about whether or not AGT #$knowsValue of some particular predicate applied to X, etc."))
)
(defrelation |knowsValue|
  :arity 3
  :domains (|IntelligentAgent| |Thing|)
  :range |BinaryPredicate|
  :annotations ( |TernaryPredicate|
     |ModalRelationship|
     (DOCUMENTATION "(#$knowsValue AGT X PRED) means that, if (PRED X VAL) is true, then the #$Agent ?AGT knows that; i.e., (#$knows AGT (PRED X VAL)).  E.g., this is a more compact way of expressing `people know their own date of birth' than if one had to use #$knows.  One could just write  (#$implies (#$isa ?A #$Agent) (#$knowsValue ?A ?A #$birthDate); presumably this would be asserted in a context (#$Microtheory) in which all actions were performed by human beings, or else there would have to be an extra qualifier to that effect added to the rule."))
)
(defrelation |languageOfCommunication|
  :arity 2
  :domain |Communicating|
  :range |Language|
  :annotations ( |FunctionalSlot|
     |Role|
     (DOCUMENTATION "The predicate #$languageOfCommunication is used to indicate a language used by agents in a particular communication event.  (#$languageOfCommunication COM LANG) means that in the #$Communicating COM, the information transferred is expressed in the language LANG.  LANG may be a natural language, a computer language, a musical system, or other symbolic system such as #$AmericanSignLanguage."))
)
(defrelation |languageSpoken|
  :arity 2
  :is-primitive (:and |knowsAbout| |hasCommConvention|)
  :domain |IntelligentAgent|
  :range |NaturalLanguage|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$languageSpoken INTAGENT NATLANG) means the #$IntelligentAgent INTAGENT speaks the natural human language NATLANG at least somewhat fluently.  The language must be speakable by humans, as are English, Latin, or Japanese, but not LISP, C or LINCOS.  So, for example, (#$languageSpoken #$Lenat #$EnglishLanguage).   See #$NaturalLanguage."))
)
(defrelation |lastName|
  :arity 2
  :is-primitive |nameOfAgent|
  :domain |Person|
  :range |HumanFamilyNameString|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$lastName X STRNG) means that #$Person X is known by the #$HumanFamilyNameString STRNG as his or her last name (surname).  E.g., (#$lastName #$Lenat ``Lenat'').  A person rarely has more than one last name at any one time.  Last names may change as a result of certain actions, such as marriages, deaths, etc., in various cultures."))
)
(defrelation |lastSubEvents|
  :arity 2
  :is-primitive (:and |temporallyFinishedBy| |subEvents|)
  :domain |Event|
  :range |Event|
  :annotations ( |SubProcessSlot|
     (DOCUMENTATION "(#$lastSubEvents ?X ?Y) implies (#$subEvents ?X ?Y) and (#$temporallyFinishedBy ?X ?Y).  For example, one Cyc axiom says that if ?X is a #$WagingWar event, and (#$lastSubEvents ?X ?Y) is true, and ?Y is a #$Surrendering event, then the the identity of those for whom the war was #$successfulForAgents can be inferred from the particular roles that are played by the various parties during the surrender.  This is how one might infer, from Lee surrendering to Grant, that the South lost the American Civil War."))
)
(defrelation |LateralRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (LateralRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the sub-region consisting of the flanks or side parts or lateral main sections (away from the mid-line) of REGOROBJ, or the lateral main areas of REGOROBJ as opposed to the medial or middle area; the right and left regions then both include parts of the lateral regions.  #$LateralRegionFn applies when REGOROBJ itself has an intrinsic right/left orientation (unlike, say, a sphere), but if REGOROBJ is a part within a larger region or object that has its own right/left orientation, the function returns REGOROBJ's portions farthest from the mid-line (with respect to left and right) of the larger region or object."))
)
(defrelation |laterSubAbstractions|
  :arity 2
  :domain |SomethingExisting|
  :range |SomethingExisting|
  :annotations ( |ComplexTemporalRelation|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$laterSubAbstractions SUB1 SUB2) means that SUB1 and SUB2 are both a #$subAbstrac of the same entity (i.e., (#$hasSameEntityAs SUB1 SUB2)) and the sub-abstraction SUB2 starts sometime after the beginning of SUB1 (i.e., (#$startsAfterStartingOf SUB2 SUB1)).  For example, #$RichardFeynman while working on the Manhattan Project was a #$laterSubAbstractions than #$RichardFeynman in his first year of graduate school at Princeton."))
)
(defrelation |laterThan|
  :arity 2
  :domain |Date|
  :range |Date|
  :annotations ( |EvaluatableFunction|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "#$laterThan is similar to #$greaterThan, but takes #$Dates as arguments.  (#$laterThan DATE1 DATE2) is true when DATE1 and DATE2 are #$Dates, and DATE1 starts after DATE2 is over.  #$laterThan is evaluatable."))
)
(defrelation |laws|
  :arity 2
  :is-primitive |cotemporal|
  :domain |GeopoliticalEntity|
  :range |GovernmentCOC|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$laws is used to relate a geopolitical region (country, state, city, etc.) to a law or entire legal code which applies there.  (#$laws GEOPOL CODE) means that the #$GeopoliticalEntity GEOPOL officially has the law (or set of laws) CODE.  See also #$GovernmentCOC for the representation of a #$Law or a #$LegalCode as a #$Microtheory."))
)
(defrelation |LeftRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (LeftRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the region consisting of the left half or flank or left main portion of REGOROBJ.  It applies only when REGOROBJ itself has an intrinsic left/right orientation, or is part of a larger region or object that has a left/right orientation."))
)
(defrelation |legallyCapableOf|
  :arity 3
  :domains (|Agent| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$legallyCapableOf indicates that an agent is legally able to take a certain role in a certain type of action.  (#$legallyCapableOf AGT SIT-TYPE ROLE) means that the individual AGT is legally qualified and/or entitled to act in this ROLE in #$Situations of the type SIT-TYPE.  For example, a person over 21 years of age is #$legallyCapableOf smoking cigarettes in the United States."))
)
(defrelation |lengthOfObject|
  :arity 2
  :is-primitive (:and |(MeaningInSystemFn SENSUS-Information1997 SIZE-PROPERTY-ASCRIPTION)| |(MeaningInSystemFn SENSUS-Information1997 LINEAR-SIZE)|)
  :domain |SpatialThing|
  :range |Distance|
  :annotations ( |PhysicalAmountSlot|
     (DOCUMENTATION "(#$lengthOfObject OBJ LEN) means that the tangible object OBJ has a length LEN.  Which dimension counts as length depends upon the object's orientation (which may be intrinsic or determined relative to its environment)."))
)
(defrelation |levelWith|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SymmetricBinaryPredicate|
     |SpatialPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$levelWith OBJ1 OBJ2) means that OBJ1 and OBJ2 are roughly the same vertical distance from some horizontal surface in the frame of reference."))
)
(defrelation |lightSource|
  :arity 3
  :domains (|PartiallyTangible| |PartiallyTangible|)
  :range |IlluminationModeAttribute|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$lightSource is used to indicate the source of an illumination falling on a particular object.  (#$lightSource OBJ SOURCE MODE) means that OBJ is illuminated by SOURCE with the type of illumination (#$IlluminationModeAttribute) MODE."))
)
(defrelation |likesAsFriend|
  :arity 2
  :is-primitive (:and |acquaintedWith| |likesObject|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$likesAsFriend AGT1 AGT2) means that AGT1 enjoys interacting socially with AGT2.  See also the #$FeelingAttributeTypes #$Friendliness. 
Note: this predicate does not imply that AGT1 likes AGT2 only as a friend -- there may be romantic feelings, and other feelings, as well."))
)
(defrelation |likesObject|
  :arity 2
  :domain |Animal|
  :range |PartiallyTangible|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$likesObject AGT OBJ) means that when the sentient agent AGT is interacting in some way with OBJ, that agent feels some measure of #$Enjoyment  --- that is, (#$feelsEmotion AGT #$Enjoyment).  The kind of interactions that produce #$Enjoyment depend largely on what kind of thing OBJ is.  Thus, `Joe likes the Mona Lisa' implies that Joe feels #$Enjoyment when viewing the Mona Lisa.  But `Joe likes pizza' implies that Joe feels #$Enjoyment when eating that kind of food.  There are some specialized predicates of #$likesObject that give more information about the kind of interaction between AGT and OBJ that results in #$Enjoyment; see, e.g., #$likesSensorially and #$likesAsFriend."))
)
(defrelation |likesRoleInActivity|
  :arity 3
  :domains (|Agent| |ActorSlot|)
  :range |Event|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$likesRoleInActivity AGT ROLE EVT) means that if the #$Agent AGT has the relation ROLE to the #$Event EVT, then AGT is likely to feel some positive measure of #$Enjoyment.  This predicate is useful to represent sentences such as `Joe likes running' or `Fred liked receiving the money'."))
)
(defrelation |likesSensorially|
  :arity 2
  :domain |PerceptualAgent|
  :range |SensoryAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$likesSensorially AGT SENSUM) means that the #$PerceptualAgent AGT derives some physical pleasure from the sensory experience of SENSUM (a taste, odor, or other #$SensoryAttribute)."))
)
(defrelation |linkBetweenInSystem|
  :arity 4
  :domains (|Path-Simple| |Thing| |Thing|)
  :range |Thing|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$linkBetweenInSystem LINK X Y SYS) means that in the #$PathSystem SYS, LINK (a link in SYS) has its two end points X and Y (nodes in SYS).  A link in a path system is one of the paths in the system whose end points are nodes in the system and that have no other nodes along them.  For each link LINK in SYS, there is a unique pair {X, Y} of different nodes in SYS such that (#$linkBetweenInSystem LINK X Y SYS) and (#$linkBetweenInSystem LINK Y X SYS) hold, and for two points (nodes) in SYS, there could be several different ('parallel') links between them.  No point in SYS that is not a node can be an end point of a link.  If node X is an end-point of LINK and (#$linkBetweenInSystem LINK X Y SYS) holds, then (#$pointOnPath X LINK) holds.  A link in SYS may have many points on it other than its end-points, but these points cannot be nodes in SYS (another way to put this is to say that there are exactly two nodes on a link, though there can be any number, greater than 1, of points on the link).  Only nodes in SYS can be 'intersection' point in SYS (see #$junctionInSystem), which implies that there is, in the system SYS, no point on a link LINK between X and Y that is an 'intersection' point of LINK and another link or a loop.  When defining a path system, it is convenient (and also quite safe) to start with a name of the system, say SYS1 (with an assertion (#$isa SYS1 #$PathSystem)), and enter the names of links in SYS, say Link1, Link2 etc. (with assertions (#$isa Link1 #$Path-Simple) etc.), and then only enter assertions of the form (#$linkBetweenInSystem LINK X Y SYS1) for each link in SYS1 and its end points X and Y--the rules related to a path systems will generate assertions like (#$nodeInSystem X SYS1), (#$pointInSystem X SYS1), (#$linkInSystem LINK SYS1) and (#$pathInSystem LINK SYS1) etc.  If one later needs to add something else to the system, say a point A on a link LINK other than its end nodes X and Y, he/she may further enter (#$betweenOnPath A X Y LINK) and (#$pointInSystem A SYS1) without changing anything else.  Note that (#$linkBetweenInSystem LINK X Y SYS) is actually an abbreviation of (#$and (#$linkInSystem LINK SYS) (#$nodeInSystem X SYS) (#$nodeInSystem Y SYS) (#$pathBetween LINK X Y))."))
)
(defrelation |linkClosedSubSystems|
  :arity 2
  :is-primitive |subPathSystems|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     (DOCUMENTATION "(#$linkClosedSubSystems SYS SUBSYS) means that the path system SUBSYS is a subsystem of the path system SYS (i.e., (#$subPathSystems SYS SUBSYS) holds) and SUBSYS 'preserves' all links in SYS between nodes in SUBSYS, i.e., if (#$linkBetweenInSystem LINK X Y SYS) holds and X and Y are in SUBSYS, LINK is a link in SUBSYS."))
)
(defrelation |LinkFn|
  :arity 2
  :domain |Thing|
  :range |SetOrCollection|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "For each #$PathSystem SYS, (#$LinkFn SYS) denotes the set of all links in SYS (see #$PathSystem).  Note that the function #$LinkFn and the predicate #$linkInSystem are interdefinable.  We normally use #$LinkFn, for convenience, when we consider some relations between different path systems even though for a single path system SYS, we can also replace each (#$linkInSystem X SYS) by (#$elementOf X (#$LinkFn SYS))."))
)
(defrelation |linkInSystem|
  :arity 2
  :domain |Path-Simple|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$linkInSystem LINK SYS) means that LINK is an instance of #$Path-Simple taken as a primitive path (called a link) in the #$PathSystem SYS.  For each link LINK in a path system SYS, there is a unique pair {X, Y} of different nodes in SYS (see #$nodeInSystem) such that X and Y are the two end-points of LINK in SYS.  Other 'points' can also be on LINK, but they cannot be nodes in SYS.  There can be no point on a link that is different from its end points but nevertheless on another link, i.e., no matter how many points there are on a particular link in a path system, none of them can be an 'intersection' (see #$junctionInSystem) except the end points of the link, which are nodes in the system.  See #$linkBetweenInSystem.  Each link in SYS is also a path in SYS, i.e., (#$linkInSystem LINK SYS) implies (#$pathInSystem LINK SYS).  Note that there is no general collection of all links.  Any path can be a link if you can somehow ignore the intersection points on it--it all depends on the #$PathSystem."))
)
(defrelation |LiquidFn|
  :arity 2
  :domain |TangibleStuffCompositionType|
  :range (:AND |TangibleStuffStateType| (:FILLED-BY SUPERRELATIONS |LiquidTangibleThing|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "A #$CollectionDenotingFunction.  #$LiquidFn takes as an argument a collection COL, membership in which is based only on physical and/or chemical composition and not on any other property (see #$TangibleStuffCompositionType).  (#$LiquidFn COL) is the collection of elements of COL that are in the #$LiquidStateOfMatter.  E.g., the mud in my driveway belongs to the collection (#$LiquidFn #$EarthStuff)."))
)
(defrelation |lispDefun|
  :arity 2
  :domain |EvaluatableFunction|
  :range |CycSystemSymbol|
  :annotations ( |RelationshipPredicate|
     |FunctionalSlot|
     |BinaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$lispDefun is used to relate an evaluatable Cyc function to the name of the piece of code that is used to evaluate it.  (#$lispDefun E-FUN NAME) means that the #$CycSystemSymbol NAME is the name of a piece of Heuristic Level (SubL) code in the Cyc system which is used to compute the value of expressions containing the #$EvaluatableFunction E-FUN."))
)
(defrelation |Liter|
  :annotations ( |UnitOfMeasureNoPrefix|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     |UnitOfVolume|
     (DOCUMENTATION "The measurement function used in Cyc to represent the standard unit of capacity in the Metric system (and also in Cyc). See also #$UnitOfVolume, #$MKSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |litigants|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |Trial|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(litigants ARG1 ARG2) means that the agent ARG2 is one of the contending parties in the lawsuit ARG1."))
)
(defrelation |LogFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$LogFn is the unary mathematical function that returns the natural logarithm of the number taken as its argument.  Its inverse (i.e., #$inverseFunc) is #$ExpFn."))
)
(defrelation |LoopFn|
  :arity 2
  :domain |Thing|
  :range |SetOrCollection|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "For each #$PathSystem SYS, (#$LoopFn SYS) denotes the set of all loops in SYS (see #$PathSystem).  Note that the function #$LoopFn and the predicate #$loopInSystem are interdefinable.  We normally use #$LoopFn, for convenience, when we consider some relations between different path systems even though for a single path system SYS, we can also replace each (#$loopInSystem X SYS) by (#$elementOf X (#$LoopFn SYS))."))
)
(defrelation |loopInSystem|
  :arity 2
  :is-primitive |cycleInSystem|
  :domain |Path-Generic|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$loopInSystem LOOP SYS) means that LOOP is a 'loop' in SYS, which is like a link in SYS except that it has exactly one node on it as if it is a link whose two end nodes are the same.  Each loop in SYS is also a cycle in SYS, see #$cycleInSystem.  The differences between a loop and a (non-loop) cycle in SYS include that (i) there is exactly one point in SYS on a loop (which must be a node in SYS), but there may in general be any finite number of nodes (and even as many points as there are real numbers) on some (non-loop) cycle in SYS, and that (ii) The unique node in SYS on a loop may or may not be an end point of a link in SYS, but each node on a (non-loop) cycle in SYS must be an end point of at least two links in SYS.  These imply that there can be at most one 'intersection point' on a loop in SYS but there can be any finite number of 'intersection points' on a (non-loop) cycle in SYS.  See #$pointOnCycle and #$junctionInSystem. Note that under current treatment of loops in a path system, if one would like to talk about a 'loop' in a path system a 'part' of which is a path in the system, then he/she should make it a cycle rather than a loop in the system because according to what we said above, no 'part' of a loop in the system can be presented as a path in the system."))
)
(defrelation |loves|
  :arity 2
  :is-primitive (:and |positiveVestedInterest| |likesAsFriend|)
  :domain |Animal|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$loves AGENT1 AGENT2) means AGENT1 loves AGENT2; AGENT2 has a strong emotional affect on AGENT1 whereby AGENT1 is usually loyal and devoted to and wishes well AGENT2, seeks AGENT2's companionship, and will incur substantial personal cost to help AGENT2.  Any #$Agent can love any other #$Agent, though there are specialized types of love which are restricted to two animals, two adult people, two corporations, a person and a corporation, etc."))
)
(defrelation |LowAmountFn|
  :arity 2
  :domain (:AND |PrimitiveAttributeType| (:FILLED-BY SUPERRELATIONS |ScalarInterval|))
  :range |ScalarInterval|
  :annotations ( |GenericValueFunction|
     (DOCUMENTATION "#$LowAmountFn is a Cyc function, in particular, an #$IndividualDenotingFunction.  It is one of several functions used to denote so-called `generic' amounts of a wide variety of attributes.  When ATT is a type of attribute, (#$LowAmountFn ATT) returns an instance of ATT which is considered `a low amount of' ATT in the current context.  A low amount of ATT is more than (#$VeryLowAmountFn ATT) but less than (#$MediumAmountFn ATT)."))
)
(defrelation |Mach-UnitOfSpeed|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfSpeed|
     (DOCUMENTATION "The speed of sound on earth at sea level.  344.4 m/s"))
)
(defrelation |madeBy|
  :arity 2
  :domain |Product|
  :range |CommercialOrganization|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$madeBy was used to indicate that a particular product was made by a particular company.  (#$madeBy PROD COMORG) means that PROD, an individual instance of #$Product, was manufactured by the #$CommercialOrganization COMORG.  Cf. #$makesProductType."))
)
(defrelation |mainConstituent|
  :arity 2
  :is-primitive (:and |cotemporal| |constituents|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |FunctionalSlot|
     |CompositionPredicate|
     (DOCUMENTATION "The predicate #$mainConstituent is used to indicate the most significant portion of an element of #$ExistingStuffType that makes up a particular #$PartiallyTangible thing.  (#$mainConstituent X Y) means that X's #$constituents include Y, and (as a default) the physical properties of the thing X are those of its main constituent, Y.  For example, for a particular instance of #$Lemonade, there is an instance of #$Water which is the #$mainConstituent, and most of the physical properties of the #$Lemonade derive from #$Water.  On the other hand, a person is NOT considered to have some portion of #$Water as #$mainConstituent, even though much of a person's mass is #$Water, because the physical properties of a person are not the same as those of water."))
)
(defrelation |mainProduct|
  :arity 2
  :is-primitive |physicalParts|
  :domain |FormalProduct|
  :range |Product|
  :annotations ( |PartPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$mainProduct is used to identify the main item in a particular set of stuff that a customer gets when buying a packaged product.  (#$mainProduct FORM PROD) means that the particular #$Product PROD is the main item of the #$FormalProduct FORM--as distinct from the accessories, agreements, packaging, literature, etc., that come along with it."))
)
(defrelation |mainTransportees|
  :arity 2
  :is-primitive |transportees|
  :domain |TransportationEvent|
  :range |PartiallyTangible|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(mainTransportees TRAN MT) means that MT is one of the main transportees, or of the primary things intended to be transported (as opposed to incidentals), in the instance TRAN of TransportationEvent."))
)
(defrelation |majorUndertakingsOf|
  :arity 2
  :is-primitive (:and |performedBy| |temporallyIntersects|)
  :domain |Action|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$majorUndertakingsOf ACTION AGENT) means that AGENT consciously performed ACTION.  The success and consequence(s) of ACTION are important to AGENT.  As a result, for a sentient AGENT, failure usually results in AGENT feeling negative emotions, and success positive emotions."))
)
(defrelation |makesProductType|
  :arity 2
  :domain |CommercialOrganization|
  :range (:AND |ProductType| (:FILLED-BY SUPERRELATIONS |Product|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$makesProductType is used to indicate that a particular company makes a specific (i.e., type of) product.  (#$makesProductType ORG PRODTYP) means that the #$CommercialOrganization ORG manufactures the #$ProductType PRODTYP.  Cf. #$madeBy."))
)
(defrelation |MakingFn|
  :arity 2
  :domain (:AND |TemporalStuffType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :range (:AND |ScriptType| |TemporalObjectType| (:FILLED-BY SUPERRELATIONS |MakingSomething|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$MakingFn is a Cyc function, in particular a #$CollectionDenotingFunction.  (#$MakingFn TYPE) denotes the set of events in which elements of some TYPE of thing are made (whether manufactured, constructed, produced, etc.)  E.g., (#$MakingFn #$Automobile) is the set of events in which cars are manufactured.  Having this function saves us from having to create tens of thousands of new terms for peanut-butter-making, business-card-making, etc."))
)
(defrelation |maleficiary|
  :arity 2
  :is-primitive |preActors|
  :domain |Event|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$maleficiary ACT AGT) means that the #$Agent AGT is harmed by the occurrence of the action ACT.  That is, the interest or welfare of AGT is thwarted, blocked, or harmed in ACT."))
)
(defrelation |MaleFn|
  :arity 2
  :domain (:AND |OrganismClassificationType| (:FILLED-BY SUPERRELATIONS |Animal|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |MaleAnimal|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$MaleFn is a Cyc function, in particular, an instance of #$CollectionDenotingFunction.  (#$MaleFn ORGTYPE) returns that subset of the animal taxonomic collection ORGTYPE which includes all and only the males of ORGTYPE.  For example, (#$MaleFn #$Person) and #$MalePerson denote the same collection, while (#$MaleFn #$Deer) denotes the collection of all bucks."))
)
(defrelation |maleParentActor|
  :arity 2
  :is-primitive |parentActors|
  :domain |BiologicalReproductionEvent|
  :range |Organism-Whole|
  :annotations ( |FunctionalSlot|
     |ActorSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$maleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the male parent in the #$SexualReproductionEvent ?EVENT."))
)
(defrelation |malleabilityOfObject|
  :arity 2
  :domain |SolidTangibleThing|
  :range |Malleability|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$malleabilityOfObject OBJ DEGREE) indicates that the instance of #$SolidTangibleThing OBJ has the degree of #$Malleability DEGREE."))
)
(defrelation |maritalStatus|
  :arity 2
  :domain |Person|
  :range |MaritalStatusOfPeople|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$maritalStatus PRSN MSTAT) means #$Person PRSN has the #$MaritalStatusOfPeople MSTAT.  The latter may be: #$Married, #$Widowed, #$Single, etc.  E.g., (#$maritalStatus #$KeithRichards #$Married).  The marital status of a person depends on whether, and when, that person was married to another person, and how the marriage ended."))
)
(defrelation |massNumber|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$massNumber WORD STRING) means that STRING is the mass noun form of WORD.  For example, `paper' is the mass noun form of #$Paper-TheWord."))
)
(defrelation |massOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Mass|
  :annotations ( |PhysicalAmountSlot|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "(#$massOfObject OBJ MASS) means that the tangible object OBJ has #$Mass MASS."))
)
(defrelation |mate|
  :arity 2
  :is-primitive (:and |friends| |positiveVestedInterest|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |SymmetricBinaryPredicate|
     |InterPersonalRelationSlot|
     |AntiTransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(mate PERSON1 PERSON2) means that PERSON1 and PERSON2 are mates and long-term monogamous companions.  In the #$AngloAmericanSocialLifeMt each person has at most only one mate at a time.  Hence, this predicate has #$SingleEntry arguments."))
)
(defrelation |maximalConnectedSubSystems|
  :arity 2
  :is-primitive (:and |pointClosedSubSystems| |linkClosedSubSystems|)
  :domain |Thing|
  :range |ConnectedPathSystem|
  :annotations ( |TransitiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     (DOCUMENTATION "(#$maximalConnectedSubSystems SYS SUB) means that SUB is a 'maximal' connected subsystem of SYS, i.e., that SUB is an entire connected piece of SYS without other disconnected pieces of SYS.  That is to say, (i) SUB is a connected path system, and consequently must have at least one node, say NODE, in it, and (ii) SUB is a subsystem of SYS, and (iii) for every connected subsystem SUB1 of SYS containing NODE, SUB1 is a subsystem of SUB.  Thus a maximal connected subsystem SUB of a path system SYS must satisfy the conditions that (a) for each point X in SUB and each point Y in SYS that is not in SUB, X and Y are not connected in SYS, and that (b) for any nodes X and Y in SUB, for any link LINK in SYS between X and Y, LINK must also be in SUB, and that (c) for each point X in SYS, if X is on a link in SYS which is also a link in SUB, then X must also be in SUB.  It follows that if SUB is a maximal connected subsystem of SYS, SUB must be a link-closed subsystem as well as a point-closed subsystem of SYS.  Another consequence is that if SUB is a maximal connected subsystem of SYS, and if X is a point in SUB and is on a loop in SYS, then the loop must also be in SUB."))
)
(defrelation |maxQuantValue|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarPointValue|
  :annotations ( |ReflexiveBinaryPredicate|
     |RelationshipPredicate|
     (DOCUMENTATION "(#$maxQuantValue SCALAR POINT) means that the upper limit of the quantity SCALAR is POINT, an element of #$ScalarPointValue.  SCALAR is an element of #$ScalarInterval.  For example, the #$maxQuantValue for the pay of mail room employees might be (#$DollarsPerHour 6.5); e.g., (#$maxQuantValue `MailPay' (#$DollarsPerHour 6.5)).  Another example: (#$maxQuantValue (#$Unity 5 10) 10)."))
)
(defrelation |MeaningInSystemFn|
  :arity 3
  :domains (|IndexedInfoSource| |CharacterString|)
  :range |Thing|
  :annotations ( |ReifiableFunction|
     (DOCUMENTATION "The function (MeaningInSystemFn INFOSOURCE STRING), applied to a character string or code STRING in some external information system INFOSOURCE, returns whatever concept is meant by that string or code in that system.  For example, the value of (#$MeaningInSystemFn #$WordNet-Information ''N221566'') is the concept (or WordNet `synset') represented by the synonyms (rampart|bulwark|wall), meaning 'an embankment built around a space for defensive purposes' in the WordNet system.  The STRING can have any format chosen by the person who builds the representation of the external system; usually it will include some index string that is used as an identifier in the external system.  In addition, the STRING may arbitrarily contain any further characters or information, depending on how the external information is selected and processed.  This function allows you to relate a concept in an external system to an arbitrarily complicated expression composed of Cyc concepts.  If the external concept has a direct, exact mapping to a single Cyc constant, then it is better to use the predicate #$synonymousExternalConcept rather than this function.  If the there is a direct correspondence to one Cyc constant, but it is only an approximate correspondence of meaning, you can use #$overlappingExternalConcept."))
)
(defrelation |measure|
  :arity 2
  :domain |TemporalThing|
  :range |Time-Quantity|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$measure ?X ?Y) indicates that ?Y is total elapsed time from the start of ?X to its end.  For continuous #$TemporalThings, the #$measure of the object is the same as its #$duration (qv).  But if the #$TemporalThing is discontinuous, then the #$measure will be greater than the #$duration.  For example, `GeorgeWashingtonSleeping' has a #$measure that is about three times as long as its #$duration, assuming he slept about 8 hours a night.  Note:  Unfortunately, in some disciplines, such as Real Analysis, these two terms' definitions are switched!  In such contexts, one could assert to Cyc that the preferred denotation of #$duration was #$Measure-TheWord, and that the preferred denotation of #$measure was #$Duration-TheWord, but notice that the two concepts --- #$measure and #$duration --- are still distinct and useful in that discipline, they just happen to have different names there."))
)
(defrelation |MedialRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (MedialRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the sub-region consisting of the center parts or middle section (near the mid-line) of REGOROBJ, or the medial main portion of REGOROBJ as opposed to the right and left portions.  It applies when REGOROBJ itself has an intrinsic right/left orientation (unlike, say, a sphere), but if REGOROBJ is a part within a larger region or object that has its own right/left orientation, the function returns REGOROBJ's portion nearest the mid-line (with respect to left and right) of the larger region or object."))
)
(defrelation |mediators|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |SocialOccurrence|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The facilitators of a process including the agents, brokers, or mediators that assist in arranging a contract, transaction, or agreement among several parties."))
)
(defrelation |MediumAmountFn|
  :arity 2
  :domain (:AND |PrimitiveAttributeType| (:FILLED-BY SUPERRELATIONS |ScalarInterval|))
  :range |ScalarInterval|
  :annotations ( |GenericValueFunction|
     (DOCUMENTATION "#$MediumAmountFn is a Cyc function, in particular, an element of #$IndividualDenotingFunction.  It is one of several functions used to denote so-called `generic' amounts of a variety of attributes.  When ATT is a type of attribute, (#$MediumAmountFn ATT) returns an instance of ATT which is considered `a medium amount of' ATT in the current context.  A medium amount of ATT is more than (#$VeryLowAmountFn ATT) but less than (#$HighAmountFn ATT)."))
)
(defrelation |Megabyte|
  :annotations ( |UnitOfMeasureWithPrefix|
     (DOCUMENTATION "The measurement function used in Cyc to represent a common unit of computer memory and disk capacity.  The value of (#$Megabyte 1) equals approximately one million (8-bit) bytes.  See also #$UnitOfMeasure."))
)
(defrelation |MegaHertz|
  :annotations ( |UnitOfMeasureWithPrefix|
     |UnitOfFrequency|
     (DOCUMENTATION "The measurement function used in Cyc to represent the common unit of frequency.     See also #$UnitOfFrequency, #$UnitOfMeasure."))
)
(defrelation |memberOfSpecies|
  :arity 2
  :is-primitive |isa|
  :domain |Organism-Whole|
  :range (:AND |BiologicalSpecies| (:FILLED-BY SUPERRELATIONS |Organism-Whole|))
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$memberOfSpecies ORG SPECIES) means that the organism ORG is a member of the #$BiologicalSpecies SPECIES."))
)
(defrelation |memberOfThisPoliticalParty|
  :arity 2
  :is-primitive |hasMembers|
  :domain |PoliticalParty|
  :range |HumanAdult|
  :annotations ( |TaxonomicSlot|
     (DOCUMENTATION "(#$memberOfThisPoliticalParty PARTY PERS) means that #$Person PERS is a (registered) member of #$PoliticalParty PARTY.  For example, (#$memberOfThisPoliticalParty #$DemocraticParty #$BillClinton)."))
)
(defrelation |Meter|
  :annotations ( |UnitOfMeasureNoPrefix|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     |UnitOfDistance|
     (DOCUMENTATION "The measurement function used in Cyc to represent the basic unit of measure in the metric system.  The meter is also the basic unit of measure for length in CYC.  See also #$MKSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |MetersPerSecond|
  :annotations ( |UnitOfMeasureNoPrefix|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     |UnitOfSpeed|
     (DOCUMENTATION "(#$MetersPerSecond NUMBER) returns a dimensionless rate or speed of NUMBER meters per second.  Notice that this result is not presently thought of as incorporating a vector, although it might be modified to do so at some point in the future if this should prove appropriate."))
)
(defrelation |MetersPerSecondPerSecond|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfAcceleration|
     |MKSUnitOfMeasure|
     |StandardUnitOfMeasure|
     (DOCUMENTATION "The basic measure of acceleration"))
)
(defrelation |middleName|
  :arity 2
  :is-primitive |nameOfAgent|
  :domain |Person|
  :range |HumanGivenNameString|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$middleName X STRNG) means that #$Person X is known by the #$HumanGivenNameString STRNG as his or her middle name.  E.g., (#$middleName #$Lenat ``Bruce'').  A person rarely has more than one middle name.  In some cultures, when a wedding occurs, one party changes their middle name to whatever their #$lastName used to be, thus leading to cases where the person's new middle name is actually a #$HumanFamilyNameString rather than a #$HumanGivenNameString --- the same is true in some cultures when an infant is born and given, as a middle name, the last name of a grandparent (other than the infant's last name)."))
)
(defrelation |MilesPerHour|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfSpeed|
     (DOCUMENTATION "A unit of speed"))
)
(defrelation |minQuantValue|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarPointValue|
  :annotations ( |ReflexiveBinaryPredicate|
     |RelationshipPredicate|
     (DOCUMENTATION "(#$minQuantValue SCALAR POINT) means that the lower limit of SCALAR is POINT, an element of #$ScalarPointValue.  SCALAR is an element of #$ScalarInterval.  For example, the #$minQuantValue for the pay of mail room employees might be (#$DollarsPerHour 4.5); e.g., (#$minQuantValue `MailPay' (#$DollarsPerHour 4.5)).  Another example: (#$minQuantValue (#$Unity 5 10) 5)."))
)
(defrelation |MinusFn|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$MinusFn is the unary mathematical function that changes the sign of the number taken as its argument; e.g., (#$MinusFn 2) returns -2, and (#$MinusFn -2) returns 2."))
)
(defrelation |Minute-UnitOfAngularMeasure|
  :annotations ( |UnitOfAngularDistance|
     |UnitOfMeasureNoPrefix|
     (DOCUMENTATION "A unit to measure the size of angles, in the Imperial system of measurement.  60 minutes = 1 degree (#$Degree-UnitOfAngularMeasure)"))
)
(defrelation |MinuteFn|
  :arity 3
  :domains (|NonNegativeInteger| |CalendarHour|)
  :range |CalendarMinute|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$MinuteFn ?M ?H) denotes a #$CalendarMinute -- in particular, minute number ?M of hour ?H.  For example, (#$MinuteFn 12 (#$HourFn 18 (#$DayFn 14 (#$MonthFn #$February (#$YearFn 1966))))) denotes 6:12pm Feb. 14th, 1966"))
)
(defrelation |MinutesDuration|
  :annotations ( |UnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfTime|
     (DOCUMENTATION "#$MinutesDuration is a function that takes one or two numbers and returns, as its value, some amount of #$Time.  An expression of the form (#$MinutesDuration ?min ?max) denotes a quantity of #$Time that is at least ?min minutes and at most ?max minutes.  An expression of the form (#$MinutesDuration ?num) denotes a quantity of #$Time that is exactly ?num minutes."))
)
(defrelation |MobFn|
  :arity 2
  :domain |ObjectType|
  :range (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Mob|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$MobFn is a Cyc #$CollectionDenotingFunction.  #$MobFn is used for referring to specializations of #$Mob; esp. note that applications of #$MobFn produce COLLECTIONS (of mobs), not individual mobs.  #$MobFn takes any element of #$ObjectType as its argument and returns a subset of #$Mob, namely the collection containing those mobs whose #$groupMembers are elements of that #$ObjectType.  (#$MobFn OBJ-TYPE) denotes the collection of all mobs whose members belong to (#$isa) OBJ-TYPE.  For example, a clump of hair on my head is an element of (#$MobFn #$Hair-Strand).  The collection #$Galaxy is a subset of (#$MobFn #$Star).  And the collection #$Applauding (i.e., all applause events) could be referred to as (#$MobFn `HandClappingEvent')."))
)
(defrelation |MoleculeFn|
  :arity 2
  :domain (:AND |ChemicalCompoundType| (:FILLED-BY SUPERRELATIONS |MolecularStuff|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Molecule|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$MoleculeFn is a Cyc function, specifically a #$CollectionDenotingFunction.  It takes an instance of #$ChemicalCompoundType as its sole argument and returns the set of all molecules of that compound.  (#$MoleculeFn X) denotes the collection of all #$Molecules of #$MolecularStuff X.  For example, (#$MoleculeFn #$Water) is the collection of all water molecules."))
)
(defrelation |monetaryValue|
  :arity 2
  :domain |SomethingExisting|
  :range |Money|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The value of an element of #$SomethingExisting. For the time being, expressed in a monetary curency."))
)
(defrelation |moneyTransferMode|
  :arity 2
  :domain |MoneyTransfer|
  :range (:AND |MoneyTenderType| (:FILLED-BY SUPERRELATIONS |TenderObject|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$moneyTransferMode TRANSACTION
TYPE) means that in some particular money transfer TRANSACTION,
the #$MoneyTenderType used in that transaction was TYPE, e.g.,
#$CreditCard, #$Check-TenderObject, etc."))
)
(defrelation |moneyTransferred|
  :arity 2
  :domain (:AND |MoneyTransfer| |Buying|)
  :range |Money|
  :annotations ( |CostBreakdownSlot|
     |IntervalBasedQuantitySlot|
     |Role|
     (DOCUMENTATION "This predicate indicates the amount of money involved in a particular transfer of funds.  (#$moneyTransferred TRANS MONEY) means that MONEY is the quantity of #$Money transferred in the money transfer event TRANS.  
Note: MONEY is distinct from the physical #$TenderObjects (q.v.) used to accomplish that transfer (cf. #$objectTendered).  For example, the #$moneyTransferred to pay a car payment might be the amount US$400, while the #$objectTendered in the paying is an instance of #$Check-TenderObject."))
)
(defrelation |MonthFn|
  :arity 3
  :domains ((:AND |MonthOfYearType| |TemporallyDisjointIntervalType| |AnnualEventType|
             |ConventionalClassificationType| (:FILLED-BY SUPERRELATIONS |CalendarMonth|))
            |CalendarYear|)
  :range |CalendarMonth|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$MonthFn ?M ?YR) denotes a #$CalendarMonth -- in particular, the month of type ?M during ?YR.  For example, (#$MonthFn #$February (#$YearFn 1966)) denotes Feb. of 1966.  Note that #$MonthFn -- unlike #$DayFn, #$HourFn, etc. -- does NOT take a number as its first argument."))
)
(defrelation |MonthsDuration|
  :annotations ( |UnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfTime|
     (DOCUMENTATION "This is a function that takes one or two numbers and returns, as its value, some amount of #$Time.  An expression of the form (#$MonthsDuration ?min ?max) denotes a quantity of #$Time that is at least ?min months and at most ?max months.  (#$MonthsDuration ?num) denotes a quantity of #$Time that is exactly ?num months."))
)
(defrelation |mother|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Animal|
  :range |FemaleAnimal|
  :annotations ( |FamilyRelationSlot|
     |AntiTransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$mother OFFSPRING FEMALE) means that the #$FemaleAnimal FEMALE is the female biological parent of the #$Animal OFFSPRING



."))
)
(defrelation |mtInferenceFunction|
  :arity 2
  :domain |Microtheory|
  :range |CycSystemSymbol|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The function which is used to perform inference within this microtheory."))
)
(defrelation |multiplicationUnits|
  :arity 3
  :domains (|UnitOfMeasure| |UnitOfMeasure|)
  :range |UnitOfMeasure|
  :annotations ( |BookkeepingPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$multiplicationUnits is used to state what measurement units should be used for the product of two physical quantities, given the units measuring each of the quantities multiplied.  (#$multiplicationUnits UM-1 UM-2 PROD-UM) means that the value of (#$TimesFn (UM-1 x) (UM-2 y)) should be given in the units PROD-UM.  For example, (#$multiplicationUnits #$Mile #$Mile #$SquareMile).  See also #$UnitOfMeasure, #$TimesFn."))
)
(defrelation |myCreationTime|
  :arity 2
  :domain |ReifiableTerm|
  :range |PositiveInteger|
  :annotations ( |BookkeepingPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$myCreationTime X TIME) means that the constant X was created at time TIME.  TIME is not, however, an instance of #$Date.  This assertion is not intended for inference, only for documentation, so the format is a simple one, designed for human readability and for use by internal Cyc functions.  The format of TIME is YYYYMMDD, so for example, 19870911 is September 11, 1987."))
)
(defrelation |myCreator|
  :arity 2
  :domain |ReifiableTerm|
  :range |Cyclist|
  :annotations ( |BookkeepingPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$myCreator X Y) means that Y is the constant representing the person who introduced the constant X into the Cyc vocabulary. In general, the editing interfaces to the Cyc KB only allow the KB to be modified when an instance of #$Cyclist is designated as the author of the changes."))
)
(defrelation |myEntity|
  :arity 2
  :domain |SomethingExisting|
  :range |Entity|
  :annotations ( |InterExistingObjectSlot|
     |FunctionalSlot|
     (DOCUMENTATION "(#$myEntity ?X ?Y) indicates that ?Y is an #$Entity (qv) and that ?X is some subabstraction of ?Y.  That is, (#$subAbstrac ?Y ?X).  Note that each #$SomethingExisting ?X will generally have one unique #$Entity ?Y of which it is a #$subAbstrac.  E.g., (#$myEntity AlbertEinsteinWhileAtPrinceton AlbertEinstein)."))
)
(defrelation |nameOfAgent|
  :arity 2
  :is-primitive |nameString|
  :domain |Agent|
  :range |ProperNameString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$nameOfAgent AGT STRING) means STRING is the name(s) of AGT.  AGT can be a #$Person, #$Animal, #$Organization, etc.  In most contexts, this means that AGT may normally be called STRING, in that context, and should therefore include their #$salutation if the context is a formal one, should omit their #$lastName if it is unambiguous and the context is an intimate one, etc.."))
)
(defrelation |nameString|
  :arity 2
  :domain |ReifiableTerm|
  :range |ProperNameString|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$nameString THING STRING) means that
the name of the thing THING is the string STRING. Use it to connect
constants or NATS with their names. For agents, use the more 
specific predicate #$nameOfAgent."))
)
(defrelation |nativeLanguage|
  :arity 2
  :is-primitive |languageSpoken|
  :domain |Person|
  :range |Language|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The first language spoken by a person.  EntryFormat is #$SetTheFormat, to cover cases of bi-lingual childhoods."))
)
(defrelation |near|
  :arity 2
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |IrreflexiveBinaryPredicate|
     |SpatialPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$near THIS THAT) means that the distance between THIS and THAT doesn't exceed the maximum dimension of the smaller object.  Thus, two pebbles one mile apart would not be #$near each other, but a pebble one centimeter above the earth would be #$near the earth."))
)
(defrelation |negationAttribute|
  :arity 2
  :domain |AttributeValue|
  :range |AttributeValue|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$negationAttribute ATT1 ATT2) means that a thing cannot have both ATT1 and ATT2 as attributes at the same or overlapping times."))
)
)    ; END EVAL-WHEN 6

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 7
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |negationInverse|
  :arity 2
  :domain |BinaryPredicate|
  :range |BinaryPredicate|
  :annotations ( |RuleMacroPredicate|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$negationInverse is used to describe a relationship between some elements of #$BinaryPredicate.  (#$negationInverse PRED INV) means that if PRED holds between a pair of items <X,Y>, then INV does NOT hold between the inverted pair <Y,X>.  In other words, #$negationInverse is syntactic shorthand for (#$implies (PRED X Y) (#$not (INV Y X))).  Note that PRED and INV may take the same value; e.g., (#$negationInverse #$father #$father) is true and means that if X's #$father is Y, then X is NOT Y's #$father.  Thus, #$negationInverse is true for all elements of #$AsymmetricBinaryPredicate."))
)
(defrelation |negationPreds|
  :arity 2
  :domain |Predicate|
  :range |Predicate|
  :annotations ( |RuleMacroPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "The predicate #$negationPreds is used to represent a relation between some elements of #$Predicate.  (#$negationPreds PRED1 PRED2) means that PRED1 is a negation of PRED2 in the sense that any tuple in the extension of PRED1 is NOT also a tuple in the extension of PRED1.  In other words, (#$negationPreds PRED1 PRED2) is shorthand for (#$implies (PRED1 {arg-list}) (#$not (PRED2 {arg-list}))).  For example, (#$negationPreds #$transportees #$transporter)."))
)
(defrelation |negativeVestedInterest|
  :arity 2
  :domain |Agent|
  :range |TemporalThing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$negativeVestedInterest  AGT OBJ) means #$Agent AGT has a negative interest in the object OBJ or in the good fortune of OBJ, and a positive interest in its misfortune.  Generally, AGT will be helped or pleased by the destruction, diminution, weakening, or retarding of OBJ, and will be hurt or displeased if OBJ is preserved or enhanced.  See #$positiveVestedInterest."))
)
(defrelation |NoAmountFn|
  :arity 2
  :domain (:AND |PrimitiveAttributeType| (:FILLED-BY SUPERRELATIONS |ScalarInterval|))
  :range |ScalarInterval|
  :annotations ( |GenericValueFunction|
     (DOCUMENTATION "NoAmountFn is a Cyc function, in particular, an element of #$IndividualDenotingFunction.  It is one of several functions used to denote so-called `generic' values for a wide variety of attributes.  When ATT is a type of attribute, (#$NoAmountFn ATT) returns a zero amount of ATT.  For example, (#$NoAmountFn #$Elasticity) represents zero elasticity and is the property of things that don't re-expand at all following compression; e.g.,instances of #$Ceramic, #$Silicon, or #$Sugar-Generic."))
)
(defrelation |NodeFn|
  :arity 2
  :domain |Thing|
  :range |SetOrCollection|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "For each #$PathSystem SYS, (#$NodeFn SYS) denotes the set of all nodes in SYS (see #$PathSystem).  Note that the function #$NodeFn and the predicate #$nodeInSystem are interdefinable.  We normally use #$NodeFn, for convenience, when we consider some relations between different path systems even though for a single path system SYS, we can replace each (#$nodeInSystem X SYS) by (#$elementOf X (#$NodeFn SYS))."))
)
(defrelation |nonDeliberateActors|
  :arity 2
  :is-primitive |actors|
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$nonDeliberateActors ACT ACTR) means that ACTR has a #$Role in the #$Event ACT but is not acting deliberately.  Examples: (1) President #$JohnKennedy was a #$nonDeliberateActors in his assassination; (2) a person is a #$nonDeliberateActors in his/her own autonomic bodily functioning (e.g., heart beating, digesting); (3) Mount #$Vesuvius-Volcano was a #$nonDeliberateActors in the event of its eruption that destroyed Pompeii.  #$nonDeliberateActors is a negative specification of the role an actor has in an event; the role of particular #$nonDeliberateActors might be further specified positively, e.g., with #$bodilyActedOn or #$bodilyDoer."))
)
(defrelation |nonVolitionalResult-RST|
  :arity 2
  :domain |LinguisticObject|
  :range |LinguisticObject|
  :annotations ( |AsymmetricBinaryPredicate|
     |RSTRelation|
     (DOCUMENTATION "The discourse relation that holds between two segments of text when ARG1 specifies something which could be a nonvolitional cause of ARG2."))
)
(defrelation |northeastOf|
  :arity 2
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$northeastOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the north-east of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference.  Note that REGION-2 is therefore southwest of REGION-1; thus, no distinct predicate is needed to represent `southwest of'.  Example: (#$northeastOf #$Philippines #$Taiwan-RepublicOfChina)."))
)
(defrelation |northOf|
  :arity 2
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$northOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the north of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference.  Note that REGION-2 is therefore south of REGION-1; thus, no distinct predicate is needed to represent `south of'.  Example: (#$northOf #$CityOfPhiladelphiaPA #$CityOfWashingtonDC)."))
)
(defrelation |northwestOf|
  :arity 2
  :domain |GeographicalRegion|
  :range |GeographicalRegion|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$northwestOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the northwest of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference.  Note that REGION-2 is therefore southeast of REGION-1; thus, no distinct predicate is needed to represent `southeast of'.  Example: (#$northwestOf #$UnitedKingdomOfGreatBritainAndNorthernIreland #$France)."))
)
(defrelation |notices|
  :arity 2
  :is-primitive |beliefs|
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$notices AGT PROP) means that
AGT believes the proposition PROP because AGT has seen, heard,
smelled, etc. PROP via some element of #$Perceiving.  Although
(#$notices AGT PROP) implies (#$beliefs AGT PROP) {via the assertion
(#$genlPreds #$notices #$beliefs)}, exceptions occur if AGT believes
they have been hallucinating or drugged, for example.  The predicate
#$beliefs, unlike #$notices, can include propositions gathered through
inferring, dreaming, intuiting.  The temporal extent of (#$notices AGT
PROP) is at least a 'short time' following the perceiving of PROP.
The extent of this time is a function of the type of fact perceived
noticed, when forgetting or other overriding information comes into
play."))
)
(defrelation |Nth|
  :arity 3
  :domains (|Series| |PositiveInteger|)
  :range |Thing|
  :annotations ( |ReifiableFunction|
     (DOCUMENTATION "(#$Nth SER N) denotes the Nth member of the series SER, provided that N is an integer greater than or equal to 1 and less than or equal to the #$seriesLength of SER."))
)
(defrelation |NucleusFn|
  :arity 2
  :domain (:AND |ElementStuffTypeByNumberOfProtons| (:FILLED-BY SUPERRELATIONS |ElementStuff|))
  :range (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |AtomicNucleus|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$NucleusFn is a Cyc function, specifically a #$CollectionDenotingFunction.  #$NucleusFn takes an instance of #$ElementStuffTypeByNumberOfProtons (q.v.) as its single argument and returns a collection of all the atomic nucleii belonging to element-stuff of that type.  Thus, (#$NucleusFn E) denotes a subset of #$AtomicNucleus whose elements all have the same number of protons. For example, (#$NucleusFn #$Carbon) is the collection of #$Carbon nuclei, each of which has six protons."))
)
(defrelation |numericallyEqual|
  :arity 2
  :domain |ScalarInterval|
  :range |ScalarInterval|
  :annotations ( |NumericComparison|
     |EvaluatableFunction|
     |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$numericallyEqual is Cyc's representation of the equals ( = ) of arithmetic, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values.  For any two instances of #$ScalarInterval, (#$numericallyEqual SI-1 SI-2) means that the minimum of SI-1 is equal to the mininum of SI-2 and that the maximum of SI-1 is equal to the maximum of SI-2.  See also #$ScalarInterval."))
)
(defrelation |numInhabitants|
  :arity 2
  :domain (:AND |Agent| |GeographicalRegion|)
  :range |Integer|
  :annotations ( |IntangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$numInhabitants is used to indicate the number of people living in a region.  (#$numInhabitants REGION NUMBER) means that the #$GeographicalAgent REGION has this #$Integer NUMBER of inhabitants.  Note that, for any particular country, NUMBER is not necessarily the same as the number of its citizens, since citizens may be living abroad, and aliens may be residing in the country.  Examples: (#$numInhabitants #$CityOfRomeItaly 2800000); (#$numInhabitants #$CityOfTokyoJapan 8300000)."))
)
(defrelation |objectActedOn|
  :arity 2
  :is-primitive |preActors|
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$objectActedOn is used to relate an event to an entity (or entities) significantly affected in that event.  That entity must exist before the event, but may be either destroyed in the event (see #$inputsDestroyed), or merely affected by it (e.g., see #$damages, #$objectOfStateChange). (#$objectActedOn EVENT OBJECT) means that OBJECT is altered or affected in EVENT, and the change that OBJECT undergoes is central or focal to understanding EVENT.  Thus, scissors are NOT an #$objectActedOn in a #$HairCuttingEvent.  The focal change in a haircut is hair getting shorter; thus, hair is a legitimate #$objectActedOn in a #$HairCuttingEvent.  The almost microscopic dulling that scissors undergo in a single haircut is a comparatively insignificant change with respect to a single haircut, considered as a #$HairCuttingEvent.  

Note: long-term effects of usage on devices should be axiomatized in connection with #$UsingAFn constants."))
)
(defrelation |objectControlled|
  :arity 2
  :is-primitive |objectActedOn|
  :domain |ControllingSomething|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "This predicate is used to indicate that a particular object is being controlled in a particular event.  (#$objectControlled EVENT OBJ) means that the object OBJ is being controlled in the #$Event EVENT.
Note: #$objectControlled does not assume or require physical contact between controller and object controlled."))
)
(defrelation |objectEmitted|
  :arity 2
  :is-primitive |objectMoving|
  :domain |EmittingAnObject|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "This predicate is used in connection with particular instances of #$EmittingAnObject, to identify the object which `comes out' during the event.  (#$objectEmitted EMIT OBJ) means that OBJ is emitted from the #$emitter during the emission event EMIT.  The #$objectEmitted is also an #$objectMoving in EMIT.  For example, in a particular human #$BirthEvent, some particular #$HumanInfant is an #$objectEmitted."))
)
(defrelation |objectFoundInLocation|
  :arity 2
  :is-primitive (:and |cotemporal| |inRegion|)
  :domain |PartiallyTangible|
  :range |SpatialThing|
  :annotations ( |CotemporalObjectsSlot|
     |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     (DOCUMENTATION "(#$objectFoundInLocation OBJ LOC) means that OBJ has the location LOC. OBJ is not a part of LOC.  Examples: the #$ArcDeTriomphe is located in the #$CityOfParisFrance; the #$AlaskanPipeline is found in #$Alaska-State; the #$TownOfGettysburgPA is located in the Eastern region of Pennsylvania (note that the town's territory is part of Pennsylvania, but the town as a social organization is distinct).  See also the #$comment on #$inRegion.  Cf., for cases where OBJ is a spatial part of LOC, #$physicalDecompositions, #$geographicalSubRegions."))
)
(defrelation |objectMoving|
  :arity 2
  :is-primitive (:and |temporallyIntersects| |transferredThing|)
  :domain |MovementEvent|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$objectMoving is used to refer to an object which is moving in a particular #$MovementEvent.  (#$objectMoving MOVE OBJECT) means that OBJECT is in motion at some point during the #$MovementEvent MOVE and this movement is focal in MOVE.  In some cases, such as an instance of #$LocomotionEvent, OBJECT causes MOVE directly.  OBJECT's motion in MOVE may be translational, rotational, or some combination of these.  OBJECT may be a solid -- such as an animal, an automobile, or a tennis ball -- or a fluid, such as lava flowing or a warm air mass rising."))
)
(defrelation |objectOfPossessionTransfer|
  :arity 2
  :is-primitive |transferredThing|
  :domain |ChangeInUserRights|
  :range |SomethingExisting|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$objectOfPossessionTransfer identifies the object which `changes hands' in a particular event wherein some user's rights to it are changed.  (#$objectOfPossessionTransfer EVENT OBJECT) means that in EVENT, all or some rights to use OBJECT are transferred from one agent (the #$fromPossessor) to another (the #$toPossessor).  EVENT is an element of #$ChangeInUserRights (q.v.), for example, a buying, renting, lending, repossessing, etc."))
)
(defrelation |objectOfStateChange|
  :arity 2
  :is-primitive (:and |postActors| |objectActedOn|)
  :domain |IntrinsicStateChangeEvent|
  :range |PartiallyTangible|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$objectOfStateChange is used to identify the object of an instance of #$IntrinsicStateChangeEvent.  (#$objectOfStateChange EVENT OBJECT) means that OBJECT is an #$Entity that undergoes some kind of intrinsic change of state in EVENT.  OBJECT exists before EVENT, is directly involved in EVENT, and persists after EVENT.  (Accordingly, this predicate inherits the #$genlPreds #$preActors and #$postActors through #$objectActedOn.)  The change which OBJECT undergoes is internal or intrinsic; this predicate is not used for extrinsic changes, e.g., in location, orientation, ownership, status, etc.  



Note: If OBJECT were destroyed by EVENT and went out of existence in the course of EVENT, then the right predicate to use would be #$inputsDestroyed, rather than #$objectOfStateChange."))
)
(defrelation |objectPaidFor|
  :arity 2
  :is-primitive |objectOfPossessionTransfer|
  :domain |MonetaryExchangeOfUserRights|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$objectPaidFor EVENT OBJECT) means that in the #$MonetaryExchangeOfUserRights EVENT, the right to possess OBJECT is transferred from one #$Agent to another.  OBJ is not the #$objectTendered but the goods that are bought or rented."))
)
(defrelation |objectRemoved|
  :arity 2
  :is-primitive (:and |postActors| |objectActedOn| |objectMoving|)
  :domain |RemovingSomething|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(#$objectRemoved REMOVING OBJ) means OBJ is removed from its previous location in the removing event REMOVING.  The force that does the REMOVING comes from some other object than OBJ."))
)
(defrelation |objectSelected|
  :arity 2
  :is-primitive |actors|
  :domain (:AND |HumanActivity| |PurposefulAction|)
  :range |Individual|
  :annotations ( |FunctionalSlot|
     |ActorSlot|
     (DOCUMENTATION "(#$objectSelected SEL OBJ) means that OBJ is the object that is chosen in the event SEL, an instance of #$SelectingSomething.  If what is selected in SEL is a collection, rather than an individual object, then use the predicate #$activityObjectType to represent the object of SEL."))
)
(defrelation |objectsInContact|
  :arity 3
  :domains (|PhysicalContactSituation| |PartiallyTangible|)
  :range |PartiallyTangible|
  :annotations ( |Role|
     |TernaryPredicate|
     (DOCUMENTATION "The predicate #$objectsInContact indicates that two objects physically touch in a particular #$PhysicalContactSituation.  (#$objectsInContact SIT OBJ-1 OBJ-2) means that OBJ-1 and OBJ-2 are in contact in the #$PhysicalContactSituation SIT.  For example, a #$ClothingItem and its #$wearer are #$objectsInContact during the wearing.  A father and son in a #$CarryingPiggyback event are #$objectsInContact.  (#$objectsInContact SIT OBJ-1 OBJ-2) entails (#$holdsIn SIT (#$touches OBJ-1 OBJ-2)); #$touches covers both direct touching and touching indirectly (i.e., through a thin layer, e.g., through clothing)."))
)
(defrelation |objectTakenCareOf|
  :arity 2
  :is-primitive (:and |postActors| |objectActedOn|)
  :domain (:AND |HumanActivity| |ActionOnObject| |PurposefulAction|)
  :range |SomethingExisting|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(#$objectTakenCareOf EV OBJ) means that OBJ is acted on in EV by some #$Agent in order to maintain, preserve, or promote the health

or good condition of OBJ."))
)
(defrelation |objectTendered|
  :arity 2
  :is-primitive |objectOfPossessionTransfer|
  :domain |MoneyTransfer|
  :range |TenderObject|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "This predicate indicates the financial instrument which is used in a particular transfer of money.  (#$objectTendered TRANS OBJECT) means that the #$TenderObject OBJECT is used to transfer funds in the #$MoneyTransfer event TRANS.  See also #$TenderObject.
Note: OBJECT is distinct from the quantity of #$Money transferred (see #$moneyTransferred) although of course OBJECT has some value --- is `worth' a certain amount, generally calculated from the numbers printed or stamped or engraved on the #$TenderObject OBJECT --- which in turn is an element of #$Money."))
)
(defrelation |objectTested|
  :arity 2
  :is-primitive |objectActedOn|
  :domain (:AND |Thinking| |PurposefulAction|)
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$objectTested EVAL OBJ) mean that OBJ is the specific object or portion being tested in EVAL.  For example, if someone has a blood test, then the object tested is the portion of blood used to run the test fulfulls the role of #$objectTested, rather than the person or the collection of that person's blood."))
)
(defrelation |obscuresFrom|
  :arity 3
  :domains (|PartiallyTangible| |PartiallyTangible|)
  :range |Agent|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(obscuresFrom OBJ1 OBJ2 OBJ3) means that OBJ1 visually blocks OBJ2 from OBJ3's view."))
)
(defrelation |occurrencesPerPeriod|
  :arity 3
  :domains (|TemporalObjectType| |TemporalObjectType|)
  :range |Integer|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$occurrencesPerPeriod ?X ?Y ?N) indicates that ?N instances of ?X occur during each instance of ?Y.  For example, to indicate that there are seven calendar days in each calendar week, we would write the axiom (#$occurrencesPerPeriod #$CalendarDay #$CalendarWeek 7)."))
)
(defrelation |officiator|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |SocialOccurrence|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$officiator points to the agent who performs official functions at an event. For example, it is used to indicate the person who plays the role of a priest or justice of the peace at a wedding; also, a master of ceremonies, a judge, a referee.  An #$officiator is one of the performers at the social event where s/he officiates, usually not the only one."))
)
(defrelation |offspringActors|
  :arity 2
  :is-primitive |outputsCreated|
  :domain |BiologicalReproductionEvent|
  :range |BiologicalLivingObject|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$offspringActors EVENT ORGANISM) means that ORGANISM is an offspring created in the #$BiologicalReproductionEvent EVENT ."))
)
(defrelation |Ohm|
  :annotations ( |StandardUnitOfMeasure|
     |MKSUnitOfMeasure|
     (DOCUMENTATION "The standard unit of electrical resistance.  The resistance of a circuit in which a 1-#$Volt #$ElectricalPotentialDifference produces a 1-#$Coulomb #$ElectricalCurrent."))
)
(defrelation |oilSolubility|
  :arity 2
  :domain |PartiallyTangible|
  :range |Solubility|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$oilSolubility OBJ DEGREE) means that the particular tangible OBJ has this DEGREE of #$Solubility in #$Oil."))
)
(defrelation |oldConstantName|
  :arity 2
  :domain |Thing|
  :range |CycSystemString|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "If this constant has been renamed after Oct 95, and if the system variable cyc::*note-old-constant-name* is set to t on the machine on which the name change occurred, then this slot automatically records the most recent name that this constant had."))
)
(defrelation |on-Physical|
  :arity 2
  :is-primitive (:and |supportedBy| |above-Touching|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$on-Physical OVER UNDER) means that the object OVER is above, supported by, and touching the object UNDER.  OVER and UNDER may be at rest or in motion, or one may be in motion and the other at rest (relative to it).  Examples: a person on a bicycle; groceries on a checkout conveyor belt; a statue on a pedestal.  Note that only #$touches (and not #$touchesDirectly) is implied."))
)
(defrelation |onLine|
  :arity 2
  :is-primitive |spatiallyIntersects|
  :domain |SpatialThing|
  :range |Line|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$onLine OBJ LINE) means that OBJ is an object or region with one or more dimensions much smaller than the length of the #$Line LINE, and OBJ #$spatiallyIntersects or touches LINE but does not include all of LINE.  One object can be on several different #$Lines.  See also #$onPath and #$onPath-Generic."))
)
(defrelation |onPath|
  :arity 2
  :is-primitive (:and |onPath-Generic| |cotemporal| |objectFoundInLocation|)
  :domain |PartiallyTangible|
  :range |Path-Simple|
  :annotations ( |CotemporalObjectsSlot|
     |IrreflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$onPath ARG1 PATH) means that ARG1 is located along (on or adjacent to) the #$Path-Generic PATH.  ARG1 could be a moving object or it could be a stationary point (see the more specific predicate #$pointOnPath)  For example, Saint Louis, Missouri was #$onPath U.S. Route 66, as was Missouri, any car driving along it, and any lamp-post on it."))
)
(defrelation |onPath-Generic|
  :arity 2
  :domain |PartiallyTangible|
  :range |Path-Generic|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(onPath-Generic LOC PATH) means that LOC, a location, is on the path PATH.  Here at least a part of LOC should be a part of PATH (e.g., as a part of the meaning of the sentence that Austin is on I35, a part of Austin is a part of I35).  Note that #$onPath-Generic is used for #$Path-Generic.  If one wants to be clear that the path PATH is an instance of #$Path-Simple, then #$onPath rather than #$onPath-Generic should be used."))
)
(defrelation |opinions|
  :arity 2
  :is-primitive |beliefs|
  :domain |IntelligentAgent|
  :range |CycFormula|
  :annotations ( |PropositionalAttitudeSlot|
     (DOCUMENTATION "(#$opinions AGT PROP) means that the #$Agent AGT believes that PROP (represented by a #$CycFormula) may be true, but they aren't sure about it, their mind might be changed, they are usually aware that PROP is just an opinion, etc.  They may or may not have an argument to justify PROP.  
Note: Opinion implies belief.  So if (#$opinions AGT PROP), then (#$beliefs AGT PROP) is true.
Note:  Opinion and knowledge are mutually exclusive: if (#$knows AGT PROP), then it is NOT true that (#$opinions AGT PROP)."))
)
(defrelation |oppositeAttributeValue|
  :arity 2
  :is-primitive |negationAttribute|
  :domain |AttributeValue|
  :range |AttributeValue|
  :annotations ( |SymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(#$oppositeAttributeValue ATT1 ATT2) means that ATT2 is the opposite of ATT1.  E.g., #$DeviceOn and #$DeviceOff."))
)
(defrelation |oppositeDirection-Interval|
  :arity 2
  :is-primitive |oppositeAttributeValue|
  :domain |UnitVectorInterval|
  :range |UnitVectorInterval|
  :annotations ( |SpatialPredicate|
     |AntiTransitiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$oppositeDirection-Interval COMING GOING) means that the vector which points in the opposite direction to the vector COMING is the vector GOING.  More technically, COMING and GOING are both elements of #$UnitVectorInterval in Cyc's spatial representation, and the midpoint of the direction interval COMING is 180 degrees from the midpoint of the direction interval GOING.  Examples: (#$oppositeDirection-Interval #$North-Generally #$South-Generally), (#$oppositeDirection-Interval #$DorsalDirection #$VentralDirection).  If a precise opposite direction is needed, use #$oppositeDirection-Precise."))
)
(defrelation |oppositeDirection-Precise|
  :arity 2
  :is-primitive |oppositeDirection-Interval|
  :domain |Vector-Precise|
  :range |Vector-Precise|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |SymmetricBinaryPredicate|)
)
(defrelation |or|
  :annotations ( |VariableArityRelation|
     |CommutativeRelation|
     |LogicalConnective|
     (DOCUMENTATION "The predicate #$or is the disjunction relation in Cyc.  #$or is a variable-arity relation and takes any number of elements of #$CycFormula as its arguments.  (#$or P Q ... Z) is true if at least one of the formulas P, Q, ..., or Z is true in Cyc."))
)
(defrelation |orientation|
  :arity 2
  :domain |PartiallyTangible|
  :range |OrientationAttribute|
  :annotations ( |BinaryPredicate|
     |SpatialPredicate|
     (DOCUMENTATION "(#$orientation OBJECT ORTN) means that the tangible OBJECT is oriented in the way described by the #$OrientationAttribute ORTN.  Examples: (#$orientation OBJ #$RightSideUp), (#$orientation OBJ #$VerticalOrientation).  #$orientation is asserted with respect to the current context's #$FrameOfReference."))
)
(defrelation |origin-RoundTrip|
  :arity 2
  :is-primitive (:and |fromLocation| |toLocation| |nonDeliberateActors|)
  :domain |Translation-RoundTrip|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$origin-RoundTrip TRIP PLACE) means that the #$Translation-RoundTrip event TRIP leaves from and returns to the location PLACE.  PLACE is both the #$fromLocation and #$toLocation of the entire TRIP, considered as a whole.  For example, some commuters to Manhattan leave and return each day to #$Connecticut-State, which is their #$origin-RoundTrip.  See also #$destination-RoundTrip."))
)
(defrelation |orthography|
  :arity 2
  :domain |Language|
  :range |CommunicationConvention|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$orthography ?LANG ?WRIT) means that the #$WritingSystem ?WRIT is the usual mode of writing used to encode the #$Language ?LANG; that it is used by most of the people who customarily engage in writing ?LANG."))
)
(defrelation |Ounce|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfMass|
     |FPSUnitOfMeasure|
     (DOCUMENTATION "The measurement function used in Cyc to represent the ounce used for measuring weight within the British (FPS) system.  See also #$FPSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |outputs|
  :arity 2
  :is-primitive (:and |actors| |postActors|)
  :domain |CreationOrDestructionEvent|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$outputs is used to relate a particular event to any of the outputs from that event.  (#$outputs EVENT OBJECT) means that OBJECT is an output from the #$CreationOrDestructionEvent EVENT; i.e., OBJECT is either created as a result of EVENT, or it is something left after another thing was destroyed in EVENT.  For example, silicon chips are #$outputsCreated in a chip manufacturing process, while scrap metal is #$outputsRemaining after cars are put through a crusher.
Note that those two types of cases should be distinguished by using (respectively) the specialized predicates #$outputsCreated or #$outputsRemaining whenever they are appropriate, rather than only the more general predicate #$outputs."))
)
(defrelation |outputsCreated|
  :arity 2
  :is-primitive (:and |startsDuring| |nonDeliberateActors| |outputs|)
  :domain |CreationEvent|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$outputsCreated is used to identify items created by a particular event.  (#$outputsCreated EVENT OBJECT) means that OBJECT doesn't exist before EVENT but comes into existence sometime during EVENT, as a result of EVENT.  #$outputsCreated is a specialization of #$nonDeliberateActors, since it would in general be impossible for OBJECT to act deliberately in its own creation."))
)
(defrelation |outputsRemaining|
  :arity 2
  :is-primitive (:and |preActors| |outputs|)
  :domain |DestructionEvent|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$outputsRemaining is used to identify leftovers which survive from the #$inputs to a particular event.  (#$outputsRemaining EVENT OBJECT) means that OBJECT persists after EVENT, and that it existed before EVENT as an identifiable part of one of the things destroyed during EVENT (see #$inputsDestroyed).  Examples: (1) when a sheet of plywood is sawn through in a cutting event, the original board is destroyed and the #$outputsRemaining are the two smaller plywood pieces; (2) after a #$FiltrationProcess, the #$suspendedPart and the #$suspendingFluid are the #$outputsRemaining from the original mixture which has been destroyed."))
)
(defrelation |overlappingExternalConcept|
  :arity 3
  :domains (|Thing| |IndexedInfoSource|)
  :range |CharacterString|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$overlappingExternalConcept ?TERM ?SOURCE ?STRING) means that the Cyc
concept ?TERM overlaps semantically with the concept named by ?STRING in the
external data source ?SOURCE."))
)
(defrelation |overlapsStart|
  :arity 2
  :is-primitive |endsDuring|
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |AsymmetricBinaryPredicate|
     |ComplexTemporalRelation|
     (DOCUMENTATION "(#$overlapsStart FIRST SECOND) means that FIRST starts before SECOND and ends during SECOND.  That is, the #$startingPoint of FIRST is before the #$startingPoint of SECOND, and the #$endingPoint of FIRST is before the #$endingPoint of SECOND.  So this is actually a STRONGER relation than might be suggested just by its name alone, since the name alone does not suggest that FIRST must end during SECOND.  If all you mean to say, in some situation, is that FIRST starts before SECOND, then do NOT use #$overlapsStart; just use the #$startsAfterStartingOf relation; i.e., say (#$startsAfterStartingOf SECOND FIRST).  Also note that #$overlapsStart is, in a way, a WEAKER relation than might be suggested by its name alone.  Namely, the #$startingPoint of SECOND might not even be a point of FIRST (if FIRST is discontinuous).







Note:  This Cyc temporal relation is equivalent to what James Allen independently dubbed the OVERLAPS relation."))
)
(defrelation |overrides|
  :arity 2
  :domain |Assertion|
  :range |Assertion|
  :annotations ( |MetaKnowledgePredicate|
     |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$overrides is used to tell Cyc which rule to prefer when it encounters two conflicting rules while reasoning with default assertions.  (#$overrides FIRST SECOND) means that if the assertions FIRST and SECOND both appear in conflicting arguments for and against some proposition, favor the argument that contains FIRST."))
)
(defrelation |owns|
  :arity 2
  :is-primitive (:and |cotemporal| |hasOwnershipIn|)
  :domain |Agent|
  :range |SomethingExisting|
  :annotations ( |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$owns AGENT OBJECT) means that AGENT owns OBJECT -- that is, AGENT enjoys #$FullUseRights (q.v.) over OBJECT.  
Note:  There are commonsense rules relating #$owns to #$controls.  E.g., ownership typically implies control.  But they are just default rules, as there are many exceptions (e.g., when the owner of a building leases it to a company for ten years, the owner gives up almost all `control' over it during that decade)."))
)
(defrelation |ownsShare|
  :arity 3
  :domains (|Agent| |SomethingExisting|)
  :range |NonNegativeNumber|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$ownsShare is used to state how much of some thing is owned by a particular #$Agent.  (#$ownsShare AGENT SOMETHING SHARE) means that the #$Agent AGENT has SHARE #$Percent (q.v.) ownership of the object or company SOMETHING.  Note that SHARE is a percentage and does not refer directly to a number of shares of #$Stock."))
)
(defrelation |parallelObjects|
  :arity 2
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |SpatialPredicate|
     |SymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     (DOCUMENTATION "(#$parallelObjects OBJ1 OBJ2) means that both OBJ1 and OBJ2 have a lengthwise axis, and those axes are parallel to each other."))
)
(defrelation |parallelVectors|
  :arity 2
  :domain |VectorInterval|
  :range |VectorInterval|
  :annotations ( |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$parallelVectors VECTOR1 VECTOR2) means that VECTOR1 is parallel to VECTOR2."))
)
(defrelation |parentActors|
  :arity 2
  :is-primitive |preActors|
  :domain |BiologicalProductionEvent|
  :range |BiologicalLivingObject|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$parentActors EV P) means that organism P is one of the parents in the #$BiologicalReproductionEvent EV."))
)
(defrelation |parentCompany|
  :arity 2
  :domain |Organization|
  :range |Business|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$parentCompany relates an organization to the business which is its parent company.  (#$parentCompany ORG1 ORG2) means that ORG1 is a (partly or wholly owned) subsidiary of ORG2.  ORG2 is the parent company that owns and substantially controls ORG1.  E.g., (#$parentCompany TheLAWeekly TheVillageVoice)."))
)
(defrelation |partitionedInto|
  :arity 2
  :is-primitive |covering|
  :domain |SetOrCollection|
  :range |DisjointSetOrCollection|
  :annotations ( |TaxonomicSlot|
     (DOCUMENTATION "(#$partitionedInto SETORCOL PART) means that the mathematical set or collection PART is a partition of the mathematical set or collection SETORCOL -- that is, the elements of PART are themselves mathematical sets or collections, and every element of SETORCOL is an element of exactly one element of PART, and every element of PART is a subset of SETORCOL.  Or to put it another way, PART is a set or collection of disjoint sets or collections whose union is co-extensional with SETORCOL.  Typically, the #$DisjointSetOrCollection that plays the role of PART in an assertion about partitioning will be a set specified by enumerating its elements, using the function #$ThePartition.  (This is a special #$ReifiableFunction whose principal reason-for-being is to facilitate the inference heuristics associated with assertions about partitioning.)"))
)
(defrelation |parts|
  :arity 2
  :is-primitive |(MeaningInSystemFn SENSUS-Information1997 GENERALIZED-POSSESSION)|
  :domain |Individual|
  :range |Individual|
  :annotations ( |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |PartPredicate|
     (DOCUMENTATION "(#$parts WHOLE PART) means that #$Individual PART is a part of #$Individual WHOLE.  This predicate is very general.  It can be used to refer to concepts including #$physicalParts, #$subEvents, #$timeSlices, and #$groupMembers."))
)
(defrelation |passengers|
  :arity 2
  :is-primitive |transportees|
  :domain |TransportationEvent|
  :range |Person|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "(#$passengers MOVE PAS) means that PAS is a human #$transportees in MOVE who is not a #$driverActor for any #$subEvents of Move.  Any PAS is not a #$driverActor for any #$subEvents of MOVE.  PAS is likely to be sitting (see #$SittingPosture) during the MOVE."))
)
(defrelation |pastTense|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$pastTense WORD STRING) means that STRING is the past tense verb form of WORD. The regular past tense form is formed from the infinitive verb form with an `-ed' suffix.  Verbs in the Cyc lexicon will have a #$pastTense entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `helped'. Irregular example: `ate'."))
)
(defrelation |pathBetween|
  :arity 3
  :domains (|Path-Simple| |Thing|)
  :range |Thing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$pathBetween PATH X Y) means that the #$Path-Simple PATH goes between points (or places) X and Y, where X and Y do not 'overlap', and no further.  Both X and Y have to be on PATH (see #$pointOnPath).  Note that (#$pathBetween PATH X Y) is more specific than (#$pathConnects PATH X Y) because here the PATH cannot extend beyond X and Y.  Within a particular #$PathSystem, a path's end points in the system are unique, and #$pathBetweenInSystem is restricted to paths and points in the system.  When considered without a context of a path system, a path may have several different places at one end, such as Austin and Texas both being at the same end of some path along Highway I-35."))
)
(defrelation |pathConnects|
  :arity 3
  :domains (|Path-Simple| |SpatialThing|)
  :range |SpatialThing|
  :annotations ( |SpatialPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "(#$pathConnects PATH HERE THERE) means that PATH is an individual element of #$Path-Simple that connects HERE and THERE.  Often PATH is a physical path or connection along which objects or information capable of using that path may travel, back and forth, between HERE and THERE.  Note that (#$pathConnects ?PATH ?A ?B) doesn't mean that PATH cant't extend beyond ?A and ?B (in contrast with #$pathBetween ?A ?B)."))
)
(defrelation |PathsConcatenatedFn|
  :arity 3
  :domains (|Path-Simple| |Path-Simple|)
  :range |Path-Simple|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "A function joining two paths end-to-end in series.  For each path PATH1 between X and Y, and each path PATH2 between Y and Z, if every point A on both paths satisfies the conditions (#$pathBetween PATH1 X A) and (#$pathBetween PATH2 A Z), then (#$PathsConcatenatedFn PATH1 PATH2) denotes the path obtained by concatenating PATH1 and PATH2, i.e., the path that is a super path of both PATH1 and PATH2 and is between X and Z.  Note that when you use (#$PathsConcatenatedFn PATH1 PATH2), PATH1 and PATH2 cannot intersect, i.e., no point is on both paths except their end-points.  This function is not defined on the cartesian product #$Path-Simple x #$Path-Simple.  It is rather defined on a proper subset of it."))
)
(defrelation |pathTerminus|
  :arity 2
  :domain |Path-Simple|
  :range |PartiallyTangible|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "#$pathTerminus (PATH END) means that END is a terminating end of a #$Path-Customary PATH, and that there are no further paths of the same type issuing from END.  The terminal end of any #$Path-Customary may be a dead-end, closed off path end, or it may be open, or it may be a terminus of motion; it is not generally a #$JunctionOfPaths with one or more paths of the same basic type issuing beyond it.  Contrast this with the predicate #$deadEndInSystem that indicates a terminus with respect to a specified #$PathSystem only."))
)
(defrelation |pathway-Complete|
  :arity 2
  :is-primitive |pathway-Partial|
  :domain |Movement-TranslationEvent|
  :range |Path-Generic|
  :annotations ( |FunctionalSlot|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$pathway-Complete is used to indicate the whole route travelled by a moving object in a particular event.  (#$pathway-Complete MOVE PATH) means that PATH is the entire trajectory along which an #$objectMoving travels in the #$Movement-TranslationEvent MOVE.  There is exactly one #$pathway-Complete if (and only if) MOVE is an element of #$Translation-SinglePath.  If MOVE is an element of #$Translation-MultiPath, then there are at least two #$pathway-Completes; i.e., at least two distinct values of PATH such that (#$pathway-Complete MOVE PATH) is true.  PATH may be a marked or unmarked #$Path-Generic (q.v.).  By definition, the #$pathway-Complete of a #$Movement-TranslationEvent connects the starting and stopping points (#$fromLocation, #$toLocation) of the whole movement event.  (See also #$pathConnects.)  Use #$pathwayPassesThrough to state that an object passes through a particular location on the #$Path-Generic. 



Note:  Compare #$pathway-Complete with #$pathway-Partial; the former refers to the entire route of a particular #$Translation-Complete.  A sub-region of a #$pathway-Complete is NOT itself considered a #$pathway-Complete of the same movement event; i.e., if (#$pathway-Complete MOVE PATH) is true, and we cut PATH up into ten pieces PATH1, ..., PATH10, then it will generally not be true that (#$pathway-Complete MOVE PATH8),  but it will be true that (#$pathway-Partial MOVE PATH8)."))
)
(defrelation |pathway-Partial|
  :arity 2
  :is-primitive (:and |temporallyIntersects| |eventOccursAt|)
  :domain |Movement-TranslationEvent|
  :range |Path-Generic|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(pathway-Partial EVENT PATH) means that EVENT is a movement along a trajectory (see #$pathway-Complete) which has a sub-path in common with a sub-path of PATH.  For example, if a certain trip to Dallas from Austin is via highway I-35, that does not mean either that the whole journey is along I-35 (it also may be along driveways and side streets), or that it is along all of I-35 (which would take you from the Mexican border all the way to the Canadian border).  A part of the journey is along a part of I-35.  This is in contrast to #$pathway-Complete, which relates a movement to its entire path."))
)
(defrelation |pathwayPassesThrough|
  :arity 2
  :is-primitive |nonDeliberateActors|
  :domain |Translation-SinglePath|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$pathwayPassesThrough MOVE LOC) means that the #$pathway-Complete of MOVE, which is an instance of #$Translation-SinglePath, passes through LOC, which is an instance of #$PartiallyTangible, and thus can be a location, a river or another path, etc.  More formally, any #$objectMoving which undergoes motion from the #$fromLocation to the #$toLocation passes through LOC.  Here `passes through LOC' means that OBJ both arrives and leaves LOC.  Thus, LOC can not be a super region of any #$fromLocation nor any #$toLocations of MOVE. Otherwise it would be possible to state (#$pathwayPassesThrough TripToTheStore01 TheUniverse).  On the other hand, LOC can be a sub region of some #$toLocation or some #$fromLocation."))
)
(defrelation |perceives|
  :arity 2
  :domain |PerceptualAgent|
  :range (:AND |TemporalThing| |SpatialThing|)
  :annotations ( |PerceivingSlot|
     (DOCUMENTATION "(#$perceives AGENT OBJ) means that AGENT has come to know of OBJ via the action of at least one of its senses (e.g. sight, hearing, smell, etc).  Precisely what tangible aspects of OBJ have been apprehended depend on the sensory modality used (see predicates which have #$perceives as a #$genlPreds).  For example, if (#$sees AGENT OBJ), then AGENT knows of some visual aspects of OBJ.  Whereas if (#$smells AGENT OBJ), then AGENT knows of some olfactory aspects of OBJ.  Only tangible things, #$PhysicalEvents or #$PartiallyTangibles, can be perceived"))
)
(defrelation |Percent|
  :annotations ( |UnitOfMeasureNoPrefix|
     |DimensionlessUnitOfMeasure|
     |EvaluatableFunction|
     (DOCUMENTATION "#$Percent is a function whose results are percentages.  E.g., (#$Percent 1) represents 1% in Cyc (and is equal to .01); (#$Percent 110) is the same as 1.1; (#$Percent 0.1) is the same as 0.1%, which is the same as .001."))
)
(defrelation |perfect|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$perfect WORD STRING) means that STRING is the perfect verb form of WORD. This form is also known as the past participle. The regular perfect verb form is often the same as the past tense verb form. Verbs in the Cyc lexicon will have a #$perfect entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `helped'. Irregular example: `eaten'."))
)
(defrelation |performanceLevel|
  :arity 5
  :domains (|SomethingExisting| |Event| |ActorSlot|
            (:AND |ScriptPerformanceAttributeType| (:FILLED-BY SUPERRELATIONS |ScriptPerformanceAttribute|)))
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |QuintaryPredicate|
     (DOCUMENTATION "This predicate relates performers to particular individual actions.  (#$performanceLevel OBJ EVT ROLE PERF-ATT LEVEL) means that the individual OBJ plays the role ROLE in the action EVT, and does so with the performance attribute PERF-ATT to the degree LEVEL.  Such an assertion expresses actual performance in a particular action; for example, (#$performanceLevel #$Joe DiggingHole54001 #$performedBy #$Strength #$Low) means Joe exerted a low level of strength while digging that particular hole.  This does not imply much about Joe's potential to exert strength, about strength required in general for hole-digging, etc., it just talks about that one single event.  To talk about typical or expected performance, use #$skillLevel."))
)
(defrelation |performedBy|
  :arity 2
  :is-primitive (:and |deliberateActors| |doneBy|)
  :domain |Action|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$performedBy relates an event to an agent who performs it deliberately, which in Cyc means, intentionally and volitionally.  (#$performedBy ACT DOER) means that the agent DOER deliberately does the action ACT.  DOER must be an #$Agent.  For example, (#$performedBy #$AssassinationOfPresidentLincoln #$JohnWilkesBooth).  If ACT has multiple performers, ACT will be #$performedBy each of them.  See also #$deliberateActors, #$doneBy."))
)
(defrelation |performedByPart|
  :arity 2
  :is-primitive |performedBy|
  :domain |Action|
  :range |Organization|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$performedByPart ACT ORG) means that the #$Organization ORG is considered to be the performer of the #$Action ACT, though in fact only some subordinate part of ORG (i.e., a member or a sub-organization), rather than all of the organization, is directly involved in ACT.  For example, (#$performedByPart OperationDesertStorm USArmy) since only certain divisions of the US Army participated in Operation Desert Storm."))
)
(defrelation |perpendicularObjects|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$perpendicularObjects OBJ1 OBJ2) means that the longest axis of OBJ1 is perpendicular to the longest axis of OBJ2."))
)
(defrelation |perpendicularVectors|
  :arity 2
  :domain |VectorInterval|
  :range |VectorInterval|
  :annotations ( |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$perpendicularVectors VECTOR1 VECTOR2) means that VECTOR1 is perpendicular to VECTOR2.  E.g., (#$perpendicularVectors #$SouthEast-Directly #$SouthWest-Directly),  (#$perpendicularVectors #$East-Directly #$North-Directly)."))
)
(defrelation |perpetrator|
  :arity 2
  :is-primitive |performedBy|
  :domain |Action|
  :range |SocialBeing|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The #$Agent(s) that performed this possibly criminal act."))
)
(defrelation |phoneNumberText|
  :arity 2
  :domain |ContactLocation|
  :range |PhoneNumber|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$phoneNumberText is used to relate a telephone number to a contact location.  (#$phoneNumberText LOC NUM) means NUM is a string denoting (one of) the phone number(s) of the #$ContactLocation LOC."))
)
(defrelation |physicalDecompositions|
  :arity 2
  :is-primitive (:and |cotemporal| |spatiallyIntersects| |parts|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$physicalDecompositions WHOLE PART) -- PART is any spatial part or decomposition of WHOLE.  PART may be discontinuous, diffused throughout the object, discrete and identifiable, etc."))
)
(defrelation |physicalExtent|
  :arity 2
  :is-primitive |parts|
  :domain |CompositeTangibleAndIntangibleObject|
  :range |PartiallyTangible|
  :annotations ( |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |FunctionalSlot|
     (DOCUMENTATION "(#$physicalExtent WHOLE PART) means that PART is the physical part of the #$CompositeTangibleAndIntangibleObject WHOLE."))
)
(defrelation |physicalParts|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalDecompositions|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |PhysicalFeatureDescribingPredicate|
     |CotemporalObjectsSlot|
     |AntiSymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$physicalParts WHOLE PART) -- WHOLE is a physical object and PART is one of its distinct, non-diffuse, identifiable parts, such as the relationship between a car and its wheels or bumpers.  The #$physicalParts of an object include only those spatial decompositions which are distinct, identifiable parts."))
)
(defrelation |physicalPortions|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalDecompositions|)
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$physicalPortions ?WHOLE ?PART) means ?PART is a representative spatial chunk of ?WHOLE.  Every intrinsic property which is true of ?WHOLE should be true of ?PART.  Spatial parts of ?WHOLE which are not representative of the whole would be #$physicalParts or #$physicalDecompositions , not #$physicalPortions.  For example, the SpaghettiSauce001 which is part of SpaghettiDinner001 is a #$physicalParts of the dinner.  A #$physicalPortions of the dinner would include some sauce, some noodles, some parmesan cheese, etc. - parts of all the #$constituents.   This is the spatial analog of #$timeSlices (not #$subEvents)."))
)
(defrelation |physicalQuarters|
  :arity 2
  :domain |Organization|
  :range |ConstructionArtifact|
  :annotations ( |SubProcessSlot|
     (DOCUMENTATION "The predicate #$physicalQuarters is used to relate an organization to the building(s) it occupies.  (#$physicalQuarters ORG BLDG) means that the #$Organization ORG is located in the #$ConstructionArtifact BLDG, which may consist of one or more buildings, rooms, offices, etc."))
)
(defrelation |physicalStructuralAttributes|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |PartiallyTangible|
  :range |PhysicalStructuralAttribute|
  :annotations ( |TangibleSubstancePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$physicalStructuralAttributes OBJ ATT) means that the physical structure of the tangible object OBJ is (at least partially) determined or described by its attribute ATT.  See also #$PhysicalStructuralAttribute."))
)
(defrelation |physicalStructuralIntegrity|
  :arity 2
  :domain |PartiallyTangible|
  :range |GenericAttribute|
  :annotations ( |TangibleSubstancePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$physicalStructuralIntegrity SUBST DEGREE) means that the tangible object SUBST has DEGREE ability to maintain its physical structure intact in the face of various forces.  DEGREE is a #$GenericAttribute.  The #$physicalStructuralIntegrity of an object may be inferred from some of its other physical attributes; e.g., something with the #$physicalStructuralAttributes #$Granular has a #$Low degree of #$physicalStructuralIntegrity; things whose #$stateOfMatter is #$LiquidStateOfMatter have #$VeryLow #$physicalStructuralIntegrity."))
)
(defrelation |pipeEndsAtCavity|
  :arity 2
  :is-primitive (:and |pathTerminus| |connectedTo-Rigidly|)
  :domain |Pipe-GenericConduit|
  :range |PartiallyTangible|
  :annotations ( |AsymmetricBinaryPredicate|
     |SpatialPredicate|
     |ConnectionPredicate|
     (DOCUMENTATION "(#$pipeEndsAtCavity PIPE CAV) means that PIPE is a #$Pipe-GenericConduit that joins the larger-diameter #$Cavity CAV at a #$PipeEndToCavityJunction, allowing flow or access between them.  The flange where a water pipe enters a water tank is one example, as is the junction of the #$Esophagus and the #$Stomach in animals.  See also the collection #$PipeEndToCavityJunction."))
)
(defrelation |pipesDirectlyConnected|
  :arity 2
  :is-primitive |connectedTo|
  :domain |Pipe-GenericConduit|
  :range |Pipe-GenericConduit|
  :annotations ( |SymmetricBinaryPredicate|
     |ConnectionPredicate|
     (DOCUMENTATION "(pipesDirectlyConnected PIPE1 PIPE2) means that there is a #$JunctionOfPipes connecting two #$Pipe-GenericConduits, PIPE1 to PIPE2, (or else they are #$endToEndConnected) allowing flow of #$FluidTangibleThings between them."))
)
(defrelation |PITOfIBTFn|
  :arity 2
  :domain |InformationBearingThing|
  :range |PropositionalInformationThing|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The Cyc function #$PITOfIBTFn is an element of #$IndividualDenotingFunction.  Given as its argument a particular instance of #$InformationBearingThing (q.v.), #$PITOfIBTFn returns the information content of that thing.  The object returned is an element of #$PropositionalInformationThing (q.v.).  Thus, (#$PITOfIBTFn IBT) denotes the abstract, propositional chunk of information that is represented in IBT.  For example: if IBT is a particular printed copy of Psalm 23, then (#$PITOfIBTFn MyCopyOfPsalm23) refers to the propositional content of Psalm 23."))
)
(defrelation |plaintiffs|
  :arity 2
  :is-primitive |litigants|
  :domain |Trial|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(plaintiffs ARG1 ARG2) means that the agent ARG2 is the complaining party (the party bringing an accusation of wrong-doing) in the lawsuit ARG1."))
)
(defrelation |plural|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$plural WORD STRING) means that STRING is the plural noun form of WORD.  For example, the #$plural form of #$Hit-TheWord is `hits', and the plural form of #$Goose-TheWord is `geese'."))
)
(defrelation |PlusFn|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     |CommutativeRelation|
     |VariableArityRelation|
     |NonPredicateFunction|
     |EvaluatableFunction|
     (DOCUMENTATION "#$PlusFn is Cyc's addition operator; it is a variable-arity mathematical function.  #$PlusFn takes a variable number of quantities as arguments, and it yields a new quantity which is the result of adding those arguments together.  All of the arguments to #$PlusFn must be elements of #$ScalarInterval, as is its result.  Examples: (#$PlusFn 2 3 4) returns 9; (#$PlusFn (#$Meter 1.5) (#$Meter 0.7)) returns (#$Meter 2.2).  See also #$VariableArityRelation."))
)
(defrelation |pointClosedSubSystems|
  :arity 2
  :is-primitive |subPathSystems|
  :domain |Thing|
  :range |Thing|
  :annotations ( |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     (DOCUMENTATION "(#$pointClosedSubSystems SYS SUBSYS) means that the path system SUBSYS is a subsystem of the path system SYS (i.e., (#$subPathSystems SYS SUBSYS) holds) and SUBSYS 'preserves' all points in SYS that are on links in SUBSYS, i.e., if LINK is a link in SUBSYS (and hence is a link in SYS) and X is a point in SYS and is on LINK, then X must be a point in SUBSYS."))
)
(defrelation |PointFn|
  :arity 2
  :domain |Thing|
  :range |SetOrCollection|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "For each #$PathSystem SYS, (#$PointFn SYS) denotes the set of all points in SYS (see #$PathSystem).  Note that the function #$PointFn and the predicate #$pointInSystem are interdefinable.  We normally use #$PointFn, for convenience, when we consider some relations between different path systems even though for a single path system SYS, we can replace each (#$pointInSystem X SYS) by (#$elementOf X (#$PointFn SYS))."))
)
(defrelation |pointingToward|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$pointingToward OBJ1 OBJ2) means that OBJ1 has a pointing axis and that its axis points toward OBJ2.  A pointing axis is ascribed to objects that have directionality (e.g., a gun, a projectile, an arrow, an extended finger)."))
)
(defrelation |pointInSystem|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$pointInSystem POINT SYS) means that POINT is an instance of #$Thing, SYS is an instance of #$PathSystem, and POINT is a 'point' on a path in SYS or is a 'node' in SYS.  Note that for each path system SYS there is at least one POINT such that (#$pointInSystem POINT SYS) holds.  For any path system SYS, the set of all points in SYS has an important subset, the set of all 'nodes' in SYS.  See #$nodeInSystem for the difference between nodes and points that are not nodes in a path system.  Note that in some cases (such as making a 'closed world' or talking about different systems), using (#$PointFn SYS) to denote the set of all points in a path system SYS is more convenient than using the predicate #$pointInSystem."))
)
(defrelation |pointOfContact|
  :arity 3
  :domains (|Agent| (:AND |ContactLocationType| (:FILLED-BY SUPERRELATIONS |ContactLocation|)))
  :range |ContactLocation|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$pointOfContact (#$pointOfContact AGENT LOCTYPE LOC) means the #$Agent AGENT has as its LOCTYPE (a #$ContactLocationType such as #$Workplace, #$HumanResidence, #$BillingLocation, etc.) a particular #$ContactLocation LOC, where that agent can be contacted.  Typically, LOC is a complete address, i.e., it is not a generic location such as Austin, TX."))
)
)    ; END EVAL-WHEN 7

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 8
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |pointOfContactInfo|
  :arity 4
  :domains (|Agent| (:AND |ContactLocationType| (:FILLED-BY SUPERRELATIONS |ContactLocation|)) |BinaryPredicate|)
  :range |Thing|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "The predicate #$pointOfContactInfo allows us to characterize a string of information as belonging to a certain kind of contact location for a particular person, without actually reifying those contact locations.  (#$pointOfContactInfo AGENT LOC-TYPE INFO-TYPE STRING) means that AGENT's contact locations of type LOC-TYPE (e.g., #$Workplace) have STRING as their contact address of INFO-TYPE (e.g., #$phoneNumberText, #$faxNumberText, #$addressText).  For example, to say that Keith Goolsbey's home phone number is 512-123-4567, we write: (#$pointOfContactInfo #$Goolsbey #$HumanResidence #$phoneNumberText ``(512) 123-4567'').  Note: the disadvantage of this shorthand method is that all of AGENT's contact locations of the type LOC-TYPE are assumed to have the same STRING of INFO-TYPE."))
)
(defrelation |pointsOfContact|
  :arity 2
  :domain |Agent|
  :range |ContactLocation|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$pointsOfContact indicates the places at which a particular agent can be reached.  (#$pointsOfContact AGENT LOC) means that the #$Agent AGENT can be contacted at the #$ContactLocation LOC."))
)
(defrelation |porosityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Porosity|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$porosityOfObject OBJ DEGREE) means that the tangible object OBJ has the degree of #$Porosity DEGREE."))
)
(defrelation |portalConnectsRegions|
  :arity 3
  :domains (|Portal| |PartiallyTangible|)
  :range |PartiallyTangible|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$portalConnectsRegions PORTAL HERE THERE) means that the regions HERE and THERE each contain PORTAL as a physical part."))
)
(defrelation |portalHasCovering|
  :arity 2
  :is-primitive |physicalParts|
  :domain |Portal|
  :range |PortalCovering|
  :annotations ( |PhysicalPartPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "A general predicate for relating instances of portal to their coverings.  Specpreds include #$doorwayHasCovering and #$windowHasCovering."))
)
(defrelation |posForms|
  :arity 2
  :domain |EnglishWord|
  :range (:AND |LinguisticObjectType| (:FILLED-BY SUPERRELATIONS |SpeechPart|))
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$posForms is used to indicate the different parts of speech that a particular English word has associated with it.  (#$posForms WORD POS) means that the #$EnglishWord WORD has a form that can serve as the #$SpeechPart POS.  For example, #$Dot-TheWord has forms for both #$SimpleNoun and #$Verb.  Forms of a word used for different parts of speech may or may not differ from each other in sound and/or spelling.  To find out, or to specify, the string that represents a particular POS form of a specific word, use #$partOfSpeech."))
)
(defrelation |positiveVestedInterest|
  :arity 2
  :domain |Agent|
  :range |TemporalThing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$positiveVestedInterest AGT OBJ) means #$Agent AGT has a positive interest in the object OBJ or in the good fortune of OBJ.  Generally, AGT will be helped or pleased by the preservation or enhancement of OBJ.
Note:  the restriction of OBJ to #$TemporalThing means that it would be incorrect to use this predicate to say that Douglas Adams has a #$positiveVestedInterest in the number 42.  Rather, what he has a vested interest in is public popularity and faddism focusing on that number.  A fad is a #$TemporalThing, but the number 42 isn't."))
)
(defrelation |possesses|
  :arity 2
  :domain |Agent|
  :range |SomethingExisting|
  :annotations ( |Predicate|
     (DOCUMENTATION "(#$possesses AGENT OBJECT) means that OBJECT is in the physical possession of AGENT.  Compare with #$owns."))
)
(defrelation |postActors|
  :arity 2
  :is-primitive |actors|
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$postActors is used to indicate a participant that continues to exist after a particular event.  (#$postActors EVENT OBJECT) means that OBJECT exists after EVENT ends.  It makes no commitment about OBJECT's condition before or during EVENT.  #$postActors is a very general element of #$ActorSlot; it subsumes #$outputsCreated, #$doneBy, and many others."))
)
(defrelation |postalCodeOfAddress|
  :arity 2
  :domain |ContactLocation|
  :range |PostalCode|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "The predicate #$postalCodeOfAddress maps from a particular element of #$ContactLocation to a corresponding element of #$PostalCode.  (#$postalCodeOfAddress LOC PC) means that the location LOC has the #$PostalCode PC.  For example, if LOC had the address: P.O. Box 1677-B, New York, NY, 10014, PC would be the string `10014'.  See also #$ContactLocation."))
)
(defrelation |postConfiguration|
  :arity 2
  :domain |Event|
  :range |StaticSituation|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$postConfiguration EVT CONFIG) means CONFIG is a #$Configuration that begins immediately after the action EVT ends, and is directly (probably causally) related to EVT.  See #$postEvents and #$preConfiguration for related predicates."))
)
(defrelation |PosteriorRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (PosteriorRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the region consisting of the back or rear half or section, or posterior main portion, of REGOROBJ.  It applies only when REGOROBJ itself has an intrinsic front/back orientation, or is a (non-backward-facing) part of a larger region or object that has a front/back orientation."))
)
(defrelation |postEvents|
  :arity 2
  :domain |Event|
  :range |Event|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ComplexTemporalRelation|
     |Role|
     (DOCUMENTATION "This predicate relates one event to another that follows it.  (#$postEvents BEFORE AFTER) implies two things: 

(1) BEFORE occurs strictly before AFTER; i.e., AFTER starts after BEFORE has ended; i.e., (#$startsAfterEndingOf AFTER BEFORE); and

(2) BEFORE and AFTER are significantly relevant to each other.  This required `relevance' of the two arguments to each other is difficult to formalize but often intuitively clearcut.  Often, e.g., AFTER is caused by BEFORE."))
)
(defrelation |postureOfAnimal|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |Animal|
  :range |Posture|
  :annotations ( |FunctionalSlot|
     |ShapeDescribingPredicate|
     (DOCUMENTATION "(#$postureOfAnimal ?AN ?POS) means that the #$Animal ?AN is in the #$Posture ?POS.  #$Postures are types of attributes that describe bodily configurations and/or orientations of #$Animals.  See #$Posture for examples."))
)
(defrelation |Pound-UnitOfMass|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfMass|
     |FPSUnitOfMeasure|
     (DOCUMENTATION "The measurement function used in Cyc to represent the basic unit of mass in the British (FPS) system.  Technically, the FPS pound is exclusively a unit of force, analogous to the #$Newton in the MKS system.  The usage here is occasioned primarily by the fact that interconversions between pounds and kilograms are often used in the terrestrial frame of reference.  In fact, the FPS unit of mass, analogous to the #$Kilogram in the MKS system, is called the 'slug'.  See also #$FPSUnitOfMeasure, #$UnitOfMeasure, #$Pound-UnitOfForce."))
)
(defrelation |preActors|
  :arity 2
  :is-primitive (:and |startsAfterStartingOf| |actors|)
  :domain |Event|
  :range |SomethingExisting|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$preActors is used to indicate a participant that pre-exists a particular event.  (#$preActors EVENT OBJECT) means that OBJECT exists before EVENT begins.  It makes no commitment about OBJECT's condition during or after EVENT.  #$preActors is a very general #$ActorSlot, subsuming #$doneBy, #$objectActedOn, #$objectMoving, and many others."))
)
(defrelation |preConfiguration|
  :arity 2
  :is-primitive |startsAfterEndingOf|
  :domain |Event|
  :range |StaticSituation|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$preConfiguration EVT CONFIG) means CONFIG is an element of #$Configuration that holds just prior to the start of EVT, and CONFIG is directly related to EVT.  The required `salience' of the two arguments to each other is difficult to formalize but usually intuitively clearcut.  Commonly, CONFIG and EVT share many of the same objects involved in various roles, and there is often a causal connection as well.   For instance, the configuration CONFIG might be somehow `taken apart' by event EVT, might `trigger' EVT, etc."))
)
(defrelation |presenter|
  :arity 2
  :is-primitive |socialParticipants|
  :domain |SocialGathering|
  :range |Person|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$presenter GATHERING PERSON) means that PERSON speaks to a set of audience members who have a role in GATHERING."))
)
(defrelation |prettyName|
  :arity 2
  :domain |CycIndexedTerm|
  :range |CycSystemString|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$prettyName TERM STRING) means that STRING is the English word or           expression (sequence of words) commonly used to refer to the #$Cyc           term TERM.  The predicate #$prettyName is used by the code which           generates CycL to English paraphrases, but its applicability is not           restricted to this use."))
)
(defrelation |primaryFunction|
  :arity 3
  :is-primitive |intendedBehaviorCapable|
  :domains (|Artifact| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$primaryFunction is used to indicate what an artifact was primarily designed to do.  (#$primaryFunction ART SITTYPE ROLE) means that the primary function of the #$Artifact OBJ is to serve as described by ROLE in situations of the type SITTYPE.  Examples: the #$primaryFunction of instances of #$MammographyFacility is to be the #$providerOfService in instances of #$MammographicBreastCancerScreening; the #$primaryFunction of a pump is to be the #$providerOfMotiveForce in instances of #$TransportingGoods in which liquids are transported.
Note: in the #$SimpleDeviceFunctioningMt, it is assumed that every #$PhysicalDevice has only one primary function."))
)
(defrelation |primitiveAttributeTypes|
  :arity 2
  :domain |CompositeAttributeType|
  :range |PrimitiveAttributeType|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$primitiveAttributeTypes is used to relate a type of complex attribute to its basic components.  (#$primitiveAttributeTypes COMP PRIM) means that PRIM is an element of #$PrimitiveAttributeType that makes up the #$CompositeAttributeType, COMP.  PRIM can be thought of as one axis for the composite scale.  For example, hue, intensity, and saturation are each a primitive scale for the composite attribute `color'.  Another case: #$Speed is a primitive component of the composite attribute #$VelocityVector."))
)
(defrelation |products|
  :arity 2
  :is-primitive |outputs|
  :domain |CreationOrDestructionEvent|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$products EV OBJ) means that OBJ is one of the intended outputs of event EV.  For unintended outputs, see #$byProducts.  For a particular EV and OBJ, it will not be true that both (#$products EV OBJ) and (#$byProducts EV OBJ)."))
)
(defrelation |programUsed|
  :arity 2
  :is-primitive (:and |unchangedActors| |instrument-Generic|)
  :domain |Action|
  :range |ComputerProgram|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$programUsed EV PROG) means that PROG is the computer program used in the action EV."))
)
(defrelation |propositionalInfoAbout|
  :arity 2
  :domain |PropositionalInformationThing|
  :range |Thing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$propositionalInfoAbout ?MT ?OBJ) means that the #$PropositionalInformationThing ?MT is 'about' ?OBJ, i.e. it is a #$Microtheory with assertions concerning this object.  For example, a microtheory which is the propositional content of a portrait of #$GeorgeWashington might only have #$GeorgeWashington as the ?OBJ of this predicate."))
)
(defrelation |propositionsPerceived|
  :arity 2
  :domain |Perceiving|
  :range |CycFormula|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$propositionsPerceived PERCEIVING PROP) means that in the #$Perceiving event PERCEIVING, the perceiver mentally grasps the proposition(s) PROP.  E.g., ten people witness a particular car crash, and yet each one gets their own particular set of propositions which they later can relate to the police; there are ten separate #$Perceivings in this case, and each one has its own unique set of #$propositionsPerceived."))
)
(defrelation |providerOfMotiveForce|
  :arity 2
  :is-primitive |preActors|
  :domain |MovementEvent|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$providerOfMotiveForce ACT OBJ) means that OBJ provides, through its expenditure of energy, a significant fraction of the physical force required to make ACT happen. For example, if ACT is an element of #$PedalingABicycle, OBJ will be the person who is operating the bike.  Another example: in the use of a belt sanding tool, there will be two values for #$providerOfMotiveForce, the electric sander and the person operating the sander.  In that case, although force is transmitted and applied through the sandpaper, the paper doesn't count as a #$providerOfMotiveForce, because it only transmits force and does not itself expend energy.   Note that inferences involving this constant require that every #$providerOfMotiveForce be a whole object, not just a part of an object.  For example: (=> (#$and (#$isa ?LOCO #$LocomotionEvent) (#$providerOfMotiveForce ?LOCO ?OBJ)) (#$objectMoving ?LOCO ?OBJ)) or (=> (#$and (#$isa ?LOC #$LocomotionEvent) (#$providerOfMotiveForce ?LOC ?PROV)) (#$doneBy ?LOC ?PROV)) or (#$domainAssumptions #$ManualHumanActivitiesMt (#$forAll ?U (#$forAll ?PERS (#$implies (#$and (#$isa ?U #$Action) (#$providerOfMotiveForce ?U ?PERS)) (#$isa ?PERS #$Person))))))."))
)
(defrelation |providerOfService|
  :arity 2
  :is-primitive (:and |performedBy| |preActors| |deliberateActors|)
  :domain |ServiceEvent|
  :range |Agent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The Cyc predicate #$providerOfService is used to relate a service to the agent that provides it.  (#$providerOfService SEVT AGT) means that the #$ServiceEvent SEVT is performed or provided by the #$Agent AGT.  Typically, AGT acts in order to serve the #$recipientOfService in SEVT."))
)
(defrelation |PureFn|
  :arity 2
  :domain (:AND |ChemicalCompoundType| (:FILLED-BY SUPERRELATIONS |TangibleThing|))
  :range (:AND |PureCompoundType| (:FILLED-BY SUPERRELATIONS |PureCompound|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$PureFn is a Cyc function, specifically a #$CollectionDenotingFunction.  (#$PureFn X) denotes the subset of the #$ChemicalCompoundType X whose instances are chemically pure.  Note that #$PureFn can be applied only to instances of #$ChemicalCompoundType (such as #$Fructose or #$Water), but not to mixtures (such as #$Air).  See also #$PureCompound."))
)
(defrelation |purpose-RST|
  :arity 2
  :domain |LinguisticObject|
  :range |LinguisticObject|
  :annotations ( |AsymmetricBinaryPredicate|
     |RSTRelation|
     (DOCUMENTATION "The discourse relation that holds between two segments of text when ARG1 specifies something which is initiated with the purpose of achieving ARG2. #$purpose-RST is agnostic as to volition; see also #$volitionalCause-RST."))
)
(defrelation |purposeInEvent|
  :arity 3
  :domains (|Agent| |PurposefulAction|)
  :range |Goal|
  :annotations ( |TernaryPredicate|
     |ModalRelationship|
     (DOCUMENTATION "(#$purposeInEvent AGT EVT G) means that the agent AGT is taking part in event EVT because (1) AGT wants G to become true, and also (2) AGT expects and believes that EVT occurring will (help) make G true."))
)
(defrelation |QuarterFn|
  :arity 3
  :domains (|PositiveInteger| |CalendarYear|)
  :range |CalendarQuarter|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$QuarterFn ?N ?YR) denotes the Nth #$CalendarQuarter of the year ?YR. For example, (#$QuarterFn 2 (#$YearFn 1966)) denotes the second quarter of 1966."))
)
(defrelation |QuartersDuration|
  :annotations ( |UnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |UnitOfTime|
     (DOCUMENTATION "This is a function that takes one or two numbers and returns, as its value, some amount of #$Time.  An expression of the form (#$QuartersDuration ?min ?max) denotes a quantity of #$Time that is at least ?min quarter-years and at most ?max quarter-years.  (#$QuartersDuration ?num) denotes a quantity of #$Time that is exactly ?num quarter-years."))
)
(defrelation |QuotientFn|
  :arity 3
  :domains (|ScalarInterval| |ScalarInterval|)
  :range |ScalarInterval|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$QuotientFn is the division operator, a binary mathematical function.  (#$QuotientFn DIVIDEND DIVISOR) yields a new quantity that is the result of dividing the DIVIDEND by DIVISOR.  For example, (#$QuotientFn 24 6) returns 4."))
)
(defrelation |quotientUnits|
  :arity 3
  :domains (|UnitOfMeasure| |UnitOfMeasure|)
  :range |UnitOfMeasure|
  :annotations ( |BookkeepingPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$quotientUnits is used to state what measurement units should be used for the quotient of two physical quantities, given the units measuring the dividend and divisor.  (#$quotientUnits UM-1 UM-2 QUOT-UM) means that the value of (#$QuotientFn (UM-1 x) (UM-2 y)) should be given in the units QUOT-UM.  Examples: (#$quotientUnits #$Newton #$SquareMeter #$Pascal-UnitOfPressure); (#$quotientUnits #$Unity #$DaysDuration #$PerDay); (#$quotientUnits (#$Micro #$Gram) (#$Milli #$Liter) #$MicrogramsPerMilliliter).  See also #$UnitOfMeasure, #$QuotientFn."))
)
(defrelation |Radian|
  :annotations ( |UnitOfMeasureNoPrefix|
     |StandardUnitOfMeasure|
     |UnitOfAngularDistance|
     (DOCUMENTATION "This is the basic unit of angular measure.  2
 radians make a complete circle."))
)
(defrelation |RadiansPerSecond|
  :annotations ( |StandardUnitOfMeasure|
     |MKSUnitOfMeasure|
     |UnitOfAngularSpeed|
     |UnitOfMeasureNoPrefix|
     (DOCUMENTATION "The basic measure of #$RateOfRotation."))
)
(defrelation |RadiansPerSecondPerSecond|
  :annotations ( |StandardUnitOfMeasure|
     |MKSUnitOfMeasure|
     |UnitOfAngularAcceleration|
     |UnitOfMeasureNoPrefix|
     (DOCUMENTATION "The basic measure of angular acceleration"))
)
(defrelation |radius|
  :arity 2
  :domain |PartiallyTangible|
  :range |Distance|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The radius of an object with a circular shape."))
)
(defrelation |raininessOfRegion|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |OutdoorLocation|
  :range |Raininess|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$raininessOfRegion LOC DEGREE) indicates the intensity with which it is raining at the #$OutdoorLocation LOC.  (If it is not raining at LOC, it will be the case that (#$raininessOfRegion LOC (#$NoAmountFn #$Raininess)).)"))
)
(defrelation |rateOfRotationOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |RateOfRotation|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "#$rateOfRotationOfObject relates an instance of #$PartiallyTangible to the rate of change of its physical component's angular separation from a reference vector as measured from a point of origin."))
)
(defrelation |recipientOfInfo|
  :arity 2
  :is-primitive |informationDestination|
  :domain |InformationTransferEvent|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$recipientOfInfo is used to indicate who receives information in a particular communication event.  (#$recipientOfInfo TRANSFER RECIP) means that the information transferred in the #$InformationTransferEvent TRANSFER is received by the #$Agent RECIP.  After TRANSFER, RECIP understands or conceives of the information transferred in TRANSFER; Cyc does NOT conclude that s/he #$knows the information or counts it among his/her #$beliefs, because RECIP might not believe it.  In receiving the information transferred, RECIP may be acting intentionally or unintentionally.  See also #$infoTransferred."))
)
(defrelation |recipientOfService|
  :arity 2
  :is-primitive (:and |postActors| |preActors| |beneficiary|)
  :domain |ServiceEvent|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "(#$recipientOfService ACT AGNT) means the #$Agent AGNT is the recipient of the #$ServiceEvent ACT.  The service is performed on, for, or to AGNT, and AGNT is correspondingly affected by it."))
)
(defrelation |reciprocalTransfers|
  :arity 2
  :domain |TransferringPossession|
  :range |TransferringPossession|
  :annotations ( |SymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(#$reciprocalTransfers ?T1 ?T2) means that ?T1 and ?T2 are transfers of possession done in exchange for each other.  They are part of some #$ExchangeOfUserRights."))
)
(defrelation |RectangularSolidFn|
  :arity 4
  :domains (|Distance| |Distance| |Distance|)
  :range |AbstractShape|
  :annotations ( |ShapeFunction|
     (DOCUMENTATION "The Cyc function #$RectangularSolidFn is a #$ShapeFunction (q.v.).  (#$RectangularSolidFn LN BR HT) returns an abstract rectangular solid of length LN, breadth BR, and height HT.  For example, the #$shape of a 2-by-4 stud is #$Rectangular3DShape; it #$fitsIn the shape denoted by (#$RectangularSolidFn (#$Inch 2) (#$Inch 4) (#$Foot-UnitOfMeasure 8))."))
)
(defrelation |reductionOfPathSystems|
  :arity 2
  :is-primitive |linkClosedSubSystems|
  :domain |Thing|
  :range |MultiGraph|
  :annotations ( |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$reductionOfPathSystems SYS RED) means that (i) every node in SYS is a node in RED, (ii) every point in RED is a node in RED (and hence a node in SYS), and (iii) (#$linkClosedSubSystems SYS RED) holds. It is easy to see that when (#$reductionOfPathSystems SYS RED) holds, RED must be an instance of #$MultiGraph.  But RED is not only a multi-graph, it is THE multi-graph that underlies the path system SYS, i.e., the only difference between SYS and RED is that SYS is obtainable by adding to RED some points that are on a link in RED between the end-nodes."))
)
(defrelation |referredServiceProvider|
  :arity 2
  :is-primitive |providerOfService|
  :domain |ServiceEvent|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The agent ARG2 who provides the service ARG1 was referred by another agent."))
)
(defrelation |relationType|
  :arity 3
  :domains (|BinaryPredicate| |Collection|)
  :range |Collection|
  :annotations ( |RuleMacroPredicate|
     |TernaryPredicate|
     (DOCUMENTATION "(#$relationType SLOT COL1 COL2) means that, for every instance of COL1 (INS1), there is some instance of COL2 (INS2) such that (SLOT INS1 INS2) holds.  #$relationType is thus redundant with a huge set of commonly-occurring rules.  By having this predicate (along with an axiom defining it, and, eventually, coded support for quick inferencing with it), those rules can be stated more tersely and reasoning at the collection level is possible."))
)
(defrelation |relationTypeCount|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |NonNegativeInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$relationTypeCount SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are exactly NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold.  Thus, (#$relationTypeCount #$anatomicalParts #$Dog #$Leg 4) means simply `dogs have four legs'."))
)
(defrelation |relationTypeMax|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |PositiveInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$relationTypeMax SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are at most NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold.  Thus (#$relationTypeMax #$anatomicalParts #$Mammal #$Leg 4) would mean `every mammal has at most four legs'."))
)
(defrelation |relationTypeMin|
  :arity 4
  :domains (|BinaryPredicate| |Collection| |Collection|)
  :range |NonNegativeInteger|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$relationTypeMin SLOT COL1 COL2 NUM) means that, for every instance of COL1 (INS1) there are at least NUM instances of COL2 (INS2, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS1 INS3), ..., hold.  Thus (#$relationTypeMin #$subEvents #$EatingEvent #$Swallowing 1) would mean `every eating event has at least one swallowing sub-event'."))
)
(defrelation |relatives|
  :arity 2
  :domain |Animal|
  :range |Animal|
  :annotations ( |ReflexiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     |FamilyRelationSlot|
     (DOCUMENTATION "(#$relatives ANIM1 ANIM2) means ANIM2 is some biological relative of ANIM1."))
)
(defrelation |RentingFn|
  :arity 2
  :domain (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |PartiallyTangible|))
  :range (:AND |TemporalObjectType| |ProductType| |ScriptType| (:FILLED-BY SUPERRELATIONS |Renting|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$RentingFn is a Cyc function, and in particular a #$CollectionDenotingFunction.  It returns a subset of actions which are instances of #$Renting.  (#$RentingFn TYPE) denotes the collection of events in which an #$Agent gets the use and/or possession (but not ownership) of an instance of TYPE by paying some #$Money to the owner.  For instance, (#$RentingFn #$Automobile) returns a set of all the events in which an agent rents an automobile.
Note:  That means that the value of (#$RentingFn #$Automobile) is both extensionally and intensionally the same as the collection #$RentingOfAutomobile."))
)
(defrelation |rents|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Agent|
  :range |PartiallyTangible|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$rents relates an agent to something that s/he is renting.  (#$rents AGT OBJ) means that the #$Agent AGT is renting the object (possibly a piece of real estate) OBJ from another, unspecified agent.   AGT is the borrower, renter, lessee or tenant.  AGT has temporary use and enjoyment of OBJ, for a charge.  See also #$TemporaryUserRightsAgreement, #$TemporaryChangeOfUserRights, #$Renting."))
)
(defrelation |representsAgentInEvent|
  :arity 3
  :domains (|Agent| |Agent|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "ARG1 represents ARG2 in the event ARG3.  ARG2 often has multiple entries, when ARG1 is appointed to represent the group's interests."))
)
(defrelation |representsAgentToAgent|
  :arity 3
  :domains (|Agent| |Agent|)
  :range |Agent|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$representsAgentToAgent AGENT1 AGENT2 AGENT3) means that in in dealings with AGENT3,  AGENT1 represents AGENT2.  For example, if Joe Terwilliger is a salesman working for IBM, and is their sales rep to NASA, then we could represent that by asserting to Cyc  (#$representsAgentToAgent JoeTerwilliger IBM #$NASA)."))
)
(defrelation |requiredArg1Pred|
  :arity 2
  :domain |Collection|
  :range |Predicate|
  :annotations ( |RuleMacroPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$requiredArg1Pred COL PRED) means that for every instance INS of COL, there exists some X1..Xn-1 such that (PRED INS X1 .. Xn-1), where the #$arity of PRED is n."))
)
(defrelation |requiredArg2Pred|
  :arity 2
  :domain |Collection|
  :range |Predicate|
  :annotations ( |BinaryPredicate|
     |RuleMacroPredicate|
     (DOCUMENTATION "(#$requiredArg2Pred COL PRED) means that for every instance INS of COL, there exists some X1..Xn-1 such that (PRED X INS .. Xn-1), where the #$arity of PRED is n. "))
)
(defrelation |requiresForRole|
  :arity 3
  :domains (|Situation| |Collection|)
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$requiresForRole ?SIT ?COL ?ROLE) means that success of the #$Situation ?SIT depends upon the existence of an element of the collection ?COL playing the role ?ROLE in ?SIT."))
)
(defrelation |resemblesInAttribute|
  :arity 3
  :domains (|Thing| |Thing|)
  :range |AttributeType|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$resemblesInAttribute THING1 THING2 ATTRIBUTE) means that the two things THING1 and THING2 resemble each other in their values of the #$AttributeType ATTRIBUTE.  Here 'resembles' means has a 'close' or similar value in that attribute -- what this means, and what the standard of closeness or similarity is, depends on the context.  See also #$identicalInAttribute and #$differentInAttribute."))
)
(defrelation |residenceOfOrganization|
  :arity 2
  :domain |Organization|
  :range |GeographicalRegion|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$residenceOfOrganization indicates the geographical location of a particular organization's main offices.  (#$residenceOfOrganization ORG GEOGREG) means that the #$Organization ORG has its chief office at the location GEOGREG.  GEOGREG is typically a #$City but may be a larger or smaller #$GeographicalRegion.  For example, the #$residenceOfOrganization of the #$UnitedStatesFederalGovernment is the #$CityOfWashingtonDC."))
)
(defrelation |residesInDwelling|
  :arity 2
  :is-primitive |cotemporal|
  :domain (:AND |Person| |Animal|)
  :range (:AND |HumanResidence| |ShelterConstruction|)
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$residesInDwelling X SHELT) means the #$Person or #$Animal X resides or lives in the #$ShelterConstruction SHELT -- meaning the place where it sleeps, spends much of its time, lays its eggs, a place which it cleans and maintains and repairs, a place it defends against intrusion, etc.  A person or animal may reside in more than one dwelling.  For example, a person on a camping trip might #$residesInDwelling some tent, during that trip, and at the same time it would still be true that he or she #$residesInDwelling  their `normal' apartment or house.    See also #$occupantsAre and #$residesInRegion.  A couple other notes:

Note:  #$residesInDwelling is not the same as legal domicile, though often of course they coincide. 

Note:  #$residesInDwelling is not appropriate for one animal living in/on another, as a parasite or symbiote.  A more general predicate, #$objectFoundInLocation, would be the appropriate one to use for the case of a #$Flea living on a #$Dog."))
)
(defrelation |residesInRegion|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Animal|
  :range |GeographicalRegion|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$residesInRegion X REG) means the individual #$Animal or #$Person X lives or resides primarily in the #$GeographicalRegion REG.  Notice that everyone (every first argument X) is likely to have many different regions REG that make the assertion (#$residesInRegion X REG) true.  E.g., Karen resides in Austin, in Texas, in the United States, in North America, etc.  See also #$residesInDwelling."))
)
(defrelation |resistanceOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |ElectricalResistance|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$resistanceOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$ElectricalResistance.  A lower value of DEGREE indicates OBJ is a better conductor, i.e., one that conducts with less energy lost to heat."))
)
(defrelation |resistanceToBioDeterioration|
  :arity 2
  :domain |PartiallyTangible|
  :range |BioDeteriorationResistance|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$resistanceToBioDeterioration OBJ DEGREE) means that the tangible object OBJ has the indicated DEGREE of resistance to biological deterioration."))
)
(defrelation |resistanceToCorrosion|
  :arity 2
  :domain |PartiallyTangible|
  :range |CorrosionResistance|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$resistanceToCorrosion OBJ DEGREE) means that the tangible object OBJ has the stated DEGREE of #$CorrosionResistance.  The higher DEGREE is, the less readily OBJ will corrode."))
)
(defrelation |resistanceToRadiation|
  :arity 2
  :domain |PartiallyTangible|
  :range |RadiationResistance|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |TangibleObjectPredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$resistanceToRadiation OBJ DEGREE) indicates how resistant a tangible object OBJ is to radiation.  A higher DEGREE of resistance means that an object is less penetrable by #$ElectromagneticRadiation."))
)
(defrelation |responseTo|
  :arity 2
  :domain |Acknowledging-CommunicationAct|
  :range |PropositionalInformationThing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$responseTo ?ACT ?PIT) means that ?ACT is an acknowledging act to signify receipt of the abstract information ?PIT that is being acknowledged and to indicate a response.  The ?ACT may be an #$Accepting-CommunicationAct or a #$Rejecting-CommunicationAct, or several others.  Some may be combinations, e.g. David may accept part of #$Wanda's order (say the part about cleaning the kitchen) but not the other part (say cleaning the bathroom).  See also #$acknowledgedAct which relates the two acts directly."))
)
(defrelation |resultantMentalObjects|
  :arity 2
  :domain |Perceiving|
  :range |MentalObject|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$resultantMentalObjects PEVT PERCEPT) means that during the #$Perceiving event PEVT, the perceiver acquires the #$MentalObject PERCEPT (i.e., feeling some emotion, deducing some conclusion, observing some facts, etc.)"))
)
(defrelation |resultGenl|
  :arity 2
  :domain |CollectionDenotingFunction|
  :range |Collection|
  :annotations ( |RuleMacroPredicate|
     |FunctionalSlot|
     |BinaryPredicate|
     (DOCUMENTATION "The Cyc predicate #$resultGenl is used to specify that a certain collection is a superset of the value returned by a particular collection-denoting function.  (#$resultGenl CDF COL) means that when the #$CollectionDenotingFunction CDF is applied to its legal number and type of arguments, the result will be a subset of the #$Collection COL -- i.e., the #$genls of (CDF ARG1 [ARG2 ... ARGN]) will include COL.  Examples: (#$resultGenl #$UsingAFn #$Action), i.e., `every using of a [particular kind of] object is an action'; (#$resultGenl #$AttemptingFn #$PurposefulAction), i.e., `every attempt [at a specific action] is a purposeful act'; (#$resultGenl #$BachelorsDegreeInFn #$BachelorsDegree), i.e., `every bachelor's degree [in some subject] is a bachelor's degree'; (#$resultGenl #$JointTypeBetweenFn #$Connection), i.e., `every joint [between specific things] is a connection'.  See also #$resultIsa."))
)
(defrelation |resultIsa|
  :arity 2
  :domain |Relationship|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     |RuleMacroPredicate|
     (DOCUMENTATION "The Cyc predicate #$resultIsa is used to indicate that the value returned by a particular function is an element of a certain Cyc collection.  In other words, when FUNC is applied to its legal number of valid arguments in a non-atomic term, that resultant term is an element of the #$Collection COL; Thus, (#$resultIsa FUNC COL) means that applications of FUNC return elements of COL; i.e., (#$resultIsa FUNC COL) implies that (#$isa (FUNC ARG1 [ARG2 ... ARGN]) COL).  For example, since legal uses of #$PlusFn always return a quantity, (#$resultIsa #$PlusFn #$ScalarInterval) is asserted in Cyc.  Another example: because Cyc knows that (#$resultIsa #$GovernmentFn #$RegionalGovernment), Cyc concludes that the government of France is an element of #$RegionalGovernment; i.e., (#$isa (#$GovernmentFn #$France) #$RegionalGovernment).  See also #$resultGenl."))
)
(defrelation |RightRegionFn|
  :arity 2
  :domain |AnimalBodyRegion|
  :range |AnimalBodyRegion|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "The function (RightRegionFn REGOROBJ), applied to a region or object REGOROBJ, means the region consisting of the right half or flank or right main portion of REGOROBJ.  It applies only when REGOROBJ itself has an intrinsic left/right orientation, or is part of a larger region or object that has a left/right orientation."))
)
(defrelation |rightsGranted|
  :arity 2
  :domain |ChangeInUserRights|
  :range |UserRightsAttribute|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "This predicate is used to indicate what #$UserRightsAttributes are acquired in events which bring about a #$ChangeInUserRights.  (#$rightsGranted EVENT URA) means that in the #$ChangeInUserRights EVENT, the #$UserRightsAttribute URA is granted (to some agent).  For example, (#$rightsGranted ''LouisianaPurchase'' #$ExclusiveUserRights), since no country other than the USA could then claim it as one of their territories.   If EVENT is a #$Buying event, then almost always both (#$rightsGranted EVENT #$FullUseRights) and (#$rightsGranted EVENT #$ExclusiveUserRights) are true."))
)
(defrelation |rigidityOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |Rigidity|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "(#$rigidityOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$Rigidity.  A higher DEGREE of #$Rigidity means more force is required to change the shape of OBJ than for a lower DEGREE."))
)
(defrelation |rotationallyConnectedTo|
  :arity 2
  :is-primitive |connectedTo|
  :domain |SolidTangibleThing|
  :range |SolidTangibleThing|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$rotationallyConnectedTo OBJ1 OBJ2) means that OBJ1 and OBJ2 are connected in such a way that rotational motion, and only rotational motion, can happen between them.  The rotational motion may be fully or partially rotational.  Non-rotational movement between two rotationally connected objects at their connection point can occur only if the connection is broken, deformed, or disassembled.  Positive examples: Femurs are rotationally connected to hips, doors are rotationally connected to door frames, doorknobs are rotationally connected to doors, and propellers are rotationally connected to airplanes; in computer trackballs the ball is rotationally connected to the housing.  Negative examples: a planet orbiting around a star (they are not connected).  Cf. #$MovingInACircle."))
)
(defrelation |salientAssertions|
  :arity 2
  :domain |ReifiableTerm|
  :range |Assertion|
  :annotations ( |MetaKnowledgePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$salientAssertions ?TERM ?ASSERTION) means that some #$Cyclist has deemed it useful to mark ?ASSERTION as one of the assertions which is most useful to examine when trying to figure out the intended meaning of ?TERM.  Statements using #$salientAssertions are wholly intended for human consumption; they are not used by Cyc's inference engine in any way. "))
)
(defrelation |salutation|
  :arity 2
  :domain |Person|
  :range |CourtesyTitle|
  :annotations ( |IntangibleObjectPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(#$salutation PRSN TITLE) means the #$Person PRSN's name may have the #$CourtesyTitle TITLE attached to it, such as: Mr., Ms., Mrs., Miss, Dr., etc., when that person is addressed."))
)
(defrelation |satisfiesDescription|
  :arity 3
  :domains (|CycSystemList| |CycSystemList|)
  :range |Microtheory|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "ARG1 is a list of things (item1, item2, ...) which, taken together, satisfy the descriptions in the MT ARG3 of the roles listed in ARG2 (role1, role2, ...).  For example, we might see (#$satisfiesDescription (Joe Jane) (TheHusband TheWife) #$HumanSocialLifeMt)."))
)
(defrelation |satisfiesStandard|
  :arity 2
  :domain (:AND |FormalProductType| (:FILLED-BY SUPERRELATIONS |Product|))
  :range |ProductStandard|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$satisfiesStandard is used to identify a product standard that applies to a certain type of products.  (#$satisfiesStandard PRODTYPE STAND) means that every instance of the #$FormalProductType PRODTYPE satisfies the #$ProductStandard STAND.  STAND will contain a description of the desired physical form and/or function for the type of product (or service) denoted by PRODTYPE, and the instances of PRODTYPE fulfill those specifications.  See also #$ProductStandard."))
)
(defrelation |schooling|
  :arity 3
  :domains (|Person| |EducationalOrganization|)
  :range |StudentStatusAttribute|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$schooling PERSN SCHL LVL) means #$Person PERSN has attained formal schooling up to #$EducationLevelAttribute LVL at the #$EducationalOrganization SCHL.  This will refer to a particular #$subAbstrac of a #$Person, not the person as a whole lifetime #$Entity.  And of course the schooling itself generally occurs at but one of many #$timeSlices of the school."))
)
(defrelation |Second-UnitOfAngularMeasure|
  :annotations ( |UnitOfMeasureNoPrefix|
     |UnitOfAngularDistance|
     (DOCUMENTATION "A unit to measure the size of angles, in the Imperial system of measurement.  60 seconds = 1 minute (#$Minute-UnitOfAngularMeasure)"))
)
(defrelation |SecondFn|
  :arity 3
  :domains (|NonNegativeInteger| |CalendarMinute|)
  :range |CalendarSecond|
  :annotations ( |NonPredicateFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$SecondFn S MINUTE) denotes second number S of minute MINUTE.  For example, (#$SecondFn 59 (#$MinuteFn 12 (#$HourFn 18 (#$DayFn 14 (#$MonthFn #$February (#$YearFn 1966)))))) denotes 6:12:59pm Feb. 14th, 1966"))
)
(defrelation |SecondsDuration|
  :annotations ( |UnitOfTime|
     |CGSUnitOfMeasure|
     |UnitOfMeasureNoPrefix|
     |StandardUnitOfMeasure|
     |UnitOfMeasure|
     (DOCUMENTATION "Seconds are the standard unit of #$Time in Cyc.  Think of #$SecondsDuration as a function; it takes one or two numbers and returns, as its value, some amount of #$Time.   An expression of the form (#$SecondsDuration ?num) denotes a quantity of #$Time that is exactly ?num seconds long.  An expression of the form (#$SecondsDuration ?min ?max) denotes a quantity of #$Time that is at least ?min seconds at most ?max seconds long.
Note:  Cyc's ontology contains ways to specify nonuniform distributions (e.g., a normal distribution with a mean and standard deviation), but for most purposes this simple uniform specification of `a piece of time' has proven itself to be the most useful building block."))
)
(defrelation |sees|
  :arity 2
  :is-primitive |perceives|
  :domain |PerceptualAgent|
  :range (:AND |SpatialThing| |TemporalThing|)
  :annotations ( |PerceivingSlot|
     (DOCUMENTATION "(#$sees AGENT OBJ) means that the #$PerceptualAgent AGENT perceives at least some of the visual properties (color, shape, texture, etc) of the object(s) or event(s) OBJ."))
)
(defrelation |seller|
  :arity 2
  :is-primitive |exchangers|
  :domain |CommercialActivity|
  :range |Agent|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$seller relates an agent to a sales event.  (#$seller EVENT AGENT) means that the #$Agent AGENT sells something in the #$CommercialActivity EVENT."))
)
(defrelation |sellingAgent|
  :arity 2
  :is-primitive (:and |mediators| |sellingPerformer|)
  :domain |CommercialActivity|
  :range |LegalAgent|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |ActorSlot|
     |FunctionalSlot|
     (DOCUMENTATION "A selling agent acts on behalf of a would be seller to bring about a buying event involving his/her/its client as the seller. "))
)
(defrelation |sellingPerformer|
  :arity 2
  :is-primitive (:and |socialParticipants| |performedBy|)
  :domain |CommercialActivity|
  :range |LegalAgent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(sellingPerformer COM AGENT) means that the #$CommercialActivity COM is #$performedBy the #$Agent AGENT, who in that event actually pursues and attempts to make a sale.  AGENT may also be (and in many cases is) the #$seller of the goods or services sold, or s/he may be the #$sellingAgent representing the #$seller."))
)
(defrelation |sellsProductType|
  :arity 2
  :domain (:AND |InsuranceProvider| |MedicalCareOrganization|)
  :range |ProductType|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$sellsProductType identifies a particular seller of a specific product.  (#$sellsProductType AGT PRODTYPE) means that the individual #$Agent AGT sells the #$ProductType PRODTYPE.  For example, the Wendy's in the Texas Student Union sells hamburgers.  The implication is that AGT typically and often sells products of PRODTYPE, not just as a one-time sale."))
)
(defrelation |senderOfInfo|
  :arity 2
  :is-primitive (:and |deliberateActors| |doneBy| |informationOrigin|)
  :domain |InformationTransferEvent|
  :range |Agent|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     (DOCUMENTATION "The predicate #$senderOfInfo is used to indicate the sending agent in a particular transfer of information.  (#$senderOfInfo TRANSFER SENDER) means that SENDER is an agent who is the source of information transferred in the #$InformationTransferEvent TRANSFER.  At the time of TRANSFER (and typically for some period beforehand), SENDER conceives of the information transferred in TRANSFER.  It's not the case that SENDER necessarily #$knows the `information' or has it among his/her #$beliefs, because TRANSFER could involve lying; e.g., #$GeorgeWashington's telling his father, `I didn't chop down the cherry tree'.  SENDER normally performs TRANSFER intentionally, but some transfers may be unintentional; e.g., when one repeats some gossip unwittingly within earshot of the person being discussed, the transfer to the overhearer is unintentional.  See also #$infoTransferred."))
)
(defrelation |seniorExecutives|
  :arity 2
  :is-primitive (:and |cotemporal| |hasWorkers|)
  :domain |Organization|
  :range |Person|
  :annotations ( |AntiTransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$seniorExecutives is used to identify the upper-level managers in a particular organization.  (#$seniorExecutives ORG PERSON) means PERSON is an employee with a high executive position in the #$Organization ORG.  #$seniorExecutives relates an organization to the people who hold its principal corporate offices (#$CompanyPresident, etc.) and also positions like Chief of Staff, General, Admiral, Chief Corporate Counsel, Managing Partner, Chief Scientist, Chief Engineer, etc."))
)
(defrelation |sensoryResponse|
  :arity 4
  :domains (|PhysicalEvent| |ActorSlot| (:AND |SensoryReactionType| (:FILLED-BY SUPERRELATIONS |SensoryAttribute|)))
  :range |GenericAttribute|
  :annotations ( |FunctionalPredicate|
     |QuaternaryPredicate|
     (DOCUMENTATION "(#$sensoryResponse EVT ROLE SENSTYPE DEGREE) means that a #$PerceptualAgent who participates in the #$PhysicalEvent EVT in the manner ROLE has an immediate sensory reaction of the #$SensoryReactionType SENSTYPE with DEGREE of intensity. For example, Cyc's knowledge base contains a rule that says that if $E is a touching-something-very-cold event, then (#$sensoryResponse $E #$doneBy #$LevelOfDiscomfort #$Positive) --- i.e., that whoever does that touching action is likely to feel some discomfort. Note that #$sensoryResponse is one of the few predicates that are quaternary; i.e., that take four arguments."))
)
(defrelation |seriesLength|
  :arity 2
  :domain |Series|
  :range |PositiveInteger|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$seriesLength SER LEN) means that the series, SER, is LEN members long.  Note that some #$Series have an unknown or infinite number of members."))
)
(defrelation |seriesOrderedBy|
  :arity 2
  :domain |Series|
  :range |BinaryPredicate|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$seriesOrderedBy SER PRED) means that PRED is the relation that imposes an order on the members of SER.  Each member of the series stands in the relation PRED to the succeeding members of the series.  For example, if SER is a line of cars driving north, the ordering relation might be #$northOf (or ''aheadOf''). "))
)
(defrelation |seriesOrderedByInverse|
  :arity 2
  :domain |Series|
  :range |BinaryPredicate|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$seriesOrderedByInverse SER PRED) means that PRED is the relation that imposes an order on the members of SER.  Each member of the series stands in the relation PRED to the series members that come before it.  For example, if SER is a line of cars driving south, the ordering relation might be #$northOf (or ''behind'').  See also #$seriesOrderedBy."))
)
(defrelation |shape|
  :arity 2
  :domain |PartiallyTangible|
  :range (:AND |ShapeType| (:FILLED-BY SUPERRELATIONS |AbstractShape|))
  :annotations ( |ShapeDescribingPredicate|
     |PhysicalAttributeDescriptionSlot|
     (DOCUMENTATION "The predicate #$shape is used to indicate the type of geometrical shape that characterizes a particular object.  (#$shape OBJ SHAPETYPE) means that the tangible object OBJ has an overall geometrical shape of the kind SHAPETYPE.  For example, the #$shape of the Transamerica Building in San Francisco is a #$PyramidShape.  Other elements of #$ShapeType include #$Square, #$Circle, #$SphereShape, #$CylinderShape, etc."))
)
(defrelation |sharedNotes|
  :arity 2
  :domain (:AND |Thing| |CycIndexedTerm|)
  :range |SharedNote|
  :annotations ( |MetaKnowledgePredicate|
     |DistributingMetaKnowledgePredicate|
     |BinaryPredicate|
     (DOCUMENTATION "#$sharedNotes is a predicate belonging to the Cyc collection #$DocumentationConstant.  Often KB builders wish to repeat the same documentation in the #$comment of many constants.  Rather than actually duplicating text in the KB, it is possible to create a special constant to 'hold' the documentation; this constant will be an instance of #$SharedNote.  (#$sharedNotes X N) means that N is an element of #$SharedNote whose #$comment contains shared documentation about the constant X.  Since #$sharedNotes are usually shared, it is reasonable to expect other axioms, such as (sharedNotes Y N) and (sharedNotes Z N) to be in the KB as well."))
)
(defrelation |shareholders|
  :arity 2
  :domain |Organization|
  :range |Agent|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "The predicate #$shareholders identifies particular agents as owners of shares in a particular organization.  (#$shareholders ORG AGENT) means AGENT owns one or more shares of #$Stock in the company ORG and hence is an owner of the company and may receive dividends from the company.  #$shareholders indicates owners of a company's stock generically, whether they hold common or preferred shares.  Voting shareholders may vote (one vote per share) for the Board of Directors.  Shareholders do not normally participate in the operation of a company, and they are not personally liable for the debts of the company."))
)
(defrelation |shearStrengthOfObject|
  :arity 2
  :domain |PartiallyTangible|
  :range |ShearStrength|
  :annotations ( |IntervalBasedQuantitySlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "(#$shearStrengthOfObject OBJ DEGREE) means that the tangible object OBJ has a DEGREE amount of #$ShearStrength, i.e., resistance to shearing stress."))
)
(defrelation |sheetSurfaceConnected|
  :arity 2
  :is-primitive (:and |connectedTo| |touchesDirectly|)
  :domain |SheetOfSomeStuff|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |InterExistingObjectSlot|
     (DOCUMENTATION "(#$sheetSurfaceConnected MEMBRANE OBJ2) means that  MEMBRANE is connected all over most of one surface to a surface of OBJ2.  For example, a bi-layer membrane would have two parts #$sheetSurfaceConnected to each other.  Or, a membrane could be attached over most of its surface to an object's surface, as the #$VisceralPleura is attached to the surface of the #$Lung in the  body.  The membrane(s) may be flexible, but the surface connection is firm (i.e. no sliding can occur without a separation, tearing, or breaking occurring)."))
)
(defrelation |siblingDisjointExceptions|
  :arity 2
  :domain |Collection|
  :range |Collection|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$siblingDisjointExceptions is used to state exceptions to constraints normally imposed from #$SiblingDisjointCollection.  (#$siblingDisjointExceptions COL1 COL2) means that the relationship between the collections COL1 and COL2 is exempt from the disjointness constraint which would otherwise be imposed because COL1 and COL2 are both instances of some element of #$SiblingDisjointCollection.  (See #$SiblingDisjointCollection for a full explanation of the constraints.)   For example, #$Killing-Biological and #$PhysicallyAttackingAnAgent are both elements of #$DefaultDisjointScriptType, which in turn is an element of #$SiblingDisjointCollection.  The exception is useful in this case because it lifts the constraint that physically attacking and killing an agent must be disjoint from each other, while letting us continue to conclude that killing and attacking are each disjoint from many other kinds of actions.  By asserting (#$siblingDisjointExceptions #$Killing-Biological #$PhysicallyAttackingAnAgent), we block the disjointness constraint between those two collections, without disturbing the constraints between each of those collections and all the other instances of their parent (disjoint) collection, #$DefaultDisjointScriptType.  In other words, (#$siblingDisjointExceptions COL1 COL2) prevents COL1 and COL2 from being considered disjoint if they would otherwise be disjoint due to their being both instances of the same #$SiblingDisjointCollection."))
)
(defrelation |siblingOrganizations|
  :arity 2
  :domain |Organization|
  :range |Organization|
  :annotations ( |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "The predicate #$siblingOrganizations relates two organizations which are immediate #$subOrganizations of a common (unspecified) parent organization.  (#$siblingOrganizations ORG1 ORG2) means that the #$Organizations ORG1 and ORG2 are sister organizations within some hierarchically structured organization; ORG1 and ORG2 are at the same `level' from the top."))
)
)    ; END EVAL-WHEN 8

(eval-when #+:CLTL2 (:EXECUTE :LOAD-TOPLEVEL :COMPILE-TOPLEVEL)  ; EVAL-WHEN 9
          #-:CLTL2(LOAD EVAL COMPILE)
(defrelation |siblings|
  :arity 2
  :is-primitive (:and |biologicalRelatives| |positiveVestedInterest| |acquaintedWith|)
  :domain |Animal|
  :range |Animal|
  :annotations ( |FamilyRelationSlot|
     |SymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$siblings ANIM1 ANIM2) means that ANIM1 and ANIM2 are siblings.  Either they share one or more biological parents, or are siblings by adoption, marriage, or some other social arrangement.  Generally siblings are reasonably close in age (within 15 years or so) and have grown up together in the same family."))
)
(defrelation |simultaneousWith|
  :arity 2
  :is-primitive |cotemporal|
  :domain |TimePoint|
  :range |TimePoint|
  :annotations ( |PrimitiveTemporalRelation|
     |SymmetricBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$simultaneousWith ?X ?Y) means that #$TimePoints ?X and ?Y occur at exactly the same time. 
Note:  Individual #$TimePoints are seldom mentioned in axioms; rather, the axiom is likely to use some #$ComplexTemporalRelation, such as #$cotemporal or #$temporalBoundsIdentical, which holds between two #$TemporalThings.   These #$ComplexTemporalRelations are themselves usually defined in terms of #$PrimitiveTemporalRelations, such as #$after and #$simultaneousWith, which relate one #$TimePoint to another."))
)
(defrelation |singular|
  :arity 2
  :domain |EnglishWord|
  :range |CharacterString|
  :annotations ( |BinaryPredicate|
     |IntangibleObjectPredicate|
     (DOCUMENTATION "(#$singular WORD STRING) means that STRING is the singular noun form of WORD.  For example, the #$singular form of #$Hit-TheWord is `hit'."))
)
(defrelation |SituationFn|
  :arity 2
  :domain |CycFormula|
  :range (:AND |SituationType| (:FILLED-BY SUPERRELATIONS |Situation|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$SituationFn is a Cyc function, specifically a #$CollectionDenotingFunction.  (#$SituationFn FORM) denotes a collection of situations in which the #$CycFormula FORM is true.  FORM may contain variables.  For example, FORM might describe the general situation in which a letter is addressed to a person who has filed a mail forwarding order.  If FORM is true in a particular case, then that is a situation of the (#$SituationFn FORM) kind, and related axioms may indicate inferences or actions to take.  Every collection denoted by a #$SituationFn expression is an element of (#$isa) SituationType."))
)
(defrelation |skillCapableOf|
  :arity 3
  :domains (|Animal| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Situation|)))
  :range |Role|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "The predicate #$skillCapableOf indicates that an agent has the skill to take a certain role in a certain type of situation or event.  (#$skillCapableOf AGT SIT-TYPE ROLE) means that a particular #$Agent AGT has the necessary skills to act in this ROLE in normal instances of SIT-TYPE.  For example, to express that #$Gumby is capable of swimming, Cyc would say (#$skillCapableOf #$Gumby #$Swimming-Generic #$performedBy).  #$skillCapableOf entails that AGT has any anatomical and/or intellectual prerequisites for performing the skill; however, it is neutral as to whether AGT has the necessary resources of time, money, opportunity, etc., to use the skill in any particular situation of SIT-TYPE."))
)
(defrelation |skillLevel|
  :arity 5
  :domains (|SomethingExisting| (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Event|)) |ActorSlot|
            (:AND |ScriptPerformanceAttributeType| (:FILLED-BY SUPERRELATIONS |ScriptPerformanceAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuintaryPredicate|
     (DOCUMENTATION "This predicate relates performers to types of actions.  (#$skillLevel OBJ ACT-TYPE ROLE PERF-ATT LEVEL) means that the #$SomethingExisting OBJ has the ability to play the role ROLE in elements of the type of #$Event ACT-TYPE, with LEVEL degree of PERF-ATT.  For example, (#$skillLevel Joe #$DiggingAHole #$performedBy #$Agility #$High) means that, in general, Joe can dig holes with great agility.  To talk about actual performance in a particular action, use #$performanceLevel."))
)
(defrelation |skillRequired|
  :arity 4
  :domains ((:AND |ScriptType| (:FILLED-BY SUPERRELATIONS |AnimalActivity|))
            (:AND |ScriptType| (:FILLED-BY SUPERRELATIONS |AnimalActivity|))
            (:AND |ScriptPerformanceAttributeType| (:FILLED-BY SUPERRELATIONS |ScriptPerformanceAttribute|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     (DOCUMENTATION "(#$skillRequired ACT-TYPE OTHER-TYPE PERF-ATT LEVEL) means that if one is to successfully perform an instance of some kind of action (ACT-TYPE), then one must be capable of performing instances of another kind of action (OTHER-TYPE) with the performance attribute PERF-ATT at a level of at least LEVEL.  For example, (#$skillRequired PlayingVolleyball ServingAVolleyball #$Competence #$Low).  If you can't even serve a volleyball at a `Low' competence level, you're not so much `playing' volleyball as developing the skills to play it."))
)
(defrelation |skinColor|
  :arity 2
  :domain |Person|
  :range |Color|
  :annotations ( |PhysicalAttributeDescriptionSlot|
     |FunctionalSlot|
     (DOCUMENTATION "(#$skinColor PERSON SKINCOL) means #$Person PERSON has the #$HumanSkinColor SKINCOL."))
)
(defrelation |SkolemFuncNFn|
  :arity 4
  :domains (|CycSystemList| |CycSystemSymbol| |NonNegativeScalarInterval|)
  :range |Thing|
  :annotations ( |FunctionTheMathematicalType|)
)
(defrelation |SkolemFunctionFn|
  :arity 3
  :domains (|CycSystemList| |CycSystemSymbol|)
  :range |Thing|
  :annotations ( |FunctionTheMathematicalType|)
)
(defrelation |smells|
  :arity 2
  :is-primitive (:and |perceives| |cotemporal|)
  :domain |PerceptualAgent|
  :range (:AND |TemporalThing| |SpatialThing|)
  :annotations ( |CotemporalObjectsSlot|
     |PerceivingSlot|
     (DOCUMENTATION "(#$smells ?AGT ?OBJ) means that OBJ releases a scent (see #$Odor) which the #$PerceptualAgent ?AGT is able to perceive.  In the situation 'Joe smells the coffee burning' Cyc should know both (#$smells Joe Coffee01) and (#$smells Joe BurningOfCoffeeEvent01)."))
)
(defrelation |socialClass|
  :arity 2
  :domain |Person|
  :range |SocialClass-Lifestyle|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "(#$socialClass PRSN CLS) means that in the surrounding culture, the #$Person PRSN has the #$SocialClass-Lifestyle CLS.  As the name suggests, this predicate indicates PRSN's approximate social status as determined by his or her style of life -- quality of life, access to material goods and services, and social associations.  It may also depend on a cultural non-material system of social rank, based on birth, office, manners, vocal accent or other factors.  E.g., (#$socialClass #$DonaldTrump #$UpperClass) was true even when he lost his fortune and was (temporarily) bankrupt; and (#$socialClass #$BillGates #$UpperMiddleClass) was true, at least for a while, after he became a billionaire.  This is a good example of a predicate whose precise meaning, and associated heuristic rules, vary quite a bit from context to context, such as from country to country, from century to century, etc."))
)
(defrelation |socialParticipants|
  :arity 2
  :is-primitive |preActors|
  :domain |SocialOccurrence|
  :range |Agent|
  :annotations ( |AsymmetricBinaryPredicate|
     |ActorSlot|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$socialParticipants SO AGT) means that the #$Agent AGT participates --- in some social role --- in the #$SocialOccurrence SO.  In every culture there are many specializations of this #$ActorSlot; some #$SocialOccurrences have very elaborate role structures (e.g., a lawsuit in 1990's America), and some are fairly simple (e.g., rudely bumping into someone.)  See #$SocialOccurrence."))
)
(defrelation |socialStatus|
  :arity 4
  :domains (|Person| |SocialStatusAttributeType| (:AND |ExistingObjectType| (:FILLED-BY SUPERRELATIONS |Person|)))
  :range |GenericAttribute|
  :annotations ( |QuaternaryPredicate|
     |FunctionalPredicate|
     (DOCUMENTATION "(#$socialStatus PRSN STAT GROUP DEGREE) means that the #$Person PRSN has the social status type STAT (such qualities as #$Glamor, #$Credibility, etc.) at the generic strength level DEGREE (e.g., #$High, #$VeryLow, #$Low, etc.), according to the reference population group GROUP.  For example, in the context of 1980s America, it was true that (#$socialStatus #$Madonna #$Glamor #$HumanTeenager #$VeryHigh).  I.e., Madonna had a `high glamor' status among American teenagers in the 1980's."))
)
(defrelation |SolidFn|
  :arity 2
  :domain |TangibleStuffCompositionType|
  :range (:AND |TangibleStuffStateType| (:FILLED-BY SUPERRELATIONS |SolidTangibleThing|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "A #$CollectionDenotingFunction.  #$SolidFn takes as an argument a collection COL, membership in which is based only on physical and/or chemical composition and not on any other property (see #$TangibleStuffCompositionType).  (#$SolidFn COL) is the collection of elements of COL that are in the #$SolidStateOfMatter.  E.g., the ice cubes in my lemonade belong to the collection (#$SolidFn #$Water-Fresh)."))
)
(defrelation |solubleIn|
  :arity 2
  :domain |PartiallyTangible|
  :range |LiquidTangibleThing|
  :annotations ( |TangibleSubstancePredicate|
     |InterExistingObjectSlot|
     (DOCUMENTATION "(#$solubleIn SOLUTE SOLVENT) means that the piece of #$PartiallyTangible stuff SOLUTE will ordinarily dissolve if placed into the #$LiquidTangibleThing SOLVENT.  See also #$Solubility."))
)
(defrelation |solute|
  :arity 2
  :is-primitive (:and |constituents| |cotemporal|)
  :domain |Solution|
  :range |PartiallyTangible|
  :annotations ( |CompositionPredicate|
     |AntiTransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$solute indicates a particular #$TangibleThing in a #$Solution which is dissolved in the #$solvent of that #$Solution."))
)
(defrelation |solvent|
  :arity 2
  :is-primitive (:and |mainConstituent| |cotemporal|)
  :domain |Solution|
  :range |PartiallyTangible|
  :annotations ( |CompositionPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$solvent indicates a particular liquid in a #$Solution in which the #$solute is dissolved."))
)
(defrelation |spaceRegionPortals|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Interior|
  :range |Portal|
  :annotations ( |PhysicalPartPredicate|
     |BinaryPredicate|
     (DOCUMENTATION "(spaceRegionPortals REGION HOLE) means that HOLE is a #$Portal into the interior region REGION.  All the portals of this #$Interior space region are related to it by spaceRegionPortals."))
)
(defrelation |spatiallyIntersects|
  :arity 2
  :is-primitive |near|
  :domain |SpatialThing|
  :range |SpatialThing|
  :annotations ( |ReflexiveBinaryPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$spatiallyIntersects REGION1 REGION2) is true if and only if REGION1 and REGION2 share a common sub-region."))
)
(defrelation |spatiallyIntrinsicArg|
  :arity 2
  :domain |Predicate|
  :range |PositiveInteger|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$spatiallyIntrinsicArg PRED N) means that the Cyc predicate PRED expresses a property that is spatially intrinsic for its argument position N. That means, if a formula using PRED



is true for some object OBJ (in the Nth argument position), we can assume the truth of every similar formula in which any spatial part of OBJ is substituted in for OBJ. For



example, since (#$spatiallyIntrinsicArg #$temperatureOfObject 1) is true, if we know (#$temperatureOfObject `Coffee007' (#$DegreeCelsius 90)), we can expect that any spatial part of `Coffee007' will also have that temperature. An example of a property that is NOT spatially intrinsic is #$massOfObject; though a whole rock may weigh two pounds, there are spatial parts of the rock that don't.  Another example of a relation that is not spatially intrinsic, but might at first seem to be, is #$constituents.  In (#$constituents `ChocolateMilk37' `Milk36'), it is not the case that every spatial part of `ChocolateMilk37' has `Milk36' among its #$constituents.  #$constituents means, rather, that every part of its first argument has some part of the second argument among its components, but that is different from the intended meaning of #$spatiallyIntrinsicArg."))
)
(defrelation |spectators|
  :arity 2
  :is-primitive |preActors|
  :domain |Event|
  :range |Agent|
  :annotations ( |ActorSlot|
     |AsymmetricBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$spectators E AGT) means that in the #$Event E,  the #$Agent AGT is an onlooker of E but not actively acting in it in any other way.   AGT will observe all or part of E."))
)
(defrelation |speedOfObject-Translation|
  :arity 2
  :domain |PartiallyTangible|
  :range |Speed|
  :annotations ( |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$speedOfObject-Translation is used to give the speed with which an object is moving in a particular translational motion.  As you should remember from freshman physics, velocity has a speed and direction.  Speed is a scalar quantity, i.e., it has no direction, only magnitude.  Thus, `100 miles per hour straight up' is a velocity, and `100 miles per hour' is the corresponding speed."))
)
(defrelation |SphereFn|
  :arity 2
  :domain |Distance|
  :range (:AND |AbstractShape| |ThreeDimensionalShape|)
  :annotations ( |ShapeFunction|
     (DOCUMENTATION "The Cyc function #$SphereFn is a #$ShapeFunction (q.v.).  (#$SphereFn D) returns an abstract #$SphereShape which has diameter D.  Examples: the #$shape of a 2-inch rubber ball is #$SphereShape; the ball #$fitsIn the shape denoted by (#$SphereFn (#$Inch 2)). The #$shape of #$PlanetEarth is also #$SphereShape; Earth #$fitsIn the shape denoted by (#$SphereFn (#$Mile 8000))."))
)
(defrelation |spouse|
  :arity 2
  :is-primitive (:and |cohabitingFamilyMembers| |mate| |loves|)
  :domain |Person|
  :range |Person|
  :annotations ( |FamilyRelationSlot|
     |InterActorSlot|
     |SymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(#$spouse PERSON1 PERSON2) means the two #$Persons PERSON1 and PERSON2 are married.  
Note: in some contexts (cultures), a person is not restricted to having only one cotemporal spouse."))
)
(defrelation |SqrtFn|
  :arity 2
  :domain |RealNumber|
  :range |RealNumber|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$SqrtFn is the unary mathematical function that returns the square root of its argument; e.g., (#$SqrtFn 4) returns 2."))
)
(defrelation |SquaredFn|
  :arity 2
  :domain |RealNumber|
  :range |RealNumber|
  :annotations ( |FunctionFromQuantitiesToQuantities|
     (DOCUMENTATION "#$SquaredFn is the unary mathematical function that returns the square of the real number taken as its argument; e.g., (#$SquaredFn 9) returns 81."))
)
(defrelation |SquareMile|
  :annotations ( |UnitOfMeasureNoPrefix|
     |FPSUnitOfMeasure|
     |UnitOfArea|
     (DOCUMENTATION "The measurement function used in Cyc to represent the square mile used as a unit of measure for area, within the British (FPS) system.  See also #$FPSUnitOfMeasure, #$UnitOfMeasure."))
)
(defrelation |StartFn|
  :arity 2
  :domain |TemporalThing|
  :range |TimePoint|
  :annotations ( |IndividualDenotingFunction|
     |ReifiableFunction|
     (DOCUMENTATION "#$StartFn is a function that takes a #$TemporalThing and returns the #$TimePoint it began.  Thus:  (#$startingPoint ?X (#$StartFn ?X))"))
)
(defrelation |startingDate|
  :arity 2
  :is-primitive |startsDuring|
  :domain |TemporalThing|
  :range |Date|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$startingDate ?X ?Y) indicates that ?Y is a #$Date such that (#$temporallySubsumes ?Y (#$StartFn ?X)). This is NOT the same as #$startingPoint (qv).  Rather, it means that ?X happened (started to happen, came into existence, etc.) sometime on that date.
Note:  the date is tied to a time interval on a calendar, but need not be a particular day; it might be a particular calendar month, a particular calendar year, etc."))
)
(defrelation |startingPoint|
  :arity 2
  :domain |TemporalThing|
  :range |TimePoint|
  :annotations ( |TemporalRelation|
     (DOCUMENTATION "(#$startingPoint ?X ?T) indicates that ?T is the #$TimePoint at which ?X begins, the earliest moment of its temporal extent."))
)
(defrelation |startsAfterEndingOf|
  :arity 2
  :is-primitive (:and |temporallyDisjoint| |endsAfterEndingOf| |startsAfterStartingOf|)
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |IrreflexiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ComplexTemporalRelation|
     (DOCUMENTATION "(#$startsAfterEndingOf AFTER BEFORE) means (#$after (#$StartFn AFTER) (#$EndFn BEFORE)).   That is, the #$startingPoint of AFTER is later than the #$endingPoint of BEFORE.



Note:  Cyc's #$startsAfterEndingOf relation is equivalent to what James Allen independently dubbed the AFTER relation."))
)
(defrelation |startsAfterStartingOf|
  :arity 2
  :is-primitive |endsAfterStartingOf|
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |ComplexTemporalRelation|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$startsAfterStartingOf X Y) means (#$after (#$StartFn X) (#$StartFn Y)).  That is, the #$startingPoint of X is later than the #$startingPoint of Y.  This implies nothing about whether X and Y overlap, or how much they overlap, except that they can't be fully #$cotemporal."))
)
(defrelation |startsDuring|
  :arity 2
  :is-primitive (:and |temporalBoundsIntersect| |startsAfterStartingOf|)
  :domain |TemporalThing|
  :range |TemporalThing|
  :annotations ( |AsymmetricBinaryPredicate|
     |ComplexTemporalRelation|
     |IrreflexiveBinaryPredicate|
     (DOCUMENTATION "(#$startsDuring ?X ?Y) means ?Y covers the start of ?X, i.e. the #$startingPoint of ?X is properly contained (#$temporalBoundsContain) within ?Y.  Note that ?X and ?Y do not necessarily intersect in time, however, they would if ?Y were #$temporallyContinuous."))
)
(defrelation |startsRelativeToEndOf|
  :arity 3
  :domains (|TemporalThing| |Time-Quantity|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION " (#$startsRelativeToEndOf ?X ?D ?Y) means that the ?X starts duration ?D after ?Y ends.  That is, the #$startingPoint of ?X is after the #$endingPoint of ?Y, by an amount of time ?D."))
)
(defrelation |startsRelativeToStartOf|
  :arity 3
  :domains (|TemporalThing| |Time-Quantity|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION " (#$startsRelativeToStartOf ?X ?D ?Y) means that ?X starts duration ?D after ?Y starts.  That is, the #$startingPoint of ?X is after the #$startingPoint of ?Y, by an amount of time ?D."))
)
(defrelation |stateOfAddress|
  :arity 2
  :is-primitive |objectFoundInLocation|
  :domain |ContactLocation|
  :range |CountrySubsidiary|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "(#$stateOfAddress LOC STATE) means that the #$ContactLocation LOC is located in STATE.  Note that STATE may be an element of #$State-Geopolitical (q.v.), or it may belong to some other kind of #$CountrySubsidiary.  For example, #$Cycorp's #$stateOfAddress is #$Texas-State.  See also #$ContactLocation."))
)
(defrelation |stateOfDevice|
  :arity 2
  :is-primitive |hasAttributes|
  :domain |PhysicalDevice|
  :range |DeviceState|
  :annotations ( |FunctionalSlot|
     |TangibleObjectPredicate|
     (DOCUMENTATION "This predicate is used to identify the state of operation that a particular device is in.  (#$stateOfDevice DEV STATE) means that the #$PhysicalDevice DEV is in the #$DeviceState STATE.  Thus, (#$stateOfDevice HAL #$DeviceOff) says that the computer HAL is switched off."))
)
(defrelation |stateOfMatter|
  :arity 2
  :domain |PartiallyTangible|
  :range |StateOfMatter-SolidLiquidGaseous|
  :annotations ( |TangibleSubstancePredicate|
     |IntervalBasedQuantitySlot|
     (DOCUMENTATION "The predicate #$stateOfMatter is used to indicate the physical state of a tangible thing.  (#$stateOfMatter SUBST STATE) means that the tangible substance SUBST is in the physical state STATE.  STATE is an element of #$StateOfMatter-SolidLiquidGaseous (solid, semi-solid, liquid, or gaseous)."))
)
(defrelation Stib
  :arity 2
  :domain |TemporalThing|
  :range |TimeInterval|
  :annotations ( |ReifiableFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$STIB ?X) returns the `Short Time Interval Before' ?X.  The function #$STIB is used to state axioms which assert propositions about the world just before some #$TemporalThing.  E.g., just before some event begins, or just before some tangible object comes into being.  Whether the propositions hold beyond the bounds of the short interval specified depends the nature of the proposition.  Consider the axiom `before launching, the Space Shuttle's fuel tanks are full'. The fuel tanks are only known to be full immediately before the launching event, and for some (measurable but potentially short) time interval before that launch, and so we use #$STIB to specify the time interval in which the assertion of fullness will hold.  Before or after that time, additional axioms are required to conclude whether the tanks are full or not.  Also see:  #$STIF."))
)
(defrelation Stif
  :arity 2
  :domain |TemporalThing|
  :range |TimeInterval|
  :annotations ( |ReifiableFunction|
     |IndividualDenotingFunction|
     (DOCUMENTATION "(#$STIF ?X) returns the `Short Time Interval Following' ?X.  The function #$STIF is used to state axioms which assert propositions about the world just after some #$TemporalThing (i.e., after an event ends, after a tangible object ceases to exist, etc.).  Each of those propositions may or may not hold beyond the bounds of that short interval.  Consider the axiom `after swimming, the swimmer is wet'. The swimmer is only known to be wet for a short time interval immediately following the swimming event, and so we use #$STIF to specify that short time interval in which the assertion of wetness will hold.  Beyond that time, additional axioms would be required to decide whether the wetness would persist or not.  Also see: #$STIB."))
)
(defrelation |StockInFn|
  :arity 2
  :domain |LegalCorporation|
  :range (:AND |Collection| (:FILLED-BY SUPERRELATIONS |Stock|))
  :annotations ( |CollectionDenotingFunction|
     (DOCUMENTATION "#$StockInFn is a Cyc function, specifically a #$CollectionDenotingFunction. It is used to represent a collection of stock in a particular company.  (#$StockInFn COMPANY) applied to a #$LegalCorporation COMPANY returns the collection of all shares of #$Stock in that corporation."))
)
(defrelation |streetAddressText|
  :arity 2
  :domain |ContactLocation|
  :range |StreetAddress|
  :annotations ( |FunctionalSlot|
     (DOCUMENTATION "The predicate #$streetAddressText maps from a particular place to a string representing its street address.  (#$streetAddressText LOC STREET) means that LOC is found at the number and street given in the string STREET.  See also #$ContactLocation."))
)
(defrelation |structureMemberIsa|
  :arity 2
  :domain |Situation|
  :range |Collection|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$structureMemberIsa SIT COL) means that each of the #$structureMembers of the situation SIT is an element of the collection COL."))
)
(defrelation |structureMembers|
  :arity 2
  :is-primitive |parts|
  :domain |Situation|
  :range |Thing|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "#$structureMembers is a very general predicate, encompassing all the ways a #$Situation's structure can be composed out of parts.  In (#$structureMembers WHOL PRT), PRT could be a member of a #$Group or #$Series (if WHOL is a #$Group or #$Series), the #$subEvents of an #$Event (if WHOL is an #$Event), and so on."))
)
(defrelation |stuckTo|
  :arity 2
  :is-primitive |connectedTo-Rigidly|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |ConnectionPredicate|
     |SymmetricBinaryPredicate|
     (DOCUMENTATION "(#$stuckTo OBJ1 OBJ2) means that OBJ1 and OBJ2 are held together by an adhesive force that is at least strong enough to support the whole weight of (the lighter of) OBJ1 or OBJ2.  Either OBJ1 or OBJ2 must be `sticky' or have a sticky surface; e.g., duct tape, honey, chewing gum, and perhaps magnetism.  #$stuckTo may represent a weak form of connection, one that may be separated by manual force.







Note: If a third object (such as glue) supplies the adhesive force holding OBJ1 and OBJ2 together, or if OBJ1 or OBJ2 were acted on non-trivially (e.g., welding, not simply contact or pressure), then see #$bondedTo and its specializations."))
)
(defrelation |stuffUsed|
  :arity 2
  :is-primitive |instrument-Generic|
  :domain |Event|
  :range |PartiallyTangible|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$stuffUsed relates an event to some tangible substance which facilitates that event.  (#$stuffUsed EVENT STUFF) means that STUFF is a portion of an element of #$ExistingStuffType which plays an instrumental role in EVENT.  STUFF may or may not be consumed in the course of EVENT.  Examples: portions of #$Water are #$stuffUsed in instances of #$WashingDishes, #$WashingHair, #$WashingClothesInAMachine, etc.; portions of #$EdibleOil are #$stuffUsed in some instances of #$Frying food and #$BakingBread."))
)
(defrelation |subAbsOfEntityAfter|
  :arity 3
  :domains (|Entity| |SomethingExisting|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$subAbsOfEntityAfter ?X ?Y ?Z) indicates that ?X is an #$Entity,  ?Y is some subabstraction of ?X, and (#$contiguousAfter ?Y ?Z).  This provides one way to talk about the effects wrought by some state-changing process.  For example, for Washing001 involving Hair001, (#$subAbsOfEntityAfter Hair001 ?SUB Washing001) would imply that ?SUB is Wet.  Usually the preferred alternative is to use the #$holdsIn representation: (#$holdsIn (#$STIF Washing001) 'Hair001 is Wet')."))
)
(defrelation |subAbsOfEntityBefore|
  :arity 3
  :domains (|Entity| |SomethingExisting|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$subAbsOfEntityBefore ?X ?Y ?Z) indicates that ?X is an #$Entity,  ?Y is some subabstraction of ?X, and (#$contiguousAfter ?Z ?Y). This provides one way to talk about pre-conditions for some state-changing process.  For example, 'Egg001 was raw before being scrambled' -- if (#$subAbsOfEntityBefore Egg001 ?SUB Scrambling001), then ?SUB is raw.  Usually the preferred alternative is to use the #$holdsIn representation: (#$holdsIn (#$STIB Scrambling001) 'Egg001 is raw')."))
)
(defrelation |subAbsOfEntityDuring|
  :arity 3
  :domains (|Entity| |SomethingExisting|)
  :range |TemporalThing|
  :annotations ( |TernaryPredicate|
     (DOCUMENTATION "(#$subAbsOfEntityDuring ENTITY SUB TEMP) -- SUB is a #$subAbstrac (a time-slice) of the #$Entity ENTITY, and SUB is cotemporal with the #$TemporalThing TEMP.  For example, (#$subAbsOfEntityDuring Karen KarenDuring1992 #$TheYear1992)."))
)
(defrelation |subAbstrac|
  :arity 2
  :is-primitive (:and |parts| |temporallySubsumes| |timeSlices|)
  :domain |SomethingExisting|
  :range |SomethingExisting|
  :annotations ( |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |TemporalPartSlot|
     (DOCUMENTATION "(#$subAbstrac WHOLE SUB) means SUB is a temporal part 
(one of the #$timeSlices) of WHOLE, where WHOLE and SUB are both elements of 
#$SomethingExisting.  Both entities and subabstractions are subabstactions of 
themselves.  So the predicate #$subAbstrac is the restriction of the predicate 
#$timeSlices to the domain, and hence also range, #$SomethingExisting.  
`AlbertEinsteinWhileAtPrinceton' is a #$subAbstrac of `AlbertEinsteinAsAnAdult',
 which in turn is a #$subAbstrac of 'AlbertEinstein', which in turn is a 
#$subAbstrac only of itself (hence 'AlbertEinstein' is an element of 
#$Entity (q.v.))."))
)
(defrelation |subAgreements|
  :arity 2
  :domain |Agreement|
  :range |Agreement|
  :annotations ( |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "The predicate #$subAgreements relates a particular agreement to the subordinate agreements it comprises.  (#$subAgreements AGR SUB) means that both AGR and SUB are elements of #$Agreement, and AGR has SUB as a sub-part."))
)
(defrelation |subBeliefSystem|
  :arity 2
  :domain |BeliefSystem|
  :range |BeliefSystem|
  :annotations ( |TaxonomicSlot|
     |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$subBeliefSystem SYS SUB) indicates that SUB is a more specialized `branch' of belief system BSYS.  Thus the #$beliefStatements of SUB will be a superset of the #$beliefStatements of BSYS (sometimes with a few changes and deletions.)  Some examples of this are:  (#$subBeliefSystem #$Islam #$ShiiteIslam), (#$subBeliefSystem #$ProtestantReligion #$PresbyterianReligion), and (#$subBeliefSystem #$MilesianSchoolBeliefs #$AnaximandersPhilosophy)."))
)
(defrelation |subEvents|
  :arity 2
  :is-primitive (:and |parts| |temporallySubsumes|)
  :domain |Event|
  :range |Event|
  :annotations ( |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     |SubProcessSlot|
     |ComplexTemporalRelation|
     (DOCUMENTATION "(#$subEvents WHOLE PART) means that the event PART is a meaningful part of the event WHOLE.  So both WHOLE and PART are elements of #$Event.  The predicate #$subEvents can be used to decompose events in time, in space, and/or in other ways.  Following a recipe often has this property:  the task is broken down into several sub-tasks, some of which happen before others, and some of which happen simultaneously but involve different ingredients.  One could also decompose `making dinner' into #$subEvents according to how dangerous they are, which might be useful if one had kids of various ages helping.  Often, a more specialized relation than #$subEvents can be used; e.g., if you have subevents that decompose an action in time only, then the more specialized predicate #$subProcesses should be used."))
)
(defrelation |subGoals|
  :arity 2
  :domain |Goal|
  :range |Goal|
  :annotations ( |TaxonomicSlot|
     |AsymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$subGoals G SUB) means that SUB is a subordinate goal of G.  In other words, SUB is an intermediate objective or milestone to be accomplished in the course of pursuing the overall #$Goal G."))
)
(defrelation |subGroups|
  :arity 2
  :is-primitive |cotemporal|
  :domain |Group|
  :range |Group|
  :annotations ( |PartPredicate|
     |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$subGroups is used to relate a particular group to its subgroups.  (#$subGroups GROUP SUB) means that (1) GROUP includes all the #$groupMembers of SUB, and (2) SUB and GROUP co-exist as groups.  Examples: the stars in the constellation Big Dipper constitute a group which is one of the #$subGroups of the Milky Way galaxy; Democrats in the House of Representatives in 1997 are a subgroup of the group of U.S. House Members for that year."))
)
(defrelation |subOrganizations|
  :arity 2
  :is-primitive (:and |subGroups| |affiliatedWith|)
  :domain |Organization|
  :range |Organization|
  :annotations ( |TransitiveBinaryPredicate|
     |IrreflexiveBinaryPredicate|
     |NonPhysicalPartPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$subOrganizations relates a particular organization to
one of its sub-organizations. (#$subOrganizations ORG1 ORG2) means ORG2 is a
 sub-organization of ORG1, whether it is at the very next organizational level
down, e.g., (#$subOrganizations NationalLeague-Baseball NationalLeagueEast-Baseball),
or several levels down the heirarchy, e.g., (#$subOrganizations NationalLeague-Baseball NewYorkMets)."))
)
(defrelation |SubPathBetweenFn|
  :arity 4
  :domains (|Path-Simple| |Thing| |Thing|)
  :range |Path-Simple|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "Given a path PATH and different points X and Y on it, (#$SubPathBetweenFn PATH X Y) gives a unique subpath SUB of PATH that is between X and Y.  This function should not be used without the context of a #$PathSystem because only with the reference to a path system can we be certain about the existence of such a subpath (e.g., Austin and Texas are different points on I-35, but there is no subpath of I35 that is between Austin and Texas).  To put this in another way, let SYS be any path system.  If PATH is a path in SYS and X and Y are different points in SYS and are also points on PATH, (#$SubPathBetweenFn PATH X Y) is the only subpath (in SYS) of PATH that is between X and Y.  See #$pathInSystem.  Note that this function is not defined on the cartesian product #$Path-Simple x #$Thing x #$Thing, but on a proper subset of it."))
)
(defrelation |subPaths|
  :arity 2
  :is-primitive (:and |subPaths-Generic| |cotemporal|)
  :domain |Path-Simple|
  :range |Path-Simple|
  :annotations ( |ReflexiveBinaryPredicate|
     |CotemporalObjectsSlot|
     |AntiSymmetricBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "Provided PATH1 and PATH2 are instances of #$Path-Simple, (#$subPaths PATH1 PATH2) means that PATH2 is a sub-path of PATH1, and that any 'point' on PATH2 must also be on PATH1."))
)
(defrelation |subPaths-Generic|
  :arity 2
  :is-primitive (:and |cotemporal| |physicalParts|)
  :domain |Path-Generic|
  :range |Path-Generic|
  :annotations ( |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |PhysicalPartPredicate|
     |SpatialPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "If PATH1 and PATH2 are instances of #$Path-Generic, which includes #$Path-Simple and #$Path-Cyclic, then (#$subPaths-Generic PATH1 PATH2) means that PATH2 is a sub-path of PATH1, and that any object #$onPath PATH2 must also be #$onPath PATH1.  See also #$subPaths which does not apply to #$Path-Cyclic, just to #$Path-Simple."))
)
(defrelation |subPathSystems|
  :arity 2
  :domain |Thing|
  :range |Thing|
  :annotations ( |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     (DOCUMENTATION "(#$subPathSystems SYS SUBSYS) means that the path system SUBSYS is a subsystem of the path system SYS.  Technically, this means the following: (i) Every point in SUBSYS is a point in SYS, (ii) every node in SUBSYS is a node in SYS, (iii) every link in SUBSYS is a link in SYS, and (iv) every loop in SUBSYS is a loop in SYS.  Some consequences of these conditions are as follows.  (a) Every point in SUBSYS that is a node in SYS is a node in SUBSYS.  (b) For any nodes X and Y in SUBSYS and each link LINK in SUBSYS, LINK is between X and Y in SYS iff it is between X and Y in SUBSYS.  (c) For each point X in SYS that is not a node in SYS, if X is on a link in SYS that is not in SUBSYS, X is not in SUBSYS.  (d) Isolated points and deadends in SUBSYS must be nodes in SYS.  (e) For each loop LOOP in SUBSYS, the only node in SYS on LOOP must be a node in SUBSYS.  (f) If SYS is a #$SimpleGraph-GraphTheoretic (or a #$MultiGraph), all subsystems of SYS are #$SimpleGraph-GraphTheoretics (or #$MultiGraphs).  Predicates concerning particular kinds of subsystems of path systems, i.e., predicates that take #$subPathSystems as #$genlPreds, include #$linkClosedSubSystems, #$pointClosedSubSystems, #$maximalConnectedSubSystems, #$reductionOfPathSystems, etc."))
)
(defrelation |subSeries|
  :arity 2
  :domain |Series|
  :range |Series|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(#$subSeries SER1 SER2) means that SER2 is a sub-series of SER1.  This means that all the members of SER2 are members of SER1, that SER1 and SER2 share the same ordering principle, and that, if the first member of SER2 is the Mth member of SER1, the Nth member of SER2 is the (N + M - 1)th member of SER1.  So a subseries is an uninterrupted ''slice'' of the whole."))
)
(defrelation |subsetOf|
  :arity 2
  :domain |SetOrCollection|
  :range |SetOrCollection|
  :annotations ( |ReflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$subsetOf SUB SUPER) means that every element of the mathematical set or collection SUB is an element of the mathematical set or collection SUPER."))
)
(defrelation |subsumedByIntervalType|
  :arity 2
  :domain |TemporalThing|
  :range |TemporalObjectType|
  :annotations ( |BinaryPredicate|
     |IntensionalRepresentationPredicate|
     (DOCUMENTATION "(#$subsumedByIntervalType ?X ?Y) means that a time interval of type ?Y (i.e., something which #$isa ?Y) #$temporallySubsumes ?X.  For example, (#$subsumedByIntervalType FredsBirth #$Wednesday) means that Fred was born on a Wednesday.  As another example, Cyc contains an axiom which says, in a typical modern service-providing context, that each instance of #$HairCuttingEvent is #$subsumedByIntervalType #$DaytimeWorkingHours -- i.e., it is true as a default that the typical professional haircut is given during normal daytime working hours."))
)
(defrelation |subsumesIntervalType|
  :arity 2
  :is-primitive |intersectsIntervalType|
  :domain |TemporalObjectType|
  :range |TemporalObjectType|
  :annotations ( |TransitiveBinaryPredicate|
     |ReflexiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |TemporalRelation|
     (DOCUMENTATION "(#$subsumesIntervalType X Y) indicates that every instance of X #$temporallySubsumes some instance of Y.  For example, one of Cyc's axioms states that in the #$NorthernHemisphereMt (the context in which the location is assumed to be somewhere north of the equator) it is true that (#$subsumesIntervalType #$CalendarWinter #$January).  That is, in that micro-theory, each Winter contains a January.  In the base KB -- that is, independent of context -- it is true that (#$subsumesIntervalType #$CalendarQuarter #$CalendarMonth), which means that every calendar quarter contains at least one entire calendar month."))
)
(defrelation |successfulForAgents|
  :arity 2
  :is-primitive |performedBy|
  :domain |PurposefulAction|
  :range |Agent|
  :annotations ( |ActorSlot|
     (DOCUMENTATION "The predicate #$successfulForAgents is used to indicate that a particular agent achieves its goal in a particular action.  (#$successfulForAgents ENDEAVOR AGT) means that the #$Agent AGT is successful in accomplishing the #$PurposefulAction ENDEAVOR.  This means that each of the purposes AGT had in doing ENDEAVOR has come true.  See also #$purposeInEvent."))
)
(defrelation |succession-RST|
  :arity 2
  :domain |LinguisticObject|
  :range |LinguisticObject|
  :annotations ( |RSTRelation|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "The discourse relation that holds between two segments of text when they describe events which are related to one another by succession."))
)
(defrelation |SuccessorFn|
  :arity 2
  :domain |Integer|
  :range |Integer|
  :annotations ( |NonPredicateFunction|
     (DOCUMENTATION "(#$SuccessorFn ?N) denotes the next #$Integer after ?N.  This is somewhat broader than the ordinary ''successor'' function on natural numbers, since #$SuccessorFn applies to all #$Integers."))
)
(defrelation |superTaxons|
  :arity 2
  :is-primitive |genls|
  :domain |BiologicalTaxon|
  :range |BiologicalTaxon|
  :annotations ( |TransitiveBinaryPredicate|
     |AsymmetricBinaryPredicate|
     |NonPhysicalPartPredicate|
     (DOCUMENTATION "The predicate #$superTaxons is used to relate elements of #$BiologicalTaxon.  (#$superTaxons TAXON  GEN-TAXON) means that GEN-TAXON is a #$BiologicalTaxon above (i.e., more general and inclusive than) the more specific #$BiologicalTaxon TAXON.  Every instance of TAXON must therefore also be an instance of GEN-TAXON; the same holds for the #$taxonMembers relation.  Example: (#$superTaxons #$DomesticCat #$FelisGenus).  See also #$taxonMembers."))
)
(defrelation |suppliers|
  :arity 2
  :is-primitive (:and |doesBusinessWith| |cotemporal|)
  :domain |Organization|
  :range |Agent|
  :annotations ( |CotemporalObjectsSlot|
     (DOCUMENTATION "The predicate #$suppliers represents a relationship between an organization and an agent.  (#$suppliers ORG AGT) means that the #$Agent AGT supplies some goods or services to the #$Organization ORG on an ongoing basis, usually for payment."))
)
(defrelation |supportedBy|
  :arity 2
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |IrreflexiveBinaryPredicate|
     |TransitiveBinaryPredicate|
     (DOCUMENTATION "(#$supportedBy OBJECT SUPPORTER) means that SUPPORTER is at least partially responsible for OBJECT maintaining its current position.  If OBJECT were not #$supportedBy this supporter, it would fall."))
)
(defrelation |surfaceAttributeOfSurf|
  :arity 2
  :domain |Surface-Physical|
  :range |AttributeValue|
  :annotations ( |BinaryPredicate|
     (DOCUMENTATION "(surfaceAttributeOfSurf SURF SURFATT) means that the particular individual #$Surface-Physical SURF has the #$SurfaceAttribute SURFATT over most or all of its area.  It may have more than one such surface attribute."))
)
(defrelation |surfaceParts|
  :arity 2
  :is-primitive |externalParts|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |TransitiveBinaryPredicate|
     |AntiSymmetricBinaryPredicate|
     |PhysicalPartPredicate|
     (DOCUMENTATION "(#$surfaceParts BIG LITTLE) means that LITTLE is a physical part of a surface of BIG, or that LITTLE is a physical part of BIG itself and a surface of LITTLE is part of a surface of BIG.  Positive exemplars: the skin of an orange is a #$surfaceParts of the orange, #$Texas-State is a #$surfaceParts of #$UnitedStatesOfAmerica, a window of a house is a #$surfaceParts of that house.  Borderline positive exemplars: the inside surface of a coffee cup is one of the #$surfaceParts of the cup; the inside surface of a beer-can in some contexts is a #surfaceParts of the can.  Negative exemplars:  the brain is not a #$surfaceParts of a person."))
)
(defrelation |surroundsCompletely|
  :arity 2
  :is-primitive |surroundsHorizontally|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |TransitiveBinaryPredicate|
     |SpatialPredicate|
     |AsymmetricBinaryPredicate|
     (DOCUMENTATION "(#$surroundsCompletely OUTSIDE INSIDE) means that OUTSIDE completely surrounds INSIDE.  In other words, all rays with origins at INSIDE pass through OUTSIDE by default (with some exceptions).  OUTSIDE is not a part of INSIDE (or vice versa).  Examples: a candy bar inside its wrapper; the body of a pregnant mammalian female containing a foetus; a fish in water."))
)
(defrelation |surroundsHorizontally|
  :arity 2
  :is-primitive |cotemporal|
  :domain |PartiallyTangible|
  :range |PartiallyTangible|
  :annotations ( |SpatialPredicate|
     |AsymmetricBinaryPredicate|
     |CotemporalObjectsSlot|
     (DOCUMENTATION "(#$surroundsHorizontally OUTSIDE INSIDE) means that OUTSIDE surrounds a horizontal slice of INSIDE.  That is, there is some horizontal cross section of INSIDE such that all rays drawn horizontally from points in that cross section pass through OUTSIDE, and along each of those rays there are points which are in OUTSIDE and beyond all points of INSIDE.  Thus, (#$surroundsHorizontally OUTSIDE INSIDE) is NOT true if INSIDE shares a boundary with OUTSIDE; e.g., Texas is not surrounded by the USA.  Positive cases: water surrounds islands; foothills may surround a mountain range.  See also #$surroundsCompletely."))
)
(defrelation |suspendedIn|
  :arity 2
  :is-primitive |in-ImmersedFully|
  :domain |PartiallyTangible|
  :range |FluidTangibleThing|
  :annotations ( |SpatialPredicate|
     |AsymmetricBinaryPredicate|
     |AntiTransitiveBinaryPredicate|
     (DOCUMENTATION "(#$suspendedIn OBJ FLUID) means that OBJ is fully immersed in FLUID, and OBJ is suspended in FLUID by the kind of force that supports any suspension particle.  Note that while #$suspendedIn correctly describes the condition of a #$suspendedPart in its #$suspendingFluid (e.g., a dirt particle suspended in water), #$suspendedIn can also be used more broadly (e.g., a hot air balloon is #$suspendedIn air).  See also #$Suspension."))
)
(defrelation |suspendedPart|
  :arity 2
  :is-primitive (:and |constituents| |cotemporal|)
  :domain |Suspension|
  :range |Particle|
  :annotations ( |