;;; -*- 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|
  :